zelari-code 2.34.1 → 2.36.0

package/dist/cli/main.bundled.js

@@ -1473,7 +1473,7 @@ var init_anthropicOAuth = __esm({
     init_grokOAuth();
     DEFAULT_ANTHROPIC_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
     ANTHROPIC_AUTHORIZE_URL = "https://claude.ai/oauth/authorize";
-    ANTHROPIC_TOKEN_URL = "https://console.anthropic.com/v1/oauth/token";
+    ANTHROPIC_TOKEN_URL = "https://platform.claude.com/v1/oauth/token";
     ANTHROPIC_REDIRECT_URI = "https://console.anthropic.com/oauth/code/callback";
     ANTHROPIC_SCOPE = "org:create_api_key user:profile user:inference";
     AnthropicOAuthError = class extends Error {
@@ -1495,7 +1495,35 @@ function registerDefaultRefreshImpls() {
   if (!registry.has("chatgpt")) registry.set("chatgpt", chatgptRefreshAdapter);
   if (!registry.has("anthropic")) registry.set("anthropic", anthropicRefreshAdapter);
 }
-var registry, grokRefreshAdapter, chatgptRefreshAdapter, anthropicRefreshAdapter;
+function normalizeRefreshError(providerId, err) {
+  const code = err?.code;
+  const message = err instanceof Error ? err.message : String(err);
+  if (code === "invalid_grant" || message.includes("invalid_grant")) {
+    return new RefreshRejectedError(
+      `${providerId}: refresh token rejected (invalid_grant) \u2014 run /login ${providerId} to re-authenticate`,
+      providerId,
+      err
+    );
+  }
+  return err;
+}
+async function runRefreshImpl(id3, refreshToken) {
+  const existing = inflightRefresh.get(id3);
+  if (existing) return existing;
+  const impl = getRefreshImpl(id3);
+  if (!impl) {
+    throw new Error(`No refresh impl registered for provider "${id3}"`);
+  }
+  const run = Promise.resolve().then(() => impl(id3, refreshToken)).catch((err) => {
+    throw normalizeRefreshError(id3, err);
+  });
+  inflightRefresh.set(id3, run);
+  void run.finally(() => {
+    if (inflightRefresh.get(id3) === run) inflightRefresh.delete(id3);
+  }).catch(() => void 0);
+  return run;
+}
+var registry, grokRefreshAdapter, chatgptRefreshAdapter, anthropicRefreshAdapter, RefreshRejectedError, inflightRefresh;
 var init_refreshRegistry = __esm({
   "src/cli/refreshRegistry.ts"() {
     "use strict";
@@ -1514,6 +1542,17 @@ var init_refreshRegistry = __esm({
     anthropicRefreshAdapter = async (_providerId, refreshToken) => {
       return refreshAnthropicToken({ refreshToken });
     };
+    RefreshRejectedError = class extends Error {
+      constructor(message, providerId, cause) {
+        super(message);
+        this.providerId = providerId;
+        this.cause = cause;
+        this.name = "RefreshRejectedError";
+      }
+      /** Marker callers can check without importing the class. */
+      reloginRequired = true;
+    };
+    inflightRefresh = /* @__PURE__ */ new Map();
   }
 });
 
@@ -1742,11 +1781,7 @@ var init_keyStore = __esm({
       "anthropic"
     ];
     defaultRefreshImpl = async (providerId, refreshToken) => {
-      const impl = getRefreshImpl(providerId);
-      if (!impl) {
-        throw new Error(`No refresh impl registered for provider "${providerId}"`);
-      }
-      return impl(providerId, refreshToken);
+      return runRefreshImpl(providerId, refreshToken);
     };
   }
 });
@@ -1767,10 +1802,11 @@ function effortLevelsFor(id3, model) {
   const m = (model ?? "").trim();
   switch (id3) {
     case "grok":
-    case "openai-compatible":
-    case "custom":
       if (grokHasXhigh(m)) return [...BASE_EFFORTS, "xhigh"];
       return [...BASE_EFFORTS];
+    case "openai-compatible":
+    case "custom":
+      return [...BASE_EFFORTS, "xhigh", "max"];
     case "chatgpt":
       if (gptHasMax(m)) return [...BASE_EFFORTS, "xhigh", "max"];
       if (gptHasXhigh(m)) return [...BASE_EFFORTS, "xhigh"];
@@ -1983,13 +2019,14 @@ function translateOpenAiCompatibleThinking(providerId, spec, model) {
       };
   }
 }
-function translateResponsesThinking(spec, model) {
+function translateResponsesThinking(spec, model, providerId) {
   if (spec === "auto") return { patch: {}, degraded: false };
+  const id3 = providerId ?? "chatgpt";
   switch (spec.kind) {
     case "off":
       return { patch: { reasoning: { effort: "minimal" } }, degraded: false };
     case "effort": {
-      const resolved = clampEffort("chatgpt", model, spec.effort);
+      const resolved = clampEffort(id3, model, spec.effort);
       return withClampNote(
         { reasoning: { effort: resolved.effort } },
         resolved.clamped,
@@ -1997,7 +2034,7 @@ function translateResponsesThinking(spec, model) {
       );
     }
     case "budget":
-      return degrade('thinking "budget" is not supported for chatgpt \u2014 use low/medium/high/xhigh/max');
+      return degrade(`thinking "budget" is not supported on the Responses API for "${id3}" \u2014 use low/medium/high/xhigh/max`);
   }
 }
 function translateAnthropicThinking(spec, model) {
@@ -2046,6 +2083,7 @@ __export(providerConfig_exports, {
   clearKrakenVerifier: () => clearKrakenVerifier,
   getActiveModel: () => getActiveModel,
   getActiveProvider: () => getActiveProvider,
+  getApiStyleFor: () => getApiStyleFor,
   getCustomEndpoint: () => getCustomEndpoint,
   getKrakenVerifierOverride: () => getKrakenVerifierOverride,
   getModelForProvider: () => getModelForProvider,
@@ -2054,6 +2092,7 @@ __export(providerConfig_exports, {
   getThinkingForProvider: () => getThinkingForProvider,
   loadProviderConfig: () => loadProviderConfig,
   setActiveProviderId: () => setActiveProviderId,
+  setApiStyleFor: () => setApiStyleFor,
   setCustomEndpoint: () => setCustomEndpoint,
   setKrakenVerifier: () => setKrakenVerifier,
   setModelForProvider: () => setModelForProvider,
@@ -2071,6 +2110,7 @@ function mergeStoredProviderConfig(parsed) {
       modelByProvider: { ...DEFAULTS.modelByProvider, ...parsed.modelByProvider },
       thinkingByProvider: { ...DEFAULTS.thinkingByProvider, ...parsed.thinkingByProvider },
       customEndpoints: mergeCustomEndpoints(parsed.customEndpoints),
+      apiStyleByProvider: mergeApiStyles(parsed.apiStyleByProvider),
       krakenVerifier: mergeKrakenVerifier(parsed.krakenVerifier)
     };
   }
@@ -2084,6 +2124,17 @@ function cloneDefaults() {
     customEndpoints: { ...DEFAULTS.customEndpoints }
   };
 }
+function mergeApiStyles(raw) {
+  if (!raw || typeof raw !== "object") return {};
+  const result = {};
+  const validIds = new Set(PROVIDERS.map((p3) => p3.id));
+  for (const [key, value] of Object.entries(raw)) {
+    if (!validIds.has(key)) continue;
+    if (value !== "responses") continue;
+    result[key] = "responses";
+  }
+  return result;
+}
 function applyEnvOverrides(config2) {
   const envActive = process.env.ANATHEMA_ACTIVE_PROVIDER;
   const envModel = process.env.OPENAI_MODEL;
@@ -2155,6 +2206,23 @@ function clearCustomEndpoint(id3) {
   delete config2.customEndpoints[id3];
   writeProviderConfig(config2);
 }
+function getApiStyleFor(id3) {
+  return getProviderConfig().apiStyleByProvider?.[id3] === "responses" ? "responses" : "chat";
+}
+function setApiStyleFor(id3, style) {
+  const spec = PROVIDERS.find((p3) => p3.id === id3);
+  if (!spec) {
+    throw new Error(`Unknown provider id: "${id3}". Available: ${PROVIDERS.map((p3) => p3.id).join(", ")}`);
+  }
+  if (style !== "chat" && style !== "responses") {
+    throw new Error(`Invalid api style: "${style}". Use 'chat' or 'responses'.`);
+  }
+  const config2 = getProviderConfig();
+  if (!config2.apiStyleByProvider) config2.apiStyleByProvider = {};
+  if (style === "chat") delete config2.apiStyleByProvider[id3];
+  else config2.apiStyleByProvider[id3] = "responses";
+  writeProviderConfig(config2);
+}
 function mergeKrakenVerifier(raw) {
   if (!raw || typeof raw !== "object") return void 0;
   const provider = typeof raw.provider === "string" ? raw.provider.trim() : "";
@@ -2362,23 +2430,23 @@ async function resolveAuthToken(provider, options) {
   return resolved?.apiKey;
 }
 async function resolveDiscoveryHeaders(provider, authToken) {
-  const headers2 = { Accept: "application/json" };
-  if (!authToken) return headers2;
+  const headers3 = { Accept: "application/json" };
+  if (!authToken) return headers3;
   if (provider === "anthropic") {
-    headers2.Authorization = `Bearer ${authToken}`;
-    headers2["x-api-key"] = authToken;
-    headers2["anthropic-version"] = "2023-06-01";
-    headers2["anthropic-beta"] = "oauth-2025-04-20";
-    return headers2;
+    headers3.Authorization = `Bearer ${authToken}`;
+    headers3["x-api-key"] = authToken;
+    headers3["anthropic-version"] = "2023-06-01";
+    headers3["anthropic-beta"] = "oauth-2025-04-20";
+    return headers3;
   }
-  headers2.Authorization = `Bearer ${authToken}`;
+  headers3.Authorization = `Bearer ${authToken}`;
   if (provider === "chatgpt") {
     const { getOAuthToken: getOAuthToken2 } = await Promise.resolve().then(() => (init_keyStore(), keyStore_exports));
     const accountId = getOAuthToken2("chatgpt")?.accountId;
-    if (accountId) headers2["ChatGPT-Account-Id"] = accountId;
-    headers2["OpenAI-Beta"] = "responses=experimental";
+    if (accountId) headers3["ChatGPT-Account-Id"] = accountId;
+    headers3["OpenAI-Beta"] = "responses=experimental";
   }
-  return headers2;
+  return headers3;
 }
 function parseAnthropicModelsResponse(json3) {
   if (!json3 || typeof json3 !== "object") return [];
@@ -2430,8 +2498,8 @@ async function discoverModelsForProvider(provider, options = {}) {
   const fetchImpl = options.fetchImpl ?? fetch;
   let response;
   try {
-    const headers2 = await resolveDiscoveryHeaders(provider, authToken);
-    response = await fetchImpl(url2, { method: "GET", headers: headers2 });
+    const headers3 = await resolveDiscoveryHeaders(provider, authToken);
+    response = await fetchImpl(url2, { method: "GET", headers: headers3 });
   } catch (err) {
     throw new ModelDiscoveryError(
       `Network error contacting ${url2}: ${err instanceof Error ? err.message : String(err)}`,
@@ -3414,10 +3482,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path99) {
-  if (!path99)
+function getElementAtPath(obj, path100) {
+  if (!path100)
     return obj;
-  return path99.reduce((acc, key) => acc?.[key], obj);
+  return path100.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -3745,11 +3813,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path99, issues) {
+function prefixIssues(path100, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path99);
+    iss.path.unshift(path100);
     return iss;
   });
 }
@@ -3967,16 +4035,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path99 = []) => {
+  const processError = (error52, path100 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path99, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path100, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path99, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path100, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path99, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path100, ...issue2.path]);
       } else {
-        const fullpath = [...path99, ...issue2.path];
+        const fullpath = [...path100, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -4003,17 +4071,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path99 = []) => {
+  const processError = (error52, path100 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path99, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path100, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path99, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path100, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path99, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path100, ...issue2.path]);
       } else {
-        const fullpath = [...path99, ...issue2.path];
+        const fullpath = [...path100, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -4045,8 +4113,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path99 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path99) {
+  const path100 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path100) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -17549,13 +17617,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path99 = ref.slice(1).split("/").filter(Boolean);
-  if (path99.length === 0) {
+  const path100 = ref.slice(1).split("/").filter(Boolean);
+  if (path100.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path99[0] === defsKey) {
-    const key = path99[1];
+  if (path100[0] === defsKey) {
+    const key = path100[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -18327,7 +18395,9 @@ var init_zod = __esm({
 });
 
 // packages/core/dist/core/tools/toolTypes.js
-function typedOk(value, meta3) {
+function typedOk(value, meta3, images) {
+  if (images && images.length > 0)
+    return { ok: true, value, meta: meta3, images };
   return meta3 ? { ok: true, value, meta: meta3 } : { ok: true, value };
 }
 function typedErr(error51, meta3) {
@@ -18387,17 +18457,17 @@ var init_newlines = __esm({
 });
 
 // packages/core/dist/core/tools/builtin/fileEvents.js
-function fileReadEvent(path99, snapshotId) {
-  return { kind: "file.read", actor: { type: "tool" }, data: { path: path99, snapshotId } };
+function fileReadEvent(path100, snapshotId) {
+  return { kind: "file.read", actor: { type: "tool" }, data: { path: path100, snapshotId } };
 }
-function fileAppliedEvent(path99, snapshotId, bytes) {
-  return { kind: "file.applied", actor: { type: "tool" }, data: { path: path99, snapshotId, bytes } };
+function fileAppliedEvent(path100, snapshotId, bytes) {
+  return { kind: "file.applied", actor: { type: "tool" }, data: { path: path100, snapshotId, bytes } };
 }
-function fileRejectedEvent(path99, reason, hint) {
+function fileRejectedEvent(path100, reason, hint) {
   return {
     kind: "file.rejected",
     actor: { type: "tool" },
-    data: hint === void 0 ? { path: path99, reason } : { path: path99, reason, hint }
+    data: hint === void 0 ? { path: path100, reason } : { path: path100, reason, hint }
   };
 }
 function reReadHint(reject) {
@@ -19313,8 +19383,8 @@ async function searchFile(absPath, relPath, regex, contextLines, remainingSlots)
 }
 async function isDirectory(p3) {
   try {
-    const stat7 = await fs7.stat(p3);
-    return stat7.isDirectory();
+    const stat8 = await fs7.stat(p3);
+    return stat8.isDirectory();
   } catch {
     return false;
   }
@@ -20266,11 +20336,11 @@ var init_tools = __esm({
           if (!ctx.addDocument)
             return "Knowledge vault tool not available.";
           const title = args["title"] || "New Document";
-          const path99 = args["path"] || `notes/${title.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`;
+          const path100 = args["path"] || `notes/${title.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`;
           const content = args["content"] || "";
           const tags = args["tags"] || [];
           ctx.addDocument({
-            path: path99,
+            path: path100,
             title,
             content,
             format: "markdown",
@@ -20279,7 +20349,7 @@ var init_tools = __esm({
             workspaceId: ctx.workspaceId
           });
           ctx.addActivity("vault", "created document", title);
-          return `Document "${title}" created at "${path99}".`;
+          return `Document "${title}" created at "${path100}".`;
         }
       }
     ];
@@ -25104,16 +25174,16 @@ function runRetentionFromEnv() {
     maxTotalBytes: Number.isFinite(parseMb) && parseMb > 0 ? Math.round(parseMb * 1024 * 1024) : DEFAULT_RUN_RETENTION_MAX_MB * 1024 * 1024
   };
 }
-async function dirSize(path99) {
+async function dirSize(path100) {
   let total = 0;
   let entries;
   try {
-    entries = await readdir(path99, { withFileTypes: true });
+    entries = await readdir(path100, { withFileTypes: true });
   } catch {
     return 0;
   }
   for (const entry of entries) {
-    const child = join3(path99, entry.name);
+    const child = join3(path100, entry.name);
     if (entry.isDirectory())
       total += await dirSize(child);
     else {
@@ -25140,19 +25210,19 @@ async function enforceRunRetention(runsDir, options = {}) {
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    const path99 = join3(runsDir, entry.name);
+    const path100 = join3(runsDir, entry.name);
     let startedAt = 0;
     let endedAt;
     let completed = false;
     try {
-      const manifest = JSON.parse(await readFile(join3(path99, "manifest.json"), "utf8"));
+      const manifest = JSON.parse(await readFile(join3(path100, "manifest.json"), "utf8"));
       startedAt = manifest.startedAt ?? 0;
       endedAt = manifest.endedAt;
       completed = Boolean(endedAt) && manifest.status !== "running";
     } catch {
       completed = false;
     }
-    infos.push({ name: entry.name, path: path99, startedAt, endedAt, completed, bytes: await dirSize(path99) });
+    infos.push({ name: entry.name, path: path100, startedAt, endedAt, completed, bytes: await dirSize(path100) });
   }
   const remove = async (info) => {
     await rm(info.path, { recursive: true, force: true });
@@ -25639,12 +25709,12 @@ var init_engine = __esm({
        * content digest) and the returned ref carries the event seq when the
        * emitter resolved one.
        */
-      async fsEvidence(observation, path99, sha256, content, extra = {}) {
+      async fsEvidence(observation, path100, sha256, content, extra = {}) {
         const digest = sha256 && content !== void 0 ? sha256(content) : void 0;
-        const seq = await this.emitEvidence({ observation, path: path99, ...extra, ...digest ? { digest } : {} });
+        const seq = await this.emitEvidence({ observation, path: path100, ...extra, ...digest ? { digest } : {} });
         return {
           tier: "fs-observation",
-          ref: path99,
+          ref: path100,
           capturedAt: Date.now(),
           ...digest ? { digest } : {},
           ...seq !== void 0 ? { seq } : {}
@@ -29106,7 +29176,8 @@ ${shared.content}`,
             return {
               content: resultStr,
               isError: !result.ok,
-              durationMs: Date.now() - startMs
+              durationMs: Date.now() - startMs,
+              ...result.ok && result.images && result.images.length > 0 ? { images: result.images } : {}
             };
           })();
           inflight.set(callKey, prom);
@@ -29127,7 +29198,8 @@ ${shared.content}`,
             toolCallId: p3.toolCallId,
             content: r.content,
             isError: r.isError,
-            endEvent
+            endEvent,
+            ...r.images ? { images: r.images } : {}
             // Cache already written in invokeOne; no need to re-set.
           };
         };
@@ -29679,7 +29751,8 @@ ${cached2}`
                   yield item.endEvent;
                   turnToolResults.push({
                     toolCallId: item.toolCallId,
-                    content: item.content
+                    content: item.content,
+                    ...item.images ? { images: item.images } : {}
                   });
                   if (item.cacheKey && item.content && !item.isError) {
                     this.toolCallCache.set(item.cacheKey, item.content);
@@ -29859,7 +29932,8 @@ ${cached2}`
                 this.config.messages.push({
                   role: "tool",
                   toolCallId: tr.toolCallId,
-                  content: tr.content
+                  content: tr.content,
+                  ...tr.images ? { images: tr.images } : {}
                 });
               }
               if (truncatedToolCall) {
@@ -31660,11 +31734,11 @@ var init_synthesisAudit = __esm({
 import { existsSync as existsSync10, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "node:fs";
 import { join as join5 } from "node:path";
 function loadNfrSpec(zelariRoot) {
-  const path99 = join5(zelariRoot, "nfr-spec.json");
-  if (!existsSync10(path99))
+  const path100 = join5(zelariRoot, "nfr-spec.json");
+  if (!existsSync10(path100))
     return null;
   try {
-    const raw = JSON.parse(readFileSync9(path99, "utf8"));
+    const raw = JSON.parse(readFileSync9(path100, "utf8"));
     if (raw.version !== 1 || !Array.isArray(raw.targets))
       return null;
     return raw;
@@ -34047,9 +34121,9 @@ var init_types9 = __esm({
 import { readFileSync as readFileSync14 } from "node:fs";
 import { join as join11 } from "node:path";
 function readLessonsDeduped(zelariRoot) {
-  const path99 = join11(zelariRoot, LESSONS_FILE);
+  const path100 = join11(zelariRoot, LESSONS_FILE);
   try {
-    const raw = readFileSync14(path99, "utf8");
+    const raw = readFileSync14(path100, "utf8");
     const byId = /* @__PURE__ */ new Map();
     for (const line of raw.split(/\r?\n/)) {
       if (!line.trim())
@@ -34150,8 +34224,8 @@ function keywordsFrom(check2, signature) {
   return [.../* @__PURE__ */ new Set([...fromId, ...words])].slice(0, 12);
 }
 function writeLesson(zelariRoot, lesson) {
-  const path99 = join12(zelariRoot, LESSONS_FILE);
-  appendFileSync(path99, `${JSON.stringify(lesson)}
+  const path100 = join12(zelariRoot, LESSONS_FILE);
+  appendFileSync(path100, `${JSON.stringify(lesson)}
 `, "utf8");
 }
 function findSimilar(lessons, signature) {
@@ -36118,9 +36192,9 @@ function findCycle(nodes) {
     if (color.get(start) !== WHITE)
       continue;
     const stack = [[start, 0]];
-    const path99 = [];
+    const path100 = [];
     color.set(start, GRAY);
-    path99.push(start);
+    path100.push(start);
     while (stack.length > 0) {
       const top = stack[stack.length - 1];
       const [id3, idx] = top;
@@ -36133,17 +36207,17 @@ function findCycle(nodes) {
           continue;
         const c = color.get(dep);
         if (c === GRAY) {
-          const at = path99.indexOf(dep);
-          return [...path99.slice(at), dep];
+          const at = path100.indexOf(dep);
+          return [...path100.slice(at), dep];
         }
         if (c === WHITE) {
           color.set(dep, GRAY);
-          path99.push(dep);
+          path100.push(dep);
           stack.push([dep, 0]);
         }
       } else {
         color.set(id3, BLACK);
-        path99.pop();
+        path100.pop();
         stack.pop();
       }
     }
@@ -37063,8 +37137,8 @@ var init_runner = __esm({
           failed: [...this.tentaclesById.values()].filter((r) => r.status === "error"),
           pending: []
         };
-        const path99 = await this.host.saveSnapshot(snapshot, ".zelari/kraken/snapshots");
-        this.host.log(`checkpoint: ${label ?? "auto"} \u2192 ${path99}`);
+        const path100 = await this.host.saveSnapshot(snapshot, ".zelari/kraken/snapshots");
+        this.host.log(`checkpoint: ${label ?? "auto"} \u2192 ${path100}`);
         return snapshot;
       }
       callLog(msg, data) {
@@ -38215,7 +38289,7 @@ var CORE_VERSION;
 var init_version = __esm({
   "packages/core/dist/version.js"() {
     "use strict";
-    CORE_VERSION = "2.34.1";
+    CORE_VERSION = "2.36.0";
   }
 });
 
@@ -40673,9 +40747,9 @@ function spillToolOutput(fullText, meta3) {
     const rnd = randomBytes3(3).toString("hex");
     const safeTool = (meta3?.toolName ?? "tool").replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 32);
     const file2 = `${stamp}-${safeTool}-${hash3}-${rnd}.txt`;
-    const path99 = join14(dir, file2);
-    writeFileSync12(path99, fullText, "utf8");
-    return path99;
+    const path100 = join14(dir, file2);
+    writeFileSync12(path100, fullText, "utf8");
+    return path100;
   } catch {
     return null;
   }
@@ -40721,10 +40795,10 @@ function truncateToolResult(text, capOrOpts = TOOL_RESULT_LINE_CAP) {
 ${tail2}`;
   }
   if (doSpill) {
-    const path99 = spillToolOutput(text, { toolName: opts.toolName });
-    if (path99) {
+    const path100 = spillToolOutput(text, { toolName: opts.toolName });
+    if (path100) {
       const spillNote = `
-\u2026 [full output spilled to: ${path99} \u2014 re-read with read_file if you need the complete text] \u2026`;
+\u2026 [full output spilled to: ${path100} \u2014 re-read with read_file if you need the complete text] \u2026`;
       if (preview.includes("] \u2026\n")) {
         preview = preview.replace("] \u2026\n", `] \u2026${spillNote}
 `);
@@ -41495,28 +41569,28 @@ var init_storage = __esm({
     VALID_SCALARS = /^(true|false|null|~)$/i;
     Storage = class {
       /** Read a Markdown file with frontmatter. Throws if not found. */
-      read(path99) {
-        if (!existsSync19(path99)) {
-          throw new Error(`File not found: ${path99}`);
+      read(path100) {
+        if (!existsSync19(path100)) {
+          throw new Error(`File not found: ${path100}`);
         }
-        const md = readFileSync17(path99, "utf8");
+        const md = readFileSync17(path100, "utf8");
         return parseFrontmatter(md);
       }
       /** Read a Markdown file; returns null if not found. */
-      readIfExists(path99) {
-        if (!existsSync19(path99)) return null;
-        return this.read(path99);
+      readIfExists(path100) {
+        if (!existsSync19(path100)) return null;
+        return this.read(path100);
       }
       /**
        * Write a Markdown file atomically (tmp + rename). Creates parent dirs.
        * The meta object is serialized as YAML frontmatter; body as Markdown.
        */
-      write(path99, meta3, body) {
-        mkdirSync10(dirname2(path99), { recursive: true });
-        const tmp = path99 + ".tmp-" + process.pid;
+      write(path100, meta3, body) {
+        mkdirSync10(dirname2(path100), { recursive: true });
+        const tmp = path100 + ".tmp-" + process.pid;
         const md = serializeFrontmatter(meta3, body);
         writeFileSync14(tmp, md, "utf8");
-        renameSync2(tmp, path99);
+        renameSync2(tmp, path100);
       }
       /** List all .md files in a directory (non-recursive). */
       listMarkdown(dir) {
@@ -41591,8 +41665,8 @@ function nextPlanTaskId(store6) {
   return `t${store6.counter}`;
 }
 function writePlanTaskArtifact(rootDir, task) {
-  const path99 = join17(rootDir, "plan-tasks", `${task.id}.md`);
-  mkdirSync11(dirname3(path99), { recursive: true });
+  const path100 = join17(rootDir, "plan-tasks", `${task.id}.md`);
+  mkdirSync11(dirname3(path100), { recursive: true });
   const meta3 = {
     kind: "task",
     id: task.id,
@@ -41613,7 +41687,7 @@ function writePlanTaskArtifact(rootDir, task) {
     task.notes?.trim() ? task.notes.trim() : "_(no notes)_",
     ""
   ].filter((l) => l !== null).join("\n");
-  new Storage().write(path99, meta3, body);
+  new Storage().write(path100, meta3, body);
 }
 function loadHandle(rootDir) {
   const jsonPath = join17(rootDir, "plan.json");
@@ -50815,12 +50889,9 @@ function backoffDelay(attempt, retryAfterHeader) {
   }
   return Math.min(BACKOFF_BASE_MS * 2 ** attempt, BACKOFF_CAP_MS);
 }
-function modelSupportsVision(model) {
+function modelSupportsVision(_model) {
   const force = process.env.ZELARI_VISION;
-  if (force === "1" || force === "true" || force === "on") return true;
-  if (force === "0" || force === "false" || force === "off") return false;
-  const m = model.toLowerCase();
-  return VISION_MODEL_HINTS.some((hint) => m.includes(hint));
+  return !(force === "0" || force === "false" || force === "off");
 }
 function dataUriFromImage(img) {
   return `data:${img.mime};base64,${img.dataBase64}`;
@@ -50915,6 +50986,22 @@ ${notes}
   }
   return { role: m.role, content: m.content };
 }
+function imagesFollowUpMessage(images) {
+  const labels = images.map((img) => img.alt ?? img.mime).join(", ");
+  return {
+    role: "user",
+    content: [
+      {
+        type: "text",
+        text: `[Immagine(i) dal tool: ${labels} \u2014 usa questi pixel per l'analisi visiva.]`
+      },
+      ...images.map((img) => ({
+        type: "image_url",
+        image_url: { url: dataUriFromImage(img) }
+      }))
+    ]
+  };
+}
 function positiveEnvInt(name) {
   const raw = process.env[name];
   if (!raw) return void 0;
@@ -50925,15 +51012,27 @@ function openaiCompatibleProvider(config2) {
   return async function* (params) {
     const capabilities = capabilitiesFor(params.model, config2.providerId);
     const vision = modelSupportsVision(params.model);
-    const messages = params.messages.map((m) => {
+    const msgsIn = params.messages;
+    let toolRunImages = [];
+    const messages = msgsIn.flatMap((m, i) => {
       const cacheable = !(m.role === "user" && m.images && m.images.length > 0);
       if (cacheable) {
         const cached2 = messageMappingCache.get(m);
-        if (cached2) return cached2;
+        if (cached2) return [cached2];
       }
       const mapped = mapAgentMessage(m, vision);
       if (cacheable) messageMappingCache.set(m, mapped);
-      return mapped;
+      if (m.role === "tool") {
+        if (m.images && m.images.length > 0) toolRunImages.push(...m.images);
+        const next = msgsIn[i + 1];
+        const runEnds = !next || next.role !== "tool";
+        if (runEnds && vision && toolRunImages.length > 0) {
+          const followUp = imagesFollowUpMessage(toolRunImages);
+          toolRunImages = [];
+          return [mapped, followUp];
+        }
+      }
+      return [mapped];
     });
     const generation = params.generation;
     const body = {
@@ -50985,7 +51084,7 @@ function openaiCompatibleProvider(config2) {
       const forceRecoveryTool = generation?.toolChoice === "required" && capabilities.buildRecovery.forceToolChoice && recoveryAttempt <= capabilities.buildRecovery.maxForcedTurns;
       body.tool_choice = forceRecoveryTool ? "required" : "auto";
     }
-    const headers2 = {
+    const headers3 = {
       "Content-Type": "application/json",
       Authorization: `Bearer ${config2.apiKey}`,
       ...config2.extraHeaders ?? {}
@@ -50993,7 +51092,7 @@ function openaiCompatibleProvider(config2) {
     const affinityHeader = capabilities.promptCache.conversationAffinityHeader;
     const conversationId = params.conversationId?.trim();
     if (affinityHeader && conversationId && conversationId.length <= 256 && !/[\u0000-\u001f\u007f]/.test(conversationId)) {
-      headers2[affinityHeader] = conversationId;
+      headers3[affinityHeader] = conversationId;
     }
     let response;
     let lastErrText = "";
@@ -51018,7 +51117,7 @@ function openaiCompatibleProvider(config2) {
         try {
           response = await fetch(`${config2.baseUrl}/chat/completions`, {
             method: "POST",
-            headers: headers2,
+            headers: headers3,
             body: JSON.stringify(body),
             // Cancel aborts the HTTP request; stream idle is enforced below
             // per-chunk so active multi-minute streams are not killed.
@@ -51257,7 +51356,7 @@ async function providerConfigFor(providerId) {
     ...extraFromStored(providerId)
   };
 }
-var RETRYABLE_STATUSES, MAX_RETRIES, BACKOFF_BASE_MS, BACKOFF_CAP_MS, PROVIDER_CONNECT_TIMEOUT_MS, PROVIDER_STREAM_IDLE_MS, PROVIDER_STREAM_MAX_MS, VISION_MODEL_HINTS, PROVIDER_ENDPOINTS, messageMappingCache;
+var RETRYABLE_STATUSES, MAX_RETRIES, BACKOFF_BASE_MS, BACKOFF_CAP_MS, PROVIDER_CONNECT_TIMEOUT_MS, PROVIDER_STREAM_IDLE_MS, PROVIDER_STREAM_MAX_MS, PROVIDER_ENDPOINTS, messageMappingCache;
 var init_openai_compatible = __esm({
   "src/cli/provider/openai-compatible.ts"() {
     "use strict";
@@ -51288,33 +51387,6 @@ var init_openai_compatible = __esm({
       const n = raw ? Number.parseInt(raw, 10) : 18e5;
       return Number.isFinite(n) && n >= 6e4 ? n : 18e5;
     })();
-    VISION_MODEL_HINTS = [
-      "grok-4",
-      "grok-3",
-      "grok-2-vision",
-      "grok-vision",
-      "glm-4v",
-      "glm-4.5v",
-      "glm-4.1v",
-      "glm-5v",
-      "qwen-vl",
-      "qwen2-vl",
-      "qwen2.5-vl",
-      "qwen3-vl",
-      "gpt-4o",
-      "gpt-4.1",
-      "gpt-4.5",
-      "gpt-4-vision",
-      "gpt-5",
-      "claude-3",
-      "claude-4",
-      "gemini-",
-      "gemini/",
-      "minimax-m1",
-      "minimax-m2",
-      "minimax-m3",
-      "deepseek-vl"
-    ];
     PROVIDER_ENDPOINTS = {
       "openai-compatible": "https://api.x.ai/v1",
       "minimax": "https://api.minimax.io/v1",
@@ -51709,6 +51781,16 @@ var init_driver = __esm({
 // src/cli/browser/tools.ts
 import path56 from "node:path";
 import os3 from "node:os";
+import { readFile as readFile7 } from "node:fs/promises";
+async function loadImageBlock(filePath) {
+  try {
+    const buf = await readFile7(filePath);
+    if (buf.byteLength > SCREENSHOT_MAX_BYTES) return void 0;
+    return { mime: "image/png", dataBase64: buf.toString("base64"), alt: path56.basename(filePath) };
+  } catch {
+    return void 0;
+  }
+}
 function createBrowserTool(deps = {}) {
   return {
     name: "browser_check",
@@ -51761,17 +51843,23 @@ function createBrowserTool(deps = {}) {
           note: "Weak smoke only: no selector/text/evaluate assertions. No console/page errors is necessary but not sufficient to claim a logic fix. Add waitForSelector, waitForText, or evaluate (DOM/read hooks) for stronger evidence.",
           smokeStrength: "weak"
         } : { smokeStrength: "asserted" }
-      });
+      }, void 0, await toolImages(result.screenshotPath));
     }
   };
 }
-var ActionSchema;
+async function toolImages(screenshotPath) {
+  if (!screenshotPath) return void 0;
+  const image = await loadImageBlock(screenshotPath);
+  return image ? [image] : void 0;
+}
+var SCREENSHOT_MAX_BYTES, ActionSchema;
 var init_tools5 = __esm({
   "src/cli/browser/tools.ts"() {
     "use strict";
     init_zod();
     init_toolTypes();
     init_driver();
+    SCREENSHOT_MAX_BYTES = 8 * 1024 * 1024;
     ActionSchema = external_exports.discriminatedUnion("type", [
       external_exports.object({ type: external_exports.literal("click"), selector: external_exports.string().min(1) }),
       external_exports.object({ type: external_exports.literal("fill"), selector: external_exports.string().min(1), value: external_exports.string() }),
@@ -51796,6 +51884,92 @@ var init_tools5 = __esm({
   }
 });
 
+// src/cli/tools/screenshotTool.ts
+import { execFile as execFile5 } from "node:child_process";
+import { mkdir as mkdir3, readFile as readFile8, stat as stat7 } from "node:fs/promises";
+import path57 from "node:path";
+import { promisify as promisify4 } from "node:util";
+async function captureWindows(target) {
+  const script = `Add-Type -AssemblyName System.Windows.Forms,System.Drawing;$b=[System.Windows.Forms.SystemInformation]::VirtualScreen;$bmp=New-Object System.Drawing.Bitmap $b.Width,$b.Height;$g=[System.Drawing.Graphics]::FromImage($bmp);$g.CopyFromScreen($b.Left,$b.Top,0,0,$bmp.Size);$g.Dispose(); $bmp.Save('${target.replace(/'/g, "''")}'); $bmp.Dispose();`;
+  await execFileAsync4("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], {
+    timeout: 12e3,
+    windowsHide: true
+  });
+}
+async function captureUnixLike(target) {
+  const attempts = process.platform === "darwin" ? [["screencapture", ["-x", target]]] : [
+    ["gnome-screenshot", ["-f", target]],
+    ["scrot", [target]],
+    ["import", ["-window", "root", target]]
+  ];
+  let lastErr = null;
+  for (const [bin, args] of attempts) {
+    try {
+      await execFileAsync4(bin, args, { timeout: 12e3 });
+      return;
+    } catch (e) {
+      lastErr = e;
+    }
+  }
+  throw lastErr ?? new Error("no screen-capture utility available");
+}
+function createScreenshotTool(deps = {}) {
+  return {
+    name: "screenshot",
+    description: "Capture a screenshot of the user screen(s) as PNG. Use it when the user asks to see/check something on screen (running app, game, dialog, error window) or when you need to LOOK at the current UI state to debug it. The image is returned to you as pixels (vision) and saved to disk; give the path back to the user so they can open it.",
+    permissions: ["ui"],
+    timeoutMs: 2e4,
+    inputSchema: external_exports.object({
+      note: external_exports.string().max(200).optional().describe("Why you are capturing (shown to the user with the permission prompt).")
+    }),
+    execute: async (args, ctx) => {
+      const a = args;
+      const dir = deps.outDir ?? path57.join(ctx.cwd ?? process.cwd(), ".zelari", "screenshots");
+      const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+      const target = path57.join(dir, `screenshot-${stamp}.png`);
+      const capture = deps.capture ?? (process.platform === "win32" ? captureWindows : captureUnixLike);
+      try {
+        await mkdir3(dir, { recursive: true });
+        await capture(target);
+        const meta3 = await stat7(target);
+        if (meta3.size === 0) return typedErr(`capture produced an empty file: ${target}`);
+        const buf = await readFile8(target);
+        const image = {
+          mime: "image/png",
+          dataBase64: buf.toString("base64"),
+          alt: path57.basename(target)
+        };
+        const attachable = meta3.size <= SCREENSHOT_MAX_BYTES2;
+        return typedOk(
+          {
+            ok: true,
+            path: target,
+            bytes: meta3.size,
+            ...a.note ? { note: a.note } : {},
+            ...attachable ? {} : { warning: "PNG over 8MB: pixels not attached to the model context; open the path instead." }
+          },
+          void 0,
+          attachable ? [image] : void 0
+        );
+      } catch (e) {
+        return typedErr(
+          `screen capture failed on ${process.platform}: ${e instanceof Error ? e.message : String(e)}`
+        );
+      }
+    }
+  };
+}
+var execFileAsync4, SCREENSHOT_MAX_BYTES2;
+var init_screenshotTool = __esm({
+  "src/cli/tools/screenshotTool.ts"() {
+    "use strict";
+    init_zod();
+    init_toolTypes();
+    execFileAsync4 = promisify4(execFile5);
+    SCREENSHOT_MAX_BYTES2 = 8 * 1024 * 1024;
+  }
+});
+
 // src/cli/ssh/targets.ts
 var targets_exports = {};
 __export(targets_exports, {
@@ -51837,21 +52011,21 @@ function normalizeAuth(auth) {
   return "agent";
 }
 function readSecrets() {
-  const path99 = getSshSecretsPath();
-  if (!existsSync30(path99)) return {};
+  const path100 = getSshSecretsPath();
+  if (!existsSync30(path100)) return {};
   try {
-    return JSON.parse(readFileSync22(path99, "utf8"));
+    return JSON.parse(readFileSync22(path100, "utf8"));
   } catch {
     return {};
   }
 }
 function writeSecrets(data) {
-  const path99 = getSshSecretsPath();
-  mkdirSync13(dirname4(path99), { recursive: true });
-  writeFileSync16(path99, `${JSON.stringify(data, null, 2)}
+  const path100 = getSshSecretsPath();
+  mkdirSync13(dirname4(path100), { recursive: true });
+  writeFileSync16(path100, `${JSON.stringify(data, null, 2)}
 `, "utf8");
   try {
-    chmodSync(path99, 384);
+    chmodSync(path100, 384);
   } catch {
   }
 }
@@ -51880,10 +52054,10 @@ function deleteSshPassword(id3) {
   writeSecrets({ passwords });
 }
 function readStore2() {
-  const path99 = getSshTargetsPath();
-  if (!existsSync30(path99)) return [];
+  const path100 = getSshTargetsPath();
+  if (!existsSync30(path100)) return [];
   try {
-    const parsed = JSON.parse(readFileSync22(path99, "utf8"));
+    const parsed = JSON.parse(readFileSync22(path100, "utf8"));
     const list = Array.isArray(parsed.targets) ? parsed.targets : [];
     return list.filter(
       (t) => t && typeof t.id === "string" && typeof t.host === "string" && typeof t.user === "string"
@@ -51898,11 +52072,11 @@ function readStore2() {
   }
 }
 function writeStore2(targets) {
-  const path99 = getSshTargetsPath();
-  mkdirSync13(dirname4(path99), { recursive: true });
+  const path100 = getSshTargetsPath();
+  mkdirSync13(dirname4(path100), { recursive: true });
   const clean = targets.map(({ hasPassword: _hp, ...t }) => t);
   writeFileSync16(
-    path99,
+    path100,
     `${JSON.stringify({ targets: clean }, null, 2)}
 `,
     "utf8"
@@ -52148,11 +52322,11 @@ function formatSshTargetsForPrompt() {
   ];
   for (const t of targets) {
     const tags = t.tags?.length ? ` tags=[${t.tags.join(",")}]` : "";
-    const path99 = t.defaultRemotePath ? ` remotePath=${t.defaultRemotePath}` : "";
+    const path100 = t.defaultRemotePath ? ` remotePath=${t.defaultRemotePath}` : "";
     const allow = t.allowedCommands?.length ? ` allowed=${t.allowedCommands.join("|")}` : " allowed=status-only";
     const auth = t.auth === "password" ? " auth=password" : t.auth === "keyPath" ? " auth=key" : " auth=agent";
     lines.push(
-      `- id=${t.id} name=${t.name} ${t.user}@${t.host}:${t.port ?? 22}${auth}${path99}${tags}${allow}`
+      `- id=${t.id} name=${t.name} ${t.user}@${t.host}:${t.port ?? 22}${auth}${path100}${tags}${allow}`
     );
   }
   return lines.join("\n");
@@ -52852,6 +53026,244 @@ var init_chatgpt = __esm({
   }
 });
 
+// src/cli/provider/responsesApi.ts
+function backoffDelay2(attempt, retryAfterHeader) {
+  if (retryAfterHeader) {
+    const seconds = Number.parseFloat(retryAfterHeader);
+    if (Number.isFinite(seconds) && seconds >= 0) {
+      return Math.min(seconds * 1e3, BACKOFF_CAP_MS2);
+    }
+  }
+  return Math.min(BACKOFF_BASE_MS2 * 2 ** attempt, BACKOFF_CAP_MS2);
+}
+function abortableSleep2(ms, signal) {
+  return new Promise((resolve9) => {
+    if (signal?.aborted) return resolve9();
+    const t = setTimeout(resolve9, ms);
+    signal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(t);
+        resolve9();
+      },
+      { once: true }
+    );
+  });
+}
+function headers2(config2) {
+  const h = {
+    "Content-Type": "application/json",
+    Accept: "text/event-stream",
+    Authorization: `Bearer ${config2.apiKey}`
+  };
+  if (config2.extraHeaders) Object.assign(h, config2.extraHeaders);
+  return h;
+}
+function responsesApiProvider(config2) {
+  return async function* (params) {
+    const capabilities = capabilitiesFor(params.model, config2.providerId);
+    const { instructions, input } = toInput(params.messages);
+    const body = {
+      model: params.model,
+      stream: true,
+      input
+    };
+    if (instructions) body.instructions = instructions;
+    if (params.tools && params.tools.length > 0) {
+      body.tools = params.tools.map((t) => ({
+        type: "function",
+        name: t.name,
+        description: t.description,
+        parameters: t.parameters
+      }));
+    }
+    const generation = params.generation;
+    body.temperature = generation?.temperature ?? capabilities.sampling.temperature;
+    const maxTokens = generation?.maxTokens ?? capabilities.maxOutputTokens;
+    if (typeof maxTokens === "number" && maxTokens > 0) {
+      body.max_output_tokens = maxTokens;
+    }
+    const thinkingSpec = config2.thinking ?? "auto";
+    if (thinkingSpec !== "auto") {
+      const t = translateResponsesThinking(thinkingSpec, config2.model, config2.providerId);
+      if (t.degraded) {
+        console.warn(`[thinking] ${t.note ?? "unsupported"} \u2014 falling back to provider default.`);
+      } else {
+        Object.assign(body, t.patch);
+      }
+    }
+    const base2 = config2.baseUrl.replace(/\/$/, "");
+    const url2 = `${base2}/responses`;
+    let response;
+    let lastStatus = 0;
+    let lastErrText = "";
+    for (let attempt = 0; ; attempt++) {
+      const connectController = new AbortController();
+      const connectTimer = setTimeout(
+        () => connectController.abort(
+          new Error(
+            `Provider connect timeout after ${Math.round(PROVIDER_CONNECT_TIMEOUT_MS / 1e3)}s (no response headers). Override ZELARI_PROVIDER_CONNECT_TIMEOUT_MS.`
+          )
+        ),
+        PROVIDER_CONNECT_TIMEOUT_MS
+      );
+      const signals = [connectController.signal];
+      if (params.signal) signals.push(params.signal);
+      try {
+        response = await fetch(url2, {
+          method: "POST",
+          headers: headers2(config2),
+          body: JSON.stringify(body),
+          signal: signals.length === 1 ? signals[0] : AbortSignal.any(signals)
+        });
+      } catch (err) {
+        lastStatus = 0;
+        lastErrText = err instanceof Error ? err.message : String(err);
+        if (params.signal?.aborted) {
+          yield { kind: "error", message: "aborted" };
+          return;
+        }
+        if (attempt < MAX_RETRIES2) {
+          await abortableSleep2(backoffDelay2(attempt, null), params.signal);
+          continue;
+        }
+        yield { kind: "error", message: `Network error: ${lastErrText}` };
+        return;
+      } finally {
+        clearTimeout(connectTimer);
+      }
+      if (response.ok && response.body) break;
+      lastStatus = response.status;
+      lastErrText = await response.text().catch(() => "");
+      if (!RETRYABLE_STATUSES2.has(response.status) || attempt >= MAX_RETRIES2) break;
+      await abortableSleep2(backoffDelay2(attempt, response.headers.get("retry-after")), params.signal);
+      if (params.signal?.aborted) {
+        yield { kind: "error", message: "aborted" };
+        return;
+      }
+    }
+    if (!response || !response.ok || !response.body) {
+      const msg = lastStatus === 0 ? `Network error: ${lastErrText}` : `HTTP ${lastStatus}: ${lastErrText.slice(0, 240)}`;
+      yield { kind: "error", message: msg };
+      return;
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const tools = /* @__PURE__ */ new Map();
+    let emittedTool = false;
+    const flush = function* (id3) {
+      const t = tools.get(id3);
+      if (!t?.name) return;
+      let args = {};
+      try {
+        args = JSON.parse(t.argsJson || "{}");
+      } catch {
+        args = {};
+      }
+      tools.delete(id3);
+      emittedTool = true;
+      yield { kind: "tool_call", toolCallId: t.id, toolName: t.name, args };
+    };
+    const streamStartedAt = Date.now();
+    let lastUsefulAt = streamStartedAt;
+    const streamDeadline = streamStartedAt + PROVIDER_STREAM_MAX_MS;
+    try {
+      while (true) {
+        const { value, done } = await readChunkWithTimeout(reader, {
+          idleMs: PROVIDER_STREAM_IDLE_MS,
+          deadlineMs: streamDeadline,
+          signal: params.signal,
+          lastUsefulAt: () => lastUsefulAt
+        });
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed.startsWith("data:")) continue;
+          const data = trimmed.slice(5).trim();
+          if (!data || data === "[DONE]") continue;
+          let ev;
+          try {
+            ev = JSON.parse(data);
+          } catch {
+            continue;
+          }
+          const type = typeof ev.type === "string" ? ev.type : "";
+          if (type) lastUsefulAt = Date.now();
+          if (type === "response.output_text.delta" && typeof ev.delta === "string") {
+            yield { kind: "text", delta: ev.delta };
+          } else if (type === "response.reasoning_text.delta" && typeof ev.delta === "string") {
+            yield { kind: "thinking", delta: ev.delta };
+          } else if (type === "response.output_item.added") {
+            const item = ev.item;
+            if (item?.type === "function_call") {
+              const id3 = String(item.call_id ?? item.id ?? `fc-${tools.size}`);
+              tools.set(id3, {
+                id: id3,
+                name: typeof item.name === "string" ? item.name : "",
+                argsJson: typeof item.arguments === "string" ? item.arguments : ""
+              });
+            }
+          } else if (type === "response.function_call_arguments.delta") {
+            const itemId = String(ev.item_id ?? ev.call_id ?? "");
+            const existing = itemId ? tools.get(itemId) : [...tools.values()].at(-1);
+            if (existing && typeof ev.delta === "string") existing.argsJson += ev.delta;
+          } else if (type === "response.output_item.done") {
+            const item = ev.item;
+            if (item?.type === "function_call") {
+              const id3 = String(item.call_id ?? item.id ?? "");
+              if (id3) yield* flush(id3);
+            }
+          } else if (type === "response.completed") {
+            const usage = ev.response?.usage;
+            if (usage) {
+              yield {
+                kind: "usage",
+                usage: {
+                  promptTokens: usage.input_tokens ?? usage.prompt_tokens ?? 0,
+                  completionTokens: usage.output_tokens ?? usage.completion_tokens ?? 0,
+                  totalTokens: usage.total_tokens ?? (usage.input_tokens ?? 0) + (usage.output_tokens ?? 0)
+                }
+              };
+            }
+            yield { kind: "finish", reason: emittedTool ? "tool_calls" : "stop" };
+            return;
+          } else if (type === "response.failed" || type === "error") {
+            const msg = typeof ev.message === "string" ? ev.message : JSON.stringify(ev.error ?? ev).slice(0, 200);
+            yield { kind: "error", message: msg };
+            return;
+          }
+        }
+      }
+      for (const id3 of [...tools.keys()]) yield* flush(id3);
+      yield { kind: "finish", reason: emittedTool ? "tool_calls" : "stop" };
+    } finally {
+      reader.releaseLock();
+    }
+  };
+}
+var RETRYABLE_STATUSES2, MAX_RETRIES2, BACKOFF_BASE_MS2, BACKOFF_CAP_MS2;
+var init_responsesApi = __esm({
+  "src/cli/provider/responsesApi.ts"() {
+    "use strict";
+    init_openai_compatible();
+    init_chatgpt();
+    init_thinking();
+    init_capabilities();
+    RETRYABLE_STATUSES2 = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+    MAX_RETRIES2 = (() => {
+      const raw = process.env.ZELARI_PROVIDER_MAX_RETRIES;
+      const n = raw ? Number.parseInt(raw, 10) : 3;
+      return Number.isFinite(n) && n >= 0 ? n : 3;
+    })();
+    BACKOFF_BASE_MS2 = 500;
+    BACKOFF_CAP_MS2 = 8e3;
+  }
+});
+
 // src/cli/provider/resolveStream.ts
 var resolveStream_exports = {};
 __export(resolveStream_exports, {
@@ -52860,6 +53272,9 @@ __export(resolveStream_exports, {
 function buildProviderStream(config2) {
   if (config2.providerId === "anthropic") return anthropicMessagesProvider(config2);
   if (config2.providerId === "chatgpt") return chatgptResponsesProvider(config2);
+  if (getApiStyleFor(config2.providerId) === "responses") {
+    return responsesApiProvider(config2);
+  }
   return openaiCompatibleProvider(config2);
 }
 var init_resolveStream = __esm({
@@ -52868,6 +53283,8 @@ var init_resolveStream = __esm({
     init_openai_compatible();
     init_anthropic();
     init_chatgpt();
+    init_responsesApi();
+    init_providerConfig();
   }
 });
 
@@ -53138,12 +53555,12 @@ __export(folderTrust_exports, {
   untrustFolder: () => untrustFolder
 });
 import { existsSync as existsSync31, mkdirSync as mkdirSync14, readFileSync as readFileSync23, writeFileSync as writeFileSync17 } from "node:fs";
-import path57 from "node:path";
+import path58 from "node:path";
 function trustStorePath() {
   return _overrideStorePath ?? trustConfigPath();
 }
 function normalize6(p3) {
-  const resolved = path57.resolve(p3);
+  const resolved = path58.resolve(p3);
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 function readStore3() {
@@ -53159,7 +53576,7 @@ function readStore3() {
 function writeStore3(store6) {
   const p3 = trustStorePath();
   try {
-    mkdirSync14(path57.dirname(p3), { recursive: true });
+    mkdirSync14(path58.dirname(p3), { recursive: true });
     writeFileSync17(p3, JSON.stringify(store6, null, 2), "utf8");
   } catch (err) {
     throw new Error(
@@ -53185,7 +53602,7 @@ function isFolderTrusted(folderPath) {
 }
 function trustFolder(folderPath) {
   const store6 = readStore3();
-  const normalized = path57.resolve(folderPath);
+  const normalized = path58.resolve(folderPath);
   if (!store6.folders.some((f) => normalize6(f.path) === normalize6(normalized))) {
     store6.folders.push({ path: normalized, trustedAt: (/* @__PURE__ */ new Date()).toISOString() });
     writeStore3(store6);
@@ -53311,7 +53728,7 @@ var init_lifecycleHooks = __esm({
 
 // src/cli/safety/astGate.ts
 import { promises as fs23 } from "node:fs";
-import path58 from "node:path";
+import path59 from "node:path";
 function astGateEnabled() {
   return process.env.ZELARI_AST_GATE !== "0";
 }
@@ -53346,9 +53763,9 @@ function wrapWithAstGate(original, opts) {
   const containedPathOf = (args) => {
     const raw = args["path"];
     if (typeof raw !== "string" || raw.length === 0) return null;
-    const absPath = path58.isAbsolute(raw) ? raw : path58.join(opts.root, raw);
-    const rel2 = path58.relative(opts.root, absPath);
-    if (rel2.startsWith("..") || path58.isAbsolute(rel2)) return null;
+    const absPath = path59.isAbsolute(raw) ? raw : path59.join(opts.root, raw);
+    const rel2 = path59.relative(opts.root, absPath);
+    if (rel2.startsWith("..") || path59.isAbsolute(rel2)) return null;
     return absPath;
   };
   return {
@@ -53373,7 +53790,7 @@ function wrapWithAstGate(original, opts) {
       if (!result.ok) return result;
       if (gateTarget !== null && !isAstSupported(gateTarget)) {
         process.stderr.write(
-          `[ast_gate] LOUD SKIP (unsupported-extension): ${original.name} ${gateTarget} \u2014 ${path58.extname(gateTarget) || "(no extension)"} is outside the AST surface; write KEPT, NOT syntax-gated.
+          `[ast_gate] LOUD SKIP (unsupported-extension): ${original.name} ${gateTarget} \u2014 ${path59.extname(gateTarget) || "(no extension)"} is outside the AST surface; write KEPT, NOT syntax-gated.
 `
         );
         return result;
@@ -53390,7 +53807,7 @@ function wrapWithAstGate(original, opts) {
           return result;
         }
         const post = await fs23.readFile(absPath, "utf8");
-        const syntaxError = firstSyntaxError(ts, path58.basename(absPath), post);
+        const syntaxError = firstSyntaxError(ts, path59.basename(absPath), post);
         if (!syntaxError) return result;
         const parseError = `${syntaxError.message} (line ${syntaxError.line}, col ${syntaxError.character})`;
         let revertedTo;
@@ -53401,7 +53818,7 @@ function wrapWithAstGate(original, opts) {
           await fs23.writeFile(absPath, preContent, "utf8");
           revertedTo = snapshotIdOf(preContent);
         }
-        const relLabel = path58.relative(opts.root, absPath) || path58.basename(absPath);
+        const relLabel = path59.relative(opts.root, absPath) || path59.basename(absPath);
         return typedErr(
           `[ast_gate_reverted] ${original.name}: ${absPath} written but the file no longer parses \u2014 write REVERTED (revertedTo=${revertedTo}). ${parseError}. Fix the syntax and re-apply (read_file first for a fresh snapshotId).`,
           {
@@ -53826,7 +54243,7 @@ var init_resourceClaims = __esm({
 // src/cli/toolResultCache.ts
 import { createHash as createHash15 } from "node:crypto";
 import { promises as fs24 } from "node:fs";
-import path59 from "node:path";
+import path60 from "node:path";
 function isToolCacheEnabled() {
   const raw = process.env.ZELARI_TOOL_CACHE;
   return raw !== "0" && raw !== "false" && raw !== "off";
@@ -53911,7 +54328,7 @@ async function statKey(toolName, input, ctx) {
   if (!input || typeof input !== "object") return null;
   const rawPath = input.path;
   if (typeof rawPath !== "string" || rawPath.length === 0) return null;
-  const abs = path59.isAbsolute(rawPath) ? rawPath : path59.join(ctx.cwd, rawPath);
+  const abs = path60.isAbsolute(rawPath) ? rawPath : path60.join(ctx.cwd, rawPath);
   try {
     const st = await fs24.stat(abs);
     return hashKey({
@@ -53967,7 +54384,7 @@ __export(toolRegistry_exports, {
   wrapWithSandbox: () => wrapWithSandbox
 });
 import { existsSync as existsSync32 } from "node:fs";
-import path60 from "node:path";
+import path61 from "node:path";
 function createBuiltinToolRegistry(options = {}) {
   const root = options.root ?? process.cwd();
   const audit = options.audit ?? new AuditLogger();
@@ -54192,6 +54609,15 @@ function createBuiltinToolRegistry(options = {}) {
       permissions: browserTool.permissions ?? []
     });
   }
+  if (!readOnly && !gauntletParent && process.env.ZELARI_SCREENSHOT !== "0") {
+    const screenshotTool = createScreenshotTool();
+    registry4.register(screenshotTool);
+    tools.push({
+      name: screenshotTool.name,
+      description: screenshotTool.description,
+      permissions: screenshotTool.permissions ?? []
+    });
+  }
   if (!readOnly && !gauntletParent && process.env.ZELARI_SSH !== "0") {
     for (const t of createSshTools()) {
       registry4.register(t);
@@ -54576,14 +55002,14 @@ function wrapWithDiagnostics(original, root, runner) {
 function claimedSourcePath(token, args, root) {
   const cleaned = token.replace(/^["']|["']$/g, "");
   if (!cleaned || cleaned.startsWith("-")) return null;
-  if (!DIAG_SOURCE_EXTENSIONS.has(path60.extname(cleaned).toLowerCase())) return null;
+  if (!DIAG_SOURCE_EXTENSIONS.has(path61.extname(cleaned).toLowerCase())) return null;
   const bases = [root];
   const cwd = args["cwd"];
   if (typeof cwd === "string" && cwd.length > 0) {
-    bases.unshift(path60.isAbsolute(cwd) ? cwd : path60.resolve(root, cwd));
+    bases.unshift(path61.isAbsolute(cwd) ? cwd : path61.resolve(root, cwd));
   }
   for (const base2 of bases) {
-    const candidate = path60.isAbsolute(cleaned) ? path60.normalize(cleaned) : path60.resolve(base2, cleaned);
+    const candidate = path61.isAbsolute(cleaned) ? path61.normalize(cleaned) : path61.resolve(base2, cleaned);
     try {
       const contained = resolveSandboxedPath(candidate, { root });
       if (existsSync32(contained)) return contained;
@@ -54853,6 +55279,7 @@ var init_toolRegistry = __esm({
     init_tools3();
     init_tools4();
     init_tools5();
+    init_screenshotTool();
     init_tools6();
     init_worldModel();
     init_openai_compatible();
@@ -54899,7 +55326,7 @@ var init_toolRegistry = __esm({
 
 // src/cli/metrics.ts
 import { promises as fs25, existsSync as existsSync33, statSync as statSync4, renameSync as renameSync4, appendFileSync as appendFileSync3, mkdirSync as mkdirSync15 } from "node:fs";
-import path61 from "node:path";
+import path62 from "node:path";
 async function readMetrics(file2) {
   let raw = "";
   try {
@@ -54949,7 +55376,7 @@ var init_metrics3 = __esm({
       writeQueue = Promise.resolve();
       constructor(file2) {
         this.file = file2 ?? metricsPath();
-        mkdirSync15(path61.dirname(this.file), { recursive: true });
+        mkdirSync15(path62.dirname(this.file), { recursive: true });
       }
       /** Metrics file path — doctor/summary readers use this. */
       get filePath() {
@@ -54986,8 +55413,8 @@ var init_metrics3 = __esm({
       maybeRotate() {
         if (!existsSync33(this.file)) return;
         try {
-          const stat7 = statSync4(this.file);
-          if (stat7.size >= METRICS_ROTATE_BYTES) {
+          const stat8 = statSync4(this.file);
+          if (stat8.size >= METRICS_ROTATE_BYTES) {
             const rotated = this.file.replace(/\.jsonl$/, ".1.jsonl");
             renameSync4(this.file, rotated);
           }
@@ -55281,15 +55708,15 @@ __export(completionProofProbe_exports, {
   gatherGitAttestation: () => gatherGitAttestation,
   harnessManifest: () => harnessManifest
 });
-import { execFile as execFile5 } from "node:child_process";
-import { promisify as promisify4 } from "node:util";
+import { execFile as execFile6 } from "node:child_process";
+import { promisify as promisify5 } from "node:util";
 async function readHarnessVersion() {
   if (cachedHarnessVersion !== null) return cachedHarnessVersion;
   try {
-    const { readFile: readFile9 } = await import("node:fs/promises");
+    const { readFile: readFile11 } = await import("node:fs/promises");
     const { fileURLToPath: fileURLToPath4 } = await import("node:url");
     const pkgPath = fileURLToPath4(new URL("../../../package.json", import.meta.url));
-    const parsed = JSON.parse(await readFile9(pkgPath, "utf8"));
+    const parsed = JSON.parse(await readFile11(pkgPath, "utf8"));
     if (typeof parsed.version === "string" && parsed.version.length > 0) {
       return cachedHarnessVersion = parsed.version;
     }
@@ -55313,7 +55740,7 @@ async function harnessManifest(env = process.env) {
 }
 async function git5(cwd, args) {
   try {
-    const { stdout } = await execFileAsync4("git", ["-C", cwd, ...args], {
+    const { stdout } = await execFileAsync5("git", ["-C", cwd, ...args], {
       maxBuffer: 32 * 1024 * 1024,
       windowsHide: true
     });
@@ -55355,7 +55782,7 @@ function activeTaskContractSnapshot() {
     return void 0;
   }
 }
-var HARNESS_VERSION_FALLBACK, ADAPTER_IDS, cachedHarnessVersion, execFileAsync4;
+var HARNESS_VERSION_FALLBACK, ADAPTER_IDS, cachedHarnessVersion, execFileAsync5;
 var init_completionProofProbe = __esm({
   "src/cli/kraken/completionProofProbe.ts"() {
     "use strict";
@@ -55363,7 +55790,7 @@ var init_completionProofProbe = __esm({
     HARNESS_VERSION_FALLBACK = "2.13.0";
     ADAPTER_IDS = ["node", "python", "rust", "go", "java", "dotnet"];
     cachedHarnessVersion = null;
-    execFileAsync4 = promisify4(execFile5);
+    execFileAsync5 = promisify5(execFile6);
   }
 });
 
@@ -55467,7 +55894,7 @@ var init_completionProofAttestation = __esm({
 // src/cli/kraken/completionProofPersist.ts
 import { open, rename as rename2, rm as rm2 } from "node:fs/promises";
 import { randomBytes as randomBytes5 } from "node:crypto";
-import path62 from "node:path";
+import path63 from "node:path";
 function isTruthyFlag2(v) {
   const n = v?.trim().toLowerCase();
   return n === "1" || n === "true" || n === "yes" || n === "on";
@@ -55509,8 +55936,8 @@ function isWindowsRenameBlock(err) {
   return code === "EPERM" || code === "ENOTEMPTY" || code === "EEXIST";
 }
 async function writeFileAtomic(target, data) {
-  const dir = path62.dirname(target);
-  const tmp = path62.join(dir, `.${path62.basename(target)}.${randomBytes5(6).toString("hex")}.tmp`);
+  const dir = path63.dirname(target);
+  const tmp = path63.join(dir, `.${path63.basename(target)}.${randomBytes5(6).toString("hex")}.tmp`);
   let fh = null;
   try {
     fh = await open(tmp, "w");
@@ -55555,8 +55982,8 @@ var init_completionProofPersist = __esm({
 });
 
 // src/cli/kraken/completionProof.ts
-import { mkdir as mkdir3 } from "node:fs/promises";
-import path63 from "node:path";
+import { mkdir as mkdir4 } from "node:fs/promises";
+import path64 from "node:path";
 function verdictOf(evaluation) {
   return evaluation.evaluation?.verdict ?? (evaluation.blocked ? "BLOCKED" : "PASS");
 }
@@ -55701,8 +56128,8 @@ async function writeCompletionProofDetailed(evaluation, options = {}) {
   const mode = options.persistenceMode ?? activeProofPersistenceMode();
   try {
     const baseDir = options.baseDir ?? process.cwd();
-    const dir = path63.join(baseDir, ".zelari");
-    await mkdir3(dir, { recursive: true });
+    const dir = path64.join(baseDir, ".zelari");
+    await mkdir4(dir, { recursive: true });
     const requested = options.attestation ?? {};
     const plan = requested.skipProbes || requested.verificationPlan !== void 0 ? void 0 : await defaultVerificationPlanSnapshot(baseDir);
     const wrapper = await buildAttestedWrapper(
@@ -55721,8 +56148,8 @@ async function writeCompletionProofDetailed(evaluation, options = {}) {
       baseDir
     );
     const rendered = renderCompletionProof(evaluation, options.meta ?? {}, wrapper.attestation);
-    const markdownPath = path63.join(dir, "completion-proof.md");
-    const jsonPath = path63.join(dir, "completion-proof.json");
+    const markdownPath = path64.join(dir, "completion-proof.md");
+    const jsonPath = path64.join(dir, "completion-proof.json");
     await writeFileAtomic(markdownPath, rendered.markdown);
     await writeFileAtomic(jsonPath, rendered.json);
     return { paths: { markdownPath, jsonPath }, mode, requiredBlockReason: null };
@@ -55832,12 +56259,12 @@ var init_askUserTimeout = __esm({
 // src/cli/state/fileStateStore.ts
 import { createHash as createHash17, randomUUID as randomUUID5 } from "node:crypto";
 import { promises as fs26 } from "node:fs";
-import * as path64 from "node:path";
+import * as path65 from "node:path";
 function shortId() {
   return randomUUID5().replace(/-/g, "").slice(0, 12);
 }
 async function writeJsonAtomic(filePath, data) {
-  await fs26.mkdir(path64.dirname(filePath), { recursive: true });
+  await fs26.mkdir(path65.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
   await fs26.writeFile(tmp, JSON.stringify(data, null, 2) + "\n", "utf8");
   await fs26.rename(tmp, filePath);
@@ -55898,11 +56325,11 @@ var init_fileStateStore = __esm({
       indexPath = "";
       async init(projectRoot) {
         this.root = projectRoot;
-        this.stateDir = path64.join(projectRoot, ".zelari", "state");
-        this.commitsDir = path64.join(this.stateDir, "commits");
-        this.artifactsDir = path64.join(this.stateDir, "artifacts");
-        this.headPath = path64.join(this.stateDir, "HEAD.json");
-        this.indexPath = path64.join(this.stateDir, "index.jsonl");
+        this.stateDir = path65.join(projectRoot, ".zelari", "state");
+        this.commitsDir = path65.join(this.stateDir, "commits");
+        this.artifactsDir = path65.join(this.stateDir, "artifacts");
+        this.headPath = path65.join(this.stateDir, "HEAD.json");
+        this.indexPath = path65.join(this.stateDir, "index.jsonl");
         await fs26.mkdir(this.commitsDir, { recursive: true });
         await fs26.mkdir(this.artifactsDir, { recursive: true });
       }
@@ -55915,13 +56342,13 @@ var init_fileStateStore = __esm({
         const discoveries = input.discoveries ?? [];
         const parent = await this.head();
         const id3 = shortId();
-        const artifactRel = path64.join("artifacts", id3);
-        const artifactAbs = path64.join(this.artifactsDir, id3);
+        const artifactRel = path65.join("artifacts", id3);
+        const artifactAbs = path65.join(this.artifactsDir, id3);
         await fs26.mkdir(artifactAbs, { recursive: true });
         const summary = defaultSummary(input, discoveries);
-        await fs26.writeFile(path64.join(artifactAbs, "summary.md"), summary + "\n", "utf8");
-        await writeJsonAtomic(path64.join(artifactAbs, "discoveries.json"), discoveries);
-        await writeJsonAtomic(path64.join(artifactAbs, "verification.json"), input.verification);
+        await fs26.writeFile(path65.join(artifactAbs, "summary.md"), summary + "\n", "utf8");
+        await writeJsonAtomic(path65.join(artifactAbs, "discoveries.json"), discoveries);
+        await writeJsonAtomic(path65.join(artifactAbs, "verification.json"), input.verification);
         const meta3 = {
           id: id3,
           parentId: parent?.id ?? null,
@@ -55933,14 +56360,14 @@ var init_fileStateStore = __esm({
           workspaceCheckpointId: input.workspaceCheckpointId,
           verification: {
             ...input.verification,
-            reportPath: input.verification.reportPath ?? path64.join(".zelari", "state", artifactRel, "verification.json").replace(/\\/g, "/")
+            reportPath: input.verification.reportPath ?? path65.join(".zelari", "state", artifactRel, "verification.json").replace(/\\/g, "/")
           },
           changedPaths: input.changedPaths ?? [],
           stablePromptHash: input.stablePromptHash,
           discoveryCount: discoveries.length,
           artifactDir: artifactRel.replace(/\\/g, "/")
         };
-        await writeJsonAtomic(path64.join(this.commitsDir, `${id3}.json`), meta3);
+        await writeJsonAtomic(path65.join(this.commitsDir, `${id3}.json`), meta3);
         await writeJsonAtomic(this.headPath, { id: id3, updatedAt: meta3.createdAt });
         await fs26.appendFile(this.indexPath, JSON.stringify({ id: id3, createdAt: meta3.createdAt, label: meta3.label }) + "\n", "utf8");
         return stripStored(meta3);
@@ -55951,7 +56378,7 @@ var init_fileStateStore = __esm({
         return this.get(head.id);
       }
       async get(id3) {
-        const stored = await readJsonFile(path64.join(this.commitsDir, `${id3}.json`));
+        const stored = await readJsonFile(path65.join(this.commitsDir, `${id3}.json`));
         return stored ? stripStored(stored) : null;
       }
       async list(limit = 20) {
@@ -55990,9 +56417,9 @@ var init_fileStateStore = __esm({
       async loadDiscoveries(id3) {
         const meta3 = id3 ? await this.get(id3) : await this.head();
         if (!meta3) return [];
-        const stored = await readJsonFile(path64.join(this.commitsDir, `${meta3.id}.json`));
+        const stored = await readJsonFile(path65.join(this.commitsDir, `${meta3.id}.json`));
         if (!stored?.artifactDir) return [];
-        const discPath = path64.join(this.stateDir, stored.artifactDir, "discoveries.json");
+        const discPath = path65.join(this.stateDir, stored.artifactDir, "discoveries.json");
         return await readJsonFile(discPath) ?? [];
       }
       async materializeContext(id3, maxChars = DEFAULT_MATERIALIZE_CHARS) {
@@ -56595,10 +57022,10 @@ var init_mode = __esm({
 
 // src/cli/headless.ts
 import { readFileSync as readFileSync24 } from "node:fs";
-import path65 from "node:path";
+import path66 from "node:path";
 function resolveHeadlessCwd(opts) {
   const raw = typeof opts.cwd === "string" ? opts.cwd.trim() : "";
-  return path65.resolve(raw.length > 0 ? raw : process.cwd());
+  return path66.resolve(raw.length > 0 ? raw : process.cwd());
 }
 function defaultProfileForMode(mode) {
   switch (mode) {
@@ -57700,7 +58127,7 @@ var init_planDetect = __esm({
 // src/cli/memory/legacyImport.ts
 import { createHash as createHash18 } from "node:crypto";
 import { promises as fs27 } from "node:fs";
-import * as path66 from "node:path";
+import * as path67 from "node:path";
 function sourceId(fact, line) {
   return `jsonl:${fact.id ?? createHash18("sha256").update(line).digest("hex")}`;
 }
@@ -57718,7 +58145,7 @@ function timestamp(value) {
 }
 async function importLegacyMemoryLog(backend, service) {
   const result = { found: 0, imported: 0, skipped: 0, corrupt: 0 };
-  const logPath = path66.join(path66.dirname(backend.databasePath), "log.jsonl");
+  const logPath = path67.join(path67.dirname(backend.databasePath), "log.jsonl");
   let raw;
   try {
     raw = await fs27.readFile(logPath, "utf8");
@@ -57901,7 +58328,7 @@ var init_sqliteCodec = __esm({
 // src/cli/memory/sqliteRpc.ts
 import { existsSync as existsSync36 } from "node:fs";
 import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL2 } from "node:url";
-import * as path67 from "node:path";
+import * as path68 from "node:path";
 import { Worker } from "node:worker_threads";
 function isBusy(error51) {
   const candidate = error51;
@@ -57910,10 +58337,10 @@ function isBusy(error51) {
   );
 }
 function resolveWorkerUrl() {
-  const here = path67.dirname(fileURLToPath2(import.meta.url));
-  const direct = path67.join(here, "sqliteWorker.mjs");
+  const here = path68.dirname(fileURLToPath2(import.meta.url));
+  const direct = path68.join(here, "sqliteWorker.mjs");
   if (existsSync36(direct)) return pathToFileURL2(direct);
-  return pathToFileURL2(path67.join(here, "memory", "sqliteWorker.mjs"));
+  return pathToFileURL2(path68.join(here, "memory", "sqliteWorker.mjs"));
 }
 var SqliteWorkerRpc;
 var init_sqliteRpc = __esm({
@@ -58202,7 +58629,7 @@ WHERE NOT EXISTS (SELECT 1 FROM memory_fts f WHERE f.node_id = n.id);
 // src/cli/memory/sqliteBackend.ts
 import { createHash as createHash19, randomUUID as randomUUID6 } from "node:crypto";
 import { promises as fs28 } from "node:fs";
-import * as path68 from "node:path";
+import * as path69 from "node:path";
 function boundedLimit(value, fallback = 50) {
   return Math.max(1, Math.min(Math.floor(value ?? fallback), 1e5));
 }
@@ -58264,20 +58691,20 @@ VALUES (${Array.from({ length: 19 }, () => "?").join(",")})`;
         try {
           resolved = await fs28.realpath(projectRoot);
         } catch {
-          resolved = path68.resolve(projectRoot);
+          resolved = path69.resolve(projectRoot);
         }
         if (this.initialized && resolved === this.projectRoot) return;
         if (this.initialized) await this.close();
         const filename = this.options.filename ?? "memory.db";
-        if (path68.basename(filename) !== filename || filename === "." || filename === "..") {
+        if (path69.basename(filename) !== filename || filename === "." || filename === "..") {
           throw new Error("SQLite memory filename must not contain a path.");
         }
-        const zelariDirectory = path68.join(resolved, ".zelari");
-        const directory = path68.join(zelariDirectory, "memory");
+        const zelariDirectory = path69.join(resolved, ".zelari");
+        const directory = path69.join(zelariDirectory, "memory");
         for (const candidate of [zelariDirectory, directory]) {
-          let stat7;
+          let stat8;
           try {
-            stat7 = await fs28.lstat(candidate);
+            stat8 = await fs28.lstat(candidate);
           } catch (error51) {
             if (error51.code !== "ENOENT") throw error51;
             try {
@@ -58285,19 +58712,19 @@ VALUES (${Array.from({ length: 19 }, () => "?").join(",")})`;
             } catch (mkdirError) {
               if (mkdirError.code !== "EEXIST") throw mkdirError;
             }
-            stat7 = await fs28.lstat(candidate);
+            stat8 = await fs28.lstat(candidate);
           }
-          if (stat7.isSymbolicLink() || !stat7.isDirectory()) {
+          if (stat8.isSymbolicLink() || !stat8.isDirectory()) {
             throw new Error(`Memory directory is not a real directory: ${candidate}`);
           }
         }
         const canonicalDirectory = await fs28.realpath(directory);
-        const relativeDirectory = path68.relative(resolved, canonicalDirectory);
-        if (relativeDirectory.startsWith("..") || path68.isAbsolute(relativeDirectory)) {
+        const relativeDirectory = path69.relative(resolved, canonicalDirectory);
+        if (relativeDirectory.startsWith("..") || path69.isAbsolute(relativeDirectory)) {
           throw new Error("SQLite memory directory resolves outside the active project.");
         }
         this.projectRoot = resolved;
-        this.databasePath = path68.join(canonicalDirectory, filename);
+        this.databasePath = path69.join(canonicalDirectory, filename);
         const opened = await this.rpc.open({
           dbPath: this.databasePath,
           schemaSql: SQLITE_MEMORY_BASE_SCHEMA,
@@ -58830,7 +59257,7 @@ __export(serviceFactory_exports, {
 });
 import { createHash as createHash20 } from "node:crypto";
 import { promises as fs29 } from "node:fs";
-import * as path69 from "node:path";
+import * as path70 from "node:path";
 function isMemoryV2Enabled(env = process.env) {
   if (env.ZELARI_MEMORY === "0") return false;
   if (env.ZELARI_MEMORY_BACKEND === "file" || env.ZELARI_MEMORY_BACKEND === "jsonl") return false;
@@ -58851,7 +59278,7 @@ async function canonicalProjectId(projectRoot) {
   try {
     canonical = await fs29.realpath(projectRoot);
   } catch {
-    canonical = path69.resolve(projectRoot);
+    canonical = path70.resolve(projectRoot);
   }
   canonical = canonical.replace(/\\/g, "/").replace(/\/$/, "");
   if (process.platform === "win32") canonical = canonical.toLocaleLowerCase("en-US");
@@ -59553,8 +59980,8 @@ function readPlan(ctx) {
     } catch {
     }
   }
-  const path99 = workspaceFile(ctx.rootDir, "plan");
-  const doc = ctx.storage.readIfExists(path99);
+  const path100 = workspaceFile(ctx.rootDir, "plan");
+  const doc = ctx.storage.readIfExists(path100);
   if (!doc) return { phases: [], tasks: [], milestones: [] };
   const meta3 = doc.meta;
   return {
@@ -59735,7 +60162,7 @@ function addMilestoneRecord(ctx, summary, input) {
     dueDate: input.dueDate,
     targetVersion: version2
   });
-  const path99 = join31(ctx.rootDir, "milestones", `${id3}.md`);
+  const path100 = join31(ctx.rootDir, "milestones", `${id3}.md`);
   const meta3 = {
     kind: "milestone",
     id: id3,
@@ -59752,7 +60179,7 @@ function addMilestoneRecord(ctx, summary, input) {
     `Target version: ${version2}`,
     ""
   ].join("\n");
-  ctx.storage.write(path99, meta3, body);
+  ctx.storage.write(path100, meta3, body);
   return { id: id3, created: true };
 }
 function readPlanSummary(ctx) {
@@ -59956,7 +60383,7 @@ function addIdeaStub(ctx) {
         const tags = args["tags"] ?? [];
         const category = args["category"] ?? "General";
         const id3 = `${nextAdrId(ctx)}-${slugify3(title)}`;
-        const path99 = workspaceArtifact(ctx.rootDir, "decisions", id3);
+        const path100 = workspaceArtifact(ctx.rootDir, "decisions", id3);
         const meta3 = {
           kind: "adr",
           status: "proposed",
@@ -59982,7 +60409,7 @@ function addIdeaStub(ctx) {
           ...consequences.map((c) => `- ${c}`),
           ""
         ].join("\n");
-        ctx.storage.write(path99, meta3, body);
+        ctx.storage.write(path100, meta3, body);
         return `ADR ${id3} created: "${title}". Status: proposed. Promote to accepted via /update ADR or manual edit.`;
       });
     }
@@ -60064,14 +60491,14 @@ function createDocumentStub(ctx) {
           ctx.storage.write(risksPath, riskMeta, content);
           return `Document "${title}" created at risks.md (workspace root).`;
         }
-        const path99 = workspaceArtifact(ctx.rootDir, "docs", slug);
+        const path100 = workspaceArtifact(ctx.rootDir, "docs", slug);
         const meta3 = {
           kind: "doc",
           id: slug,
           date: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
           tags
         };
-        ctx.storage.write(path99, meta3, content);
+        ctx.storage.write(path100, meta3, content);
         return `Document "${title}" created at docs/${slug}.md.`;
       });
     }
@@ -60324,11 +60751,11 @@ var init_httpTransport = __esm({
         const sid = this.sessionId;
         this.sessionId = null;
         if (!sid) return;
-        const headers2 = {
+        const headers3 = {
           ...this.opts.headers ?? {},
           "mcp-session-id": sid
         };
-        void fetch(this.opts.url, { method: "DELETE", headers: headers2 }).catch(() => {
+        void fetch(this.opts.url, { method: "DELETE", headers: headers3 }).catch(() => {
         });
       }
       // ── internals ────────────────────────────────────────────────────────
@@ -60338,15 +60765,15 @@ var init_httpTransport = __esm({
         const timer = setTimeout(() => ac.abort(), timeoutMs2 + ABORT_GRACE_MS);
         const hadSession = this.sessionId !== null;
         try {
-          const headers2 = {
+          const headers3 = {
             "content-type": "application/json",
             accept: "application/json, text/event-stream",
             ...this.opts.headers ?? {}
           };
-          if (this.sessionId) headers2["mcp-session-id"] = this.sessionId;
+          if (this.sessionId) headers3["mcp-session-id"] = this.sessionId;
           const res = await fetch(this.opts.url, {
             method: "POST",
-            headers: headers2,
+            headers: headers3,
             signal: ac.signal,
             body: JSON.stringify({ jsonrpc: "2.0", ...msg })
           });
@@ -60696,10 +61123,10 @@ function getUserMcpPath() {
 function getProjectMcpPath(projectRoot) {
   return join32(projectRoot, ".zelari", "mcp.json");
 }
-function readFile7(path99) {
-  if (!existsSync42(path99)) return {};
+function readFile9(path100) {
+  if (!existsSync42(path100)) return {};
   try {
-    const parsed = JSON.parse(readFileSync30(path99, "utf8"));
+    const parsed = JSON.parse(readFileSync30(path100, "utf8"));
     const out = {};
     for (const [name, cfg] of Object.entries(parsed.mcpServers ?? {})) {
       const hasCommand = !!cfg && typeof cfg.command === "string" && !!cfg.command.trim();
@@ -60721,17 +61148,17 @@ function readFile7(path99) {
     return {};
   }
 }
-function writeFile3(path99, servers) {
-  mkdirSync17(dirname9(path99), { recursive: true });
+function writeFile3(path100, servers) {
+  mkdirSync17(dirname9(path100), { recursive: true });
   const body = { mcpServers: servers };
-  writeFileSync19(path99, `${JSON.stringify(body, null, 2)}
+  writeFileSync19(path100, `${JSON.stringify(body, null, 2)}
 `, "utf8");
 }
 function listMcpServers(projectRoot) {
   const userPath = getUserMcpPath();
-  const userServers = readFile7(userPath);
+  const userServers = readFile9(userPath);
   const projectPath = projectRoot && projectRoot.trim() ? getProjectMcpPath(projectRoot.trim()) : null;
-  const projectServers = projectPath ? readFile7(projectPath) : {};
+  const projectServers = projectPath ? readFile9(projectPath) : {};
   const servers = [];
   for (const [name, cfg] of Object.entries(userServers)) {
     servers.push({ name, ...cfg, scope: "user", path: userPath });
@@ -60762,9 +61189,9 @@ function upsertMcpServer(opts) {
       error: "either command (stdio) or url (http) is required"
     };
   }
-  let path99;
+  let path100;
   if (opts.scope === "user") {
-    path99 = getUserMcpPath();
+    path100 = getUserMcpPath();
   } else {
     const root = opts.projectRoot?.trim();
     if (!root) {
@@ -60773,9 +61200,9 @@ function upsertMcpServer(opts) {
         error: "projectRoot required for project scope (Open Folder first)"
       };
     }
-    path99 = getProjectMcpPath(root);
+    path100 = getProjectMcpPath(root);
   }
-  const current = readFile7(path99);
+  const current = readFile9(path100);
   current[name] = {
     command: hasCommand ? opts.config.command.trim() : void 0,
     args: opts.config.args,
@@ -60786,21 +61213,21 @@ function upsertMcpServer(opts) {
     serial: opts.config.serial,
     enabled: opts.config.enabled !== false
   };
-  writeFile3(path99, current);
-  return { ok: true, path: path99 };
+  writeFile3(path100, current);
+  return { ok: true, path: path100 };
 }
 function removeMcpServer(opts) {
-  const path99 = opts.scope === "user" ? getUserMcpPath() : opts.projectRoot ? getProjectMcpPath(opts.projectRoot) : null;
-  if (!path99) {
+  const path100 = opts.scope === "user" ? getUserMcpPath() : opts.projectRoot ? getProjectMcpPath(opts.projectRoot) : null;
+  if (!path100) {
     return { ok: false, error: "projectRoot required for project scope" };
   }
-  const current = readFile7(path99);
+  const current = readFile9(path100);
   if (!(opts.name in current)) {
-    return { ok: false, error: `Server "${opts.name}" not found in ${path99}` };
+    return { ok: false, error: `Server "${opts.name}" not found in ${path100}` };
   }
   delete current[opts.name];
-  writeFile3(path99, current);
-  return { ok: true, path: path99 };
+  writeFile3(path100, current);
+  return { ok: true, path: path100 };
 }
 var init_mcpConfigIo = __esm({
   "src/cli/mcp/mcpConfigIo.ts"() {
@@ -61269,12 +61696,12 @@ __export(agentsMd_exports, {
 import { existsSync as existsSync44, readFileSync as readFileSync32, writeFileSync as writeFileSync20 } from "node:fs";
 import { createHash as createHash21 } from "node:crypto";
 import { join as join34 } from "node:path";
-import { readFile as readFile8 } from "node:fs/promises";
+import { readFile as readFile10 } from "node:fs/promises";
 async function readPackageJson3(projectRoot) {
-  const path99 = join34(projectRoot, "package.json");
-  if (!existsSync44(path99)) return null;
+  const path100 = join34(projectRoot, "package.json");
+  if (!existsSync44(path100)) return null;
   try {
-    return JSON.parse(await readFile8(path99, "utf8"));
+    return JSON.parse(await readFile10(path100, "utf8"));
   } catch {
     return null;
   }
@@ -61356,9 +61783,9 @@ async function genBuild(ctx) {
   ].join("\n");
 }
 async function genOpenQuestions(ctx) {
-  const path99 = join34(ctx.rootDir, "risks.md");
-  if (!existsSync44(path99)) return "_No open questions._";
-  const content = readFileSync32(path99, "utf8");
+  const path100 = join34(ctx.rootDir, "risks.md");
+  if (!existsSync44(path100)) return "_No open questions._";
+  const content = readFileSync32(path100, "utf8");
   const lines = content.split("\n");
   const questions = [];
   let currentTitle = "";
@@ -61632,9 +62059,9 @@ function versionKey(value) {
 function firstString2(v) {
   return typeof v === "string" && v.trim().length > 0 ? v : null;
 }
-function readFileSyncSafe(path99) {
+function readFileSyncSafe(path100) {
   try {
-    return readFileSync33(path99, "utf8");
+    return readFileSync33(path100, "utf8");
   } catch {
     return null;
   }
@@ -61882,7 +62309,7 @@ __export(evidenceFromSpine_exports, {
   evidenceRefsFromEventLines: () => evidenceRefsFromEventLines
 });
 import { existsSync as existsSync47, readFileSync as readFileSync35 } from "node:fs";
-import path70 from "node:path";
+import path71 from "node:path";
 function asRecord2(v) {
   return v && typeof v === "object" && !Array.isArray(v) ? v : void 0;
 }
@@ -61920,7 +62347,7 @@ function evidenceRefsFromEventLines(lines) {
 }
 function collectSessionEvidenceRefs(sessionId2) {
   try {
-    const file2 = path70.join(sessionsDir(), sessionId2, "events.jsonl");
+    const file2 = path71.join(sessionsDir(), sessionId2, "events.jsonl");
     if (!existsSync47(file2)) return [];
     return evidenceRefsFromEventLines(readFileSync35(file2, "utf8").split("\n"));
   } catch {
@@ -62170,8 +62597,8 @@ async function runPostCouncilHook(ctx, options) {
           sources: scope.sources
         } : void 0
       });
-      const path99 = writeCouncilCompletion(ctx.rootDir, completion);
-      completionHook = { ran: true, path: path99, completion };
+      const path100 = writeCouncilCompletion(ctx.rootDir, completion);
+      completionHook = { ran: true, path: path100, completion };
     } catch (err) {
       completionHook = {
         ran: true,
@@ -62216,7 +62643,7 @@ import {
   writeFileSync as writeFileSync22,
   mkdirSync as mkdirSync18
 } from "node:fs";
-import path71 from "node:path";
+import path72 from "node:path";
 var FeedbackStore;
 var init_councilFeedback = __esm({
   "src/cli/councilFeedback.ts"() {
@@ -62333,7 +62760,7 @@ var init_councilFeedback = __esm({
         }
       }
       save() {
-        mkdirSync18(path71.dirname(this.file), { recursive: true });
+        mkdirSync18(path72.dirname(this.file), { recursive: true });
         writeFileSync22(
           this.file,
           JSON.stringify({ entries: this.entries }, null, 2),
@@ -62408,12 +62835,12 @@ __export(ledger_exports, {
   readLedger: () => readLedger
 });
 import { appendFileSync as appendFileSync4, existsSync as existsSync50, mkdirSync as mkdirSync19, readFileSync as readFileSync38 } from "node:fs";
-import path72 from "node:path";
+import path73 from "node:path";
 function evolutionMode(env = process.env) {
   return env[EVOLUTION_ENV] === "shadow" ? "shadow" : "0";
 }
 function ledgerPath(cwd) {
-  return path72.join(cwd, LEDGER_REL);
+  return path73.join(cwd, LEDGER_REL);
 }
 function appendLedgerEntry(cwd, entry) {
   if (evolutionMode() === "0") {
@@ -62421,7 +62848,7 @@ function appendLedgerEntry(cwd, entry) {
   }
   try {
     const file2 = ledgerPath(cwd);
-    mkdirSync19(path72.dirname(file2), { recursive: true });
+    mkdirSync19(path73.dirname(file2), { recursive: true });
     appendFileSync4(file2, `${JSON.stringify(entry)}
 `, "utf8");
     return { written: true, path: file2 };
@@ -62522,7 +62949,7 @@ var init_ledger = __esm({
   "src/cli/evolution/ledger.ts"() {
     "use strict";
     EVOLUTION_ENV = "ZELARI_EVOLUTION";
-    LEDGER_REL = path72.join(".zelari", "evolution", "ledger.jsonl");
+    LEDGER_REL = path73.join(".zelari", "evolution", "ledger.jsonl");
     TIER_WEIGHTS = {
       build: 1,
       "tool-output": 1,
@@ -62664,7 +63091,7 @@ __export(fileBackend_exports, {
 });
 import { randomUUID as randomUUID7 } from "node:crypto";
 import { promises as fs31 } from "node:fs";
-import * as path73 from "node:path";
+import * as path74 from "node:path";
 function tokenize2(text) {
   return text.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((t) => t.length >= 3);
 }
@@ -62717,8 +63144,8 @@ var init_fileBackend = __esm({
       logPath = "";
       memoryDir = "";
       async init(projectRoot) {
-        this.memoryDir = path73.join(projectRoot, ".zelari", "memory");
-        this.logPath = path73.join(this.memoryDir, "log.jsonl");
+        this.memoryDir = path74.join(projectRoot, ".zelari", "memory");
+        this.logPath = path74.join(this.memoryDir, "log.jsonl");
         await fs31.mkdir(this.memoryDir, { recursive: true });
       }
       async add(content, metadata2 = {}, graph) {
@@ -62791,12 +63218,12 @@ var init_fileBackend = __esm({
 
 // src/cli/traceStore.ts
 import { promises as fs32 } from "node:fs";
-import * as path74 from "node:path";
+import * as path75 from "node:path";
 function traceDir(projectRoot) {
-  return path74.join(projectRoot, ".zelari", "trace");
+  return path75.join(projectRoot, ".zelari", "trace");
 }
 function tracePath(projectRoot, missionId) {
-  return path74.join(traceDir(projectRoot), `${missionId}.json`);
+  return path75.join(traceDir(projectRoot), `${missionId}.json`);
 }
 async function saveTrace(projectRoot, missionId, entries) {
   const dir = traceDir(projectRoot);
@@ -62833,7 +63260,7 @@ __export(zelariMission_exports, {
 });
 import { randomUUID as randomUUID8 } from "node:crypto";
 import { promises as fs33 } from "node:fs";
-import * as path75 from "node:path";
+import * as path76 from "node:path";
 function resolveMaxIterations(env = process.env) {
   const raw = env.ZELARI_MISSION_MAX_ITER;
   const n = raw ? Number.parseInt(raw, 10) : DEFAULT_MAX_ITER;
@@ -62876,10 +63303,10 @@ function isMissionAutoStart(env = process.env) {
   return env.ZELARI_MISSION_AUTO === "1";
 }
 async function writeMissionState(projectRoot, state3) {
-  const dir = path75.join(projectRoot, ".zelari");
+  const dir = path76.join(projectRoot, ".zelari");
   await fs33.mkdir(dir, { recursive: true });
   await fs33.writeFile(
-    path75.join(dir, "mission-state.json"),
+    path76.join(dir, "mission-state.json"),
     JSON.stringify(state3, null, 2) + "\n",
     "utf8"
   );
@@ -63568,7 +63995,7 @@ function safeSocketPath(socketPath) {
   return socketPath.trim();
 }
 function startPermissionBroker(socketPath, handlers, opts) {
-  const path99 = safeSocketPath(socketPath);
+  const path100 = safeSocketPath(socketPath);
   const requestTimeoutMs = opts?.requestTimeoutMs ?? PERMISSION_BROKER_DEFAULT_TIMEOUT_MS;
   const sockets = /* @__PURE__ */ new Set();
   const server = createServer2((socket) => {
@@ -63668,10 +64095,10 @@ function startPermissionBroker(socketPath, handlers, opts) {
   return new Promise((resolve9, reject) => {
     const onError = (err) => reject(err);
     server.once("error", onError);
-    server.listen(path99, () => {
+    server.listen(path100, () => {
       server.removeListener("error", onError);
       resolve9({
-        socketPath: path99,
+        socketPath: path100,
         stop: () => new Promise((res) => {
           for (const s of sockets) s.destroy();
           sockets.clear();
@@ -63682,7 +64109,7 @@ function startPermissionBroker(socketPath, handlers, opts) {
             if (done) return;
             done = true;
             if (process.platform !== "win32") {
-              unlink(path99, () => res());
+              unlink(path100, () => res());
             } else {
               res();
             }
@@ -63695,11 +64122,11 @@ function startPermissionBroker(socketPath, handlers, opts) {
   });
 }
 function requestBrokerAsk(socketPath, ask, opts) {
-  const path99 = safeSocketPath(socketPath);
+  const path100 = safeSocketPath(socketPath);
   const requestTimeoutMs = opts?.requestTimeoutMs ?? PERMISSION_BROKER_DEFAULT_TIMEOUT_MS;
   const connectTimeoutMs = opts?.connectTimeoutMs ?? PERMISSION_BROKER_DEFAULT_CONNECT_TIMEOUT_MS;
   return new Promise((resolve9, reject) => {
-    const socket = connect(path99);
+    const socket = connect(path100);
     let buffer = "";
     let settled = false;
     const settle = (fn) => {
@@ -63714,7 +64141,7 @@ function requestBrokerAsk(socketPath, ask, opts) {
       settle(
         () => reject(
           new Error(
-            `permission broker unavailable at "${path99}" (connect timed out after ${connectTimeoutMs}ms)`
+            `permission broker unavailable at "${path100}" (connect timed out after ${connectTimeoutMs}ms)`
           )
         )
       );
@@ -64903,7 +65330,7 @@ var init_prereqChecks = __esm({
 
 // src/cli/plugins/prefs.ts
 import { existsSync as existsSync53, readFileSync as readFileSync40, writeFileSync as writeFileSync23, mkdirSync as mkdirSync20 } from "node:fs";
-import path81 from "node:path";
+import path82 from "node:path";
 function getPluginPrefsPath() {
   return pluginsPrefsPath();
 }
@@ -64926,7 +65353,7 @@ function getPluginPrefs() {
 }
 function writePluginPrefs(prefs) {
   const file2 = getPluginPrefsPath();
-  mkdirSync20(path81.dirname(file2), { recursive: true });
+  mkdirSync20(path82.dirname(file2), { recursive: true });
   writeFileSync23(file2, JSON.stringify(prefs, null, 2), {
     encoding: "utf-8",
     mode: 384
@@ -64964,7 +65391,7 @@ __export(registry_exports, {
   isBinaryOnPath: () => isBinaryOnPath
 });
 import { existsSync as existsSync54 } from "node:fs";
-import path82 from "node:path";
+import path83 from "node:path";
 function detectLocalBin(bin) {
   return (cwd) => {
     try {
@@ -64982,7 +65409,7 @@ function isBinaryOnPath(bin, opts = {}) {
   const platform = opts.platform ?? process.platform;
   const exists = opts.exists ?? existsSync54;
   const pathEnv = opts.pathEnv ?? process.env.PATH ?? "";
-  const pathMod = platform === "win32" ? path82.win32 : path82.posix;
+  const pathMod = platform === "win32" ? path83.win32 : path83.posix;
   const sep4 = platform === "win32" ? ";" : ":";
   const dirs = pathEnv.split(sep4).filter((d) => d.length > 0);
   const candidates = [bin];
@@ -65378,6 +65805,16 @@ function handleProviderPicker(ctx, openPicker) {
 function handleProviderCustom(ctx, opts) {
   const id3 = ctx.activeProviderSpec.id;
   try {
+    if (opts.apiStyle) {
+      if (id3 === "chatgpt" || id3 === "anthropic") {
+        appendSystem(ctx.setMessages, `[provider] ${id3} has a fixed transport \u2014 nothing to select.`);
+        return;
+      }
+      setApiStyleFor(id3, opts.apiStyle);
+      const target = opts.apiStyle === "responses" ? "POST /responses" : "POST /chat/completions";
+      appendSystem(ctx.setMessages, `[provider] ${id3} endpoint style set to ${opts.apiStyle} (${target})`);
+      return;
+    }
     if (opts.clear) {
       clearCustomEndpoint(id3);
       appendSystem(ctx.setMessages, `[provider] cleared custom endpoint for ${id3} \u2014 falling back to default`);
@@ -66077,7 +66514,7 @@ var init_policy = __esm({
 
 // src/cli/orchestration/facts.ts
 import { promises as fs43 } from "node:fs";
-import path86 from "node:path";
+import path87 from "node:path";
 async function collectRepoFileCount(root = process.cwd()) {
   try {
     await fs43.readdir(root);
@@ -66097,7 +66534,7 @@ async function collectRepoFileCount(root = process.cwd()) {
       }
       for (const e of entries) {
         if (e.isDirectory()) {
-          if (!SKIP_DIRS.has(e.name)) queue.push(path86.join(dir, e.name));
+          if (!SKIP_DIRS.has(e.name)) queue.push(path87.join(dir, e.name));
         } else if (e.isFile()) {
           count++;
           if (count > MAX_WALK_FILES) return count;
@@ -66195,7 +66632,7 @@ var init_streamScrub = __esm({
 });
 
 // src/cli/harnessState.ts
-import path87 from "node:path";
+import path88 from "node:path";
 function asString4(v) {
   return typeof v === "string" ? v : "";
 }
@@ -66370,7 +66807,7 @@ function contractFor(t) {
   };
 }
 async function readHarnessState(sessionDir) {
-  const report = await readSessionLog(path87.join(sessionDir, "events.jsonl"));
+  const report = await readSessionLog(path88.join(sessionDir, "events.jsonl"));
   return deriveHarnessState(report.events);
 }
 var init_harnessState = __esm({
@@ -66381,12 +66818,12 @@ var init_harnessState = __esm({
 });
 
 // src/cli/headless/harnessStateEmit.ts
-import path88 from "node:path";
+import path89 from "node:path";
 async function emitHarnessStateEvent(opts) {
   if (opts.output !== "json") return;
   try {
     const sessionsDir2 = resolveSessionsDir({ workspaceRoot: opts.workspaceRoot });
-    const state3 = await readHarnessState(path88.join(sessionsDir2, opts.spine.sessionId));
+    const state3 = await readHarnessState(path89.join(sessionsDir2, opts.spine.sessionId));
     opts.emitEvent({ type: "harness_state", ...state3 });
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -66943,13 +67380,13 @@ var init_verifierLifecycle = __esm({
 
 // src/cli/extensions/sandboxedFs.ts
 import { promises as fsp } from "node:fs";
-import path89 from "node:path";
+import path90 from "node:path";
 function errText(prefix, p3, err) {
   const msg = err instanceof Error ? err.message : String(err);
   return `[extension-fs] ${prefix} "${p3}": ${msg}`;
 }
 function bindSandboxedFs(root) {
-  const resolvedRoot = path89.resolve(root);
+  const resolvedRoot = path90.resolve(root);
   return {
     root: resolvedRoot,
     async readFile(relativePath) {
@@ -66965,7 +67402,7 @@ function bindSandboxedFs(root) {
       try {
         const target = resolveSandboxedPath(relativePath, { root: resolvedRoot });
         verifyContainment(target, { root: resolvedRoot });
-        await fsp.mkdir(path89.dirname(target), { recursive: true });
+        await fsp.mkdir(path90.dirname(target), { recursive: true });
         await fsp.writeFile(target, data, "utf8");
         return typedOk({ path: target });
       } catch (err) {
@@ -67150,7 +67587,7 @@ var init_loader = __esm({
 
 // src/cli/headless/runOneTurn.ts
 import { promises as fs44 } from "node:fs";
-import path90 from "node:path";
+import path91 from "node:path";
 function planModeFromOpts(opts) {
   return (opts.phase ?? "build") === "plan";
 }
@@ -67717,7 +68154,7 @@ async function runOneTurn(opts, provider, model, providerStream, extras) {
       if (json3) {
         if (opts.exportSessionPath === "-") process.stdout.write(json3 + "\n");
         else {
-          await fs44.mkdir(path90.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
+          await fs44.mkdir(path91.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
           await fs44.writeFile(opts.exportSessionPath, json3, "utf8");
         }
       }
@@ -68696,9 +69133,9 @@ __export(triggerLock_exports, {
   releaseLock: () => releaseLock
 });
 import { promises as fs45 } from "node:fs";
-import * as path91 from "node:path";
+import * as path92 from "node:path";
 function lockPath(projectRoot) {
-  return path91.join(projectRoot, ".zelari", "trigger.lock");
+  return path92.join(projectRoot, ".zelari", "trigger.lock");
 }
 function isPidAlive(pid) {
   try {
@@ -68711,7 +69148,7 @@ function isPidAlive(pid) {
 }
 async function acquireLock(projectRoot, now = () => /* @__PURE__ */ new Date()) {
   const lp = lockPath(projectRoot);
-  const dir = path91.dirname(lp);
+  const dir = path92.dirname(lp);
   await fs45.mkdir(dir, { recursive: true });
   try {
     const raw = await fs45.readFile(lp, "utf8");
@@ -68743,7 +69180,7 @@ var init_triggerLock = __esm({
 
 // src/cli/runHeadless.ts
 import { promises as fs46 } from "node:fs";
-import path92 from "node:path";
+import path93 from "node:path";
 import { randomUUID as randomUUID10 } from "node:crypto";
 async function runHeadless(opts) {
   resetTaskSpawnCount();
@@ -68987,7 +69424,7 @@ async function runHeadlessKrakenGraph(opts, provider, model) {
   try {
     let preflightGraph;
     if (opts.runPlan && opts.runPlan.trim() !== "") {
-      const planPath = path92.join(cwd, ".zelari", "radio", `plan-${opts.runPlan}.json`);
+      const planPath = path93.join(cwd, ".zelari", "radio", `plan-${opts.runPlan}.json`);
       log(`loading pre-flight plan: ${planPath}`);
       let raw;
       try {
@@ -69030,8 +69467,8 @@ async function runHeadlessKrakenGraph(opts, provider, model) {
     log(formatKrakenGraphAscii2(graph));
     if (opts.planOnly) {
       const planId = randomUUID10();
-      const planDir = path92.join(cwd, ".zelari", "radio");
-      const planPath = path92.join(planDir, `plan-${planId}.json`);
+      const planDir = path93.join(cwd, ".zelari", "radio");
+      const planPath = path93.join(planDir, `plan-${planId}.json`);
       await fs46.mkdir(planDir, { recursive: true });
       await fs46.writeFile(
         planPath,
@@ -69409,7 +69846,7 @@ async function runHeadlessCouncilBody(opts, provider, model, providerStream, ext
       if (json3) {
         if (opts.exportSessionPath === "-") process.stdout.write(json3 + "\n");
         else {
-          await fs46.mkdir(path92.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
+          await fs46.mkdir(path93.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
           await fs46.writeFile(opts.exportSessionPath, json3, "utf8");
         }
       }
@@ -69860,7 +70297,7 @@ ${ragContext}` : slicePrompt;
         if (json3) {
           if (opts.exportSessionPath === "-") process.stdout.write(json3 + "\n");
           else {
-            await fs46.mkdir(path92.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
+            await fs46.mkdir(path93.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
             await fs46.writeFile(opts.exportSessionPath, json3, "utf8");
           }
         }
@@ -69979,6 +70416,7 @@ function parseSetConfigFlags(argv) {
   let model;
   let endpoint;
   let thinking;
+  let apiStyle;
   let endpointClear = false;
   let verifierProvider;
   let verifierModel;
@@ -69997,6 +70435,9 @@ function parseSetConfigFlags(argv) {
     } else if (arg === "--thinking") {
       thinking = argv[i + 1];
       i++;
+    } else if (arg === "--api-style") {
+      apiStyle = argv[i + 1];
+      i++;
     } else if (arg === "--endpoint-clear") {
       endpointClear = true;
     } else if (arg === "--verifier-provider") {
@@ -70009,7 +70450,7 @@ function parseSetConfigFlags(argv) {
       verifierClear = true;
     }
   }
-  if (!provider && !model && !endpoint && !endpointClear && !thinking && !verifierProvider && !verifierModel && !verifierClear) {
+  if (!provider && !model && !endpoint && !endpointClear && !thinking && !apiStyle && !verifierProvider && !verifierModel && !verifierClear) {
     return {
       request: null,
       error: "--set-config: nothing to update \u2014 provide at least one of --provider, --model, --endpoint, --thinking, --verifier-provider + --verifier-model, --verifier-clear, or --endpoint-clear"
@@ -70024,6 +70465,9 @@ function parseSetConfigFlags(argv) {
   if (endpoint !== void 0 && endpoint.trim().length === 0) {
     return { request: null, error: "--endpoint cannot be empty" };
   }
+  if (apiStyle !== void 0 && apiStyle !== "chat" && apiStyle !== "responses") {
+    return { request: null, error: "invalid --api-style " + apiStyle + " (use chat or responses)" };
+  }
   if (verifierClear && (verifierProvider || verifierModel)) {
     return { request: null, error: "--verifier-clear conflicts with --verifier-provider/--verifier-model" };
   }
@@ -70048,6 +70492,7 @@ function parseSetConfigFlags(argv) {
       model: model?.trim(),
       endpoint: endpoint?.trim(),
       endpointClear: endpointClear || void 0,
+      apiStyle,
       thinking: thinking?.trim().toLowerCase(),
       verifierProvider: verifierProvider?.trim(),
       verifierModel: verifierModel?.trim(),
@@ -70127,6 +70572,7 @@ function buildDesktopConfigSnapshot() {
       models,
       defaultModel,
       endpoint: custom2 ?? null,
+      apiStyle: p3.id === "anthropic" || p3.id === "chatgpt" ? void 0 : getApiStyleFor(p3.id),
       baseUrl: custom2 ?? builtin,
       authKind: !hasKey ? "none" : oauth ? "oauth" : "api_key",
       expiresAt: stored?.expiresAt ?? null,
@@ -70173,6 +70619,9 @@ function applySetConfig(req) {
     if (req.endpoint) {
       setCustomEndpoint(targetProvider, req.endpoint);
     }
+    if (req.apiStyle) {
+      setApiStyleFor(targetProvider, req.apiStyle);
+    }
     if (req.model) {
       setModelForProvider(targetProvider, req.model);
     }
@@ -70473,7 +70922,7 @@ function upsertSkill(opts) {
     }
     dir = getProjectSkillsDir(root);
   }
-  const path99 = skillFilePath(dir, name);
+  const path100 = skillFilePath(dir, name);
   const content = serializeSkillMd({
     name,
     description,
@@ -70482,13 +70931,13 @@ function upsertSkill(opts) {
     tools: opts.tools,
     cost: opts.cost
   });
-  const parsed = parseSkillMd(content, path99);
+  const parsed = parseSkillMd(content, path100);
   if (!parsed) {
     return { ok: false, error: "Generated SKILL.md failed validation" };
   }
-  mkdirSync23(dirname13(path99), { recursive: true });
-  writeFileSync25(path99, content, "utf8");
-  return { ok: true, path: path99 };
+  mkdirSync23(dirname13(path100), { recursive: true });
+  writeFileSync25(path100, content, "utf8");
+  return { ok: true, path: path100 };
 }
 function removeSkill(opts) {
   const name = opts.name.trim().toLowerCase();
@@ -70506,8 +70955,8 @@ function removeSkill(opts) {
     dir = getProjectSkillsDir(root);
   }
   const skillDir = join46(dir, name);
-  const path99 = skillFilePath(dir, name);
-  if (!existsSync59(path99) && !existsSync59(skillDir)) {
+  const path100 = skillFilePath(dir, name);
+  if (!existsSync59(path100) && !existsSync59(skillDir)) {
     return { ok: false, error: `Skill "${name}" not found in ${dir}` };
   }
   try {
@@ -70518,7 +70967,7 @@ function removeSkill(opts) {
       error: err instanceof Error ? err.message : String(err)
     };
   }
-  return { ok: true, path: path99 };
+  return { ok: true, path: path100 };
 }
 var NAME_RE, BUILTIN_SKILL_MODULES, builtinsLoaded;
 var init_skillConfigIo = __esm({
@@ -70639,7 +71088,7 @@ var init_jsonApi = __esm({
 });
 
 // src/cli/memory/mcpAdapter.ts
-import * as path93 from "node:path";
+import * as path94 from "node:path";
 var id2, projectId, source, SearchSchema, AddSchema, LinkSchema, RetractSchema, MEMORY_MCP_TOOLS, MemoryMcpAdapter;
 var init_mcpAdapter = __esm({
   "src/cli/memory/mcpAdapter.ts"() {
@@ -70809,8 +71258,8 @@ var init_mcpAdapter = __esm({
         this.takeWrite();
         const externalFile = args.source?.file;
         if (externalFile) {
-          const normalized = path93.normalize(externalFile);
-          if (path93.isAbsolute(normalized) || normalized === ".." || normalized.startsWith(`..${path93.sep}`)) {
+          const normalized = path94.normalize(externalFile);
+          if (path94.isAbsolute(normalized) || normalized === ".." || normalized.startsWith(`..${path94.sep}`)) {
             throw new Error("source.file must be project-relative and cannot escape the project");
           }
         }
@@ -71337,12 +71786,12 @@ function ensureHome() {
   }
 }
 function loadCompanionConfig() {
-  const path99 = getCompanionConfigPath();
-  if (!existsSync60(path99)) {
+  const path100 = getCompanionConfigPath();
+  if (!existsSync60(path100)) {
     return { projects: [] };
   }
   try {
-    const raw = JSON.parse(readFileSync45(path99, "utf8"));
+    const raw = JSON.parse(readFileSync45(path100, "utf8"));
     const projects = Array.isArray(raw.projects) ? raw.projects.filter(
       (p3) => p3 && typeof p3.path === "string" && p3.path.trim() && typeof (p3.id ?? p3.name) === "string"
     ).map((p3) => ({
@@ -71380,16 +71829,16 @@ function loadOrCreateToken(explicit) {
     return { token: explicit.trim(), created: false };
   }
   ensureHome();
-  const path99 = getCompanionTokenPath();
-  if (existsSync60(path99)) {
-    const t = readFileSync45(path99, "utf8").trim();
+  const path100 = getCompanionTokenPath();
+  if (existsSync60(path100)) {
+    const t = readFileSync45(path100, "utf8").trim();
     if (t) return { token: t, created: false };
   }
   const token = randomBytes7(24).toString("base64url");
-  writeFileSync26(path99, token + "\n", "utf8");
+  writeFileSync26(path100, token + "\n", "utf8");
   try {
     const fs48 = __require("node:fs");
-    fs48.chmodSync?.(path99, 384);
+    fs48.chmodSync?.(path100, 384);
   } catch {
   }
   return { token, created: true };
@@ -71414,17 +71863,17 @@ function mergeProjects(cfg, extraPaths) {
     byId.set(p3.id, p3);
   }
   for (const raw of extraPaths) {
-    const path99 = raw.trim();
-    if (!path99) continue;
-    let id3 = slugFromPath(path99);
+    const path100 = raw.trim();
+    if (!path100) continue;
+    let id3 = slugFromPath(path100);
     let n = 2;
-    while (byId.has(id3) && byId.get(id3).path !== path99) {
-      id3 = `${slugFromPath(path99)}-${n++}`;
+    while (byId.has(id3) && byId.get(id3).path !== path100) {
+      id3 = `${slugFromPath(path100)}-${n++}`;
     }
     byId.set(id3, {
       id: id3,
-      name: slugFromPath(path99),
-      path: path99
+      name: slugFromPath(path100),
+      path: path100
     });
   }
   return [...byId.values()];
@@ -71667,7 +72116,7 @@ var init_askUserBridge = __esm({
 
 // src/cli/serve/spineLockSweep.ts
 import { promises as fs47 } from "node:fs";
-import path94 from "node:path";
+import path95 from "node:path";
 async function sweepOrphanSpineLocks(sessionsDir2, options = {}) {
   const dir = sessionsDir2 ?? resolveSessionsDir();
   const onSwept = options.onSwept ?? ((sessionId2, reason) => {
@@ -71685,7 +72134,7 @@ async function sweepOrphanSpineLocks(sessionsDir2, options = {}) {
     return result;
   }
   for (const sessionId2 of entries) {
-    const lockPath2 = path94.join(dir, sessionId2, "writer.lock");
+    const lockPath2 = path95.join(dir, sessionId2, "writer.lock");
     try {
       const raw = await fs47.readFile(lockPath2, "utf-8");
       let lockInfo = {};
@@ -72682,9 +73131,9 @@ async function runCompanionServe(opts = {}) {
       return;
     }
     const url2 = parseUrl(req);
-    const path99 = url2.pathname.replace(/\/+$/, "") || "/";
+    const path100 = url2.pathname.replace(/\/+$/, "") || "/";
     try {
-      if (req.method === "GET" && (path99 === "/health" || path99 === "/v1/health")) {
+      if (req.method === "GET" && (path100 === "/health" || path100 === "/v1/health")) {
         sendJson2(res, 200, {
           ok: true,
           service: "zelari-companion",
@@ -72696,18 +73145,18 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      if (path99.startsWith("/v1")) {
+      if (path100.startsWith("/v1")) {
         if (!tokenMatches(token, getBearer(req))) {
           sendJson2(res, 401, { ok: false, error: "unauthorized" });
           return;
         }
       }
-      if (req.method === "GET" && path99 === "/v1/config") {
+      if (req.method === "GET" && path100 === "/v1/config") {
         const snap = buildDesktopConfigSnapshot();
         sendJson2(res, 200, { ok: true, ...snap });
         return;
       }
-      if (req.method === "GET" && path99 === "/v1/projects") {
+      if (req.method === "GET" && path100 === "/v1/projects") {
         sendJson2(res, 200, {
           ok: true,
           projects: projects.map((p3) => ({
@@ -72718,7 +73167,7 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      if (req.method === "GET" && path99 === "/v1/runs") {
+      if (req.method === "GET" && path100 === "/v1/runs") {
         sendJson2(res, 200, {
           ok: true,
           active: runs.getActive(),
@@ -72736,7 +73185,7 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      if (req.method === "POST" && path99 === "/v1/runs") {
+      if (req.method === "POST" && path100 === "/v1/runs") {
         const raw = await readBody(req);
         let body = {};
         try {
@@ -72784,7 +73233,7 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      const eventsMatch = /^\/v1\/runs\/([^/]+)\/events$/.exec(path99);
+      const eventsMatch = /^\/v1\/runs\/([^/]+)\/events$/.exec(path100);
       if (req.method === "GET" && eventsMatch) {
         const runId = eventsMatch[1];
         const run = runs.getRun(runId);
@@ -72849,7 +73298,7 @@ async function runCompanionServe(opts = {}) {
         }, 500);
         return;
       }
-      const cancelMatch = /^\/v1\/runs\/([^/]+)\/cancel$/.exec(path99);
+      const cancelMatch = /^\/v1\/runs\/([^/]+)\/cancel$/.exec(path100);
       if (req.method === "POST" && cancelMatch) {
         const runId = cancelMatch[1];
         const result = runs.cancel(runId);
@@ -72860,7 +73309,7 @@ async function runCompanionServe(opts = {}) {
         sendJson2(res, 200, { ok: true, cancelled: runId });
         return;
       }
-      const steerMatch = /^\/v1\/runs\/([^/]+)\/steer$/.exec(path99);
+      const steerMatch = /^\/v1\/runs\/([^/]+)\/steer$/.exec(path100);
       if (req.method === "POST" && steerMatch) {
         const runId = steerMatch[1];
         const raw = await readBody(req);
@@ -73029,11 +73478,11 @@ import { execSync as execSync2 } from "node:child_process";
 import { existsSync as existsSync62, readFileSync as readFileSync46, readlinkSync, statSync as statSync10 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
-import path95 from "node:path";
+import path96 from "node:path";
 function findPackageRoot(start) {
   let dir = start;
   for (let i = 0; i < 6; i += 1) {
-    const candidate = path95.join(dir, "package.json");
+    const candidate = path96.join(dir, "package.json");
     if (existsSync62(candidate)) {
       try {
         const pkg = JSON.parse(readFileSync46(candidate, "utf8"));
@@ -73041,11 +73490,11 @@ function findPackageRoot(start) {
       } catch {
       }
     }
-    const parent = path95.dirname(dir);
+    const parent = path96.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  return path95.resolve(__dirname3, "..", "..", "..");
+  return path96.resolve(__dirname3, "..", "..", "..");
 }
 function tryExec(cmd) {
   try {
@@ -73059,7 +73508,7 @@ function tryExec(cmd) {
 }
 function readPackageJson4() {
   try {
-    const pkgPath = path95.join(packageRoot, "package.json");
+    const pkgPath = path96.join(packageRoot, "package.json");
     return JSON.parse(readFileSync46(pkgPath, "utf8"));
   } catch {
     return null;
@@ -73071,7 +73520,7 @@ function getGlobalPrefix() {
   return (process.env.npm_config_prefix || process.env.NPM_CONFIG_PREFIX || "").trim();
 }
 function isSourceCheckout() {
-  return existsSync62(path95.join(packageRoot, "src", "cli", "main.ts")) && existsSync62(path95.join(packageRoot, "apps", "desktop", "package.json"));
+  return existsSync62(path96.join(packageRoot, "src", "cli", "main.ts")) && existsSync62(path96.join(packageRoot, "apps", "desktop", "package.json"));
 }
 function checkShim(pkgName) {
   const prefix = getGlobalPrefix();
@@ -73080,9 +73529,9 @@ function checkShim(pkgName) {
   }
   const isWin = process.platform === "win32";
   const shimName = isWin ? "zelari-code.cmd" : "zelari-code";
-  const shimPath = path95.join(prefix, shimName);
+  const shimPath = path96.join(prefix, shimName);
   if (!existsSync62(shimPath)) {
-    const localBin = path95.join(packageRoot, "bin", "zelari-code.js");
+    const localBin = path96.join(packageRoot, "bin", "zelari-code.js");
     if (isSourceCheckout() && existsSync62(localBin)) {
       return WARN(
         `global shim not found at ${shimPath}
@@ -73116,8 +73565,8 @@ function checkShim(pkgName) {
          fix:  npm install -g ${pkgName}@latest --force`
       );
     }
-    const resolved = path95.resolve(path95.dirname(shimPath), target);
-    const expected = path95.join(
+    const resolved = path96.resolve(path96.dirname(shimPath), target);
+    const expected = path96.join(
       prefix,
       "node_modules",
       pkgName,
@@ -73159,7 +73608,7 @@ function checkNode(pkg) {
   return OK(`node ${raw} (engines.node ${enginesNode ?? ">= 20.0.0"})`);
 }
 function checkBundle() {
-  const bundle = path95.join(packageRoot, "dist", "cli", "main.bundled.js");
+  const bundle = path96.join(packageRoot, "dist", "cli", "main.bundled.js");
   if (!existsSync62(bundle)) {
     return FAIL(
       `dist/cli/main.bundled.js missing at ${bundle}
@@ -73180,7 +73629,7 @@ function checkRuntimeDeps() {
   const missing = [];
   for (const dep of required2) {
     try {
-      const localReq = createRequire3(path95.join(packageRoot, "package.json"));
+      const localReq = createRequire3(path96.join(packageRoot, "package.json"));
       localReq.resolve(dep);
     } catch {
       missing.push(dep);
@@ -73457,7 +73906,7 @@ var init_doctor = __esm({
     init_metrics3();
     init_contextGrowthSummary();
     require3 = createRequire3(import.meta.url);
-    __dirname3 = path95.dirname(fileURLToPath3(import.meta.url));
+    __dirname3 = path96.dirname(fileURLToPath3(import.meta.url));
     packageRoot = findPackageRoot(__dirname3);
     OK = (message) => ({
       ok: true,
@@ -73566,7 +74015,7 @@ __export(userSettings_exports, {
   settingsOverrides: () => settingsOverrides
 });
 import { existsSync as existsSync63, readFileSync as readFileSync47 } from "node:fs";
-import path96 from "node:path";
+import path97 from "node:path";
 function parseBool(raw) {
   const v = raw.trim().toLowerCase();
   if (["1", "true", "yes", "on"].includes(v)) return true;
@@ -73633,8 +74082,8 @@ function envValueFor(key, env) {
 function resolveUserSettings(opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
   const env = opts.env ?? process.env;
-  const userPath = path96.join(zelariHome(), SETTINGS_FILE_NAME);
-  const projectPath = path96.join(cwd, ".zelari", SETTINGS_FILE_NAME);
+  const userPath = path97.join(zelariHome(), SETTINGS_FILE_NAME);
+  const projectPath = path97.join(cwd, ".zelari", SETTINGS_FILE_NAME);
   const warnings = [];
   const userLayer = loadFileLayer(userPath, "user", warnings);
   const projectLayer = loadFileLayer(projectPath, "project", warnings);
@@ -73848,7 +74297,7 @@ __export(inspectSession_exports, {
   renderInspectReport: () => renderInspectReport,
   runInspectSession: () => runInspectSession
 });
-import path97 from "node:path";
+import path98 from "node:path";
 import { existsSync as existsSync64 } from "node:fs";
 function formatLimit(limit) {
   return `${Math.round(limit / 1e3)}k`;
@@ -73882,8 +74331,8 @@ function renderInspectReport(state3) {
 }
 async function runInspectSession(opts) {
   const sessionsDir2 = resolveSessionsDir({ workspaceRoot: opts.cwd ?? process.cwd() });
-  const sessionDir = path97.join(sessionsDir2, opts.sessionId);
-  const eventsPath = path97.join(sessionDir, "events.jsonl");
+  const sessionDir = path98.join(sessionsDir2, opts.sessionId);
+  const eventsPath = path98.join(sessionDir, "events.jsonl");
   if (!existsSync64(sessionDir)) {
     console.error(`zelari-code inspect: no session directory at ${sessionDir}`);
     return 1;
@@ -73917,14 +74366,14 @@ __export(inspect_exports, {
   collectInspectReport: () => collectInspectReport,
   runInspect: () => runInspect
 });
-import path98 from "node:path";
+import path99 from "node:path";
 import { existsSync as existsSync65, readFileSync as readFileSync48, readdirSync as readdirSync13 } from "node:fs";
 async function collectInspectReport(cwd = process.cwd()) {
   ensureBuiltinSkillsLoadedSync();
   const snap = listSkillsSnapshot(cwd);
   const mcp = listMcpServers(cwd);
-  const userMcpPath = path98.join(zelariHome(), "mcp.json");
-  const projectMcpPath = path98.join(cwd, ".zelari", "mcp.json");
+  const userMcpPath = path99.join(zelariHome(), "mcp.json");
+  const projectMcpPath = path99.join(cwd, ".zelari", "mcp.json");
   const globalHooks = globalHooksDir();
   const projectHooks = projectHooksDir(cwd);
   const projectTrusted = isFolderTrusted(cwd);
@@ -73952,9 +74401,9 @@ async function collectInspectReport(cwd = process.cwd()) {
     configSources: [
       { path: userMcpPath, exists: existsSync65(userMcpPath) },
       { path: projectMcpPath, exists: existsSync65(projectMcpPath) },
-      { path: path98.join(zelariHome(), "provider.json"), exists: existsSync65(path98.join(zelariHome(), "provider.json")) },
-      { path: path98.join(cwd, ".zelari", "AGENTS.md"), exists: existsSync65(path98.join(cwd, ".zelari", "AGENTS.md")) },
-      { path: path98.join(cwd, "AGENTS.md"), exists: existsSync65(path98.join(cwd, "AGENTS.md")) }
+      { path: path99.join(zelariHome(), "provider.json"), exists: existsSync65(path99.join(zelariHome(), "provider.json")) },
+      { path: path99.join(cwd, ".zelari", "AGENTS.md"), exists: existsSync65(path99.join(cwd, ".zelari", "AGENTS.md")) },
+      { path: path99.join(cwd, "AGENTS.md"), exists: existsSync65(path99.join(cwd, "AGENTS.md")) }
     ],
     skills: {
       total: snap.skills.length,
@@ -73994,8 +74443,8 @@ function listJsonFiles(dir) {
 }
 function findAgentsMd(cwd) {
   const candidates = [
-    path98.join(cwd, "AGENTS.md"),
-    path98.join(cwd, ".zelari", "AGENTS.md")
+    path99.join(cwd, "AGENTS.md"),
+    path99.join(cwd, ".zelari", "AGENTS.md")
   ];
   const found = [];
   for (const c of candidates) {
@@ -79250,10 +79699,10 @@ init_ledger();
 
 // src/cli/evolution/proposals.ts
 import { existsSync as existsSync51, readFileSync as readFileSync39 } from "node:fs";
-import path76 from "node:path";
-var PROPOSALS_REL = path76.join(".zelari", "evolution", "proposals.jsonl");
+import path77 from "node:path";
+var PROPOSALS_REL = path77.join(".zelari", "evolution", "proposals.jsonl");
 function proposalsPath(cwd) {
-  return path76.join(cwd, PROPOSALS_REL);
+  return path77.join(cwd, PROPOSALS_REL);
 }
 function readProposalStore(cwd) {
   const file2 = proposalsPath(cwd);
@@ -79541,6 +79990,24 @@ ${formatSkillList(availableSkills)}`
           customEndpoint: url2
         };
       }
+      if (subcommand === "api") {
+        const target = args[1];
+        if (!target || target === "show") {
+          return {
+            handled: true,
+            kind: "provider_custom",
+            message: "Usage: /provider api chat \u2014 POST /chat/completions (default)\n         /provider api responses \u2014 POST /responses (OpenAI Responses API)\nApplies to the active provider; chatgpt/anthropic have a fixed transport."
+          };
+        }
+        if (target !== "chat" && target !== "responses") {
+          return {
+            handled: true,
+            kind: "provider_custom",
+            message: `[provider] unknown api style: ${target}. Use: chat | responses`
+          };
+        }
+        return { handled: true, kind: "provider_custom", apiStyle: target };
+      }
       const providerId = subcommand;
       const sub = args[1];
       if (sub === "refresh") {
@@ -80345,11 +80812,11 @@ function handleCacheStats(ctx) {
 init_messageHelpers();
 init_serviceFactory();
 import { promises as fs35 } from "node:fs";
-import * as path78 from "node:path";
+import * as path79 from "node:path";
 
 // src/cli/memory/promotion.ts
 import { promises as fs34 } from "node:fs";
-import * as path77 from "node:path";
+import * as path78 from "node:path";
 var START = "<!-- zelari:memory-promotions:start -->";
 var END = "<!-- zelari:memory-promotions:end -->";
 var DURABLE_KINDS = /* @__PURE__ */ new Set(["fact", "decision", "constraint", "preference", "procedure"]);
@@ -80360,16 +80827,16 @@ function lineFor(node) {
 }
 async function promoteMemoryToAgentsMd(projectRoot, node) {
   if (node.status !== "active") {
-    return { added: false, path: path77.join(projectRoot, "AGENTS.md"), reason: `memory is ${node.status}` };
+    return { added: false, path: path78.join(projectRoot, "AGENTS.md"), reason: `memory is ${node.status}` };
   }
   if (!DURABLE_KINDS.has(node.kind)) {
-    return { added: false, path: path77.join(projectRoot, "AGENTS.md"), reason: `${node.kind} is not a durable instruction kind` };
+    return { added: false, path: path78.join(projectRoot, "AGENTS.md"), reason: `${node.kind} is not a durable instruction kind` };
   }
-  const root = await fs34.realpath(projectRoot).catch(() => path77.resolve(projectRoot));
-  const target = path77.join(root, "AGENTS.md");
+  const root = await fs34.realpath(projectRoot).catch(() => path78.resolve(projectRoot));
+  const target = path78.join(root, "AGENTS.md");
   try {
-    const stat7 = await fs34.lstat(target);
-    if (stat7.isSymbolicLink() || !stat7.isFile()) throw new Error("AGENTS.md must be a regular project file.");
+    const stat8 = await fs34.lstat(target);
+    if (stat8.isSymbolicLink() || !stat8.isFile()) throw new Error("AGENTS.md must be a regular project file.");
   } catch (error51) {
     if (error51.code !== "ENOENT") throw error51;
   }
@@ -80431,25 +80898,25 @@ function sourceLine(source2) {
   return entries.length ? entries.map(([key, value]) => `${key}=${value}`).join(" \xB7 ") : "unknown";
 }
 function isInside(root, target) {
-  const relative6 = path78.relative(root, target);
-  return relative6 === "" || !relative6.startsWith("..") && !path78.isAbsolute(relative6);
+  const relative6 = path79.relative(root, target);
+  return relative6 === "" || !relative6.startsWith("..") && !path79.isAbsolute(relative6);
 }
 async function safeExportPath(cwd, requested) {
-  const lexicalRoot = path78.resolve(cwd);
+  const lexicalRoot = path79.resolve(cwd);
   const root = await fs35.realpath(lexicalRoot).catch(() => lexicalRoot);
-  const fallback = path78.join(root, ".zelari", "memory", `export-${Date.now()}.json`);
-  const target = requested?.trim() ? path78.resolve(root, requested.trim()) : fallback;
+  const fallback = path79.join(root, ".zelari", "memory", `export-${Date.now()}.json`);
+  const target = requested?.trim() ? path79.resolve(root, requested.trim()) : fallback;
   if (!isInside(root, target)) {
     throw new Error("Export path must stay inside the active project.");
   }
-  const parent = path78.dirname(target);
-  const relativeParent = path78.relative(root, parent);
+  const parent = path79.dirname(target);
+  const relativeParent = path79.relative(root, parent);
   let cursor = root;
-  for (const segment of relativeParent.split(path78.sep).filter(Boolean)) {
-    cursor = path78.join(cursor, segment);
+  for (const segment of relativeParent.split(path79.sep).filter(Boolean)) {
+    cursor = path79.join(cursor, segment);
     try {
-      const stat7 = await fs35.lstat(cursor);
-      if (stat7.isSymbolicLink()) {
+      const stat8 = await fs35.lstat(cursor);
+      if (stat8.isSymbolicLink()) {
         throw new Error("Export path must not traverse a symbolic link.");
       }
     } catch (error51) {
@@ -80618,9 +81085,9 @@ ${message}` : message
       }
       case "export": {
         const target = await safeExportPath(ctx.cwd, args.join(" ").trim() || void 0);
-        await fs35.mkdir(path78.dirname(target), { recursive: true });
-        const root = await fs35.realpath(ctx.cwd).catch(() => path78.resolve(ctx.cwd));
-        const realParent = await fs35.realpath(path78.dirname(target));
+        await fs35.mkdir(path79.dirname(target), { recursive: true });
+        const root = await fs35.realpath(ctx.cwd).catch(() => path79.resolve(ctx.cwd));
+        const realParent = await fs35.realpath(path79.dirname(target));
         if (!isInside(root, realParent)) {
           throw new Error("Export path resolves outside the active project.");
         }
@@ -80835,7 +81302,7 @@ import { promises as fs37 } from "node:fs";
 init_zod();
 init_taskTool();
 import { promises as fs36 } from "node:fs";
-import path79 from "node:path";
+import path80 from "node:path";
 import { randomBytes as randomBytes6 } from "node:crypto";
 var CsvFanoutArgsSchema = external_exports.object({
   csv_path: external_exports.string().min(1),
@@ -80897,27 +81364,27 @@ function parseCsv(text) {
     records.pop();
   }
   if (records.length === 0) return { headers: [], rows: [] };
-  const headers2 = records[0];
+  const headers3 = records[0];
   const rows = records.slice(1).map((r) => {
     const obj = {};
-    for (let i = 0; i < headers2.length; i++) obj[headers2[i]] = r[i] ?? "";
+    for (let i = 0; i < headers3.length; i++) obj[headers3[i]] = r[i] ?? "";
     return obj;
   });
-  return { headers: headers2, rows };
+  return { headers: headers3, rows };
 }
 function applyTemplate(template, row) {
   return template.replace(/\{([a-zA-Z_][\w-]*)\}/g, (_, k) => row[k] ?? "");
 }
-function serializeCsv(headers2, rows) {
+function serializeCsv(headers3, rows) {
   const escape = (v) => {
     if (v.includes(",") || v.includes("\n") || v.includes('"')) {
       return `"${v.replace(/"/g, '""')}"`;
     }
     return v;
   };
-  const out = [headers2.map(escape).join(",")];
+  const out = [headers3.map(escape).join(",")];
   for (const row of rows) {
-    out.push(headers2.map((h) => escape(row[h] ?? "")).join(","));
+    out.push(headers3.map((h) => escape(row[h] ?? "")).join(","));
   }
   return out.join("\n") + "\n";
 }
@@ -80929,23 +81396,23 @@ function resolveMaxConcurrency(env = process.env) {
 }
 async function runCsvFanout(args, deps, opts) {
   const start = Date.now();
-  const absCsv = path79.isAbsolute(args.csv_path) ? args.csv_path : path79.join(opts.parentCwd, args.csv_path);
-  const absOut = path79.isAbsolute(args.output_csv_path) ? args.output_csv_path : path79.join(opts.parentCwd, args.output_csv_path);
-  const { headers: headers2, rows } = await readCsv(absCsv);
-  if (headers2.length === 0) {
+  const absCsv = path80.isAbsolute(args.csv_path) ? args.csv_path : path80.join(opts.parentCwd, args.csv_path);
+  const absOut = path80.isAbsolute(args.output_csv_path) ? args.output_csv_path : path80.join(opts.parentCwd, args.output_csv_path);
+  const { headers: headers3, rows } = await readCsv(absCsv);
+  if (headers3.length === 0) {
     throw new Error(`kraken_csv_fanout: ${absCsv} is empty`);
   }
   if (!args.id_column) {
     throw new Error("kraken_csv_fanout: id_column is required");
   }
-  if (!headers2.includes(args.id_column)) {
-    throw new Error(`kraken_csv_fanout: id_column "${args.id_column}" not in CSV header [${headers2.join(", ")}]`);
+  if (!headers3.includes(args.id_column)) {
+    throw new Error(`kraken_csv_fanout: id_column "${args.id_column}" not in CSV header [${headers3.join(", ")}]`);
   }
   const concurrency = args.max_concurrency ?? resolveMaxConcurrency();
   opts.onLog?.(`csv fanout: ${rows.length} rows \xD7 ${args.agent_kind} @ concurrency=${concurrency}`);
   const perRowMs = args.max_runtime_seconds !== void 0 ? args.max_runtime_seconds * 1e3 : args.agent_kind === "general" ? TASK_TOOL_TIMEOUT_MS : 3e5;
   const outputRecords = rows.map((r) => ({ ...r, status: "pending", result: "", error: "" }));
-  const outHeaders = [...headers2, "status", "result", "error"];
+  const outHeaders = [...headers3, "status", "result", "error"];
   let writeChain2 = Promise.resolve();
   function queueWrite(contents) {
     const next = writeChain2.then(() => atomicWrite(absOut, contents));
@@ -80986,7 +81453,7 @@ async function runCsvFanout(args, deps, opts) {
         errored += 1;
         errors.push(`${row[args.id_column] ?? i}: ${res.error}`);
       }
-      await fs36.mkdir(path79.dirname(absOut), { recursive: true });
+      await fs36.mkdir(path80.dirname(absOut), { recursive: true });
       await queueWrite(serializeCsv(outHeaders, outputRecords));
     }
   }
@@ -81181,7 +81648,7 @@ function splitArgs(s) {
 // src/cli/slashHandlers/krakenWorkbench.ts
 init_messageHelpers();
 import { promises as fs38 } from "node:fs";
-import path80 from "node:path";
+import path81 from "node:path";
 
 // src/cli/kraken/workbenchView.ts
 var EMPTY = {
@@ -81298,17 +81765,17 @@ function formatWorkbenchForTerminal(p3) {
 
 // src/cli/slashHandlers/krakenWorkbench.ts
 async function handleKrakenWorkbench(ctx) {
-  const dir = path80.join(ctx.cwd, ".zelari", "radio");
+  const dir = path81.join(ctx.cwd, ".zelari", "radio");
   let latest = null;
   let latestMtime = 0;
   try {
     const files = await fs38.readdir(dir);
     for (const f of files) {
       if (!f.startsWith("workbench-") || !f.endsWith(".md")) continue;
-      const full = path80.join(dir, f);
-      const stat7 = await fs38.stat(full);
-      if (stat7.mtimeMs > latestMtime) {
-        latestMtime = stat7.mtimeMs;
+      const full = path81.join(dir, f);
+      const stat8 = await fs38.stat(full);
+      if (stat8.mtimeMs > latestMtime) {
+        latestMtime = stat8.mtimeMs;
         latest = full;
       }
     }
@@ -81322,10 +81789,10 @@ async function handleKrakenWorkbench(ctx) {
   const parsed = parseWorkbench(content);
   const rendered = formatWorkbenchForTerminal(parsed);
   if (!rendered.trim()) {
-    appendSystem(ctx.setMessages, `[kraken workbench] ${path80.basename(latest)}: (no nodes / no events yet)`);
+    appendSystem(ctx.setMessages, `[kraken workbench] ${path81.basename(latest)}: (no nodes / no events yet)`);
     return;
   }
-  appendSystem(ctx.setMessages, `[kraken workbench] ${path80.basename(latest)}:
+  appendSystem(ctx.setMessages, `[kraken workbench] ${path81.basename(latest)}:
 ${rendered}`);
 }
 
@@ -81633,14 +82100,14 @@ ${result.output.split("\n").slice(-8).join("\n")}` : "";
 init_messageHelpers();
 init_paths();
 import { promises as fs39 } from "node:fs";
-import path83 from "node:path";
+import path84 from "node:path";
 async function handlePromoteMember(ctx, memberId) {
   try {
     const { promoteMember: promoteMember2 } = await Promise.resolve().then(() => (init_council(), council_exports));
     const { skill, markdown } = promoteMember2(memberId);
     const skillDir = skillsDir();
     await fs39.mkdir(skillDir, { recursive: true });
-    const filePath = path83.join(skillDir, `${skill.id}.md`);
+    const filePath = path84.join(skillDir, `${skill.id}.md`);
     const previous = await fs39.readFile(filePath, "utf8").catch(() => null);
     const { createHash: createHash24 } = await import("node:crypto");
     const sha = (s) => createHash24("sha256").update(s, "utf8").digest("hex");
@@ -81666,7 +82133,7 @@ ${lineage}
 // src/cli/branchManager.ts
 init_paths();
 import { promises as fs40, existsSync as existsSync55, readFileSync as readFileSync41, writeFileSync as writeFileSync24, mkdirSync as mkdirSync21, statSync as statSync7, rmSync as rmSync3 } from "node:fs";
-import path84 from "node:path";
+import path85 from "node:path";
 var META_FILENAME = "meta.json";
 var SESSIONS_SUBDIR = "sessions";
 function getBranchesBaseDir() {
@@ -81676,13 +82143,13 @@ function getSessionsBaseDir() {
   return sessionsDir();
 }
 function branchPathFor(name, baseDir) {
-  return path84.join(baseDir, name);
+  return path85.join(baseDir, name);
 }
 function metaPathFor(name, baseDir) {
-  return path84.join(baseDir, name, META_FILENAME);
+  return path85.join(baseDir, name, META_FILENAME);
 }
 function sessionsPathFor(name, baseDir) {
-  return path84.join(baseDir, name, SESSIONS_SUBDIR);
+  return path85.join(baseDir, name, SESSIONS_SUBDIR);
 }
 function readBranchMeta(name, baseDir) {
   const metaPath = metaPathFor(name, baseDir);
@@ -81707,7 +82174,7 @@ function readBranchMeta(name, baseDir) {
 }
 function writeBranchMeta(name, baseDir, meta3) {
   const metaPath = metaPathFor(name, baseDir);
-  mkdirSync21(path84.dirname(metaPath), { recursive: true });
+  mkdirSync21(path85.dirname(metaPath), { recursive: true });
   writeFileSync24(metaPath, JSON.stringify(meta3, null, 2), "utf-8");
 }
 async function countSessions(name, baseDir) {
@@ -81758,14 +82225,14 @@ async function createBranch(name, fromSessionId, baseDir = getBranchesBaseDir(),
   if (branchExists(name, baseDir)) {
     throw new BranchAlreadyExistsError(name);
   }
-  const sourcePath = path84.join(sessionsBaseDir, `${fromSessionId}.jsonl`);
+  const sourcePath = path85.join(sessionsBaseDir, `${fromSessionId}.jsonl`);
   if (!existsSync55(sourcePath)) {
     throw new SessionNotFoundError(`Source session "${fromSessionId}" not found at ${sourcePath}`);
   }
   const branchPath = branchPathFor(name, baseDir);
   const branchSessionsPath = sessionsPathFor(name, baseDir);
   mkdirSync21(branchSessionsPath, { recursive: true });
-  const destPath = path84.join(branchSessionsPath, `${fromSessionId}.jsonl`);
+  const destPath = path85.join(branchSessionsPath, `${fromSessionId}.jsonl`);
   await fs40.copyFile(sourcePath, destPath);
   const meta3 = {
     name,
@@ -81869,14 +82336,14 @@ async function handleBranchCheckout(ctx, branchName) {
 // src/cli/slashHandlers/workspace.ts
 init_messageHelpers();
 import { promises as fs41 } from "node:fs";
-import path85 from "node:path";
+import path86 from "node:path";
 async function handleWorkspaceShow(ctx, what) {
   try {
-    const zelari = path85.join(process.cwd(), ".zelari");
+    const zelari = path86.join(process.cwd(), ".zelari");
     let content;
     switch (what) {
       case "plan": {
-        const planPath = path85.join(zelari, "plan.md");
+        const planPath = path86.join(zelari, "plan.md");
         try {
           content = await fs41.readFile(planPath, "utf-8");
         } catch {
@@ -81885,7 +82352,7 @@ async function handleWorkspaceShow(ctx, what) {
         break;
       }
       case "decisions": {
-        const decisionsDir = path85.join(zelari, "decisions");
+        const decisionsDir = path86.join(zelari, "decisions");
         try {
           const files = (await fs41.readdir(decisionsDir)).filter((f) => f.endsWith(".md")).sort();
           if (files.length === 0) {
@@ -81895,7 +82362,7 @@ async function handleWorkspaceShow(ctx, what) {
 `];
             const { parseFrontmatter: parseFrontmatter2 } = await Promise.resolve().then(() => (init_storage(), storage_exports));
             for (const f of files) {
-              const raw = await fs41.readFile(path85.join(decisionsDir, f), "utf-8");
+              const raw = await fs41.readFile(path86.join(decisionsDir, f), "utf-8");
               const { meta: meta3, body } = parseFrontmatter2(raw);
               const title = meta3.title ?? body.split("\n")[0]?.replace(/^#\s*/, "").trim() ?? f;
               lines.push(`- **${f.replace(/\.md$/, "")}** [${meta3.status ?? "unknown"}] ${title}`);
@@ -81908,7 +82375,7 @@ async function handleWorkspaceShow(ctx, what) {
         break;
       }
       case "risks": {
-        const risksPath = path85.join(zelari, "risks.md");
+        const risksPath = path86.join(zelari, "risks.md");
         try {
           content = await fs41.readFile(risksPath, "utf-8");
         } catch {
@@ -81917,7 +82384,7 @@ async function handleWorkspaceShow(ctx, what) {
         break;
       }
       case "agents": {
-        const agentsPath = path85.join(process.cwd(), "AGENTS.MD");
+        const agentsPath = path86.join(process.cwd(), "AGENTS.MD");
         try {
           content = await fs41.readFile(agentsPath, "utf-8");
         } catch {
@@ -81926,7 +82393,7 @@ async function handleWorkspaceShow(ctx, what) {
         break;
       }
       case "docs": {
-        const docsDir = path85.join(zelari, "docs");
+        const docsDir = path86.join(zelari, "docs");
         try {
           const files = (await fs41.readdir(docsDir)).filter((f) => f.endsWith(".md")).sort();
           content = files.length ? `# Docs (${files.length})
@@ -81968,7 +82435,7 @@ async function handleWorkspaceReset(ctx, force) {
     return;
   }
   try {
-    const target = path85.join(process.cwd(), ".zelari");
+    const target = path86.join(process.cwd(), ".zelari");
     await fs41.rm(target, { recursive: true, force: true });
     appendSystem(ctx.setMessages, "[workspace] .zelari/ removed");
   } catch (err) {
@@ -82306,6 +82773,7 @@ function useSlashDispatch(params) {
       handleProviderCustom(providerCtx, {
         endpoint: result.customEndpoint,
         clear: result.customClear,
+        apiStyle: result.apiStyle,
         message: result.message
       });
       setInput("");
@@ -83851,8 +84319,8 @@ function normalizeDraft(raw, sourceUrl, provider, model) {
   let name = String(o.name ?? "").trim().toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64);
   if (!name || !/^[a-z0-9][a-z0-9-]{0,63}$/.test(name)) {
     try {
-      const path99 = new URL(sourceUrl).pathname.split("/").filter(Boolean).pop()?.replace(/\.[a-z0-9]+$/i, "").toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48);
-      name = path99 && /^[a-z0-9]/.test(path99) ? path99 : "imported-skill";
+      const path100 = new URL(sourceUrl).pathname.split("/").filter(Boolean).pop()?.replace(/\.[a-z0-9]+$/i, "").toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48);
+      name = path100 && /^[a-z0-9]/.test(path100) ? path100 : "imported-skill";
     } catch {
       name = "imported-skill";
     }