@matheuskrumenauer/tanya 0.2.0-beta.0 → 0.4.0-beta.0

package/dist/cli.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { existsSync as existsSync15, readFileSync as readFileSync7 } from "fs";
-import { join as join20, resolve as resolve12 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync8 } from "fs";
+import { join as join22, resolve as resolve12 } from "path";
 import { Command, Option } from "commander";
 
 // src/config/env.ts
@@ -40,6 +40,170 @@ function numberEnvValue(local, key, fallback) {
   return Number.isFinite(parsed) ? parsed : fallback;
 }
 
+// src/providers/adapters/deepseek.ts
+var deepSeekAdapter = {
+  id: "deepseek",
+  matchBaseUrl: /api\.deepseek\.com/i,
+  defaultBaseUrl: "https://api.deepseek.com",
+  defaultModel: "deepseek-chat",
+  capabilities: {
+    toolChoiceRequired: false,
+    parallelToolCalls: false,
+    jsonMode: true,
+    vision: false,
+    reasoning: true,
+    flattenSchemas: false
+  }
+};
+
+// src/providers/adapters/types.ts
+function withoutUnsupportedToolChoice(req) {
+  if (req.tool_choice === "required") {
+    const { tool_choice: _toolChoice, ...rest } = req;
+    return rest;
+  }
+  return req;
+}
+
+// src/providers/adapters/grok.ts
+var grokAdapter = {
+  id: "grok",
+  matchBaseUrl: /(?:api\.)?x\.ai/i,
+  defaultBaseUrl: "https://api.x.ai/v1",
+  defaultModel: "grok-3-mini",
+  capabilities: {
+    toolChoiceRequired: false,
+    parallelToolCalls: false,
+    jsonMode: true,
+    vision: true,
+    reasoning: true,
+    flattenSchemas: false
+  },
+  preRequest: withoutUnsupportedToolChoice
+};
+
+// src/providers/adapters/groq.ts
+var groqAdapter = {
+  id: "groq",
+  matchBaseUrl: /api\.groq\.com/i,
+  defaultBaseUrl: "https://api.groq.com/openai/v1",
+  defaultModel: "llama-3.3-70b-versatile",
+  capabilities: {
+    toolChoiceRequired: false,
+    parallelToolCalls: false,
+    jsonMode: true,
+    vision: false,
+    reasoning: false,
+    flattenSchemas: false
+  }
+};
+
+// src/providers/adapters/ollama.ts
+var ollamaAdapter = {
+  id: "ollama",
+  matchBaseUrl: /(?:localhost:11434|127\.0\.0\.1:11434|ollama)/i,
+  defaultBaseUrl: "http://localhost:11434/v1",
+  defaultModel: "qwen2.5-coder:7b",
+  capabilities: {
+    toolChoiceRequired: false,
+    parallelToolCalls: false,
+    jsonMode: true,
+    vision: false,
+    reasoning: false,
+    flattenSchemas: false
+  },
+  preRequest: withoutUnsupportedToolChoice
+};
+
+// src/providers/adapters/openai.ts
+var openAiAdapter = {
+  id: "openai",
+  matchBaseUrl: /(?:api\.)?openai\.com/i,
+  defaultBaseUrl: "https://api.openai.com/v1",
+  defaultModel: "gpt-4.1-mini",
+  capabilities: {
+    toolChoiceRequired: true,
+    parallelToolCalls: true,
+    jsonMode: true,
+    vision: true,
+    reasoning: true,
+    flattenSchemas: false
+  }
+};
+
+// src/providers/adapters/qwen.ts
+var qwenAdapter = {
+  id: "qwen",
+  matchBaseUrl: /(?:dashscope|aliyuncs|qwen)/i,
+  defaultBaseUrl: "https://dashscope.aliyuncs.com/compatible-mode/v1",
+  defaultModel: "qwen3-coder-plus",
+  capabilities: {
+    toolChoiceRequired: false,
+    parallelToolCalls: false,
+    jsonMode: true,
+    vision: true,
+    reasoning: true,
+    flattenSchemas: true
+  },
+  preRequest: (req) => ({
+    ...withoutUnsupportedToolChoice(req),
+    parallel_tool_calls: false
+  })
+};
+
+// src/providers/adapters/together.ts
+var togetherAdapter = {
+  id: "together",
+  matchBaseUrl: /api\.together\.xyz/i,
+  defaultBaseUrl: "https://api.together.xyz/v1",
+  defaultModel: "Qwen/Qwen3-Coder-480B-A35B-Instruct-FP8",
+  capabilities: {
+    toolChoiceRequired: false,
+    parallelToolCalls: false,
+    jsonMode: true,
+    vision: false,
+    reasoning: false,
+    flattenSchemas: true
+  },
+  preRequest: withoutUnsupportedToolChoice
+};
+
+// src/providers/adapters/index.ts
+var providerAdapters = [
+  deepSeekAdapter,
+  qwenAdapter,
+  grokAdapter,
+  groqAdapter,
+  togetherAdapter,
+  ollamaAdapter,
+  openAiAdapter
+];
+var aliases = /* @__PURE__ */ new Map([
+  ["deepseek-reasoner", "deepseek"],
+  ["deepseek-chat", "deepseek"],
+  ["xai", "grok"],
+  ["openai-compatible", "openai"],
+  ["custom", "openai"]
+]);
+function resolveProviderAdapter(input = {}) {
+  const provider = normalizeProviderId(input.provider);
+  if (provider) {
+    const explicit = providerAdapters.find((adapter) => adapter.id === provider);
+    if (explicit) return explicit;
+  }
+  const baseUrl = input.baseUrl?.trim();
+  if (baseUrl) {
+    const matched = providerAdapters.find((adapter) => adapter.matchBaseUrl?.test(baseUrl));
+    if (matched) return matched;
+  }
+  return openAiAdapter;
+}
+function normalizeProviderId(provider) {
+  const normalized = provider?.trim().toLowerCase();
+  if (!normalized) return null;
+  return aliases.get(normalized) ?? normalized;
+}
+
 // src/config/env.ts
 function loadDotEnv(cwd) {
   const envPath = join(cwd, ".env");
@@ -48,11 +212,18 @@ function loadDotEnv(cwd) {
 }
 function loadConfig(cwd = process.cwd()) {
   const local = loadDotEnv(cwd);
-  const provider = envValue(local, "TANYA_PROVIDER") === "custom" ? "custom" : "deepseek";
   const profile = envValue(local, "TANYA_PROFILE") === "reasoner" ? "reasoner" : "chat";
+  const requestedProvider = envValue(local, "TANYA_PROVIDER").trim();
+  const requestedBaseUrl = envValue(local, "TANYA_BASE_URL").trim();
+  const providerSeed = requestedProvider || (requestedBaseUrl ? "" : "deepseek");
+  const adapter = resolveProviderAdapter({
+    provider: providerSeed,
+    baseUrl: requestedBaseUrl
+  });
+  const provider = providerSeed || adapter.id;
   const apiKey = provider === "deepseek" ? envValue(local, "DEEPSEEK_API_KEY") || envValue(local, "TANYA_API_KEY") : envValue(local, "TANYA_API_KEY");
-  const baseUrl = provider === "deepseek" ? envValue(local, "DEEPSEEK_BASE_URL") || envValue(local, "TANYA_BASE_URL") || "https://api.deepseek.com" : envValue(local, "TANYA_BASE_URL");
-  const profileModelDefault = profile === "reasoner" ? "deepseek-reasoner" : "deepseek-chat";
+  const baseUrl = provider === "deepseek" ? envValue(local, "DEEPSEEK_BASE_URL") || envValue(local, "TANYA_BASE_URL") || adapter.defaultBaseUrl || "https://api.deepseek.com" : envValue(local, "TANYA_BASE_URL") || adapter.defaultBaseUrl || "";
+  const profileModelDefault = profile === "reasoner" && adapter.id === "deepseek" ? "deepseek-reasoner" : adapter.defaultModel ?? "deepseek-chat";
   const model = envValue(local, "TANYA_MODEL") || profileModelDefault;
   const profileTimeoutDefault = profile === "reasoner" ? 18e4 : 9e4;
   const timeoutMs = numberEnvValue(local, "TANYA_TIMEOUT_MS", profileTimeoutDefault);
@@ -144,12 +315,12 @@ function buildAutoBriefBlock(metadata) {
   }
   return lines;
 }
-function normalizeRunContext(input2) {
-  if (!isRecord(input2)) throw new Error("Context file must contain a JSON object.");
-  const taskInput = isRecord(input2.task) ? input2.task : void 0;
-  const artifactsInput = Array.isArray(input2.artifacts) ? input2.artifacts : void 0;
-  const verificationInput = isRecord(input2.verification) ? input2.verification : void 0;
-  const contextFilesInput = Array.isArray(input2.contextFiles) ? input2.contextFiles : void 0;
+function normalizeRunContext(input) {
+  if (!isRecord(input)) throw new Error("Context file must contain a JSON object.");
+  const taskInput = isRecord(input.task) ? input.task : void 0;
+  const artifactsInput = Array.isArray(input.artifacts) ? input.artifacts : void 0;
+  const verificationInput = isRecord(input.verification) ? input.verification : void 0;
+  const contextFilesInput = Array.isArray(input.contextFiles) ? input.contextFiles : void 0;
   const artifacts = artifactsInput?.filter(isRecord).map((artifact) => ({
     path: asString(artifact.path) ?? "",
     ...asString(artifact.sourcePath) ? { sourcePath: asString(artifact.sourcePath) } : {},
@@ -170,10 +341,10 @@ function normalizeRunContext(input2) {
     ...asString(taskInput.summary) ? { summary: asString(taskInput.summary) } : {}
   } : void 0;
   const verificationCommands = verificationInput ? stringArray(verificationInput.commands) : void 0;
-  const instructions = stringArray(input2.instructions);
-  const languages = stringArray(input2.languages);
-  const frameworks = stringArray(input2.frameworks);
-  const stack = asString(input2.stack);
+  const instructions = stringArray(input.instructions);
+  const languages = stringArray(input.languages);
+  const frameworks = stringArray(input.frameworks);
+  const stack = asString(input.stack);
   return {
     ...task && Object.keys(task).length > 0 ? { task } : {},
     ...artifacts?.length ? { artifacts } : {},
@@ -183,8 +354,8 @@ function normalizeRunContext(input2) {
     ...languages ? { languages } : {},
     ...frameworks ? { frameworks } : {},
     ...stack ? { stack } : {},
-    ...isRecord(input2.expected_report) ? { expected_report: input2.expected_report } : {},
-    ...isRecord(input2.metadata) ? { metadata: input2.metadata } : {}
+    ...isRecord(input.expected_report) ? { expected_report: input.expected_report } : {},
+    ...isRecord(input.metadata) ? { metadata: input.metadata } : {}
   };
 }
 function loadRunContextFile(path) {
@@ -281,12 +452,12 @@ function relativeMaterializedPath(root, artifact, source) {
   }
   return basename(source);
 }
-function materializeCliArtifacts(input2) {
-  const artifactInputs = unique(input2.artifacts);
-  const contextInputs = unique(input2.contextPaths ?? []);
-  if (artifactInputs.length === 0 && contextInputs.length === 0 && !input2.artifactOutputRoot) return input2.baseContext;
-  const cwd = resolve2(input2.cwd);
-  const root = input2.root ? resolve2(input2.root) : void 0;
+function materializeCliArtifacts(input) {
+  const artifactInputs = unique(input.artifacts);
+  const contextInputs = unique(input.contextPaths ?? []);
+  if (artifactInputs.length === 0 && contextInputs.length === 0 && !input.artifactOutputRoot) return input.baseContext;
+  const cwd = resolve2(input.cwd);
+  const root = input.root ? resolve2(input.root) : void 0;
   const targetRoot = resolve2(cwd, ".tania", "artifacts");
   const contextTargetRoot = resolve2(cwd, ".tania", "context");
   const materialized = [];
@@ -366,13 +537,13 @@ function materializeCliArtifacts(input2) {
       "utf8"
     );
   }
-  const artifactOutputRoot = input2.artifactOutputRoot ? resolve2(input2.artifactOutputRoot) : void 0;
+  const artifactOutputRoot = input.artifactOutputRoot ? resolve2(input.artifactOutputRoot) : void 0;
   return {
-    ...input2.baseContext ?? {},
-    artifacts: [...input2.baseContext?.artifacts ?? [], ...materialized],
-    contextFiles: [...input2.baseContext?.contextFiles ?? [], ...contextFiles],
+    ...input.baseContext ?? {},
+    artifacts: [...input.baseContext?.artifacts ?? [], ...materialized],
+    contextFiles: [...input.baseContext?.contextFiles ?? [], ...contextFiles],
     instructions: [
-      ...input2.baseContext?.instructions ?? [],
+      ...input.baseContext?.instructions ?? [],
       ...materialized.length > 0 ? [
         "Caller artifacts were provided through Tanya's artifact input contract and materialized under .tania/artifacts.",
         "Read relevant materialized artifact paths before implementing related code."
@@ -387,14 +558,14 @@ function materializeCliArtifacts(input2) {
       "When reporting artifact reuse, use the artifact sourcePath label when available."
     ],
     expected_report: {
-      ...input2.baseContext?.expected_report ?? {},
+      ...input.baseContext?.expected_report ?? {},
       artifact_reuse: true
     },
     metadata: {
-      ...input2.baseContext?.metadata ?? {},
+      ...input.baseContext?.metadata ?? {},
       ...artifactOutputRoot ? { artifactOutputRoot } : {},
       tanyaMaterializedContext: true,
-      keepMaterializedContext: input2.keepContext === true
+      keepMaterializedContext: input.keepContext === true
     }
   };
 }
@@ -471,6 +642,50 @@ function createCosmoSink(stream = process.stdout) {
           partialOutput: event.partialOutput
         });
         break;
+      case "command_invoked":
+        ensureEventLine();
+        writeEvent(stream, {
+          t: "status",
+          message: `Command invoked: /${event.name}`,
+          key: `tanya:command:${event.name}`,
+          command: event.name,
+          args: event.args,
+          runId: event.runId
+        });
+        break;
+      case "tool_call_parse_warning":
+        ensureEventLine();
+        writeEvent(stream, {
+          t: "status",
+          message: `Tool-call parse warning: ${event.reason}`,
+          key: `tanya:tool-call-parse-warning:${event.toolCallId ?? event.turn ?? "unknown"}`,
+          provider: event.provider,
+          tool: event.tool,
+          attempt: event.attempt
+        });
+        break;
+      case "schema_flatten_warning":
+        ensureEventLine();
+        writeEvent(stream, {
+          t: "status",
+          message: `Schema flatten warning: ${event.reason}`,
+          key: `tanya:schema-flatten-warning:${event.tool ?? event.path}`,
+          provider: event.provider,
+          tool: event.tool,
+          path: event.path
+        });
+        break;
+      case "provider_throttle":
+        ensureEventLine();
+        writeEvent(stream, {
+          t: "status",
+          message: `Provider throttle: waiting ${Math.ceil(event.waitMs / 1e3)}s before retry ${event.attempt}.`,
+          key: `tanya:provider-throttle:${event.provider}:${event.attempt}`,
+          provider: event.provider,
+          attempt: event.attempt,
+          waitMs: event.waitMs
+        });
+        break;
       case "final":
         ensureEventLine();
         if (event.message.trim()) {
@@ -520,6 +735,10 @@ var knownEventTypes = /* @__PURE__ */ new Set([
   "tool_cancel_requested",
   "tool_cancelled",
   "tool_result",
+  "tool_call_parse_warning",
+  "schema_flatten_warning",
+  "provider_throttle",
+  "command_invoked",
   "final",
   "error"
 ]);
@@ -536,27 +755,237 @@ function createJsonlSink(stream = process.stdout) {
   };
 }
 
-// src/providers/openAiCompatible.ts
-var RETRYABLE_HTTP_STATUSES = /* @__PURE__ */ new Set([429, 500, 502, 503]);
-var MAX_FETCH_ATTEMPTS = 3;
-function sleep(ms) {
-  return new Promise((resolve13) => setTimeout(resolve13, ms));
+// src/providers/schemaFlatten.ts
+function flattenJsonSchema(schema) {
+  const warnings = [];
+  const root = clone(schema);
+  const flattened = flattenValue(root, root, "#", warnings, /* @__PURE__ */ new Set());
+  return { schema: flattened, warnings };
 }
-function retryAfterMs(response) {
+function flattenToolDefinition(tool) {
+  const result = flattenJsonSchema(tool.function.parameters);
+  return {
+    schema: {
+      ...tool,
+      function: {
+        ...tool.function,
+        parameters: result.schema
+      }
+    },
+    warnings: result.warnings.map((warning) => ({ ...warning, tool: tool.function.name }))
+  };
+}
+function flattenToolDefinitions(tools) {
+  const flattened = [];
+  const warnings = [];
+  for (const tool of tools) {
+    const result = flattenToolDefinition(tool);
+    flattened.push(result.schema);
+    warnings.push(...result.warnings);
+  }
+  return { schema: flattened, warnings };
+}
+function flattenValue(value, root, path, warnings, seenRefs) {
+  if (Array.isArray(value)) {
+    return value.map((item, index) => flattenValue(item, root, `${path}/${index}`, warnings, seenRefs));
+  }
+  if (!isObject(value)) return value;
+  const ref = typeof value.$ref === "string" ? value.$ref : null;
+  if (ref) {
+    const resolved = resolveLocalRef(root, ref);
+    if (resolved === void 0) {
+      warnings.push({ path, reason: `unresolved $ref ${ref}; leaving reference in place` });
+      return value;
+    }
+    if (seenRefs.has(ref)) {
+      warnings.push({ path, reason: `circular $ref ${ref}; leaving reference in place` });
+      return value;
+    }
+    warnings.push({ path, reason: `inlined $ref ${ref}` });
+    seenRefs.add(ref);
+    const flattened = flattenValue(resolved, root, path, warnings, seenRefs);
+    seenRefs.delete(ref);
+    const { $ref: _ref, ...overrides } = value;
+    return isObject(flattened) ? flattenObject({ ...flattened, ...overrides }, root, path, warnings, seenRefs) : flattened;
+  }
+  return flattenObject(value, root, path, warnings, seenRefs);
+}
+function flattenObject(object, root, path, warnings, seenRefs) {
+  const withoutDefs = stripDefinitions(object);
+  if (Array.isArray(withoutDefs.oneOf)) {
+    return flattenOneOf(withoutDefs, root, path, warnings, seenRefs);
+  }
+  const output = {};
+  for (const [key, raw] of Object.entries(withoutDefs)) {
+    output[key] = flattenValue(raw, root, `${path}/${escapePointer(key)}`, warnings, seenRefs);
+  }
+  return output;
+}
+function flattenOneOf(object, root, path, warnings, seenRefs) {
+  const variants = object.oneOf;
+  const flattenedVariants = variants.map((variant, index) => flattenValue(variant, root, `${path}/oneOf/${index}`, warnings, seenRefs)).filter(isObject);
+  if (flattenedVariants.length === 0) {
+    warnings.push({ path, reason: "oneOf had no object variants; dropped oneOf" });
+    const { oneOf: _oneOf2, ...rest2 } = object;
+    return flattenObject(rest2, root, path, warnings, seenRefs);
+  }
+  const commonType = commonScalar(flattenedVariants.map((variant) => variant.type));
+  const commonProperties = commonObjectProperties(flattenedVariants);
+  const commonRequired = commonRequiredFields(flattenedVariants);
+  const { oneOf: _oneOf, ...rest } = object;
+  warnings.push({ path, reason: `collapsed oneOf (${variants.length} variants) to common object shape` });
+  return flattenObject({
+    ...rest,
+    ...commonType ? { type: commonType } : {},
+    ...Object.keys(commonProperties).length ? { properties: commonProperties } : {},
+    ...commonRequired.length ? { required: commonRequired } : {}
+  }, root, path, warnings, seenRefs);
+}
+function commonObjectProperties(variants) {
+  const propertyMaps = variants.map((variant) => isObject(variant.properties) ? variant.properties : {});
+  if (propertyMaps.length === 0) return {};
+  const commonKeys = Object.keys(propertyMaps[0] ?? {}).filter((key) => propertyMaps.every((properties) => key in properties));
+  const output = {};
+  for (const key of commonKeys) output[key] = propertyMaps[0]?.[key];
+  return output;
+}
+function commonRequiredFields(variants) {
+  const requiredLists = variants.map((variant) => Array.isArray(variant.required) ? variant.required.filter((item) => typeof item === "string") : []);
+  if (requiredLists.length === 0) return [];
+  return requiredLists[0]?.filter((key) => requiredLists.every((list) => list.includes(key))) ?? [];
+}
+function commonScalar(values) {
+  const [first] = values;
+  return typeof first === "string" && values.every((value) => value === first) ? first : null;
+}
+function resolveLocalRef(root, ref) {
+  if (!ref.startsWith("#/")) return void 0;
+  const parts = ref.slice(2).split("/").map(unescapePointer);
+  let current = root;
+  for (const part of parts) {
+    if (!isObject(current) && !Array.isArray(current)) return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function stripDefinitions(object) {
+  const { $defs: _defs, definitions: _definitions, ...rest } = object;
+  return rest;
+}
+function clone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function isObject(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function escapePointer(value) {
+  return value.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function unescapePointer(value) {
+  return value.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+
+// src/providers/retry.ts
+var DEFAULT_MAX_RETRIES = 3;
+var DEFAULT_MAX_WAIT_MS = 3e4;
+var DEFAULT_INITIAL_WAIT_MS = 500;
+var DEFAULT_PROVIDER_CONCURRENCY = 4;
+var semaphores = /* @__PURE__ */ new Map();
+function retryAfterMs(response, now = Date.now()) {
   const raw = response.headers.get("retry-after");
   if (!raw) return null;
   const seconds = Number(raw);
-  if (Number.isFinite(seconds) && seconds >= 0) return Math.min(seconds * 1e3, 6e4);
+  if (Number.isFinite(seconds) && seconds >= 0) return Math.max(0, seconds * 1e3);
   const dateMs = Date.parse(raw);
-  if (!Number.isNaN(dateMs)) return Math.min(Math.max(dateMs - Date.now(), 0), 6e4);
+  if (!Number.isNaN(dateMs)) return Math.max(dateMs - now, 0);
+  return null;
+}
+function backoffMs(attempt, options = {}) {
+  const initial = options.initialWaitMs ?? DEFAULT_INITIAL_WAIT_MS;
+  const max = options.maxWaitMs ?? DEFAULT_MAX_WAIT_MS;
+  return Math.min(initial * 2 ** Math.max(0, attempt - 1), max);
+}
+function retryWaitMs(response, attempt, options = {}) {
+  if (response.status === 429) {
+    const retryAfter = retryAfterMs(response);
+    if (retryAfter !== null) return Math.min(retryAfter, options.maxWaitMs ?? DEFAULT_MAX_WAIT_MS);
+  }
+  if (response.status >= 500 && response.status <= 599 || response.status === 429) {
+    return backoffMs(attempt, options);
+  }
   return null;
 }
-function backoffMs(attempt, response) {
-  const retryAfter = response?.status === 429 ? retryAfterMs(response) : null;
-  if (retryAfter !== null) return retryAfter;
-  const base = 100 * 2 ** attempt;
-  const jitter = base * 0.1 * (Math.random() * 2 - 1);
-  return Math.max(0, Math.round(base + jitter));
+async function fetchWithProviderRetry(options) {
+  const semaphore = getProviderSemaphore(options.provider, options.concurrency ?? DEFAULT_PROVIDER_CONCURRENCY);
+  return semaphore.run(() => fetchWithRetry(options));
+}
+async function fetchWithRetry(options) {
+  const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+  const sleep2 = options.sleep ?? defaultSleep;
+  let response;
+  for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
+    response = await options.fetch();
+    const retryAttempt = attempt + 1;
+    const waitOptions = {
+      ...options.initialWaitMs !== void 0 ? { initialWaitMs: options.initialWaitMs } : {},
+      ...options.maxWaitMs !== void 0 ? { maxWaitMs: options.maxWaitMs } : {}
+    };
+    const waitMs = attempt < maxRetries ? retryWaitMs(response, retryAttempt, waitOptions) : null;
+    if (waitMs === null) return response;
+    await options.onThrottle?.({ provider: options.provider, attempt: retryAttempt, waitMs });
+    await sleep2(waitMs);
+  }
+  return response;
+}
+function getProviderSemaphore(provider, concurrency) {
+  const normalizedProvider = provider || "unknown";
+  const existing = semaphores.get(normalizedProvider);
+  if (existing && existing.limit === concurrency) return existing;
+  const created = new ProviderSemaphore(Math.max(1, Math.floor(concurrency)));
+  semaphores.set(normalizedProvider, created);
+  return created;
+}
+function defaultSleep(ms) {
+  return new Promise((resolve13) => setTimeout(resolve13, ms));
+}
+var ProviderSemaphore = class {
+  limit;
+  active = 0;
+  queue = [];
+  constructor(limit) {
+    this.limit = limit;
+  }
+  async run(fn) {
+    await this.acquire();
+    try {
+      return await fn();
+    } finally {
+      this.release();
+    }
+  }
+  acquire() {
+    if (this.active < this.limit) {
+      this.active += 1;
+      return Promise.resolve();
+    }
+    return new Promise((resolve13) => {
+      this.queue.push(() => {
+        this.active += 1;
+        resolve13();
+      });
+    });
+  }
+  release() {
+    this.active -= 1;
+    const next = this.queue.shift();
+    if (next) next();
+  }
+};
+
+// src/providers/openAiCompatible.ts
+function providerConcurrency() {
+  const raw = Number(envValue({}, "TANYA_PROVIDER_CONCURRENCY"));
+  return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : 4;
 }
 var OpenAiCompatibleProvider = class {
   id;
@@ -566,18 +995,20 @@ var OpenAiCompatibleProvider = class {
   timeoutMs;
   temperature;
   topP;
+  adapter;
   constructor(options) {
+    this.adapter = resolveProviderAdapter({ provider: options.id, baseUrl: options.baseUrl });
     this.id = options.id;
     this.apiKey = options.apiKey;
-    this.baseUrl = options.baseUrl.replace(/\/$/, "");
-    this.model = options.model;
+    this.baseUrl = (options.baseUrl || this.adapter.defaultBaseUrl || "").replace(/\/$/, "");
+    this.model = options.model || this.adapter.defaultModel || "";
     const envTimeout = parseInt(envValue({}, "TANYA_TIMEOUT_MS"), 10);
     const envTimeoutMs = Number.isFinite(envTimeout) && envTimeout > 0 ? envTimeout : null;
     this.timeoutMs = envTimeoutMs ?? options.timeoutMs ?? 9e4;
     this.temperature = options.temperature ?? 0;
     this.topP = options.topP ?? 0.2;
   }
-  async *streamChat(input2) {
+  async *streamChat(input) {
     if (!this.apiKey) {
       throw new Error(`Missing API key for provider "${this.id}".`);
     }
@@ -587,54 +1018,62 @@ var OpenAiCompatibleProvider = class {
       if (timeout) clearTimeout(timeout);
       timeout = setTimeout(() => controller.abort(), this.timeoutMs);
     };
-    const requestBody = JSON.stringify({
+    const request = {
       model: this.model,
-      messages: input2.messages,
-      tools: input2.tools?.length ? input2.tools : void 0,
-      tool_choice: input2.tools?.length ? "auto" : void 0,
-      temperature: input2.temperature ?? this.temperature,
-      top_p: input2.topP ?? this.topP,
-      max_tokens: input2.maxTokens ?? 8192,
+      messages: input.messages,
+      temperature: input.temperature ?? this.temperature,
+      top_p: input.topP ?? this.topP,
+      max_tokens: input.maxTokens ?? 8192,
       stream: true
-    });
-    let response = null;
-    let finalHttpErrorDetail = "";
-    for (let attempt = 0; attempt < MAX_FETCH_ATTEMPTS; attempt += 1) {
-      resetTimeout();
-      response = await fetch(`${this.baseUrl}/chat/completions`, {
-        method: "POST",
-        signal: controller.signal,
-        headers: {
-          Authorization: `Bearer ${this.apiKey}`,
-          "Content-Type": "application/json"
-        },
-        body: requestBody
-      }).catch((error) => {
-        if (controller.signal.aborted) {
-          throw new Error(`Provider ${this.id} timed out before streaming a response.`);
-        }
-        throw error;
-      });
-      if (response.ok && response.body) break;
-      if (!RETRYABLE_HTTP_STATUSES.has(response.status) || attempt === MAX_FETCH_ATTEMPTS - 1) {
-        break;
+    };
+    const schemaWarnings = [];
+    if (input.tools?.length) {
+      if (this.adapter.capabilities.flattenSchemas) {
+        const flattened = flattenToolDefinitions(input.tools);
+        request.tools = flattened.schema;
+        schemaWarnings.push(...flattened.warnings);
+      } else {
+        request.tools = input.tools;
       }
-      finalHttpErrorDetail = await response.text().catch(() => "");
-      await sleep(backoffMs(attempt, response));
-    }
-    if (!response) {
-      if (timeout) clearTimeout(timeout);
-      throw new Error(`Provider ${this.id} failed to open a streaming response.`);
-    }
+      request.tool_choice = "auto";
+    }
+    const requestBody = JSON.stringify(this.adapter.preRequest ? this.adapter.preRequest(request) : request);
+    resetTimeout();
+    const retryOptions = {
+      provider: this.adapter.id,
+      concurrency: providerConcurrency(),
+      fetch: () => {
+        resetTimeout();
+        return fetch(`${this.baseUrl}/chat/completions`, {
+          method: "POST",
+          signal: controller.signal,
+          headers: {
+            Authorization: `Bearer ${this.apiKey}`,
+            "Content-Type": "application/json"
+          },
+          body: requestBody
+        }).catch((error) => {
+          if (controller.signal.aborted) {
+            throw new Error(`Provider ${this.id} timed out before streaming a response.`);
+          }
+          throw error;
+        });
+      },
+      ...input.onProviderThrottle ? { onThrottle: input.onProviderThrottle } : {}
+    };
+    const response = await fetchWithProviderRetry(retryOptions);
     if (!response.ok || !response.body) {
       if (timeout) clearTimeout(timeout);
-      const detail = finalHttpErrorDetail || await response.text().catch(() => "");
+      const detail = await response.text().catch(() => "");
       throw new Error(`Provider ${this.id} returned HTTP ${response.status}: ${detail.slice(0, 500)}`);
     }
     const decoder = new TextDecoder();
     let buffer = "";
     const toolCallParts = /* @__PURE__ */ new Map();
     try {
+      if (schemaWarnings.length > 0) {
+        yield { schemaWarnings };
+      }
       for await (const chunk of response.body) {
         resetTimeout();
         buffer += decoder.decode(chunk, { stream: true });
@@ -647,7 +1086,8 @@ var OpenAiCompatibleProvider = class {
           if (data === "[DONE]") return;
           let parsed;
           try {
-            parsed = JSON.parse(data);
+            const rawParsed = JSON.parse(data);
+            parsed = this.adapter.postResponse ? this.adapter.postResponse(rawParsed) : rawParsed;
           } catch (error) {
             if (envValue({}, "TANYA_DEBUG")) {
               const message = error instanceof Error ? error.message : String(error);
@@ -700,7 +1140,7 @@ var OpenAiCompatibleProvider = class {
 // src/providers/factory.ts
 function createProvider(config) {
   return new OpenAiCompatibleProvider({
-    id: config.profile === "reasoner" ? "deepseek-reasoner" : config.provider,
+    id: config.provider === "deepseek" && config.profile === "reasoner" ? "deepseek-reasoner" : config.provider,
     apiKey: config.apiKey,
     baseUrl: config.baseUrl,
     model: config.model,
@@ -710,6 +1150,161 @@ function createProvider(config) {
   });
 }
 
+// src/providers/parser.ts
+var TOOL_CALL_CORRECTION_LIMIT = 3;
+function malformedToolCallCorrectionMessage(reason) {
+  return `[your last tool call was malformed: ${reason}. Try again with valid JSON.]`;
+}
+function parseProviderToolCalls(rawToolCalls, options = {}) {
+  const warnings = [];
+  const failures = [];
+  const toolCalls = [];
+  rawToolCalls.forEach((raw, index) => {
+    const parsed = parseOneToolCall(raw, index, options.turn ?? 0);
+    warnings.push(...parsed.warnings);
+    if (parsed.failure) {
+      failures.push(parsed.failure);
+      return;
+    }
+    toolCalls.push(parsed.toolCall);
+  });
+  return { toolCalls, warnings, failures };
+}
+function parseToolArguments(rawArguments) {
+  if (rawArguments === void 0 || rawArguments === null || rawArguments === "") {
+    return { ok: true, input: {} };
+  }
+  if (typeof rawArguments === "object") {
+    return { ok: true, input: rawArguments };
+  }
+  if (typeof rawArguments !== "string") {
+    return {
+      ok: false,
+      reason: `tool arguments must be JSON object or string, got ${typeof rawArguments}`,
+      rawArguments: String(rawArguments)
+    };
+  }
+  if (!rawArguments.trim()) return { ok: true, input: {} };
+  try {
+    return { ok: true, input: JSON.parse(rawArguments) };
+  } catch {
+    const preview = previewRawToolArguments(rawArguments);
+    return {
+      ok: false,
+      reason: `malformed JSON arguments: ${preview}`,
+      rawArguments: preview
+    };
+  }
+}
+function parseOneToolCall(raw, index, turn) {
+  const warnings = [];
+  if (!isRecord2(raw)) {
+    const toolCall3 = fallbackToolCall(turn, index, "__malformed_tool_call__", "");
+    return {
+      toolCall: toolCall3,
+      warnings,
+      failure: { reason: `tool call must be an object, got ${typeof raw}`, toolCall: toolCall3, raw }
+    };
+  }
+  const idValue = typeof raw.id === "string" && raw.id.trim() ? raw.id : void 0;
+  const id = idValue ?? `call_${turn}_${index}`;
+  if (!idValue) {
+    warnings.push({
+      reason: `missing tool call id; synthesized ${id}`,
+      toolCallId: id,
+      raw
+    });
+  }
+  const functionRecord = isRecord2(raw.function) ? raw.function : raw;
+  if (!isRecord2(raw.function)) {
+    warnings.push({
+      reason: "missing function wrapper; accepted top-level name/arguments",
+      toolCallId: id,
+      raw
+    });
+  }
+  const name = typeof functionRecord.name === "string" ? functionRecord.name.trim() : "";
+  if (!name) {
+    const toolCall3 = fallbackToolCall(turn, index, "__malformed_tool_call__", stringifyArguments(functionRecord.arguments));
+    return {
+      toolCall: toolCall3,
+      warnings,
+      failure: { reason: "missing function name", toolCall: toolCall3, raw }
+    };
+  }
+  const normalizedArguments = normalizeArguments(functionRecord.arguments, warnings, id, name, raw);
+  const toolCall2 = {
+    id,
+    type: "function",
+    function: {
+      name,
+      arguments: normalizedArguments
+    }
+  };
+  const parsedArguments = parseToolArguments(normalizedArguments);
+  if (!parsedArguments.ok) {
+    return {
+      toolCall: toolCall2,
+      warnings,
+      failure: { reason: parsedArguments.reason, toolCall: toolCall2, raw }
+    };
+  }
+  return { toolCall: toolCall2, warnings };
+}
+function normalizeArguments(value, warnings, toolCallId, tool, raw) {
+  if (value === void 0 || value === null) {
+    warnings.push({
+      reason: "missing arguments; using empty object",
+      toolCallId,
+      tool,
+      raw
+    });
+    return "{}";
+  }
+  if (typeof value === "string") return value;
+  if (typeof value === "object") {
+    warnings.push({
+      reason: "arguments arrived as object; stringified for OpenAI-compatible history",
+      toolCallId,
+      tool,
+      raw
+    });
+    return JSON.stringify(value);
+  }
+  warnings.push({
+    reason: `arguments arrived as ${typeof value}; stringified for correction`,
+    toolCallId,
+    tool,
+    raw
+  });
+  return String(value);
+}
+function stringifyArguments(value) {
+  if (value === void 0 || value === null) return "";
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function fallbackToolCall(turn, index, name, args) {
+  return {
+    id: `call_${turn}_${index}`,
+    type: "function",
+    function: {
+      name,
+      arguments: args
+    }
+  };
+}
+function previewRawToolArguments(raw) {
+  return raw.length > 500 ? `${raw.slice(0, 500)}...[truncated ${raw.length - 500} chars]` : raw;
+}
+function isRecord2(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
 // src/safety/workspace.ts
 import { existsSync as existsSync3, lstatSync, realpathSync } from "fs";
 import { dirname as dirname2, resolve as resolve3, relative as relative2 } from "path";
@@ -757,28 +1352,28 @@ import sharp2 from "sharp";
 import { mkdir, readFile, writeFile } from "fs/promises";
 import { dirname as dirname3 } from "path";
 import sharp from "sharp";
-function asRecord(input2) {
-  return input2 && typeof input2 === "object" ? input2 : {};
+function asRecord(input) {
+  return input && typeof input === "object" ? input : {};
 }
-function asString2(input2, key) {
-  const value = asRecord(input2)[key];
+function asString2(input, key) {
+  const value = asRecord(input)[key];
   if (typeof value !== "string" || !value.trim()) throw new Error(`Missing string field: ${key}`);
   return value;
 }
-function asOptionalString(input2, key) {
-  const value = asRecord(input2)[key];
+function asOptionalString(input, key) {
+  const value = asRecord(input)[key];
   return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
-function asOptionalNumber(input2, key, fallback) {
-  const value = asRecord(input2)[key];
+function asOptionalNumber(input, key, fallback) {
+  const value = asRecord(input)[key];
   return typeof value === "number" && Number.isFinite(value) ? value : fallback;
 }
 function ensureRelativePath(path) {
   if (path.startsWith("/")) throw new Error(`Path must be relative to the workspace: ${path}`);
   return path;
 }
-function optionalStringArray(input2, key, fallback) {
-  const value = asRecord(input2)[key];
+function optionalStringArray(input, key, fallback) {
+  const value = asRecord(input)[key];
   if (!Array.isArray(value)) return fallback;
   return value.filter((item) => typeof item === "string" && item.trim().length > 0);
 }
@@ -855,12 +1450,12 @@ var resizeImageTool = {
       }
     }
   },
-  async run(input2, context) {
-    const source = ensureRelativePath(asString2(input2, "source"));
-    const destination = ensureRelativePath(asString2(input2, "destination"));
-    const width = Math.round(asOptionalNumber(input2, "width", 0));
-    const height = Math.round(asOptionalNumber(input2, "height", width));
-    const background = asOptionalString(input2, "background") ?? "#ffffff";
+  async run(input, context) {
+    const source = ensureRelativePath(asString2(input, "source"));
+    const destination = ensureRelativePath(asString2(input, "destination"));
+    const width = Math.round(asOptionalNumber(input, "width", 0));
+    const height = Math.round(asOptionalNumber(input, "height", width));
+    const background = asOptionalString(input, "background") ?? "#ffffff";
     if (width <= 0 || height <= 0) return { ok: false, summary: "Invalid image dimensions.", error: "width and height must be positive." };
     const sourceAbs = resolveInsideWorkspace(context.workspace, source);
     const destinationAbs = resolveInsideWorkspace(context.workspace, destination);
@@ -895,12 +1490,12 @@ var renderSvgToPngTool = {
       }
     }
   },
-  async run(input2, context) {
-    const source = ensureRelativePath(asString2(input2, "source"));
-    const destination = ensureRelativePath(asString2(input2, "destination"));
-    const width = Math.round(asOptionalNumber(input2, "width", 1024));
-    const height = Math.round(asOptionalNumber(input2, "height", width));
-    const background = asOptionalString(input2, "background") ?? "#ffffff";
+  async run(input, context) {
+    const source = ensureRelativePath(asString2(input, "source"));
+    const destination = ensureRelativePath(asString2(input, "destination"));
+    const width = Math.round(asOptionalNumber(input, "width", 1024));
+    const height = Math.round(asOptionalNumber(input, "height", width));
+    const background = asOptionalString(input, "background") ?? "#ffffff";
     if (width <= 0 || height <= 0) return { ok: false, summary: "Invalid image dimensions.", error: "width and height must be positive." };
     const sourceAbs = resolveInsideWorkspace(context.workspace, source);
     const destinationAbs = resolveInsideWorkspace(context.workspace, destination);
@@ -940,12 +1535,12 @@ var createAppleAppIconSetTool = {
       }
     }
   },
-  async run(input2, context) {
-    const source = ensureRelativePath(asString2(input2, "source"));
-    const outputDir = ensureRelativePath(asString2(input2, "outputDir"));
-    const platforms = optionalStringArray(input2, "platforms", ["ios"]);
+  async run(input, context) {
+    const source = ensureRelativePath(asString2(input, "source"));
+    const outputDir = ensureRelativePath(asString2(input, "outputDir"));
+    const platforms = optionalStringArray(input, "platforms", ["ios"]);
     const slots = slotsForPlatforms(platforms);
-    const background = asOptionalString(input2, "background") ?? "#ffffff";
+    const background = asOptionalString(input, "background") ?? "#ffffff";
     if (slots.length === 0) {
       return { ok: false, summary: "No Apple icon platforms selected.", error: "Use platforms ['ios'], ['macos'], or both." };
     }
@@ -1016,12 +1611,12 @@ var createAndroidLauncherIconSetTool = {
       }
     }
   },
-  async run(input2, context) {
-    const source = ensureRelativePath(asString2(input2, "source"));
-    const resDir = ensureRelativePath(asString2(input2, "resDir"));
-    const background = asOptionalString(input2, "background") ?? "#ffffff";
-    const iconName = sanitizeName(asOptionalString(input2, "iconName") ?? "ic_launcher");
-    const roundIconName = sanitizeName(asOptionalString(input2, "roundIconName") ?? "ic_launcher_round");
+  async run(input, context) {
+    const source = ensureRelativePath(asString2(input, "source"));
+    const resDir = ensureRelativePath(asString2(input, "resDir"));
+    const background = asOptionalString(input, "background") ?? "#ffffff";
+    const iconName = sanitizeName(asOptionalString(input, "iconName") ?? "ic_launcher");
+    const roundIconName = sanitizeName(asOptionalString(input, "roundIconName") ?? "ic_launcher_round");
     const sourceAbs = resolveInsideWorkspace(context.workspace, source);
     const generatedFiles = [];
     for (const density of androidLauncherDensities) {
@@ -1120,10 +1715,10 @@ var validateAppleAppIconSetTool = {
       }
     }
   },
-  async run(input2, context) {
-    const appIconSetDir = ensureRelativePath(asString2(input2, "appIconSetDir"));
-    const platforms = optionalStringArray(input2, "platforms", ["ios"]);
-    const requireNoAlpha = asRecord(input2).requireNoAlpha !== false;
+  async run(input, context) {
+    const appIconSetDir = ensureRelativePath(asString2(input, "appIconSetDir"));
+    const platforms = optionalStringArray(input, "platforms", ["ios"]);
+    const requireNoAlpha = asRecord(input).requireNoAlpha !== false;
     const expectedSlots = slotsForPlatforms(platforms);
     const contentsPath = `${appIconSetDir}/Contents.json`;
     const contentsText = await readFile(resolveInsideWorkspace(context.workspace, contentsPath), "utf8");
@@ -1173,10 +1768,10 @@ var validateAndroidLauncherIconSetTool = {
       }
     }
   },
-  async run(input2, context) {
-    const resDir = ensureRelativePath(asString2(input2, "resDir"));
-    const iconName = sanitizeName(asOptionalString(input2, "iconName") ?? "ic_launcher");
-    const roundIconName = sanitizeName(asOptionalString(input2, "roundIconName") ?? "ic_launcher_round");
+  async run(input, context) {
+    const resDir = ensureRelativePath(asString2(input, "resDir"));
+    const iconName = sanitizeName(asOptionalString(input, "iconName") ?? "ic_launcher");
+    const roundIconName = sanitizeName(asOptionalString(input, "roundIconName") ?? "ic_launcher_round");
     const problems = [];
     for (const density of androidLauncherDensities) {
       for (const [fileName, expectedPx] of [
@@ -1227,19 +1822,19 @@ import { mkdir as mkdir2, writeFile as writeFile2, copyFile } from "fs/promises"
 import { dirname as dirname4, join as join2 } from "path";
 import { spawn, spawnSync } from "child_process";
 import WebSocket from "ws";
-function asRecord2(input2) {
-  return input2 && typeof input2 === "object" ? input2 : {};
+function asRecord2(input) {
+  return input && typeof input === "object" ? input : {};
 }
-function asOptionalString2(input2, key) {
-  const value = asRecord2(input2)[key];
+function asOptionalString2(input, key) {
+  const value = asRecord2(input)[key];
   return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
-function asOptionalNumber2(input2, key, fallback) {
-  const value = asRecord2(input2)[key];
+function asOptionalNumber2(input, key, fallback) {
+  const value = asRecord2(input)[key];
   return typeof value === "number" && Number.isFinite(value) ? value : fallback;
 }
-function optionalStringArray2(input2, key, fallback) {
-  const value = asRecord2(input2)[key];
+function optionalStringArray2(input, key, fallback) {
+  const value = asRecord2(input)[key];
   if (!Array.isArray(value)) return fallback;
   return value.filter((item) => typeof item === "string" && item.trim().length > 0);
 }
@@ -1406,7 +2001,7 @@ function terminalSvg(config, frame) {
   ${body}
 </svg>`;
 }
-function sleep2(ms) {
+function sleep(ms) {
   return new Promise((resolve13) => setTimeout(resolve13, ms));
 }
 async function waitForJson(url, timeout = 1e4) {
@@ -1417,7 +2012,7 @@ async function waitForJson(url, timeout = 1e4) {
       if (res.ok) return await res.json();
     } catch {
     }
-    await sleep2(120);
+    await sleep(120);
   }
   throw new Error(`Timed out waiting for ${url}`);
 }
@@ -1483,7 +2078,7 @@ async function captureFrames(config, frameDir, svgDir, chromeProfile) {
     await page.send("Emulation.setDefaultBackgroundColorOverride", { color: { r: 0, g: 0, b: 0, a: 0 } });
     const html = `<!doctype html><html><head><meta charset="utf-8"><style>html,body{margin:0;width:${config.width}px;height:${config.height}px;overflow:hidden;background:transparent;}svg{display:block;width:${config.width}px;height:${config.height}px;}</style></head><body></body></html>`;
     await page.send("Page.navigate", { url: `data:text/html;charset=utf-8,${encodeURIComponent(html)}` });
-    await sleep2(250);
+    await sleep(250);
     const totalFrames = Math.round(config.fps * config.duration);
     for (let i = 0; i < totalFrames; i += 1) {
       const n = String(i + 1).padStart(4, "0");
@@ -1647,25 +2242,25 @@ var generateVideoAssetTool = {
       }
     }
   },
-  async run(input2, context) {
-    const preset = asOptionalString2(input2, "preset");
-    const outputDir = asOptionalString2(input2, "outputDir");
-    const basename4 = asOptionalString2(input2, "basename");
+  async run(input, context) {
+    const preset = asOptionalString2(input, "preset");
+    const outputDir = asOptionalString2(input, "outputDir");
+    const basename5 = asOptionalString2(input, "basename");
     const options = {
-      width: asOptionalNumber2(input2, "width", 980),
-      height: asOptionalNumber2(input2, "height", 1012),
-      fps: asOptionalNumber2(input2, "fps", 30),
-      duration: asOptionalNumber2(input2, "duration", 3),
-      formats: optionalStringArray2(input2, "formats", ["webm", "mov", "poster"]),
-      lines: optionalStringArray2(input2, "lines", [])
+      width: asOptionalNumber2(input, "width", 980),
+      height: asOptionalNumber2(input, "height", 1012),
+      fps: asOptionalNumber2(input, "fps", 30),
+      duration: asOptionalNumber2(input, "duration", 3),
+      formats: optionalStringArray2(input, "formats", ["webm", "mov", "poster"]),
+      lines: optionalStringArray2(input, "lines", [])
     };
     if (preset) options.preset = preset;
     if (outputDir) options.outputDir = outputDir;
-    if (basename4) options.basename = basename4;
-    const title = asOptionalString2(input2, "title");
-    const tab = asOptionalString2(input2, "tab");
-    const secondaryTab = asOptionalString2(input2, "secondaryTab");
-    const badge = asOptionalString2(input2, "badge");
+    if (basename5) options.basename = basename5;
+    const title = asOptionalString2(input, "title");
+    const tab = asOptionalString2(input, "tab");
+    const secondaryTab = asOptionalString2(input, "secondaryTab");
+    const badge = asOptionalString2(input, "badge");
     if (title) options.title = title;
     if (tab) options.tab = tab;
     if (secondaryTab) options.secondaryTab = secondaryTab;
@@ -1773,24 +2368,24 @@ var artifactFileExtensions = /* @__PURE__ */ new Set([
   ".yaml",
   ".css"
 ]);
-function asRecord3(input2) {
-  return input2 && typeof input2 === "object" ? input2 : {};
+function asRecord3(input) {
+  return input && typeof input === "object" ? input : {};
 }
-function asString3(input2, key) {
-  const value = asRecord3(input2)[key];
+function asString3(input, key) {
+  const value = asRecord3(input)[key];
   if (typeof value !== "string" || !value.trim()) throw new Error(`Missing string field: ${key}`);
   return value.trim();
 }
-function asOptionalString3(input2, key) {
-  const value = asRecord3(input2)[key];
+function asOptionalString3(input, key) {
+  const value = asRecord3(input)[key];
   return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
-function asOptionalNumber3(input2, key, fallback) {
-  const value = asRecord3(input2)[key];
+function asOptionalNumber3(input, key, fallback) {
+  const value = asRecord3(input)[key];
   return typeof value === "number" && Number.isFinite(value) ? value : fallback;
 }
-function asOptionalBoolean(input2, key, fallback) {
-  const value = asRecord3(input2)[key];
+function asOptionalBoolean(input, key, fallback) {
+  const value = asRecord3(input)[key];
   if (typeof value === "boolean") return value;
   if (typeof value === "string") return /^(true|yes|1)$/i.test(value.trim());
   return fallback;
@@ -2075,38 +2670,38 @@ function inferTaskSignals(task, workspace) {
   return { platforms: [...platforms].sort(), domains: [...domains].sort() };
 }
 function recommendedVerificationCommands(files, packageScripts, signals) {
-  const commands = /* @__PURE__ */ new Set();
+  const commands2 = /* @__PURE__ */ new Set();
   const hasExplicitPlatformSignal = signals.platforms.length > 0;
   const hasScript = (name) => Object.prototype.hasOwnProperty.call(packageScripts, name);
-  if (hasScript("prisma:generate")) commands.add("npm run prisma:generate");
-  if (hasScript("typecheck")) commands.add("npm run typecheck");
-  if (hasScript("test")) commands.add("npm test");
-  if (hasScript("lint")) commands.add("npm run lint");
-  if (hasScript("build")) commands.add("npm run build");
+  if (hasScript("prisma:generate")) commands2.add("npm run prisma:generate");
+  if (hasScript("typecheck")) commands2.add("npm run typecheck");
+  if (hasScript("test")) commands2.add("npm test");
+  if (hasScript("lint")) commands2.add("npm run lint");
+  if (hasScript("build")) commands2.add("npm run build");
   const text2 = files.join("\n").toLowerCase();
   if (signals.platforms.includes("android") || !hasExplicitPlatformSignal && /gradlew|settings\.gradle|androidmanifest\.xml/.test(text2)) {
-    commands.add("./gradlew test --no-daemon");
-    commands.add("./gradlew assembleDebug --no-daemon");
-    if (/ktlint/.test(text2)) commands.add("./gradlew ktlintCheck --no-daemon");
+    commands2.add("./gradlew test --no-daemon");
+    commands2.add("./gradlew assembleDebug --no-daemon");
+    if (/ktlint/.test(text2)) commands2.add("./gradlew ktlintCheck --no-daemon");
   }
   if (signals.platforms.includes("ios") || signals.platforms.includes("macos") || !hasExplicitPlatformSignal && /\.xcodeproj|\.xcworkspace/.test(text2)) {
-    commands.add("xcodebuild -list");
+    commands2.add("xcodebuild -list");
   }
   if (signals.platforms.includes("script")) {
     if (/cargo\.toml/.test(text2)) {
-      commands.add("cargo build --release");
-      commands.add("cargo test");
+      commands2.add("cargo build --release");
+      commands2.add("cargo test");
     }
     if (/pyproject\.toml|setup\.py/.test(text2)) {
-      commands.add("python -m pytest");
-      commands.add("python -m build");
+      commands2.add("python -m pytest");
+      commands2.add("python -m build");
     }
     if (/go\.mod/.test(text2)) {
-      commands.add("go build ./...");
-      commands.add("go test ./...");
+      commands2.add("go build ./...");
+      commands2.add("go test ./...");
     }
   }
-  return [...commands];
+  return [...commands2];
 }
 function capabilityPacksForSignals(signals) {
   const packs = [];
@@ -2215,16 +2810,16 @@ async function findArtifactsForSignals(params) {
   }
   return merged;
 }
-async function buildTaskBrief(input2) {
-  const maxArtifacts = Math.min(input2.maxArtifacts ?? 12, 40);
-  const maxContextFiles = Math.min(input2.maxContextFiles ?? 16, 50);
-  const files = await collectFiles(input2.workspace, 1e3);
-  const packageScripts = await readPackageScripts(input2.workspace);
-  const signals = inferTaskSignals(input2.task, input2.workspace);
+async function buildTaskBrief(input) {
+  const maxArtifacts = Math.min(input.maxArtifacts ?? 12, 40);
+  const maxContextFiles = Math.min(input.maxContextFiles ?? 16, 50);
+  const files = await collectFiles(input.workspace, 1e3);
+  const packageScripts = await readPackageScripts(input.workspace);
+  const signals = inferTaskSignals(input.task, input.workspace);
   const contextFiles = files.filter((file) => !file.endsWith("/")).map((file) => ({ path: file, role: classifyContextFile(file) })).filter((file) => Boolean(file.role)).slice(0, maxContextFiles);
-  const artifactQuery = [input2.task, signals.platforms.join(" "), signals.domains.join(" ")].filter(Boolean).join(" ");
+  const artifactQuery = [input.task, signals.platforms.join(" "), signals.domains.join(" ")].filter(Boolean).join(" ");
   const artifacts = await findArtifactsForSignals({
-    workspace: input2.workspace,
+    workspace: input.workspace,
     query: artifactQuery,
     signals,
     maxResults: maxArtifacts
@@ -2243,7 +2838,7 @@ async function buildTaskBrief(input2) {
     "scan_secrets"
   ].filter((value) => typeof value === "string");
   return {
-    task: input2.task,
+    task: input.task,
     signals,
     contextFiles,
     artifacts,
@@ -2277,13 +2872,13 @@ var inspectProjectContextTool = {
       }
     }
   },
-  async run(input2, context) {
-    const record = asRecord3(input2);
+  async run(input, context) {
+    const record = asRecord3(input);
     const root = resolveOptionalWorkspacePath(context, asOptionalString3(record, "path"));
     const rootRel = normalizePath2(relative3(context.workspace, root)) || ".";
-    const includeExcerpts = asOptionalBoolean(input2, "includeExcerpts", true);
-    const maxFiles = Math.min(asOptionalNumber3(input2, "maxFiles", 500), 2e3);
-    const maxExcerptChars = Math.min(asOptionalNumber3(input2, "maxExcerptChars", 900), 4e3);
+    const includeExcerpts = asOptionalBoolean(input, "includeExcerpts", true);
+    const maxFiles = Math.min(asOptionalNumber3(input, "maxFiles", 500), 2e3);
+    const maxExcerptChars = Math.min(asOptionalNumber3(input, "maxExcerptChars", 900), 4e3);
     const files = await collectFiles(root, maxFiles);
     const platforms = detectPlatforms(files);
     const packageScripts = await readPackageScripts(root);
@@ -2351,11 +2946,11 @@ var findReusableArtifactsTool = {
       }
     }
   },
-  async run(input2, context) {
-    const query = asOptionalString3(input2, "query") ?? "";
-    const platform = asOptionalString3(input2, "platform");
-    const maxResults = Math.min(asOptionalNumber3(input2, "maxResults", 12), 50);
-    const artifactRoot = asOptionalString3(input2, "artifactRoot");
+  async run(input, context) {
+    const query = asOptionalString3(input, "query") ?? "";
+    const platform = asOptionalString3(input, "platform");
+    const maxResults = Math.min(asOptionalNumber3(input, "maxResults", 12), 50);
+    const artifactRoot = asOptionalString3(input, "artifactRoot");
     const artifacts = await findArtifacts({
       workspace: context.workspace,
       query,
@@ -2395,13 +2990,13 @@ var buildTaskBriefTool = {
       }
     }
   },
-  async run(input2, context) {
-    const task = asString3(input2, "task");
+  async run(input, context) {
+    const task = asString3(input, "task");
     const brief = await buildTaskBrief({
       workspace: context.workspace,
       task,
-      maxArtifacts: Math.min(asOptionalNumber3(input2, "maxArtifacts", 12), 40),
-      maxContextFiles: Math.min(asOptionalNumber3(input2, "maxContextFiles", 16), 50)
+      maxArtifacts: Math.min(asOptionalNumber3(input, "maxArtifacts", 12), 40),
+      maxContextFiles: Math.min(asOptionalNumber3(input, "maxContextFiles", 16), 50)
     });
     return {
       ok: true,
@@ -2513,13 +3108,13 @@ function scoreNote(relPath, title, markdown, queryTerms) {
 function safeMaterializedPath(relPath) {
   return normalizePath3(relPath).replace(/^\.+\/?/, "").replace(/[^A-Za-z0-9._/-]/g, "_").replace(/\/+/g, "/");
 }
-async function searchObsidianNotes(input2) {
-  const vault = resolve5(input2.vaultPath);
+async function searchObsidianNotes(input) {
+  const vault = resolve5(input.vaultPath);
   if (!existsSync6(vault)) return [];
-  const queryTerms = terms(input2.query);
-  const maxResults = Math.min(input2.maxResults ?? 5, 20);
-  const maxFiles = Math.min(input2.maxFiles ?? 1e3, 5e3);
-  const maxExcerptChars = Math.min(input2.maxExcerptChars ?? 1800, 8e3);
+  const queryTerms = terms(input.query);
+  const maxResults = Math.min(input.maxResults ?? 5, 20);
+  const maxFiles = Math.min(input.maxFiles ?? 1e3, 5e3);
+  const maxExcerptChars = Math.min(input.maxExcerptChars ?? 1800, 8e3);
   const files = await collectMarkdownFiles(vault, maxFiles);
   const results = [];
   for (const file of files) {
@@ -2545,13 +3140,13 @@ async function searchObsidianNotes(input2) {
   }
   return results.sort((a, b) => b.score - a.score || String(b.modifiedAt ?? "").localeCompare(String(a.modifiedAt ?? "")) || a.path.localeCompare(b.path)).slice(0, maxResults);
 }
-async function materializeObsidianContext(input2) {
+async function materializeObsidianContext(input) {
   const notes = await searchObsidianNotes({
-    vaultPath: input2.vaultPath,
-    query: input2.query,
-    maxResults: input2.maxResults ?? 5
+    vaultPath: input.vaultPath,
+    query: input.query,
+    maxResults: input.maxResults ?? 5
   });
-  const contextRoot = resolve5(input2.workspace, ".tania", "context", "obsidian");
+  const contextRoot = resolve5(input.workspace, ".tania", "context", "obsidian");
   const contextFiles = [];
   for (const note of notes) {
     const targetRel = safeMaterializedPath(note.path);
@@ -2584,7 +3179,7 @@ async function materializeObsidianContext(input2) {
     await mkdir3(contextRoot, { recursive: true });
     await writeFile3(
       resolve5(contextRoot, "manifest.json"),
-      JSON.stringify({ generatedAt: (/* @__PURE__ */ new Date()).toISOString(), query: input2.query, notes }, null, 2),
+      JSON.stringify({ generatedAt: (/* @__PURE__ */ new Date()).toISOString(), query: input.query, notes }, null, 2),
       "utf8"
     );
   }
@@ -2592,19 +3187,19 @@ async function materializeObsidianContext(input2) {
 }
 
 // src/tools/obsidianTools.ts
-function asRecord4(input2) {
-  return input2 && typeof input2 === "object" ? input2 : {};
+function asRecord4(input) {
+  return input && typeof input === "object" ? input : {};
 }
-function asOptionalString4(input2, key) {
-  const value = asRecord4(input2)[key];
+function asOptionalString4(input, key) {
+  const value = asRecord4(input)[key];
   return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
-function asOptionalNumber4(input2, key, fallback) {
-  const value = asRecord4(input2)[key];
+function asOptionalNumber4(input, key, fallback) {
+  const value = asRecord4(input)[key];
   return typeof value === "number" && Number.isFinite(value) ? value : fallback;
 }
-function asOptionalBoolean2(input2, key, fallback) {
-  const value = asRecord4(input2)[key];
+function asOptionalBoolean2(input, key, fallback) {
+  const value = asRecord4(input)[key];
   if (typeof value === "boolean") return value;
   if (typeof value === "string") return /^(true|yes|1)$/i.test(value.trim());
   return fallback;
@@ -2629,8 +3224,8 @@ var searchObsidianNotesTool = {
       }
     }
   },
-  async run(input2, context) {
-    const query = asOptionalString4(input2, "query");
+  async run(input, context) {
+    const query = asOptionalString4(input, "query");
     if (!query) throw new Error("Missing string field: query");
     const vaultPath = envValue({}, "TANYA_OBSIDIAN_VAULT").trim();
     if (!vaultPath) {
@@ -2640,8 +3235,8 @@ var searchObsidianNotesTool = {
         output: { notes: [], guidance: "Set TANYA_OBSIDIAN_VAULT to enable generic note retrieval." }
       };
     }
-    const maxResults = Math.min(asOptionalNumber4(input2, "maxResults", 5), 20);
-    if (asOptionalBoolean2(input2, "materialize", false)) {
+    const maxResults = Math.min(asOptionalNumber4(input, "maxResults", 5), 20);
+    if (asOptionalBoolean2(input, "materialize", false)) {
       const materialized = await materializeObsidianContext({
         workspace: context.workspace,
         vaultPath,
@@ -2679,24 +3274,24 @@ function localPropertiesWriteError() {
     error: "local.properties is machine-local Android SDK configuration. Do not create or modify it; use ANDROID_HOME or ANDROID_SDK_ROOT for verification instead."
   };
 }
-function asRecord5(input2) {
-  return input2 && typeof input2 === "object" ? input2 : {};
+function asRecord5(input) {
+  return input && typeof input === "object" ? input : {};
 }
-function asString4(input2, key) {
-  const value = asRecord5(input2)[key];
+function asString4(input, key) {
+  const value = asRecord5(input)[key];
   if (typeof value !== "string" || !value.trim()) throw new Error(`Missing string field: ${key}`);
   return value;
 }
-function asOptionalNumber5(input2, key, fallback) {
-  const value = asRecord5(input2)[key];
+function asOptionalNumber5(input, key, fallback) {
+  const value = asRecord5(input)[key];
   return typeof value === "number" && Number.isFinite(value) ? value : fallback;
 }
-function asOptionalString5(input2, key) {
-  const value = asRecord5(input2)[key];
+function asOptionalString5(input, key) {
+  const value = asRecord5(input)[key];
   return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
-function asOptionalBoolean3(input2, key, fallback) {
-  const value = asRecord5(input2)[key];
+function asOptionalBoolean3(input, key, fallback) {
+  const value = asRecord5(input)[key];
   if (typeof value === "boolean") return value;
   if (typeof value === "string") return /^(true|yes|1)$/i.test(value.trim());
   return fallback;
@@ -2738,15 +3333,15 @@ function runProcess(command, args, context, timeoutMs, cwd = context.workspace)
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      const output2 = `${stdout}${stderr ? `
+      const output = `${stdout}${stderr ? `
 ${stderr}` : ""}`.trim();
-      const displayOutput = summarizeProcessOutput(output2, 12e3);
+      const displayOutput = summarizeProcessOutput(output, 12e3);
       const baseResult = {
         ok: code === 0,
-        summary: buildProcessSummary("Command", code, output2, displayOutput.truncated),
+        summary: buildProcessSummary("Command", code, output, displayOutput.truncated),
         output: displayOutput.text
       };
-      resolve13(code === 0 ? baseResult : { ...baseResult, error: output2.slice(0, 2e3) });
+      resolve13(code === 0 ? baseResult : { ...baseResult, error: output.slice(0, 2e3) });
     });
     child.on("error", (err) => {
       clearTimeout(timer);
@@ -2851,9 +3446,9 @@ ${stderr}` : ""}`.trim();
     });
     child.on("close", (code) => {
       cleanupShell();
-      const output2 = outputSoFar();
+      const output = outputSoFar();
       if (cancelled || context.signal?.aborted) {
-        const partialOutput = summarizeProcessOutput(output2, 16e3).text;
+        const partialOutput = summarizeProcessOutput(output, 16e3).text;
         resolve13({
           ok: false,
           summary: "Shell cancelled by user. Partial output captured.",
@@ -2864,13 +3459,13 @@ ${stderr}` : ""}`.trim();
         });
         return;
       }
-      const displayOutput = summarizeProcessOutput(output2, 16e3);
+      const displayOutput = summarizeProcessOutput(output, 16e3);
       const baseResult = {
         ok: code === 0,
-        summary: buildProcessSummary("Shell", code, output2, displayOutput.truncated),
+        summary: buildProcessSummary("Shell", code, output, displayOutput.truncated),
         output: displayOutput.text
       };
-      resolve13(code === 0 ? baseResult : { ...baseResult, error: output2.slice(0, 2e3) });
+      resolve13(code === 0 ? baseResult : { ...baseResult, error: output.slice(0, 2e3) });
     });
     child.on("error", (err) => {
       cleanupShell();
@@ -2900,28 +3495,28 @@ function unsafeHostPackageMutation(script) {
   }
   return null;
 }
-function summarizeProcessOutput(output2, maxChars) {
-  if (output2.length <= maxChars) return { text: output2, truncated: false };
+function summarizeProcessOutput(output, maxChars) {
+  if (output.length <= maxChars) return { text: output, truncated: false };
   const headSize = Math.floor(maxChars * 0.35);
   const tailSize = maxChars - headSize - 120;
   return {
-    text: `${output2.slice(0, headSize)}
+    text: `${output.slice(0, headSize)}
 
 [output truncated: showing head and tail; exit code remains authoritative]
 
-${output2.slice(-tailSize)}`,
+${output.slice(-tailSize)}`,
     truncated: true
   };
 }
-function buildProcessSummary(kind, code, output2, truncated) {
+function buildProcessSummary(kind, code, output, truncated) {
   const exit = code ?? "unknown";
-  const successHint = code === 0 && /BUILD SUCCEEDED|Test Suite '.+' passed|0 failures|Process completed successfully/i.test(output2) ? " Success marker found." : "";
+  const successHint = code === 0 && /BUILD SUCCEEDED|Test Suite '.+' passed|0 failures|Process completed successfully/i.test(output) ? " Success marker found." : "";
   const truncatedHint = truncated ? " Output was truncated for display, but the exit code is authoritative." : "";
   return `${kind} exited ${exit}.${successHint}${truncatedHint}`;
 }
-function filterTypeScriptErrorOutput(output2) {
-  if (typeof output2 !== "string" || !output2.trim()) return null;
-  const lines = output2.split(/\r?\n/);
+function filterTypeScriptErrorOutput(output) {
+  if (typeof output !== "string" || !output.trim()) return null;
+  const lines = output.split(/\r?\n/);
   const kept = [];
   const errorPattern = /^[^:]+\.tsx?:\d+:\d+\s+-\s+error\s+TS\d+:/;
   for (let i = 0; i < lines.length; i += 1) {
@@ -2961,7 +3556,7 @@ function resolveToolCwd(context, cwdInput) {
   if (!cwdInput) return context.workspace;
   return isAbsolute2(cwdInput) ? resolveInsideWorkspace(context.workspace, cwdInput) : resolveInsideWorkspace(context.workspace, ensureRelativePath3(cwdInput));
 }
-function runProcessWithInput(command, args, input2, context, timeoutMs) {
+function runProcessWithInput(command, args, input, context, timeoutMs) {
   return new Promise((resolve13) => {
     const child = spawn2(command, args, {
       cwd: context.workspace,
@@ -2981,20 +3576,20 @@ function runProcessWithInput(command, args, input2, context, timeoutMs) {
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      const output2 = `${stdout}${stderr ? `
+      const output = `${stdout}${stderr ? `
 ${stderr}` : ""}`.trim();
       const baseResult = {
         ok: code === 0,
         summary: `Command exited ${code ?? "unknown"}.`,
-        output: output2.slice(0, 12e3)
+        output: output.slice(0, 12e3)
       };
-      resolve13(code === 0 ? baseResult : { ...baseResult, error: output2.slice(0, 2e3) });
+      resolve13(code === 0 ? baseResult : { ...baseResult, error: output.slice(0, 2e3) });
     });
     child.on("error", (err) => {
       clearTimeout(timer);
       resolve13({ ok: false, summary: "Command failed to start.", error: err.message });
     });
-    child.stdin.end(input2);
+    child.stdin.end(input);
   });
 }
 function stripPatchPath(path, stripLevel) {
@@ -3051,9 +3646,9 @@ var listFilesTool = {
       }
     }
   },
-  async run(input2, context) {
-    const maxFiles = Math.min(asOptionalNumber5(input2, "maxFiles", 120), 500);
-    const path = asOptionalString5(input2, "path");
+  async run(input, context) {
+    const maxFiles = Math.min(asOptionalNumber5(input, "maxFiles", 120), 500);
+    const path = asOptionalString5(input, "path");
     const root = path ? resolveInsideWorkspace(context.workspace, ensureRelativePath3(path)) : context.workspace;
     const files = collectFiles2(root, maxFiles).map((file) => path ? `${path.replace(/\/+$/, "")}/${file}` : file);
     return { ok: true, summary: `Listed ${files.length} file${files.length === 1 ? "" : "s"}.`, output: files };
@@ -3078,9 +3673,9 @@ var readFileTool = {
       }
     }
   },
-  async run(input2, context) {
-    const path = asString4(input2, "path");
-    const maxChars = Math.min(asOptionalNumber5(input2, "maxChars", 12e3), 4e4);
+  async run(input, context) {
+    const path = asString4(input, "path");
+    const maxChars = Math.min(asOptionalNumber5(input, "maxChars", 12e3), 4e4);
     const abs = resolveInsideWorkspace(context.workspace, path);
     const content = await readFile4(abs, "utf8");
     return {
@@ -3110,9 +3705,9 @@ var writeFileTool = {
       }
     }
   },
-  async run(input2, context) {
-    const path = asString4(input2, "path");
-    const content = asString4(input2, "content");
+  async run(input, context) {
+    const path = asString4(input, "path");
+    const content = asString4(input, "content");
     if (isProtectedLocalConfigPath(path)) return localPropertiesWriteError();
     const abs = resolveInsideWorkspace(context.workspace, path);
     await mkdir4(dirname6(abs), { recursive: true });
@@ -3147,9 +3742,9 @@ var searchTool = {
       }
     }
   },
-  async run(input2, context) {
-    const query = asString4(input2, "query");
-    const maxResults = Math.min(asOptionalNumber5(input2, "maxResults", 80), 300);
+  async run(input, context) {
+    const query = asString4(input, "query");
+    const maxResults = Math.min(asOptionalNumber5(input, "maxResults", 80), 300);
     const result = await runProcess("rg", ["-n", "--hidden", "-g", "!node_modules", "-g", "!.git", query], context, 2e4);
     if (!result.ok && typeof result.output === "string" && !result.output) {
       return { ok: true, summary: "No matches.", output: [] };
@@ -3179,13 +3774,13 @@ var runCommandTool = {
       }
     }
   },
-  async run(input2, context) {
-    const command = asString4(input2, "command");
-    const rawArgs = asRecord5(input2).args;
+  async run(input, context) {
+    const command = asString4(input, "command");
+    const rawArgs = asRecord5(input).args;
     const args = Array.isArray(rawArgs) ? rawArgs.filter((arg) => typeof arg === "string") : [];
-    const cwdInput = asOptionalString5(input2, "cwd");
+    const cwdInput = asOptionalString5(input, "cwd");
     const cwd = resolveToolCwd(context, cwdInput);
-    const timeoutMs = Math.min(asOptionalNumber5(input2, "timeoutMs", 12e4), 3e5);
+    const timeoutMs = Math.min(asOptionalNumber5(input, "timeoutMs", 12e4), 3e5);
     const result = await runProcess(command, args, context, timeoutMs, cwd);
     return maybeFilterTypeScriptErrorResult(result, commandRunsTypeScript(command, args));
   }
@@ -3211,8 +3806,8 @@ var runShellTool = {
       }
     }
   },
-  async run(input2, context) {
-    const script = asOptionalString5(input2, "script") ?? asString4(input2, "command");
+  async run(input, context) {
+    const script = asOptionalString5(input, "script") ?? asString4(input, "command");
     if (/\b(rm\s+-rf|sudo|ssh|scp|curl\s+[^|>]*\|\s*(?:sh|bash|zsh)|while\s+true|tail\s+-f)\b/.test(script)) {
       return { ok: false, summary: "Shell script rejected by safety checks.", error: "Use bounded, non-destructive, non-interactive commands only." };
     }
@@ -3230,9 +3825,9 @@ var runShellTool = {
     if (/(?:>\s*["']?[^&|;\n]*local\.properties\b|tee\s+[^|;\n]*local\.properties\b)/.test(script)) {
       return localPropertiesWriteError();
     }
-    const cwdInput = asOptionalString5(input2, "cwd");
+    const cwdInput = asOptionalString5(input, "cwd");
     const cwd = resolveToolCwd(context, cwdInput);
-    const timeoutMs = Math.min(asOptionalNumber5(input2, "timeoutMs", 12e4), 3e5);
+    const timeoutMs = Math.min(asOptionalNumber5(input, "timeoutMs", 12e4), 3e5);
     const result = await runShell(script, context, timeoutMs, cwd);
     return maybeFilterTypeScriptErrorResult(result, shellRunsTypeScript(script));
   }
@@ -3256,9 +3851,9 @@ var applyPatchTool = {
       }
     }
   },
-  async run(input2, context) {
-    const patch = asString4(input2, "patch");
-    const explicitStrip = asOptionalNumber5(input2, "stripLevel", Number.NaN);
+  async run(input, context) {
+    const patch = asString4(input, "patch");
+    const explicitStrip = asOptionalNumber5(input, "stripLevel", Number.NaN);
     const stripLevel = Number.isFinite(explicitStrip) ? explicitStrip : inferPatchStripLevel(patch);
     const files = extractPatchFiles(patch, stripLevel);
     if (files.length === 0) {
@@ -3280,7 +3875,7 @@ var applyPatchTool = {
       context,
       6e4
     );
-    const output2 = typeof result.output === "string" ? result.output : "";
+    const output = typeof result.output === "string" ? result.output : "";
     if (!result.ok) {
       return {
         ...result,
@@ -3293,7 +3888,7 @@ var applyPatchTool = {
     return {
       ok: true,
       summary: `Applied patch to ${files.length} file${files.length === 1 ? "" : "s"}.${backupNote}`,
-      output: output2,
+      output,
       files
     };
   }
@@ -3319,12 +3914,12 @@ var searchReplaceTool = {
       }
     }
   },
-  async run(input2, context) {
-    const path = asString4(input2, "path");
-    const oldString = asString4(input2, "old_string");
-    const newString = asRecord5(input2).new_string;
+  async run(input, context) {
+    const path = asString4(input, "path");
+    const oldString = asString4(input, "old_string");
+    const newString = asRecord5(input).new_string;
     if (typeof newString !== "string") throw new Error("Missing string field: new_string");
-    const expectedCount = asOptionalNumber5(input2, "expected_count", 1);
+    const expectedCount = asOptionalNumber5(input, "expected_count", 1);
     if (isProtectedLocalConfigPath(path)) return localPropertiesWriteError();
     let abs;
     try {
@@ -3383,10 +3978,10 @@ var copyFileTool = {
       }
     }
   },
-  async run(input2, context) {
-    const source = ensureRelativePath3(asString4(input2, "source"));
-    const destination = ensureRelativePath3(asString4(input2, "destination"));
-    const overwrite = asRecord5(input2).overwrite !== false;
+  async run(input, context) {
+    const source = ensureRelativePath3(asString4(input, "source"));
+    const destination = ensureRelativePath3(asString4(input, "destination"));
+    const overwrite = asRecord5(input).overwrite !== false;
     const sourceAbs = resolveInsideWorkspace(context.workspace, source);
     const destinationAbs = resolveInsideWorkspace(context.workspace, destination);
     await mkdir4(dirname6(destinationAbs), { recursive: true });
@@ -3414,10 +4009,10 @@ var copyDirTool = {
       }
     }
   },
-  async run(input2, context) {
-    const source = ensureRelativePath3(asString4(input2, "source"));
-    const destination = ensureRelativePath3(asString4(input2, "destination"));
-    const overwrite = asRecord5(input2).overwrite !== false;
+  async run(input, context) {
+    const source = ensureRelativePath3(asString4(input, "source"));
+    const destination = ensureRelativePath3(asString4(input, "destination"));
+    const overwrite = asRecord5(input).overwrite !== false;
     const sourceAbs = resolveInsideWorkspace(context.workspace, source);
     const destinationAbs = resolveInsideWorkspace(context.workspace, destination);
     await cp(sourceAbs, destinationAbs, { recursive: true, force: overwrite, errorOnExist: !overwrite });
@@ -3448,9 +4043,9 @@ var validateApiContractRoutesTool = {
       }
     }
   },
-  async run(input2, context) {
-    const source = ensureRelativePath3(asString4(input2, "source"));
-    const target = ensureRelativePath3(asString4(input2, "target"));
+  async run(input, context) {
+    const source = ensureRelativePath3(asString4(input, "source"));
+    const target = ensureRelativePath3(asString4(input, "target"));
     const sourceText = await readFile4(resolveInsideWorkspace(context.workspace, source), "utf8");
     const targetText = await readFile4(resolveInsideWorkspace(context.workspace, target), "utf8");
     const sourceRoutes = parseMarkdownApiRoutes(sourceText);
@@ -3494,14 +4089,14 @@ var validateAndroidProjectConfigTool = {
       }
     }
   },
-  async run(input2, context) {
-    const manifestPath = ensureRelativePath3(asString4(input2, "manifestPath"));
-    const gradlePath = ensureRelativePath3(asString4(input2, "gradlePath"));
-    const minCompileSdk = asOptionalNumber5(input2, "minCompileSdk", 35);
-    const minTargetSdk = asOptionalNumber5(input2, "minTargetSdk", 35);
-    const minSdk = asOptionalNumber5(input2, "minSdk", 26);
-    const expectedIcon = asOptionalString5(input2, "expectedIcon") ?? "@mipmap/ic_launcher";
-    const expectedRoundIcon = asOptionalString5(input2, "expectedRoundIcon") ?? "@mipmap/ic_launcher_round";
+  async run(input, context) {
+    const manifestPath = ensureRelativePath3(asString4(input, "manifestPath"));
+    const gradlePath = ensureRelativePath3(asString4(input, "gradlePath"));
+    const minCompileSdk = asOptionalNumber5(input, "minCompileSdk", 35);
+    const minTargetSdk = asOptionalNumber5(input, "minTargetSdk", 35);
+    const minSdk = asOptionalNumber5(input, "minSdk", 26);
+    const expectedIcon = asOptionalString5(input, "expectedIcon") ?? "@mipmap/ic_launcher";
+    const expectedRoundIcon = asOptionalString5(input, "expectedRoundIcon") ?? "@mipmap/ic_launcher_round";
     const manifest = await readFile4(resolveInsideWorkspace(context.workspace, manifestPath), "utf8");
     const gradle = await readFile4(resolveInsideWorkspace(context.workspace, gradlePath), "utf8");
     const problems = [];
@@ -3544,9 +4139,9 @@ var validateAppleProjectFilesTool = {
       }
     }
   },
-  async run(input2, context) {
-    const record = asRecord5(input2);
-    const xcodeprojPath = asOptionalString5(input2, "xcodeprojPath");
+  async run(input, context) {
+    const record = asRecord5(input);
+    const xcodeprojPath = asOptionalString5(input, "xcodeprojPath");
     const requiredPaths = Array.isArray(record.requiredPaths) ? record.requiredPaths.filter((value) => typeof value === "string" && value.trim().length > 0) : [];
     const requireProjectReferences = record.requireProjectReferences === true;
     const problems = [];
@@ -3566,8 +4161,8 @@ var validateAppleProjectFilesTool = {
         problems.push(`Missing ${relPath}.`);
       }
       if (requireProjectReferences && pbxprojText) {
-        const basename4 = relPath.split("/").filter(Boolean).pop() ?? relPath;
-        if (!pbxprojText.includes(basename4)) problems.push(`project.pbxproj does not reference ${basename4}.`);
+        const basename5 = relPath.split("/").filter(Boolean).pop() ?? relPath;
+        if (!pbxprojText.includes(basename5)) problems.push(`project.pbxproj does not reference ${basename5}.`);
       }
     }
     return {
@@ -3599,9 +4194,9 @@ var validateFastlaneConfigTool = {
       }
     }
   },
-  async run(input2, context) {
-    const record = asRecord5(input2);
-    const fastfilePath = asOptionalString5(input2, "fastfilePath") ?? "fastlane/Fastfile";
+  async run(input, context) {
+    const record = asRecord5(input);
+    const fastfilePath = asOptionalString5(input, "fastfilePath") ?? "fastlane/Fastfile";
     const requiredLanes = Array.isArray(record.requiredLanes) ? record.requiredLanes.filter((value) => typeof value === "string" && value.trim().length > 0).map((value) => value.trim()) : [];
     const requiredFiles = Array.isArray(record.requiredFiles) ? record.requiredFiles.filter((value) => typeof value === "string" && value.trim().length > 0).map((value) => value.trim()) : [];
     const forbiddenFiles = Array.isArray(record.forbiddenFiles) ? record.forbiddenFiles.filter((value) => typeof value === "string" && value.trim().length > 0).map((value) => value.trim()) : [];
@@ -3681,9 +4276,9 @@ var validatePrismaSchemaTool = {
       }
     }
   },
-  async run(input2, context) {
-    const record = asRecord5(input2);
-    const schemaPath = ensureRelativePath3(asOptionalString5(input2, "schemaPath") ?? "prisma/schema.prisma");
+  async run(input, context) {
+    const record = asRecord5(input);
+    const schemaPath = ensureRelativePath3(asOptionalString5(input, "schemaPath") ?? "prisma/schema.prisma");
     const requiredModels = Array.isArray(record.requiredModels) ? record.requiredModels.filter((value) => typeof value === "string" && value.trim().length > 0) : [];
     const forbiddenModels = Array.isArray(record.forbiddenModels) ? record.forbiddenModels.filter((value) => typeof value === "string" && value.trim().length > 0) : [];
     const schema = await readFile4(resolveInsideWorkspace(context.workspace, schemaPath), "utf8");
@@ -3722,11 +4317,11 @@ var applyArtifactTool = {
       }
     }
   },
-  async run(input2, context) {
-    const artifactPath = ensureRelativePath3(asString4(input2, "artifactPath"));
-    const targetPath = ensureRelativePath3(asString4(input2, "targetPath"));
+  async run(input, context) {
+    const artifactPath = ensureRelativePath3(asString4(input, "artifactPath"));
+    const targetPath = ensureRelativePath3(asString4(input, "targetPath"));
     if (isProtectedLocalConfigPath(targetPath)) return localPropertiesWriteError();
-    const overwrite = asRecord5(input2).overwrite !== false;
+    const overwrite = asRecord5(input).overwrite !== false;
     const sourceAbs = resolveInsideWorkspace(context.workspace, artifactPath);
     const targetAbs = resolveInsideWorkspace(context.workspace, targetPath);
     await mkdir4(dirname6(targetAbs), { recursive: true });
@@ -3802,13 +4397,13 @@ var createIosSplashTool = {
       }
     }
   },
-  async run(input2, context) {
-    const viewPath = ensureRelativePath3(asString4(input2, "viewPath"));
-    const assetSetDir = (asOptionalString5(input2, "assetSetDir") ?? inferIosSplashAssetSetDir(viewPath)).replace(/\/+$/, "");
-    const sourceIcon = asOptionalString5(input2, "sourceIcon");
-    const appName = asOptionalString5(input2, "appName") ?? "App";
-    const brandHex = asOptionalString5(input2, "brandHex") ?? "#000000";
-    const durationMs = Math.max(0, Math.round(asOptionalNumber5(input2, "durationMs", 1200)));
+  async run(input, context) {
+    const viewPath = ensureRelativePath3(asString4(input, "viewPath"));
+    const assetSetDir = (asOptionalString5(input, "assetSetDir") ?? inferIosSplashAssetSetDir(viewPath)).replace(/\/+$/, "");
+    const sourceIcon = asOptionalString5(input, "sourceIcon");
+    const appName = asOptionalString5(input, "appName") ?? "App";
+    const brandHex = asOptionalString5(input, "brandHex") ?? "#000000";
+    const durationMs = Math.max(0, Math.round(asOptionalNumber5(input, "durationMs", 1200)));
     const durationNs = durationMs * 1e6;
     const rgb = brandHex.replace("#", "").match(/.{1,2}/g)?.slice(0, 3).map((part) => Number.parseInt(part, 16)) ?? [0, 0, 0];
     const view = [
@@ -3909,12 +4504,12 @@ var createAndroidSplashTool = {
       }
     }
   },
-  async run(input2, context) {
-    const resDir = ensureRelativePath3(asString4(input2, "resDir")).replace(/\/+$/, "");
-    const sourceIcon = asOptionalString5(input2, "sourceIcon");
-    const brandHex = asOptionalString5(input2, "brandHex") ?? "#000000";
-    const themeName = asOptionalString5(input2, "themeName") ?? "Theme.App.Starting";
-    const iconName = (asOptionalString5(input2, "iconName") ?? "ic_splash_logo").replace(/[^a-z0-9_]/gi, "_").toLowerCase();
+  async run(input, context) {
+    const resDir = ensureRelativePath3(asString4(input, "resDir")).replace(/\/+$/, "");
+    const sourceIcon = asOptionalString5(input, "sourceIcon");
+    const brandHex = asOptionalString5(input, "brandHex") ?? "#000000";
+    const themeName = asOptionalString5(input, "themeName") ?? "Theme.App.Starting";
+    const iconName = (asOptionalString5(input, "iconName") ?? "ic_splash_logo").replace(/[^a-z0-9_]/gi, "_").toLowerCase();
     const valuesPath = `${resDir}/values/splash_theme.xml`;
     const drawablePath = `${resDir}/drawable/${iconName}.png`;
     const xml = [
@@ -3964,12 +4559,12 @@ var generateAppIconsTool = {
       }
     }
   },
-  async run(input2, context) {
-    const source = ensureRelativePath3(asString4(input2, "source"));
-    const appleOutputDir = asOptionalString5(input2, "appleOutputDir");
-    const androidResDir = asOptionalString5(input2, "androidResDir");
-    const background = asOptionalString5(input2, "background") ?? "#ffffff";
-    const rawApplePlatforms = asRecord5(input2).applePlatforms;
+  async run(input, context) {
+    const source = ensureRelativePath3(asString4(input, "source"));
+    const appleOutputDir = asOptionalString5(input, "appleOutputDir");
+    const androidResDir = asOptionalString5(input, "androidResDir");
+    const background = asOptionalString5(input, "background") ?? "#ffffff";
+    const rawApplePlatforms = asRecord5(input).applePlatforms;
     const applePlatforms = Array.isArray(rawApplePlatforms) ? rawApplePlatforms.filter((item) => typeof item === "string" && item.trim().length > 0) : ["ios", "macos"];
     const files = [];
     const outputs = {};
@@ -3994,8 +4589,8 @@ var generateAppIconsTool = {
 function packageToDir(packageName) {
   return packageName.split(".").map((part) => part.replace(/[^A-Za-z0-9_]/g, "")).filter(Boolean).join("/");
 }
-function kotlinIdentifier(input2, fallback) {
-  const cleaned = input2.replace(/[^A-Za-z0-9_]/g, "").replace(/^[0-9]+/, "");
+function kotlinIdentifier(input, fallback) {
+  const cleaned = input.replace(/[^A-Za-z0-9_]/g, "").replace(/^[0-9]+/, "");
   return cleaned || fallback;
 }
 function addLineBeforeClosingPluginsBlock(gradle, line) {
@@ -4068,17 +4663,17 @@ var createAndroidFoundationTool = {
       }
     }
   },
-  async run(input2, context) {
-    const packageName = asString4(input2, "packageName").trim();
-    const appName = asOptionalString5(input2, "appName") ?? "App";
-    const sourceRoot = ensureRelativePath3(asOptionalString5(input2, "sourceRoot") ?? "app/src/main/java").replace(/\/+$/, "");
-    const rootGradlePath = ensureRelativePath3(asOptionalString5(input2, "rootGradlePath") ?? "build.gradle.kts");
-    const moduleGradlePath = ensureRelativePath3(asOptionalString5(input2, "moduleGradlePath") ?? "app/build.gradle.kts");
-    const brandPrimaryHex = (asOptionalString5(input2, "brandPrimaryHex") ?? "#A52A2A").replace(/^#?/, "0xFF");
-    const brandSecondaryHex = (asOptionalString5(input2, "brandSecondaryHex") ?? "#2D3748").replace(/^#?/, "0xFF");
-    const updateGradle = asOptionalBoolean3(input2, "updateGradle", true);
-    const overwriteExisting = asOptionalBoolean3(input2, "overwriteExisting", false);
-    const preserveExisting = overwriteExisting ? false : asOptionalBoolean3(input2, "preserveExisting", true);
+  async run(input, context) {
+    const packageName = asString4(input, "packageName").trim();
+    const appName = asOptionalString5(input, "appName") ?? "App";
+    const sourceRoot = ensureRelativePath3(asOptionalString5(input, "sourceRoot") ?? "app/src/main/java").replace(/\/+$/, "");
+    const rootGradlePath = ensureRelativePath3(asOptionalString5(input, "rootGradlePath") ?? "build.gradle.kts");
+    const moduleGradlePath = ensureRelativePath3(asOptionalString5(input, "moduleGradlePath") ?? "app/build.gradle.kts");
+    const brandPrimaryHex = (asOptionalString5(input, "brandPrimaryHex") ?? "#A52A2A").replace(/^#?/, "0xFF");
+    const brandSecondaryHex = (asOptionalString5(input, "brandSecondaryHex") ?? "#2D3748").replace(/^#?/, "0xFF");
+    const updateGradle = asOptionalBoolean3(input, "updateGradle", true);
+    const overwriteExisting = asOptionalBoolean3(input, "overwriteExisting", false);
+    const preserveExisting = overwriteExisting ? false : asOptionalBoolean3(input, "preserveExisting", true);
     const packageDir = packageToDir(packageName);
     if (!packageDir) return { ok: false, summary: "Invalid package name.", error: "packageName must contain at least one valid package segment." };
     const classPrefix = kotlinIdentifier(appName, "App");
@@ -4389,10 +4984,10 @@ var commitPlatformChangesTool = {
       }
     }
   },
-  async run(input2, context) {
-    const message = asString4(input2, "message");
-    const amend = asOptionalBoolean3(input2, "amend", false);
-    const record = asRecord5(input2);
+  async run(input, context) {
+    const message = asString4(input, "message");
+    const amend = asOptionalBoolean3(input, "amend", false);
+    const record = asRecord5(input);
     const rawPaths = Array.isArray(record.files) ? record.files : record.paths;
     const paths = Array.isArray(rawPaths) ? rawPaths.filter((path) => typeof path === "string" && path.trim().length > 0).map(ensureRelativePath3) : [];
     if (paths.length === 0) return { ok: false, summary: "No paths provided for commit.", error: "Provide at least one path to stage." };
@@ -4457,9 +5052,9 @@ var scanSecretsTool = {
       }
     }
   },
-  async run(input2, context) {
-    const scanPath = asOptionalString5(input2, "path");
-    const maxFiles = Math.min(asOptionalNumber5(input2, "maxFiles", 500), 2e3);
+  async run(input, context) {
+    const scanPath = asOptionalString5(input, "path");
+    const maxFiles = Math.min(asOptionalNumber5(input, "maxFiles", 500), 2e3);
     const root = scanPath ? resolveInsideWorkspace(context.workspace, ensureRelativePath3(scanPath)) : context.workspace;
     const files = collectFiles2(root, maxFiles);
     const findings = [];
@@ -4537,11 +5132,11 @@ var ToolRegistry = class {
   get(name) {
     return this.tools.get(name);
   }
-  run(tool, input2, context, options = {}) {
+  run(tool, input, context, options = {}) {
     const runContext = { ...context };
     if (options.onProgress) runContext.onProgress = options.onProgress;
     if (options.signal) runContext.signal = options.signal;
-    return tool.run(input2, runContext);
+    return tool.run(input, runContext);
   }
 };
 
@@ -5165,15 +5760,15 @@ function metadataBoolean(runContext, key) {
   const value = runContext?.metadata?.[key];
   return value === true || value === "true" || value === "yes";
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function metadataRecord(runContext, key) {
   const value = runContext?.metadata?.[key];
-  return isRecord2(value) ? value : void 0;
+  return isRecord3(value) ? value : void 0;
 }
 function recordArray2(value) {
-  return Array.isArray(value) ? value.filter(isRecord2) : [];
+  return Array.isArray(value) ? value.filter(isRecord3) : [];
 }
 function autoBriefRecords(runContext, key) {
   return recordArray2(metadataRecord(runContext, "autoBrief")?.[key]);
@@ -7200,14 +7795,14 @@ function normalizeVerificationCommand(line) {
   return line.replace(/^Verification:\s*/i, "").replace(/\s*->\s*(passed|failed|BUILD SUCCESSFUL|BUILD FAILED|blocked|.+)$/i, "").replace(/\s+2>&1\b/g, "").replace(/\s+/g, " ").trim();
 }
 function successfulVerificationCommands(text2) {
-  const commands = /* @__PURE__ */ new Set();
+  const commands2 = /* @__PURE__ */ new Set();
   for (const line of text2.split(/\r?\n/)) {
     if (!/^Verification:\s*/i.test(line)) continue;
     if (!/->\s*(passed|BUILD SUCCESSFUL)\b/i.test(line)) continue;
     const command = normalizeVerificationCommand(line);
-    if (command) commands.add(command);
+    if (command) commands2.add(command);
   }
-  return commands;
+  return commands2;
 }
 function hasSuccessfulVerification2(verificationLines, pattern) {
   return verificationLines.some((line) => /->\s*passed\b/i.test(line) && pattern.test(line));
@@ -7719,9 +8314,9 @@ ${content}`);
   for (const { path, content } of indexReads) {
     lines.push("", `### ${path}`, content.trim());
   }
-  const output2 = lines.join("\n");
-  return output2.length > 18e3 ? `${output2.slice(0, 17980)}
-[... truncated]` : output2;
+  const output = lines.join("\n");
+  return output.length > 18e3 ? `${output.slice(0, 17980)}
+[... truncated]` : output;
 }
 function runGit(workspace, args) {
   const result = spawnSync2("git", args, {
@@ -7846,8 +8441,8 @@ function buildExportMap(workspace) {
   if (totalExportingFiles > entries.length) {
     lines.push(`[... ${totalExportingFiles - entries.length} more files]`);
   }
-  let output2 = lines.join("\n");
-  if (output2.length <= 3e3) return output2;
+  let output = lines.join("\n");
+  if (output.length <= 3e3) return output;
   const truncatedLines = ["## Workspace export map"];
   let included = 0;
   for (const line of lines.slice(1)) {
@@ -7859,9 +8454,9 @@ function buildExportMap(workspace) {
   }
   const omitted = entries.length - included + Math.max(0, totalExportingFiles - entries.length);
   if (omitted > 0) truncatedLines.push(`[... ${omitted} more files]`);
-  output2 = truncatedLines.join("\n");
-  return output2.length > 3e3 ? `${output2.slice(0, 2980)}
-[... truncated]` : output2;
+  output = truncatedLines.join("\n");
+  return output.length > 3e3 ? `${output.slice(0, 2980)}
+[... truncated]` : output;
 }
 function detectVerificationSuggestions(workspace, projectTypes, packageScripts) {
   const suggestions = /* @__PURE__ */ new Set();
@@ -8469,6 +9064,7 @@ function loadSkillPacksFromRoot(ctx, skillsRoot) {
   return enforceBudget(matched).map((pack) => ({
     slug: pack.frontmatter.slug,
     title: pack.title,
+    sourcePath: join13(skillsRoot, `${pack.relativePath}.md`),
     content: pack.body,
     tokens: pack.tokens,
     reason: pack.reason
@@ -8478,6 +9074,19 @@ function loadSkillPacks(ctx) {
   return loadSkillPacksFromRoot(ctx, resolveDefaultSkillsRoot());
 }
 
+// src/skills/summary.ts
+function formatSkillPackSummary(packs) {
+  const totalTokens = packs.reduce((sum, pack) => sum + pack.tokens, 0);
+  const lines = [
+    `Skill packs loaded: ${packs.length}`,
+    "| slug | source | reason | tokens |",
+    "|------|--------|--------|--------|",
+    ...packs.map((pack) => `| ${pack.slug} | ${pack.sourcePath} | ${pack.reason} | ${pack.tokens} |`),
+    `Total pack tokens: ${totalTokens} / ${SKILL_PACK_TOKEN_BUDGET}`
+  ];
+  return lines.join("\n");
+}
+
 // src/agent/systemPrompt.ts
 function readProjectInstructions(workspace) {
   const path = join14(workspace, ".tania", "INSTRUCTIONS.md");
@@ -8584,25 +9193,6 @@ import { cp as cp2, mkdir as mkdir10, rm as rm2, stat as stat6 } from "fs/promis
 import { dirname as dirname12, isAbsolute as isAbsolute3, join as join15, relative as relative9, resolve as resolve9 } from "path";
 var CONTEXT_TOKEN_LIMIT = 48e3;
 var CONTEXT_SUMMARY_KEEP_RECENT = 6;
-function isMalformedToolArguments(value) {
-  return Boolean(value && typeof value === "object" && value.ok === false && typeof value.rawArguments === "string");
-}
-function previewRawToolArguments(raw) {
-  return raw.length > 500 ? `${raw.slice(0, 500)}...[truncated ${raw.length - 500} chars]` : raw;
-}
-function parseToolArguments(raw) {
-  if (!raw.trim()) return {};
-  try {
-    return JSON.parse(raw);
-  } catch {
-    const rawPreview = previewRawToolArguments(raw);
-    return {
-      ok: false,
-      error: `malformed tool arguments: ${rawPreview}`,
-      rawArguments: rawPreview
-    };
-  }
-}
 function findSafeCompressionBoundary(messages, desiredKeepCount) {
   if (messages.length <= desiredKeepCount + 1) return Math.max(1, messages.length - desiredKeepCount);
   let startIndex = messages.length - desiredKeepCount;
@@ -8624,10 +9214,10 @@ function fieldMatchesType(value, expectedType) {
   if (expectedType === "array") return Array.isArray(value);
   return typeof value === expectedType;
 }
-function validateToolInput(input2, definition) {
+function validateToolInput(input, definition) {
   const params = definition.function.parameters;
   if (!params) return null;
-  const record = input2 && typeof input2 === "object" ? input2 : {};
+  const record = input && typeof input === "object" ? input : {};
   for (const key of params.required ?? []) {
     if (!(key in record) || record[key] === void 0 || record[key] === null) {
       return `Missing required field: "${key}"`;
@@ -8706,6 +9296,7 @@ function logRunSummarySilently(params) {
         {
           ts,
           prompt: params.prompt.slice(0, 200),
+          provider: params.provider,
           model: params.model,
           durationMs: params.metrics.durationMs,
           promptTokens: params.metrics.promptTokens,
@@ -8853,8 +9444,8 @@ function repairAttemptSnapshot(attempt, manifest) {
     changedFileCount: manifest.changedFiles.length
   };
 }
-function commandLabel(toolName, input2) {
-  const record = input2 && typeof input2 === "object" ? input2 : {};
+function commandLabel(toolName, input) {
+  const record = input && typeof input === "object" ? input : {};
   if (toolName === "run_shell") {
     const script = typeof record.script === "string" ? record.script.trim() : typeof record.command === "string" ? record.command.trim() : "";
     return script || null;
@@ -8902,9 +9493,9 @@ function requiredHighLevelTool(runContext, prompt = "") {
   }
   return null;
 }
-function toolCallMayMutate(toolName, input2) {
+function toolCallMayMutate(toolName, input) {
   if (mutatingToolNames.has(toolName)) return true;
-  const record = input2 && typeof input2 === "object" ? input2 : {};
+  const record = input && typeof input === "object" ? input : {};
   if (toolName === "run_shell") {
     const script = typeof record.script === "string" ? record.script : "";
     return /\b(?:cat|printf|echo)\b[\s\S]{0,200}>\s*[^&|;\n]|\btee\s+[^|;\n]+|\b(?:mkdir|touch|rm|mv|cp)\s+|\bsed\s+-i\b|\bperl\s+-pi\b|\bktlintFormat\b/.test(script);
@@ -8931,27 +9522,27 @@ function verificationKey(label) {
   if (/\bgit\s+rev-parse\s+--short\s+HEAD\b/i.test(label)) return "git head";
   return label.replace(/\s+/g, " ").trim();
 }
-function artifactPathFromRead(toolName, input2) {
+function artifactPathFromRead(toolName, input) {
   if (toolName !== "read_file") return null;
-  const record = input2 && typeof input2 === "object" ? input2 : {};
+  const record = input && typeof input === "object" ? input : {};
   const path = typeof record.path === "string" ? record.path.trim() : "";
   if (!path) return null;
   if (path.startsWith(".tania/artifacts/")) return path;
   if (path.startsWith("artifacts/")) return path;
   return null;
 }
-function contextPathFromRead(toolName, input2, runContext) {
+function contextPathFromRead(toolName, input, runContext) {
   if (toolName !== "read_file") return null;
-  const record = input2 && typeof input2 === "object" ? input2 : {};
+  const record = input && typeof input === "object" ? input : {};
   const path = typeof record.path === "string" ? record.path.trim() : "";
   if (!path) return null;
   if (path.startsWith(".tania/context/")) return path;
   if ((runContext?.contextFiles ?? []).some((contextFile) => contextFile.path === path)) return path;
   return null;
 }
-function outsideWorkspaceReadMessage(workspace, toolName, input2) {
+function outsideWorkspaceReadMessage(workspace, toolName, input) {
   if (toolName !== "read_file") return null;
-  const record = input2 && typeof input2 === "object" ? input2 : {};
+  const record = input && typeof input === "object" ? input : {};
   const path = typeof record.path === "string" ? record.path.trim() : "";
   if (!path || !isAbsolute3(path)) return null;
   const target = resolve9(path);
@@ -9000,6 +9591,7 @@ async function runAgent(options) {
   let createdArtifactPaths = [];
   const requiredTool = requiredHighLevelTool(options.runContext, options.prompt);
   let requiredToolUsed = requiredTool ? false : true;
+  let toolCallCorrectionAttempts = 0;
   async function syncArtifactOutput() {
     const outputRootValue = options.runContext?.metadata?.artifactOutputRoot;
     if (typeof outputRootValue !== "string" || !outputRootValue.trim()) return [];
@@ -9045,6 +9637,7 @@ async function runAgent(options) {
     logRunSummarySilently({
       workspace,
       prompt: options.prompt,
+      provider: options.provider.id,
       model: options.provider.model,
       metrics,
       manifest: manifest2
@@ -9067,7 +9660,7 @@ async function runAgent(options) {
     }
     await options.sink({ type: "message_start" });
     let assistantText = "";
-    let toolCalls = [];
+    let rawToolCalls = [];
     const codingProviderOptions = isCodingTask(options.runContext) ? { temperature: 0, topP: 0.2 } : {};
     let providerAttempt = 0;
     const PROVIDER_TRANSIENT_RETRIES = 1;
@@ -9076,24 +9669,44 @@ async function runAgent(options) {
         for await (const delta of options.provider.streamChat({
           messages,
           tools: registry.list().map((tool) => tool.definition),
+          onProviderThrottle: (event) => {
+            void Promise.resolve(options.sink({
+              type: "provider_throttle",
+              provider: event.provider,
+              attempt: event.attempt,
+              waitMs: event.waitMs
+            })).catch(() => {
+            });
+          },
           ...codingProviderOptions
         })) {
           if (delta.usage) {
             totalPromptTokens += delta.usage.promptTokens;
             totalCompletionTokens += delta.usage.completionTokens;
           }
+          if (delta.schemaWarnings) {
+            for (const warning of delta.schemaWarnings) {
+              await options.sink({
+                type: "schema_flatten_warning",
+                reason: warning.reason,
+                path: warning.path,
+                provider: options.provider.id,
+                ...warning.tool ? { tool: warning.tool } : {}
+              });
+            }
+          }
           if (delta.content) {
             assistantText += delta.content;
             finalText += delta.content;
             await options.sink({ type: "message_delta", text: delta.content });
           }
-          if (delta.toolCalls?.length) toolCalls = delta.toolCalls;
+          if (delta.toolCalls?.length) rawToolCalls = delta.toolCalls;
         }
         break;
       } catch (err) {
         const message2 = err instanceof Error ? err.message : String(err);
         const isTransient = /timed out|fetch failed|ECONNRESET|EAI_AGAIN|ENOTFOUND|socket hang up/i.test(message2);
-        const noProgressYet = assistantText.length === 0 && toolCalls.length === 0;
+        const noProgressYet = assistantText.length === 0 && rawToolCalls.length === 0;
         if (isTransient && noProgressYet && providerAttempt < PROVIDER_TRANSIENT_RETRIES) {
           providerAttempt += 1;
           await options.sink({ type: "status", message: `Provider transient error (${message2.slice(0, 120)}); retrying same turn (${providerAttempt}/${PROVIDER_TRANSIENT_RETRIES}).` });
@@ -9103,6 +9716,62 @@ async function runAgent(options) {
       }
     }
     await options.sink({ type: "message_end" });
+    const parsedToolCalls = rawToolCalls.length > 0 ? parseProviderToolCalls(rawToolCalls, { turn }) : { toolCalls: [], warnings: [], failures: [] };
+    for (const warning of parsedToolCalls.warnings) {
+      await options.sink({
+        type: "tool_call_parse_warning",
+        reason: warning.reason,
+        provider: options.provider.id,
+        turn,
+        attempt: toolCallCorrectionAttempts,
+        ...warning.toolCallId ? { toolCallId: warning.toolCallId } : {},
+        ...warning.tool ? { tool: warning.tool } : {}
+      });
+    }
+    for (const failure of parsedToolCalls.failures) {
+      await options.sink({
+        type: "tool_call_parse_warning",
+        reason: failure.reason,
+        provider: options.provider.id,
+        turn,
+        attempt: toolCallCorrectionAttempts + 1,
+        toolCallId: failure.toolCall.id,
+        tool: failure.toolCall.function.name
+      });
+    }
+    if (parsedToolCalls.failures.length > 0 && toolCallCorrectionAttempts < TOOL_CALL_CORRECTION_LIMIT && turn < maxTurns - 1) {
+      toolCallCorrectionAttempts += 1;
+      messages.push({ role: "assistant", content: assistantText || null });
+      messages.push({
+        role: "user",
+        content: malformedToolCallCorrectionMessage(parsedToolCalls.failures.map((failure) => failure.reason).join("; "))
+      });
+      continue;
+    }
+    if (parsedToolCalls.failures.length > 0) {
+      const failedToolCalls = parsedToolCalls.failures.map((failure) => failure.toolCall);
+      toolErrorCount += failedToolCalls.length;
+      messages.push({
+        role: "assistant",
+        content: assistantText || null,
+        tool_calls: failedToolCalls
+      });
+      for (const failure of parsedToolCalls.failures) {
+        const error = `malformed tool call after ${TOOL_CALL_CORRECTION_LIMIT} correction attempts: ${failure.reason}`;
+        messages.push({ role: "tool", tool_call_id: failure.toolCall.id, content: JSON.stringify({ ok: false, error }) });
+        await options.sink({
+          type: "tool_result",
+          id: failure.toolCall.id,
+          tool: failure.toolCall.function.name,
+          ok: false,
+          summary: "Malformed tool call after correction attempts.",
+          error
+        });
+      }
+      continue;
+    }
+    const toolCalls = parsedToolCalls.toolCalls;
+    if (toolCalls.length > 0) toolCallCorrectionAttempts = 0;
     const assistantMessage = {
       role: "assistant",
       content: assistantText || null
@@ -9169,16 +9838,16 @@ async function runAgent(options) {
     for (const toolCall2 of toolCalls) {
       const toolName = toolCall2.function.name;
       const tool = registry.get(toolName);
-      const callInput = parseToolArguments(toolCall2.function.arguments);
-      if (isMalformedToolArguments(callInput)) {
+      const parsedInput = parseToolArguments(toolCall2.function.arguments);
+      if (!parsedInput.ok) {
         toolErrorCount += 1;
         messages.push({
           role: "tool",
           tool_call_id: toolCall2.id,
           content: JSON.stringify({
             ok: false,
-            error: callInput.error,
-            rawArguments: callInput.rawArguments
+            error: parsedInput.reason,
+            rawArguments: parsedInput.rawArguments
           })
         });
         await options.sink({
@@ -9187,11 +9856,12 @@ async function runAgent(options) {
           tool: toolName,
           ok: false,
           summary: "Invalid tool arguments (malformed JSON).",
-          output: `raw arguments (preview): ${callInput.rawArguments}`,
-          error: callInput.error
+          output: `raw arguments (preview): ${parsedInput.rawArguments}`,
+          error: parsedInput.reason
         });
         continue;
       }
+      const callInput = parsedInput.input;
       toolCallCount += 1;
       await options.sink({ type: "tool_call", id: toolCall2.id, tool: toolName, input: callInput });
       if (!tool) {
@@ -9431,12 +10101,12 @@ function runCommand(cmd, args, cwd, timeoutMs) {
     timeout: timeoutMs,
     shell: false
   });
-  const output2 = `${result.stdout ?? ""}${result.stderr ?? ""}`.trim();
+  const output = `${result.stdout ?? ""}${result.stderr ?? ""}`.trim();
   const exitCode = result.status ?? (result.error ? 1 : 0);
-  return { exitCode, output: output2 };
+  return { exitCode, output };
 }
-function parseTypeScriptErrors(output2) {
-  return output2.split(/\r?\n/).filter((line) => /\.tsx?:\d+:\d+\s*-?\s*error\s+TS\d+:/i.test(line) || /error TS\d+:/i.test(line)).slice(0, 5);
+function parseTypeScriptErrors(output) {
+  return output.split(/\r?\n/).filter((line) => /\.tsx?:\d+:\d+\s*-?\s*error\s+TS\d+:/i.test(line) || /error TS\d+:/i.test(line)).slice(0, 5);
 }
 async function detectPostRunBlockers(cwd, manifest) {
   const blockers = [];
@@ -9445,9 +10115,9 @@ async function detectPostRunBlockers(cwd, manifest) {
   const packageManager = readPackageManager(cwd);
   if (tsconfigExists && !hasPassingVerification(manifest, /tsc|typecheck|type-check/i)) {
     const typecheckCommand = scripts.typecheck ? packageScriptCommand(packageManager, "typecheck") : { cmd: "npx", args: ["tsc", "--noEmit", "--pretty", "false"] };
-    const { exitCode, output: output2 } = runCommand(typecheckCommand.cmd, typecheckCommand.args, cwd, POST_CHECK_TIMEOUT_MS);
+    const { exitCode, output } = runCommand(typecheckCommand.cmd, typecheckCommand.args, cwd, POST_CHECK_TIMEOUT_MS);
     if (exitCode !== 0) {
-      const errorLines = parseTypeScriptErrors(output2);
+      const errorLines = parseTypeScriptErrors(output);
       const summary = errorLines.length > 0 ? `TypeScript errors after run:
 ${errorLines.map((line) => `  ${line}`).join("\n")}` : "TypeScript compilation failed (post-run check)";
       blockers.push(summary);
@@ -9540,11 +10210,424 @@ ${diff.slice(0, 8e3)}
 
 // src/agent/chat.ts
 import { createInterface } from "readline/promises";
-import { stdin as input, stdout as output } from "process";
+import { stdin as processInput, stdout as processOutput } from "process";
+
+// src/commands/registry.ts
+var commands = /* @__PURE__ */ new Map();
+function registerCommand(command) {
+  const name = normalizeCommandName(command.name);
+  if (!name) throw new Error("Command name cannot be empty.");
+  commands.set(name, { ...command, name });
+}
+function getCommand(name) {
+  return commands.get(normalizeCommandName(name));
+}
+function listCommands() {
+  return [...commands.values()].sort((a, b) => {
+    const category = (a.category ?? "built-in").localeCompare(b.category ?? "built-in");
+    return category || a.name.localeCompare(b.name);
+  });
+}
+function removeCommandsByCategory(category) {
+  for (const [name, command] of commands) {
+    if (command.category === category) commands.delete(name);
+  }
+}
+async function commandIsAvailable(command, ctx) {
+  return command.availability ? await command.availability(ctx) : true;
+}
+function normalizeCommandName(name) {
+  return name.trim().replace(/^\//, "").toLowerCase();
+}
+
+// src/commands/builtin/clear.ts
+var clearCommand = {
+  name: "clear",
+  description: "Clear the active conversation history.",
+  category: "built-in",
+  handler(_args, ctx) {
+    if (ctx.clearHistory) {
+      ctx.clearHistory();
+    } else if (ctx.history) {
+      ctx.history.length = 0;
+    }
+    ctx.output.write("Conversation history cleared.\n");
+  }
+};
+registerCommand(clearCommand);
+
+// src/memory/runLogs.ts
+import { existsSync as existsSync15, readdirSync as readdirSync5, readFileSync as readFileSync7 } from "fs";
+import { join as join17 } from "path";
+var deepSeekPricingByModel = {
+  "deepseek-chat": { inputPerMillion: 0.27, outputPerMillion: 1.1 },
+  "deepseek-reasoner": { inputPerMillion: 0.55, outputPerMillion: 2.19 }
+};
+function readRunLogs(workspace, limit) {
+  const runsDir = join17(workspace, ".tania", "runs");
+  if (!existsSync15(runsDir)) return [];
+  const files = readdirSync5(runsDir).filter((file) => file.endsWith(".json")).sort().reverse();
+  const selected = limit === void 0 ? files : files.slice(0, limit);
+  return selected.flatMap((file) => {
+    try {
+      const parsed = JSON.parse(readFileSync7(join17(runsDir, file), "utf8"));
+      if (typeof parsed.ts !== "string" || typeof parsed.model !== "string") return [];
+      return [{
+        ts: parsed.ts,
+        prompt: typeof parsed.prompt === "string" ? parsed.prompt : "",
+        ...typeof parsed.provider === "string" ? { provider: parsed.provider } : {},
+        model: parsed.model,
+        durationMs: typeof parsed.durationMs === "number" ? parsed.durationMs : 0,
+        promptTokens: typeof parsed.promptTokens === "number" ? parsed.promptTokens : 0,
+        completionTokens: typeof parsed.completionTokens === "number" ? parsed.completionTokens : 0,
+        changedFiles: Array.isArray(parsed.changedFiles) ? parsed.changedFiles.filter((file2) => typeof file2 === "string") : [],
+        blockers: Array.isArray(parsed.blockers) ? parsed.blockers.filter((blocker) => typeof blocker === "string") : []
+      }];
+    } catch {
+      return [];
+    }
+  });
+}
+function estimateRunCost(log) {
+  const provider = normalizeProvider(log.provider, log.model);
+  const pricing = provider === "deepseek" ? deepSeekPricingByModel[log.model] : void 0;
+  if (!pricing) {
+    return { provider, usd: null, display: "pricing unknown" };
+  }
+  const usd = log.promptTokens / 1e6 * pricing.inputPerMillion + log.completionTokens / 1e6 * pricing.outputPerMillion;
+  return { provider, usd, display: formatUsd(usd) };
+}
+function formatRunLogLine(log) {
+  const cost = estimateRunCost(log);
+  const status = log.blockers.length > 0 ? "BLOCKED" : "OK";
+  const duration = `${Math.round(log.durationMs / 1e3)}s`;
+  const fileCount = log.changedFiles.length;
+  return `${log.ts.slice(0, 16)}  ${status.padEnd(7)} ${duration.padStart(5)}  ${cost.display.padStart(15)}  ${fileCount} file(s)  ${log.prompt.slice(0, 60)}`;
+}
+function formatUsd(usd) {
+  if (usd < 1e-3) return "<$0.001";
+  return `$${usd.toFixed(3)}`;
+}
+function normalizeProvider(provider, model) {
+  if (provider?.trim()) return provider.trim();
+  if (model.startsWith("deepseek-")) return "deepseek";
+  return "unknown";
+}
+
+// src/commands/builtin/cost.ts
+var costCommand = {
+  name: "cost",
+  description: "Show token usage and estimated run costs.",
+  category: "built-in",
+  handler(_args, ctx) {
+    const logs = readRunLogs(ctx.cwd);
+    if (logs.length === 0) {
+      ctx.output.write("No run logs found. Run tanya run first.\n");
+      return;
+    }
+    let knownTotal = 0;
+    let unknownCount = 0;
+    ctx.output.write("Recent run costs:\n");
+    for (const log of logs) {
+      const estimate = estimateRunCost(log);
+      if (estimate.usd === null) {
+        unknownCount += 1;
+      } else {
+        knownTotal += estimate.usd;
+      }
+      ctx.output.write(
+        `${log.ts.slice(0, 16)}  ${estimate.provider}:${log.model}  ${log.promptTokens.toLocaleString()} in / ${log.completionTokens.toLocaleString()} out  ${estimate.display}
+`
+      );
+    }
+    ctx.output.write(`Session total: ${formatUsd(knownTotal)}${unknownCount > 0 ? ` (${unknownCount} run${unknownCount === 1 ? "" : "s"} pricing unknown)` : ""}
+`);
+  }
+};
+registerCommand(costCommand);
+
+// src/commands/builtin/help.ts
+var helpCommand = {
+  name: "help",
+  description: "List available slash commands.",
+  category: "built-in",
+  async handler(_args, ctx) {
+    const commands2 = [];
+    for (const command of listCommands()) {
+      if (await commandIsAvailable(command, ctx)) commands2.push(command);
+    }
+    ctx.output.write("Built-in commands:\n");
+    for (const command of commands2.filter((candidate) => (candidate.category ?? "built-in") === "built-in")) {
+      ctx.output.write(`/${command.name} \u2014 ${command.description}
+`);
+    }
+    const projectCommands = commands2.filter((candidate) => candidate.category === "project");
+    if (projectCommands.length > 0) {
+      ctx.output.write("Project commands:\n");
+      for (const command of projectCommands) {
+        ctx.output.write(`/${command.name} \u2014 ${command.description}
+`);
+      }
+    }
+  }
+};
+registerCommand(helpCommand);
+
+// src/commands/builtin/memory.ts
+var DEFAULT_LIMIT = 10;
+var memoryCommand = {
+  name: "memory",
+  description: "Show recent golden-task memory.",
+  category: "built-in",
+  async handler(args, ctx) {
+    const records = [...await readGoldenTaskMemory(ctx.cwd)].sort((a, b) => b.recordedAt.localeCompare(a.recordedAt));
+    const fullId = flagValue(args, "--full");
+    if (fullId) {
+      const record = records.find((candidate) => candidate.signature === fullId);
+      ctx.output.write(record ? `${JSON.stringify(record, null, 2)}
+` : `Golden task not found: ${fullId}
+`);
+      return;
+    }
+    const limit = parseLimit(flagValue(args, "--limit"));
+    if (records.length === 0) {
+      ctx.output.write("No golden task memory found.\n");
+      return;
+    }
+    ctx.output.write("Recent golden tasks:\n");
+    for (const record of records.slice(0, limit)) {
+      const title = record.task?.title ?? "(untitled)";
+      ctx.output.write(`${record.recordedAt.slice(0, 16)}  ${record.outcome.padEnd(6)}  ${record.signature}  ${title}
+`);
+    }
+  }
+};
+function flagValue(args, flag) {
+  const index = args.indexOf(flag);
+  const value = index >= 0 ? args[index + 1] : void 0;
+  return value && !value.startsWith("--") ? value : void 0;
+}
+function parseLimit(raw) {
+  const parsed = raw ? Number(raw) : DEFAULT_LIMIT;
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : DEFAULT_LIMIT;
+}
+registerCommand(memoryCommand);
+
+// src/commands/builtin/skills.ts
+var skillsCommand = {
+  name: "skills",
+  description: "Show skill packs matched for this workspace.",
+  category: "built-in",
+  handler(args, ctx) {
+    const taskHint = args.join(" ");
+    const packs = loadPromptSkillPacks(ctx.cwd, void 0, taskHint);
+    ctx.output.write(`${formatSkillPackSummary(packs)}
+`);
+  }
+};
+registerCommand(skillsCommand);
+
+// src/commands/builtin/verify.ts
+var verifyCommand = {
+  name: "verify",
+  description: "Run Tanya's deterministic final-state verifier for the current workspace.",
+  category: "built-in",
+  async handler(_args, ctx) {
+    const beforeGitSnapshot = await captureGitSnapshot(ctx.cwd);
+    const manifest = await buildFinalManifest({
+      workspace: ctx.cwd,
+      beforeGitSnapshot,
+      changed: [],
+      verificationLines: [],
+      toolErrorCount: 0,
+      readArtifactPaths: [],
+      readContextPaths: [],
+      createdArtifactPaths: [],
+      blockers: [],
+      prompt: "Ad-hoc /verify command"
+    });
+    const report = ensureCodingReport("", manifest);
+    ctx.output.write(`${report.trim() || "No verifier evidence available for this workspace."}
+`);
+  }
+};
+registerCommand(verifyCommand);
+
+// src/commands/project.ts
+import { existsSync as existsSync16, readdirSync as readdirSync6 } from "fs";
+import { basename as basename4, extname as extname2, join as join18, relative as relative10 } from "path";
+import { pathToFileURL } from "url";
+import { tsImport } from "tsx/esm/api";
+var supportedExtensions = /* @__PURE__ */ new Set([".js", ".ts", ".sh"]);
+var loadedWorkspace = null;
+async function loadProjectCommands(workspace) {
+  if (loadedWorkspace === workspace) return;
+  loadedWorkspace = workspace;
+  removeCommandsByCategory("project");
+  const commandsDir = join18(workspace, ".tania", "commands");
+  if (!existsSync16(commandsDir)) return;
+  let files = [];
+  try {
+    files = readdirSync6(commandsDir).filter((file) => supportedExtensions.has(extname2(file))).sort();
+  } catch (error) {
+    warnProjectCommand(commandsDir, error);
+    return;
+  }
+  for (const file of files) {
+    const path = join18(commandsDir, file);
+    try {
+      const extension = extname2(file);
+      if (extension === ".sh") {
+        registerShellCommand(workspace, path);
+      } else {
+        await registerModuleCommand(path);
+      }
+    } catch (error) {
+      warnProjectCommand(path, error);
+    }
+  }
+}
+function registerShellCommand(workspace, path) {
+  const slug = basename4(path, extname2(path));
+  const relativePath = relative10(workspace, path).replace(/\\/g, "/");
+  registerCommand({
+    name: `project:${slug}`,
+    description: `Run ${relativePath}.`,
+    category: "project",
+    async handler(args, ctx) {
+      const script = ["zsh", quoteShell(relativePath), ...args.map(quoteShell)].join(" ");
+      const result = await runShellTool.run({ script }, { workspace: ctx.cwd });
+      const output = typeof result.output === "string" ? result.output : "";
+      if (output) ctx.output.write(`${output}${output.endsWith("\n") ? "" : "\n"}`);
+      if (!result.ok) ctx.output.write(`${result.error ?? result.summary}
+`);
+    }
+  });
+}
+async function registerModuleCommand(path) {
+  const href = pathToFileURL(path).href;
+  const imported = extname2(path) === ".ts" ? await tsImport(href, import.meta.url) : await import(href);
+  const command = unwrapDefaultCommand(imported);
+  if (!isCommandDefinition(command)) {
+    throw new Error("default export is not a CommandDefinition");
+  }
+  registerCommand({
+    ...command,
+    name: command.name.startsWith("project:") ? command.name : `project:${command.name}`,
+    category: "project"
+  });
+}
+function unwrapDefaultCommand(imported) {
+  if (isCommandDefinition(imported.default)) return imported.default;
+  const nested = imported.default;
+  if (nested && typeof nested === "object" && "default" in nested) {
+    return nested.default;
+  }
+  return imported.default;
+}
+function isCommandDefinition(value) {
+  return Boolean(
+    value && typeof value === "object" && typeof value.name === "string" && typeof value.description === "string" && typeof value.handler === "function"
+  );
+}
+function quoteShell(value) {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function warnProjectCommand(path, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  console.warn(`[tanya] Skipping project command ${path}: ${message}`);
+}
+
+// src/commands/index.ts
+function parseCommandLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("/")) return null;
+  const body = trimmed.slice(1).trim();
+  if (!body) return null;
+  const firstWhitespace = body.search(/\s/);
+  const rawName = firstWhitespace === -1 ? body : body.slice(0, firstWhitespace);
+  const rawArgs = firstWhitespace === -1 ? "" : body.slice(firstWhitespace).trim();
+  const name = normalizeCommandName(rawName);
+  if (!/^[a-z0-9:_-]+$/.test(name)) return null;
+  return { name, args: splitCommandArgs(rawArgs) };
+}
+function commandNameFromLine(line) {
+  return parseCommandLine(line)?.name ?? null;
+}
+async function runCommand2(line, ctx) {
+  const parsed = parseCommandLine(line);
+  if (!parsed) return false;
+  await loadProjectCommands(ctx.cwd);
+  const command = getCommand(parsed.name);
+  if (!command) return false;
+  if (!await commandIsAvailable(command, ctx)) return false;
+  await ctx.sink({
+    type: "command_invoked",
+    name: command.name,
+    args: parsed.args,
+    ...ctx.runId ? { runId: ctx.runId } : {}
+  });
+  await command.handler(parsed.args, ctx);
+  return true;
+}
+function splitCommandArgs(input) {
+  const args = [];
+  let current = "";
+  let quote = null;
+  let escaping = false;
+  for (const char of input) {
+    if (escaping) {
+      current += char;
+      escaping = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaping = true;
+      continue;
+    }
+    if (quote) {
+      if (char === quote) {
+        quote = null;
+      } else {
+        current += char;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      if (current) {
+        args.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += char;
+  }
+  if (escaping) current += "\\";
+  if (current) args.push(current);
+  return args;
+}
+
+// src/agent/chat.ts
+async function dispatchInteractiveCommand(prompt, ctx) {
+  if (!prompt.startsWith("/")) return false;
+  const handled = await runCommand2(prompt, ctx);
+  if (handled) return true;
+  const commandName = commandNameFromLine(prompt);
+  ctx.output.write(`unknown command: /${commandName ?? ""}; try /help
+`);
+  return true;
+}
 async function startInteractiveChat(inputOptions) {
+  const input = inputOptions.input ?? processInput;
+  const output = inputOptions.output ?? processOutput;
   const rl = createInterface({ input, output });
   const history = [];
   let activeAbortController = null;
+  await loadProjectCommands(inputOptions.cwd);
   output.write(`Tanya live chat (${inputOptions.provider.id}:${inputOptions.provider.model}). Type /exit to quit.
 `);
   const handleSigint = () => {
@@ -9562,17 +10645,34 @@ async function startInteractiveChat(inputOptions) {
       const prompt = (await rl.question("\nYou: ")).trim();
       if (!prompt) continue;
       if (prompt === "/exit" || prompt === "/quit") break;
-      const abortController = new AbortController();
-      activeAbortController = abortController;
-      const { message } = await runAgent({
+      if (await dispatchInteractiveCommand(prompt, {
         provider: inputOptions.provider,
-        prompt,
         cwd: inputOptions.cwd,
         sink: inputOptions.sink,
+        output,
         history,
-        signal: abortController.signal
-      });
-      activeAbortController = null;
+        clearHistory: () => {
+          history.length = 0;
+        }
+      })) {
+        continue;
+      }
+      const abortController = new AbortController();
+      activeAbortController = abortController;
+      let message;
+      try {
+        const result = await runAgent({
+          provider: inputOptions.provider,
+          prompt,
+          cwd: inputOptions.cwd,
+          sink: inputOptions.sink,
+          history,
+          signal: abortController.signal
+        });
+        message = result.message;
+      } finally {
+        activeAbortController = null;
+      }
       history.push({ role: "user", content: prompt });
       history.push({ role: "assistant", content: message });
     }
@@ -9628,6 +10728,21 @@ ${toolGlyph} ${event.tool}
         break;
       case "tool_cancelled":
         stream.write(`  cancelled: ${event.tool ?? event.toolCallId}
+`);
+        break;
+      case "command_invoked":
+        break;
+      case "tool_call_parse_warning":
+        stream.write(`  warning: malformed tool call (${event.reason})
+`);
+        break;
+      case "schema_flatten_warning":
+        stream.write(`  warning: flattened schema${event.tool ? ` for ${event.tool}` : ""} (${event.reason})
+`);
+        break;
+      case "provider_throttle":
+        stream.write(`
+Provider ${event.provider} throttled; waiting ${Math.ceil(event.waitMs / 1e3)}s before retry ${event.attempt}.
 `);
         break;
       case "final":
@@ -9651,7 +10766,7 @@ ${event.detail}` : ""}
 
 // src/tools/adRenderTools.ts
 import { mkdir as mkdir11, readFile as readFile10, readdir as readdir6, rm as rm3, writeFile as writeFile9 } from "fs/promises";
-import { dirname as dirname13, isAbsolute as isAbsolute4, join as join17 } from "path";
+import { dirname as dirname13, isAbsolute as isAbsolute4, join as join19 } from "path";
 import { spawnSync as spawnSync4 } from "child_process";
 import sharp3 from "sharp";
 function findExecutable2(name, explicit) {
@@ -9745,17 +10860,17 @@ async function loadStaticFrame(src, workspace) {
 }
 async function extractVideoFrames(params) {
   await mkdir11(params.outDir, { recursive: true });
-  const input2 = resolveAssetPath(params.src, params.workspace);
+  const input = resolveAssetPath(params.src, params.workspace);
   run2(params.ffmpegPath, [
     "-y",
     "-i",
-    input2,
+    input,
     "-vf",
     `fps=${params.fps}`,
-    join17(params.outDir, "frame-%05d.png")
+    join19(params.outDir, "frame-%05d.png")
   ], params.workspace);
   const files = (await readdir6(params.outDir)).filter((file) => file.endsWith(".png")).sort();
-  return Promise.all(files.map((file) => readFile10(join17(params.outDir, file))));
+  return Promise.all(files.map((file) => readFile10(join19(params.outDir, file))));
 }
 async function buildMediaFrames(spec, workspace, tmpDir, ffmpegPath, warnings) {
   const media = /* @__PURE__ */ new Map();
@@ -9765,7 +10880,7 @@ async function buildMediaFrames(spec, workspace, tmpDir, ffmpegPath, warnings) {
         const frames = await extractVideoFrames({
           src: asset.src,
           workspace,
-          outDir: join17(tmpDir, "media", asset.id),
+          outDir: join19(tmpDir, "media", asset.id),
           fps: spec.canvas.fps,
           ffmpegPath
         });
@@ -9861,13 +10976,13 @@ async function shadowLayer(width, height, radius) {
     }
   }).composite([{ input: mask, blend: "dest-in" }]).blur(18).extend({ top: 24, bottom: 24, left: 24, right: 24, background: { r: 0, g: 0, b: 0, alpha: 0 } }).png().toBuffer();
 }
-async function scaleOverlay(input2, scale) {
-  if (Math.abs(scale - 1) < 1e-3) return { input: input2, dx: 0, dy: 0 };
-  const meta = await sharp3(input2).metadata();
+async function scaleOverlay(input, scale) {
+  if (Math.abs(scale - 1) < 1e-3) return { input, dx: 0, dy: 0 };
+  const meta = await sharp3(input).metadata();
   const width = Math.max(1, Math.round((meta.width ?? 1) * scale));
   const height = Math.max(1, Math.round((meta.height ?? 1) * scale));
   return {
-    input: await sharp3(input2).resize(width, height).png().toBuffer(),
+    input: await sharp3(input).resize(width, height).png().toBuffer(),
     dx: Math.round(((meta.width ?? width) - width) / 2),
     dy: Math.round(((meta.height ?? height) - height) / 2)
   };
@@ -9963,12 +11078,12 @@ async function renderFullAd(options, workspace) {
   const inputPath = isAbsolute4(options.input) ? options.input : resolveInsideWorkspace(workspace, options.input);
   const spec = parseSpec(JSON.parse(await readFile10(inputPath, "utf8")));
   const outputDir = resolveInsideWorkspace(workspace, options.outputDir ?? "tanya-video-ads");
-  const basename4 = (options.basename ?? `full-ad-${Date.now()}`).replace(/[^a-zA-Z0-9._-]+/g, "-");
+  const basename5 = (options.basename ?? `full-ad-${Date.now()}`).replace(/[^a-zA-Z0-9._-]+/g, "-");
   const formats = options.formats?.length ? options.formats : ["mp4", "poster"];
   const ffmpegPath = findExecutable2("ffmpeg", options.ffmpegPath ?? envValue({}, "TANYA_FFMPEG_PATH"));
   const tmpRoot = resolveInsideWorkspace(workspace, ".tania/tmp");
-  const tmpDir = await fsMkdtemp(join17(tmpRoot, "tanya-render-ad-"));
-  const frameDir = join17(tmpDir, "frames");
+  const tmpDir = await fsMkdtemp(join19(tmpRoot, "tanya-render-ad-"));
+  const frameDir = join19(tmpDir, "frames");
   const warnings = [];
   await mkdir11(frameDir, { recursive: true });
   await mkdir11(outputDir, { recursive: true });
@@ -9980,7 +11095,7 @@ async function renderFullAd(options, workspace) {
     for (let i = 0; i < frameCount; i += 1) {
       const frame = await renderFrame(spec, scene, mediaFrames, i);
       await writeFile9(
-        join17(frameDir, `frame_${String(frameIndex).padStart(6, "0")}.jpg`),
+        join19(frameDir, `frame_${String(frameIndex).padStart(6, "0")}.jpg`),
         await sharp3(frame).jpeg({ quality: 84, mozjpeg: true }).toBuffer()
       );
       frameIndex += 1;
@@ -9995,18 +11110,18 @@ async function renderFullAd(options, workspace) {
     renderSpec: spec
   };
   if (formats.includes("poster")) {
-    const posterPath = join17(outputDir, `${basename4}-poster.png`);
-    await sharp3(await readFile10(join17(frameDir, "frame_000000.jpg"))).png().toFile(posterPath);
+    const posterPath = join19(outputDir, `${basename5}-poster.png`);
+    await sharp3(await readFile10(join19(frameDir, "frame_000000.jpg"))).png().toFile(posterPath);
     result.posterPath = posterPath;
   }
   if (formats.includes("mp4")) {
-    const mp4Path = join17(outputDir, `${basename4}.mp4`);
+    const mp4Path = join19(outputDir, `${basename5}.mp4`);
     run2(ffmpegPath, [
       "-y",
       "-framerate",
       String(spec.canvas.fps),
       "-i",
-      join17(frameDir, "frame_%06d.jpg"),
+      join19(frameDir, "frame_%06d.jpg"),
       "-c:v",
       "libx264",
       "-pix_fmt",
@@ -10245,7 +11360,7 @@ var BUILT_IN_GOLDEN_TASK_PROFILES = [
 import { execFile as execFile3 } from "child_process";
 import { mkdtemp, mkdir as mkdir12, writeFile as writeFile10 } from "fs/promises";
 import { tmpdir } from "os";
-import { join as join18 } from "path";
+import { join as join20 } from "path";
 import { promisify as promisify3 } from "util";
 function toolCall(id, name, args) {
   return {
@@ -10263,15 +11378,15 @@ function scriptedProvider(id, turns) {
     id: `golden:${id}`,
     model: "scripted",
     requests,
-    async *streamChat(input2) {
-      requests.push({ ...input2, messages: [...input2.messages] });
+    async *streamChat(input) {
+      requests.push({ ...input, messages: [...input.messages] });
       yield turns[Math.min(requests.length - 1, turns.length - 1)] ?? { content: "" };
     }
   };
 }
 var execFileAsync3 = promisify3(execFile3);
 async function createBaseWorkspace(profileId) {
-  return mkdtemp(join18(tmpdir(), `tanya-golden-${profileId.replace(/[^a-z0-9]+/gi, "-")}-`));
+  return mkdtemp(join20(tmpdir(), `tanya-golden-${profileId.replace(/[^a-z0-9]+/gi, "-")}-`));
 }
 var GENERIC_BENCHMARK_SPECS = {
   "tanya.low.search-replace": {
@@ -10423,8 +11538,8 @@ async function genericBenchmarkFixture(profile) {
   if (!spec) throw new Error(`No generic benchmark spec for ${profile.id}`);
   const workspace = await createBaseWorkspace(profile.id);
   const marker = `${profile.id.split(".").pop() ?? "benchmark"}-ready`;
-  await mkdir12(join18(workspace, "scripts"), { recursive: true });
-  await writeFile10(join18(workspace, "scripts/check.js"), [
+  await mkdir12(join20(workspace, "scripts"), { recursive: true });
+  await writeFile10(join20(workspace, "scripts/check.js"), [
     "const fs = require('fs');",
     `const targets = ${JSON.stringify(spec.targetFiles.map((file) => ({ path: file.path, marker })))};`,
     "for (const target of targets) {",
@@ -10440,37 +11555,37 @@ async function genericBenchmarkFixture(profile) {
   if (spec.useSearchReplace) {
     for (const file of spec.targetFiles) {
       const dir = file.path.split("/").slice(0, -1).join("/");
-      if (dir) await mkdir12(join18(workspace, dir), { recursive: true });
-      await writeFile10(join18(workspace, file.path), file.content.replace(marker, "PENDING_MARKER"));
+      if (dir) await mkdir12(join20(workspace, dir), { recursive: true });
+      await writeFile10(join20(workspace, file.path), file.content.replace(marker, "PENDING_MARKER"));
     }
   }
   for (const file of spec.preFiles ?? []) {
     const dir = file.path.split("/").slice(0, -1).join("/");
-    if (dir) await mkdir12(join18(workspace, dir), { recursive: true });
-    await writeFile10(join18(workspace, file.path), file.content);
+    if (dir) await mkdir12(join20(workspace, dir), { recursive: true });
+    await writeFile10(join20(workspace, file.path), file.content);
   }
   if (spec.useArtifact) {
-    await mkdir12(join18(workspace, ".tania/artifacts/generic"), { recursive: true });
-    await writeFile10(join18(workspace, ".tania/artifacts/generic/Pattern.md"), `# Pattern
+    await mkdir12(join20(workspace, ".tania/artifacts/generic"), { recursive: true });
+    await writeFile10(join20(workspace, ".tania/artifacts/generic/Pattern.md"), `# Pattern
 
 Use ${marker} in the adapted output.
 `);
   }
   if (spec.useContext) {
-    await mkdir12(join18(workspace, ".tania/context"), { recursive: true });
-    await writeFile10(join18(workspace, ".tania/context/task.md"), `# Task Context
+    await mkdir12(join20(workspace, ".tania/context"), { recursive: true });
+    await writeFile10(join20(workspace, ".tania/context/task.md"), `# Task Context
 
 Use ${marker}.
 `);
   }
   if (spec.dirtyWorktree) {
-    await writeFile10(join18(workspace, "unrelated.txt"), "baseline\n");
+    await writeFile10(join20(workspace, "unrelated.txt"), "baseline\n");
     await execFileAsync3("git", ["init"], { cwd: workspace });
     await execFileAsync3("git", ["config", "user.email", "tanya@example.test"], { cwd: workspace });
     await execFileAsync3("git", ["config", "user.name", "Tanya Benchmark"], { cwd: workspace });
     await execFileAsync3("git", ["add", "unrelated.txt"], { cwd: workspace });
     await execFileAsync3("git", ["commit", "-m", "baseline"], { cwd: workspace });
-    await writeFile10(join18(workspace, "unrelated.txt"), "pre-existing dirty change\n");
+    await writeFile10(join20(workspace, "unrelated.txt"), "pre-existing dirty change\n");
   }
   const toolCalls = [];
   if (spec.useArtifact) toolCalls.push(toolCall("read-artifact", "read_file", { path: ".tania/artifacts/generic/Pattern.md" }));
@@ -10516,8 +11631,8 @@ Use ${marker}.
 async function streamingLongToolFixture(profile) {
   const workspace = await createBaseWorkspace(profile.id);
   const script = 'for i in 1 2 3 4 5 6; do printf "stream-$i\\n"; sleep 2; done; node scripts/check.js';
-  await mkdir12(join18(workspace, "scripts"), { recursive: true });
-  await writeFile10(join18(workspace, "scripts/check.js"), [
+  await mkdir12(join20(workspace, "scripts"), { recursive: true });
+  await writeFile10(join20(workspace, "scripts/check.js"), [
     "const fs = require('fs');",
     "const text = fs.readFileSync('src/streamingLongTool.ts', 'utf8');",
     "if (!text.includes('streaming-long-tool-ready')) process.exit(1);",
@@ -10558,13 +11673,13 @@ async function streamingLongToolFixture(profile) {
 }
 async function androidSplashFixture(profile) {
   const workspace = await createBaseWorkspace(profile.id);
-  await mkdir12(join18(workspace, ".tania/artifacts/android"), { recursive: true });
-  await mkdir12(join18(workspace, "app/src/main/java/com/example/app/ui/splash"), { recursive: true });
-  await mkdir12(join18(workspace, "app/src/main/res/values"), { recursive: true });
-  await mkdir12(join18(workspace, "app/src/main/res/drawable"), { recursive: true });
-  await writeFile10(join18(workspace, ".tania/artifacts/android/SplashScreenPattern.kt"), "fun SplashPattern() {}\n");
-  await writeFile10(join18(workspace, "gradlew"), '#!/bin/sh\ncase "$*" in\n  *ktlintCheck*) echo ktlint ok ;;\n  *) echo BUILD SUCCESSFUL ;;\nesac\n');
-  await writeFile10(join18(workspace, "app/src/main/res/drawable/ic_splash_logo.png"), "png\n");
+  await mkdir12(join20(workspace, ".tania/artifacts/android"), { recursive: true });
+  await mkdir12(join20(workspace, "app/src/main/java/com/example/app/ui/splash"), { recursive: true });
+  await mkdir12(join20(workspace, "app/src/main/res/values"), { recursive: true });
+  await mkdir12(join20(workspace, "app/src/main/res/drawable"), { recursive: true });
+  await writeFile10(join20(workspace, ".tania/artifacts/android/SplashScreenPattern.kt"), "fun SplashPattern() {}\n");
+  await writeFile10(join20(workspace, "gradlew"), '#!/bin/sh\ncase "$*" in\n  *ktlintCheck*) echo ktlint ok ;;\n  *) echo BUILD SUCCESSFUL ;;\nesac\n');
+  await writeFile10(join20(workspace, "app/src/main/res/drawable/ic_splash_logo.png"), "png\n");
   const provider = scriptedProvider(profile.id, [
     {
       content: "Create Android splash resources from the artifact.",
@@ -10621,10 +11736,10 @@ async function androidSplashFixture(profile) {
 }
 async function iosFoundationFixture(profile) {
   const workspace = await createBaseWorkspace(profile.id);
-  await mkdir12(join18(workspace, ".tania/artifacts/ios"), { recursive: true });
-  await writeFile10(join18(workspace, ".tania/artifacts/ios/ThemeSystem.swift"), "import SwiftUI\n");
-  await writeFile10(join18(workspace, ".tania/artifacts/ios/SwiftDataSetup.swift"), "import SwiftData\n");
-  await writeFile10(join18(workspace, ".tania/artifacts/ios/NavigationSetup.swift"), "import SwiftUI\n");
+  await mkdir12(join20(workspace, ".tania/artifacts/ios"), { recursive: true });
+  await writeFile10(join20(workspace, ".tania/artifacts/ios/ThemeSystem.swift"), "import SwiftUI\n");
+  await writeFile10(join20(workspace, ".tania/artifacts/ios/SwiftDataSetup.swift"), "import SwiftData\n");
+  await writeFile10(join20(workspace, ".tania/artifacts/ios/NavigationSetup.swift"), "import SwiftUI\n");
   const provider = scriptedProvider(profile.id, [
     {
       content: "Create iOS foundation from theme, SwiftData, and navigation artifacts.",
@@ -10695,7 +11810,7 @@ async function iosFoundationFixture(profile) {
 }
 async function appleAppIconFixture(profile) {
   const workspace = await createBaseWorkspace(profile.id);
-  await mkdir12(join18(workspace, "CosaNostra/Assets.xcassets"), { recursive: true });
+  await mkdir12(join20(workspace, "CosaNostra/Assets.xcassets"), { recursive: true });
   const provider = scriptedProvider(profile.id, [
     {
       content: "Generate Apple app icon set with iOS and macOS slots.",
@@ -10738,14 +11853,14 @@ async function appleAppIconFixture(profile) {
 }
 async function androidFoundationFixture(profile) {
   const workspace = await createBaseWorkspace(profile.id);
-  await mkdir12(join18(workspace, ".tania/artifacts/android"), { recursive: true });
-  await mkdir12(join18(workspace, "app"), { recursive: true });
-  await writeFile10(join18(workspace, ".tania/artifacts/android/ThemeSystem.kt"), "package artifact\n");
-  await writeFile10(join18(workspace, ".tania/artifacts/android/NavigationSetup.kt"), "package artifact\n");
-  await writeFile10(join18(workspace, ".tania/artifacts/android/RoomSetup.kt"), "package artifact\n");
-  await writeFile10(join18(workspace, "gradlew"), '#!/bin/sh\ncase "$*" in\n  *ktlintCheck*) echo ktlint ok ;;\n  *) echo BUILD SUCCESSFUL ;;\nesac\n');
-  await writeFile10(join18(workspace, "build.gradle.kts"), 'plugins {\n    id("com.android.application") version "8.7.2" apply false\n}\n');
-  await writeFile10(join18(workspace, "app/build.gradle.kts"), [
+  await mkdir12(join20(workspace, ".tania/artifacts/android"), { recursive: true });
+  await mkdir12(join20(workspace, "app"), { recursive: true });
+  await writeFile10(join20(workspace, ".tania/artifacts/android/ThemeSystem.kt"), "package artifact\n");
+  await writeFile10(join20(workspace, ".tania/artifacts/android/NavigationSetup.kt"), "package artifact\n");
+  await writeFile10(join20(workspace, ".tania/artifacts/android/RoomSetup.kt"), "package artifact\n");
+  await writeFile10(join20(workspace, "gradlew"), '#!/bin/sh\ncase "$*" in\n  *ktlintCheck*) echo ktlint ok ;;\n  *) echo BUILD SUCCESSFUL ;;\nesac\n');
+  await writeFile10(join20(workspace, "build.gradle.kts"), 'plugins {\n    id("com.android.application") version "8.7.2" apply false\n}\n');
+  await writeFile10(join20(workspace, "app/build.gradle.kts"), [
     "plugins {",
     '    id("com.android.application")',
     '    id("org.jetbrains.kotlin.android")',
@@ -10806,12 +11921,12 @@ async function androidFoundationFixture(profile) {
 }
 async function backendApiFoundationFixture(profile) {
   const workspace = await createBaseWorkspace(profile.id);
-  await mkdir12(join18(workspace, ".tania/artifacts/backend"), { recursive: true });
-  await mkdir12(join18(workspace, "app/api/health"), { recursive: true });
-  await mkdir12(join18(workspace, "lib"), { recursive: true });
-  await mkdir12(join18(workspace, "prisma"), { recursive: true });
-  await writeFile10(join18(workspace, ".tania/artifacts/backend/JwtAuthRoutes.ts"), "export function authRoutePattern() {}\n");
-  await writeFile10(join18(workspace, "package.json"), JSON.stringify({ scripts: { typecheck: "tsc --noEmit", test: "node --test" }, dependencies: {} }, null, 2));
+  await mkdir12(join20(workspace, ".tania/artifacts/backend"), { recursive: true });
+  await mkdir12(join20(workspace, "app/api/health"), { recursive: true });
+  await mkdir12(join20(workspace, "lib"), { recursive: true });
+  await mkdir12(join20(workspace, "prisma"), { recursive: true });
+  await writeFile10(join20(workspace, ".tania/artifacts/backend/JwtAuthRoutes.ts"), "export function authRoutePattern() {}\n");
+  await writeFile10(join20(workspace, "package.json"), JSON.stringify({ scripts: { typecheck: "tsc --noEmit", test: "node --test" }, dependencies: {} }, null, 2));
   const provider = scriptedProvider(profile.id, [
     {
       content: "Create backend health/API foundation from the route artifact.",
@@ -11005,7 +12120,7 @@ async function runGoldenSuiteCommand(workspace, action, json = false, options =
 
 // src/init/projectInit.ts
 import { mkdir as mkdir13, readFile as readFile11, readdir as readdir7, stat as stat7, writeFile as writeFile11 } from "fs/promises";
-import { dirname as dirname14, join as join19, resolve as resolve11 } from "path";
+import { dirname as dirname14, join as join21, resolve as resolve11 } from "path";
 async function fileExists(path) {
   try {
     const entry = await stat7(path);
@@ -11015,7 +12130,7 @@ async function fileExists(path) {
   }
 }
 async function readPackageJson(workspace) {
-  const packagePath = join19(workspace, "package.json");
+  const packagePath = join21(workspace, "package.json");
   try {
     return JSON.parse(await readFile11(packagePath, "utf8"));
   } catch {
@@ -11043,10 +12158,10 @@ async function detectStack(workspace) {
   const pkg = await readPackageJson(workspace);
   const entries = await rootEntries(workspace);
   const hasPackageJson = pkg !== null;
-  const hasPrisma = await fileExists(join19(workspace, "prisma", "schema.prisma"));
+  const hasPrisma = await fileExists(join21(workspace, "prisma", "schema.prisma"));
   const hasNextConfig = entries.some((entry) => /^next\.config\.(?:js|mjs|cjs|ts)$/.test(entry));
-  const hasTsconfig = await fileExists(join19(workspace, "tsconfig.json"));
-  const hasGradlew = await fileExists(join19(workspace, "gradlew"));
+  const hasTsconfig = await fileExists(join21(workspace, "tsconfig.json"));
+  const hasGradlew = await fileExists(join21(workspace, "gradlew"));
   const xcodeProjects = entries.filter((entry) => entry.endsWith(".xcodeproj"));
   const projectTypes = [];
   if (hasNextConfig || hasDependency(pkg, "next")) projectTypes.push("Next.js");
@@ -11097,7 +12212,7 @@ function buildInstructions(detection) {
 }
 async function initTanyaProject(cwd) {
   const workspace = resolve11(cwd);
-  const instructionsPath = join19(workspace, ".tania", "INSTRUCTIONS.md");
+  const instructionsPath = join21(workspace, ".tania", "INSTRUCTIONS.md");
   const detection = await detectStack(workspace);
   await mkdir13(dirname14(instructionsPath), { recursive: true });
   try {
@@ -11236,6 +12351,7 @@ var cliOptionDefinitions = [
   { flags: "--output-dir <path>", key: "output-dir", kind: "string", property: "outputDir", aliases: ["outputDir"] },
   { flags: "--plan", key: "plan", kind: "boolean", property: "plan" },
   { flags: "--profile <id>", key: "profile", kind: "string", property: "profile" },
+  { flags: "--provider <name>", key: "provider", kind: "string", property: "provider" },
   { flags: "--prompt-file <path>", key: "prompt-file", kind: "string", property: "promptFile" },
   { flags: "--repair-attempts <count>", key: "repair-attempts", kind: "string", property: "repairAttempts" },
   { flags: "--require-verification <command>", key: "require-verification", kind: "array", property: "requireVerification" },
@@ -11382,6 +12498,11 @@ function applyCliProfileFlag(args) {
   if (!profile) return;
   process.env.TANYA_PROFILE = profile;
 }
+function applyCliProviderFlag(args) {
+  const provider = flagString(args, "provider");
+  if (!provider) return;
+  process.env.TANYA_PROVIDER = provider;
+}
 function buildRetryContext(manifest, attempt, extraBlockers = []) {
   const lines = [
     `RETRY CONTEXT (attempt ${attempt}): the previous run did not complete cleanly.`,
@@ -11403,14 +12524,6 @@ function buildRetryContext(manifest, attempt, extraBlockers = []) {
   lines.push("", "Fix the blockers above and complete the task.");
   return lines.join("\n");
 }
-function estimateRunCost(model, promptTokens, completionTokens) {
-  const isReasoner = model.includes("reasoner");
-  const inputRate = isReasoner ? 0.55 : 0.27;
-  const outputRate = isReasoner ? 2.19 : 1.1;
-  const cost = promptTokens / 1e6 * inputRate + completionTokens / 1e6 * outputRate;
-  if (cost < 1e-3) return "<$0.001";
-  return `~$${cost.toFixed(3)}`;
-}
 function usage() {
   return `Tanya CLI
 
@@ -11455,7 +12568,7 @@ Usage:
   tanya benchmark profiles      List benchmark profiles
   tanya benchmark run --all     Run executable regression benchmarks
   tanya benchmark validate      Validate recent benchmark signatures
-  tanya providers test          Test provider configuration
+  tanya providers test --provider deepseek  Test provider configuration (live only with TANYA_RUN_LIVE_PROVIDER_TESTS=1)
   tanya doctor                  Check local setup
   tanya patterns                Show forbidden-pattern fire metrics for this workspace
 
@@ -11466,7 +12579,7 @@ Install locally during development:
 }
 function readPrompt(args) {
   const promptFile = flagString(args, "prompt-file");
-  if (promptFile) return readFileSync7(resolve12(promptFile), "utf8");
+  if (promptFile) return readFileSync8(resolve12(promptFile), "utf8");
   return args.positional.join(" ").trim();
 }
 async function buildRunContextForCli(args, cwd, prompt, obsidianVault) {
@@ -11474,7 +12587,7 @@ async function buildRunContextForCli(args, cwd, prompt, obsidianVault) {
   const baseRunContext = contextFile ? loadRunContextFile(contextFile) : void 0;
   const explicitArtifactsRoot = flagString(args, "artifacts-root");
   const localArtifactsRoot = resolve12(cwd, "artifacts");
-  const artifactsRoot = explicitArtifactsRoot ?? (existsSync15(localArtifactsRoot) ? localArtifactsRoot : void 0);
+  const artifactsRoot = explicitArtifactsRoot ?? (existsSync17(localArtifactsRoot) ? localArtifactsRoot : void 0);
   let runContext = materializeCliArtifacts({
     cwd,
     root: artifactsRoot,
@@ -11574,17 +12687,6 @@ ${heading}
   }
   return matched.join("\n\n---\n\n");
 }
-function formatSkillPackSummary(packs) {
-  const totalTokens = packs.reduce((sum, pack) => sum + pack.tokens, 0);
-  const lines = [
-    `Skill packs loaded: ${packs.length}`,
-    "| slug | reason | tokens |",
-    "|------|--------|--------|",
-    ...packs.map((pack) => `| ${pack.slug} | ${pack.reason} | ${pack.tokens} |`),
-    `Total pack tokens: ${totalTokens} / ${SKILL_PACK_TOKEN_BUDGET}`
-  ];
-  return lines.join("\n");
-}
 async function askOnce(provider, prompt) {
   let text2 = "";
   for await (const delta of provider.streamChat({ messages: [{ role: "user", content: prompt }], tools: [] })) {
@@ -11596,20 +12698,31 @@ async function askOnce(provider, prompt) {
   process.stdout.write("\n");
   return text2;
 }
-async function testProvider() {
+async function testProvider(args) {
+  const requestedProvider = flagString(args, "provider") ?? "configured";
+  if (envValue({}, "TANYA_RUN_LIVE_PROVIDER_TESTS") !== "1") {
+    console.log(`skipped live provider test for ${requestedProvider}; set TANYA_RUN_LIVE_PROVIDER_TESTS=1 to run against the real endpoint.`);
+    return;
+  }
   const config = loadConfig();
   const provider = createProvider(config);
   const startedAt = Date.now();
   let text2 = "";
   for await (const delta of provider.streamChat({
-    messages: [{ role: "user", content: "Reply with exactly: pong" }],
+    messages: [
+      { role: "system", content: "You are a provider conformance probe. Keep answers short." },
+      { role: "user", content: "Reply with exactly: pong" },
+      { role: "user", content: "No tools are needed." }
+    ],
     tools: [],
     maxTokens: 12,
     temperature: 0
   })) {
     if (delta.content) text2 += delta.content;
   }
-  console.log(`ok ${provider.id}:${provider.model} ${Date.now() - startedAt}ms ${text2.trim()}`);
+  console.log(`PASS adapter: ${provider.id}:${provider.model}`);
+  console.log(`PASS streaming-chat: ${Date.now() - startedAt}ms ${text2.trim()}`);
+  console.log("PASS parser-surface: mock conformance covers malformed tool-call quirks in CI");
 }
 async function doctor(args) {
   const cwd = resolve12(args ? flagString(args, "cwd") ?? process.cwd() : process.cwd());
@@ -11627,16 +12740,16 @@ async function doctor(args) {
   else fail("provider.baseUrl", "missing \u2014 set TANYA_BASE_URL");
   ok("provider.model", `${config.provider}:${config.model} (profile=${config.profile})`);
   ok("provider.timeoutMs", `${config.timeoutMs}ms`);
-  const cwdHasGit = existsSync15(join20(cwd, ".git"));
+  const cwdHasGit = existsSync17(join22(cwd, ".git"));
   if (cwdHasGit) ok("workspace.git", `${cwd}`);
   else warn("workspace.git", `${cwd} is not a git repository \u2014 stash/retry recovery will be disabled`);
-  const cwdHasArtifacts = existsSync15(join20(cwd, "artifacts"));
-  if (cwdHasArtifacts) ok("workspace.artifacts", `${join20(cwd, "artifacts")} (auto-detected)`);
+  const cwdHasArtifacts = existsSync17(join22(cwd, "artifacts"));
+  if (cwdHasArtifacts) ok("workspace.artifacts", `${join22(cwd, "artifacts")} (auto-detected)`);
   else warn("workspace.artifacts", "no ./artifacts dir \u2014 pass --artifacts-root or run from a project that has one");
-  const fpPath = join20(cwd, ".tania", "forbidden-patterns.json");
-  if (existsSync15(fpPath)) {
+  const fpPath = join22(cwd, ".tania", "forbidden-patterns.json");
+  if (existsSync17(fpPath)) {
     try {
-      const raw = readFileSync7(fpPath, "utf8");
+      const raw = readFileSync8(fpPath, "utf8");
       const parsed = JSON.parse(raw);
       const count = Array.isArray(parsed?.patterns) ? parsed.patterns.length : 0;
       ok("workspace.forbiddenPatterns", `${count} project pattern(s) loaded from ${fpPath}`);
@@ -11646,10 +12759,10 @@ async function doctor(args) {
   } else {
     ok("workspace.forbiddenPatterns", "no project overrides (using defaults)");
   }
-  const fpMetricsPath = join20(cwd, ".tania", "memory", "forbidden-patterns-metrics.json");
-  if (existsSync15(fpMetricsPath)) {
+  const fpMetricsPath = join22(cwd, ".tania", "memory", "forbidden-patterns-metrics.json");
+  if (existsSync17(fpMetricsPath)) {
     try {
-      const raw = readFileSync7(fpMetricsPath, "utf8");
+      const raw = readFileSync8(fpMetricsPath, "utf8");
       const parsed = JSON.parse(raw);
       const totals = parsed.totals ?? {};
       const top = Object.entries(totals).sort((a, b) => b[1] - a[1]).slice(0, 5);
@@ -11666,7 +12779,7 @@ async function doctor(args) {
     ok("workspace.forbiddenPatterns.metrics", "no metrics yet (no scans recorded)");
   }
   if (config.obsidianVault) {
-    if (existsSync15(config.obsidianVault)) ok("obsidian.vault", config.obsidianVault);
+    if (existsSync17(config.obsidianVault)) ok("obsidian.vault", config.obsidianVault);
     else warn("obsidian.vault", `${config.obsidianVault} configured but path does not exist`);
   } else {
     ok("obsidian.vault", "not configured (optional)");
@@ -11695,29 +12808,29 @@ async function runVideoCommand(args) {
   if (preset === "presets" || preset === "list") {
     console.log("Video presets:");
     for (const item of videoPresets) {
-      const aliases = item.aliases.length ? ` aliases: ${item.aliases.join(", ")}` : "";
-      console.log(`- ${item.name} (${item.width}x${item.height}, ${item.fps}fps, ${item.duration}s)${aliases}`);
+      const aliases2 = item.aliases.length ? ` aliases: ${item.aliases.join(", ")}` : "";
+      console.log(`- ${item.name} (${item.width}x${item.height}, ${item.fps}fps, ${item.duration}s)${aliases2}`);
       console.log(`  ${item.description}`);
     }
     return;
   }
   if (preset === "render-ad") {
     const cwd2 = resolve12(flagString(args, "cwd") ?? process.cwd());
-    const input2 = flagString(args, "input");
-    if (!input2) {
+    const input = flagString(args, "input");
+    if (!input) {
       console.log("Usage: tanya video render-ad --input spec.json [--output-dir dir] [--basename name] [--format mp4] [--format poster]");
       return;
     }
     const formats2 = flagStrings(args, "format");
     const renderOptions = {
-      input: input2,
+      input,
       formats: formats2.length ? formats2 : ["mp4", "poster"]
     };
     const outputDir2 = flagString(args, "output-dir") ?? flagString(args, "outputDir");
-    const basename5 = flagString(args, "basename");
+    const basename6 = flagString(args, "basename");
     const ffmpegPath = flagString(args, "ffmpeg-path") ?? flagString(args, "ffmpegPath");
     if (outputDir2) renderOptions.outputDir = outputDir2;
-    if (basename5) renderOptions.basename = basename5;
+    if (basename6) renderOptions.basename = basename6;
     if (ffmpegPath) renderOptions.ffmpegPath = ffmpegPath;
     const result2 = await renderFullAd(renderOptions, cwd2);
     console.log(JSON.stringify({
@@ -11739,7 +12852,7 @@ async function runVideoCommand(args) {
   const formats = flagStrings(args, "format");
   const options = { preset };
   const outputDir = flagString(args, "output-dir") ?? flagString(args, "outputDir");
-  const basename4 = flagString(args, "basename");
+  const basename5 = flagString(args, "basename");
   const width = flagNumber(args, "width");
   const height = flagNumber(args, "height");
   const fps = flagNumber(args, "fps");
@@ -11750,7 +12863,7 @@ async function runVideoCommand(args) {
   const badge = flagString(args, "badge");
   const lines = flagStrings(args, "line");
   if (outputDir) options.outputDir = outputDir;
-  if (basename4) options.basename = basename4;
+  if (basename5) options.basename = basename5;
   if (width !== void 0) options.width = width;
   if (height !== void 0) options.height = height;
   if (fps !== void 0) options.fps = fps;
@@ -11767,6 +12880,7 @@ async function runVideoCommand(args) {
 }
 async function main() {
   const args = parseArgs(process.argv.slice(2));
+  applyCliProviderFlag(args);
   if (args.command === "help" || args.command === "--help" || args.command === "-h") {
     console.log(usage());
     return;
@@ -11777,13 +12891,13 @@ async function main() {
   }
   if (args.command === "patterns") {
     const cwd2 = resolve12(flagString(args, "cwd") ?? process.cwd());
-    const metricsPath = join20(cwd2, ".tania", "memory", "forbidden-patterns-metrics.json");
-    if (!existsSync15(metricsPath)) {
+    const metricsPath = join22(cwd2, ".tania", "memory", "forbidden-patterns-metrics.json");
+    if (!existsSync17(metricsPath)) {
       console.log(`No metrics file at ${metricsPath}. Run a tanya task in this workspace first.`);
       return;
     }
     try {
-      const parsed = JSON.parse(readFileSync7(metricsPath, "utf8"));
+      const parsed = JSON.parse(readFileSync8(metricsPath, "utf8"));
       const totals = parsed.totals ?? {};
       const lastFiredAt = parsed.lastFiredAt ?? {};
       const entries = Object.entries(totals).sort((a, b) => b[1] - a[1]);
@@ -11807,10 +12921,10 @@ async function main() {
   }
   if (args.command === "providers") {
     if (args.positional[0] !== "test") {
-      console.log("Usage: tanya providers test");
+      console.log("Usage: tanya providers test --provider <name>");
       return;
     }
-    await testProvider();
+    await testProvider(args);
     return;
   }
   if (args.command === "init") {
@@ -11840,31 +12954,13 @@ async function main() {
   }
   if (args.command === "runs") {
     const cwd2 = resolve12(flagString(args, "cwd") ?? process.cwd());
-    const runsDir = join20(cwd2, ".tania", "runs");
-    if (!existsSync15(runsDir)) {
+    const logs = readRunLogs(cwd2, 10);
+    if (logs.length === 0) {
       process.stdout.write("No run logs found. Run tanya run first.\n");
       return;
     }
-    const { readdirSync: readdirSync5, readFileSync: readFileSync8 } = await import("fs");
-    const files = readdirSync5(runsDir).filter((file) => file.endsWith(".json")).sort().reverse().slice(0, 10);
-    if (files.length === 0) {
-      process.stdout.write("No run logs found.\n");
-      return;
-    }
-    for (const file of files) {
-      try {
-        const log = JSON.parse(readFileSync8(join20(runsDir, file), "utf8"));
-        const cost = estimateRunCost(log.model, log.promptTokens ?? 0, log.completionTokens ?? 0);
-        const status = log.blockers?.length > 0 ? "BLOCKED" : "OK";
-        const duration = `${Math.round((log.durationMs ?? 0) / 1e3)}s`;
-        const fileCount = log.changedFiles?.length ?? 0;
-        process.stdout.write(
-          `${log.ts?.slice(0, 16)}  ${status.padEnd(7)} ${duration.padStart(5)}  ${cost.padStart(8)}  ${fileCount} file(s)  ${log.prompt?.slice(0, 60)}
-`
-        );
-      } catch {
-      }
-    }
+    for (const log of logs) process.stdout.write(`${formatRunLogLine(log)}
+`);
     return;
   }
   applyCliProfileFlag(args);
@@ -11878,9 +12974,9 @@ async function main() {
     const systemPrompt = buildSystemPrompt(cwd2, runContext, historyBlock, task);
     const skillPacks = loadPromptSkillPacks(cwd2, runContext, task);
     const sections = flagStrings(args, "section");
-    const output2 = selectPromptSections(systemPrompt, sections);
+    const output = selectPromptSections(systemPrompt, sections);
     process.stdout.write("=== SYSTEM PROMPT ===\n\n");
-    process.stdout.write(output2);
+    process.stdout.write(output);
     process.stdout.write("\n\n=== END SYSTEM PROMPT ===\n");
     if (sections.length === 0) {
       process.stdout.write(`
@@ -12053,7 +13149,12 @@ ${postBlockers.map((blocker) => `  - ${blocker}`).join("\n")}
       }
     }
     if (runPromptTokens > 0 || runCompletionTokens > 0) {
-      const costStr = estimateRunCost(config.model, runPromptTokens, runCompletionTokens);
+      const costStr = estimateRunCost({
+        provider: config.provider,
+        model: config.model,
+        promptTokens: runPromptTokens,
+        completionTokens: runCompletionTokens
+      }).display;
       process.stderr.write(
         `[tanya] Tokens: ${runPromptTokens.toLocaleString()} in / ${runCompletionTokens.toLocaleString()} out  ${costStr}
 `