@khalilgharbaoui/opencode-claude-code-plugin 0.56.0 → 0.57.0

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/claude-code-language-model.ts
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 
 // src/ids.ts
 import { randomInt } from "crypto";
@@ -717,6 +717,7 @@ var MAX_USAGE_ACCOUNTS = 32;
 var MAX_USAGE_WINDOWS = 8;
 var NAME = /^[a-z0-9_-]{1,64}$/;
 var STATUS = /^[a-z_]{1,32}$/;
+var TIER = /^[A-Za-z0-9][A-Za-z0-9 ]{0,23}$/;
 var MAX_RESETS_TEXT = 80;
 var pathOverride = null;
 var cache = null;
@@ -750,11 +751,28 @@ function validEntry(value) {
     noted
   };
 }
-function readStore(file, now) {
+var emptyStore = () => ({ usage: /* @__PURE__ */ new Map(), known: /* @__PURE__ */ new Map() });
+function readKnown(parsed) {
   const out = /* @__PURE__ */ new Map();
+  const known = parsed.known;
+  if (!known || typeof known !== "object" || Array.isArray(known)) return out;
+  for (const [account, raw] of Object.entries(known)) {
+    if (out.size >= MAX_USAGE_ACCOUNTS) break;
+    if (!NAME.test(account) || !raw || typeof raw !== "object" || Array.isArray(raw)) continue;
+    const record = raw;
+    if (!finite(record.at)) continue;
+    const tier = typeof record.tier === "string" && TIER.test(record.tier) ? record.tier : void 0;
+    out.set(account, { ...tier ? { tier } : {}, at: record.at });
+  }
+  return out;
+}
+function parseStore(file, now) {
+  const out = emptyStore();
   try {
     const parsed = JSON.parse(readFileSync(file, "utf8"));
-    const accounts = parsed && typeof parsed === "object" ? parsed.accounts : null;
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return out;
+    out.known = readKnown(parsed);
+    const accounts = parsed.accounts;
     if (!accounts || typeof accounts !== "object" || Array.isArray(accounts)) return out;
     const cutoff = now - USAGE_READING_MAX_AGE_MS;
     for (const [account, windows] of Object.entries(accounts)) {
@@ -765,12 +783,15 @@ function readStore(file, now) {
         const entry = validEntry(raw);
         if (entry && entry.observedAt >= cutoff) kept.set(window, entry);
       }
-      if (kept.size > 0) out.set(account, kept);
+      if (kept.size > 0) out.usage.set(account, kept);
     }
   } catch {
   }
   return out;
 }
+function readStore(file, now) {
+  return parseStore(file, now).usage;
+}
 function newestObserved(windows) {
   let newest = 0;
   for (const entry of windows.values()) newest = Math.max(newest, entry.observedAt);
@@ -784,13 +805,14 @@ function bounded(usage, now) {
   }).filter(([, windows]) => windows.size > 0).sort((a, b) => newestObserved(a[1]) - newestObserved(b[1])).slice(-MAX_USAGE_ACCOUNTS);
   return new Map(accounts);
 }
-function writeStore(file, usage) {
+function writeStore(file, usage, known) {
   const accounts = {};
   for (const [account, windows] of usage) accounts[account] = Object.fromEntries(windows);
+  const registered2 = known.size > 0 ? { known: Object.fromEntries(known) } : {};
   try {
     mkdirSync2(join2(file, ".."), { recursive: true, mode: 448 });
     const tmp = `${file}.${process.pid}.tmp`;
-    writeFileSync(tmp, JSON.stringify({ version: 1, accounts }), { mode: 384 });
+    writeFileSync(tmp, JSON.stringify({ version: 1, accounts, ...registered2 }), { mode: 384 });
     renameSync2(tmp, file);
     return true;
   } catch {
@@ -845,7 +867,8 @@ function resolveUsageSwitchAt(value) {
 function recordUsageReading(account, window, reading, now = Date.now()) {
   if (!NAME.test(account) || !NAME.test(window)) return null;
   const file = accountUsageStorePath();
-  const merged = readStore(file, now);
+  const store = parseStore(file, now);
+  const merged = store.usage;
   const previous = merged.get(account)?.get(window) ?? cached(now).get(account)?.get(window);
   const entry = applyReading(previous, reading, now);
   const windows = merged.get(account) ?? /* @__PURE__ */ new Map();
@@ -853,12 +876,13 @@ function recordUsageReading(account, window, reading, now = Date.now()) {
   merged.set(account, windows);
   const kept = bounded(merged, now);
   cache = { path: file, usage: kept };
-  return writeStore(file, kept) ? entry : null;
+  return writeStore(file, kept, store.known) ? entry : null;
 }
 function markUsageNoted(account, window, thresholds, now = Date.now()) {
   if (!NAME.test(account) || !NAME.test(window) || thresholds.length === 0) return false;
   const file = accountUsageStorePath();
-  const merged = readStore(file, now);
+  const store = parseStore(file, now);
+  const merged = store.usage;
   const entry = merged.get(account)?.get(window) ?? cached(now).get(account)?.get(window);
   if (!entry) return false;
   const updated = {
@@ -870,7 +894,28 @@ function markUsageNoted(account, window, thresholds, now = Date.now()) {
   merged.set(account, windows);
   const kept = bounded(merged, now);
   cache = { path: file, usage: kept };
-  return writeStore(file, kept);
+  return writeStore(file, kept, store.known);
+}
+function sameKnown(a, b) {
+  if (a.size !== b.size) return false;
+  for (const [account, record] of a) {
+    const other = b.get(account);
+    if (!other || other.tier !== record.tier) return false;
+  }
+  return true;
+}
+function registerKnownAccounts(accounts, now = Date.now()) {
+  const file = accountUsageStorePath();
+  const store = parseStore(file, now);
+  const known = /* @__PURE__ */ new Map();
+  for (const entry of accounts) {
+    if (known.size >= MAX_USAGE_ACCOUNTS) break;
+    if (!NAME.test(entry.account)) continue;
+    const tier = entry.tier && TIER.test(entry.tier) ? entry.tier : void 0;
+    known.set(entry.account, { ...tier ? { tier } : {}, at: now });
+  }
+  if (sameKnown(store.known, known)) return true;
+  return writeStore(file, bounded(store.usage, now), known);
 }
 function usageCrossings(account, thresholds, now = Date.now()) {
   if (thresholds.length === 0) return [];
@@ -13267,7 +13312,7 @@ function isRecord5(value) {
   if (!record || typeof record !== "object" || Array.isArray(record)) return false;
   if (typeof record.at !== "number" || !Number.isFinite(record.at)) return false;
   const ok = (field) => field === void 0 || typeof field === "string";
-  if (!ok(record.model) || !ok(record.effort) || !ok(record.account)) return false;
+  if (!ok(record.model) || !ok(record.effort) || !ok(record.account) || !ok(record.agent)) return false;
   return !!record.model;
 }
 function readEntries(file) {
@@ -13283,6 +13328,7 @@ function readEntries(file) {
         model: record.model,
         ...record.effort ? { effort: record.effort } : {},
         ...record.account ? { account: record.account } : {},
+        ...record.agent ? { agent: record.agent } : {},
         at: record.at
       });
     }
@@ -13296,11 +13342,13 @@ function recordSessionSpawn(sessionID, spawn2, now = Date.now()) {
     model: spawn2.model,
     ...spawn2.effort ? { effort: spawn2.effort } : {},
     ...spawn2.account ? { account: spawn2.account } : {},
+    ...spawn2.agent ? { agent: spawn2.agent } : {},
     at: now
   };
   const fingerprint = `${record.model}
 ${record.effort ?? ""}
-${record.account ?? ""}`;
+${record.account ?? ""}
+${record.agent ?? ""}`;
   if (lastWritten.get(sessionID) === fingerprint) return false;
   const file = spawnRecordStorePath();
   const merged = readEntries(file);
@@ -13323,6 +13371,133 @@ ${record.account ?? ""}`;
   return true;
 }
 
+// src/turn-history.ts
+import { mkdirSync as mkdirSync8, readFileSync as readFileSync10, renameSync as renameSync6, statSync as statSync9, writeFileSync as writeFileSync9 } from "fs";
+import { homedir as homedir13 } from "os";
+import { join as join16 } from "path";
+var MAX_TURN_SAMPLES = 48;
+var MAX_TURN_KEYS = 64;
+var TURN_SAMPLE_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
+var CHARS_BANDWIDTH = Math.log(4);
+var pathOverride5 = null;
+function turnHistoryStorePath() {
+  if (pathOverride5) return pathOverride5;
+  const stateRoot = process.env.XDG_STATE_HOME || join16(homedir13(), ".local", "state");
+  return join16(stateRoot, "opencode-claude-code-plugin", "turn-history.json");
+}
+function turnHistoryKey(agent, model) {
+  return `${agent || "main"}/${model}`;
+}
+var INJECTED_BLOCKS = [
+  /<system-reminder>[\s\S]*?<\/system-reminder>/g,
+  /<dcp-system-reminder>[\s\S]*?<\/dcp-system-reminder>/g,
+  /<dcp-message-id>[\s\S]*?<\/dcp-message-id>/g
+];
+function promptChars(texts) {
+  if (texts.length === 0) return void 0;
+  let total = 0;
+  for (const text of texts) {
+    let stripped = text;
+    for (const block of INJECTED_BLOCKS) stripped = stripped.replace(block, "");
+    total += stripped.trim().length;
+  }
+  return total;
+}
+function textsOf(content) {
+  if (typeof content === "string") return [content];
+  if (!Array.isArray(content)) return [];
+  const texts = [];
+  for (const part of content) {
+    if (!part || typeof part !== "object" || part.type !== "text") continue;
+    const text = part.text;
+    if (typeof text === "string") texts.push(text);
+  }
+  return texts;
+}
+function newestPromptChars(prompt) {
+  for (let index = prompt.length - 1; index >= 0; index -= 1) {
+    if (prompt[index].role === "user") return promptChars(textsOf(prompt[index].content));
+  }
+  return void 0;
+}
+function startsTurn(prompt) {
+  const last = prompt[prompt.length - 1];
+  if (!last || last.role !== "user") return false;
+  const before = prompt[prompt.length - 2];
+  return before === void 0 || before.role !== "tool";
+}
+var MAX_TURN_STARTS = 256;
+var turnStarts = /* @__PURE__ */ new Map();
+function markTurnStart(key, at, chars) {
+  turnStarts.delete(key);
+  if (turnStarts.size >= MAX_TURN_STARTS) {
+    const oldest = turnStarts.keys().next().value;
+    if (oldest !== void 0) turnStarts.delete(oldest);
+  }
+  turnStarts.set(key, { at, ...chars !== void 0 ? { chars } : {} });
+}
+function takeTurnStart(key) {
+  const start = turnStarts.get(key);
+  turnStarts.delete(key);
+  return start;
+}
+function isSample(value) {
+  const sample = value;
+  if (!sample || typeof sample !== "object" || Array.isArray(sample)) return false;
+  if (typeof sample.ms !== "number" || !Number.isFinite(sample.ms) || sample.ms < 0) return false;
+  if (typeof sample.at !== "number" || !Number.isFinite(sample.at)) return false;
+  if (sample.chars !== void 0 && (typeof sample.chars !== "number" || !Number.isFinite(sample.chars) || sample.chars < 0)) {
+    return false;
+  }
+  if (sample.effort !== void 0 && typeof sample.effort !== "string") return false;
+  return true;
+}
+function cleanSample(sample) {
+  return {
+    ms: Math.round(sample.ms),
+    ...sample.chars !== void 0 ? { chars: Math.round(sample.chars) } : {},
+    ...sample.effort ? { effort: sample.effort } : {},
+    at: sample.at
+  };
+}
+function readEntries2(file, now) {
+  const out = /* @__PURE__ */ new Map();
+  try {
+    const parsed = JSON.parse(readFileSync10(file, "utf8"));
+    const entries = parsed && typeof parsed === "object" ? parsed.turns : null;
+    if (!entries || typeof entries !== "object") return out;
+    const cutoff = now - TURN_SAMPLE_MAX_AGE_MS;
+    for (const [key, value] of Object.entries(entries)) {
+      if (!key || !Array.isArray(value)) continue;
+      const samples = value.filter(isSample).filter((sample) => sample.at >= cutoff).sort((a, b) => a.at - b.at).slice(-MAX_TURN_SAMPLES).map(cleanSample);
+      if (samples.length > 0) out.set(key, samples);
+    }
+  } catch {
+  }
+  return out;
+}
+function bounded2(history) {
+  const newest = (samples) => samples[samples.length - 1]?.at ?? 0;
+  return new Map([...history.entries()].sort((a, b) => newest(a[1]) - newest(b[1])).slice(-MAX_TURN_KEYS));
+}
+function recordTurnSample(key, sample) {
+  if (!key || !isSample(sample)) return false;
+  const file = turnHistoryStorePath();
+  const merged = readEntries2(file, sample.at);
+  const samples = [...merged.get(key) ?? [], cleanSample(sample)].sort((a, b) => a.at - b.at).slice(-MAX_TURN_SAMPLES);
+  merged.set(key, samples);
+  const kept = bounded2(merged);
+  try {
+    mkdirSync8(join16(file, ".."), { recursive: true, mode: 448 });
+    const tmp = `${file}.${process.pid}.tmp`;
+    writeFileSync9(tmp, JSON.stringify({ version: 1, turns: Object.fromEntries(kept) }), { mode: 384 });
+    renameSync6(tmp, file);
+  } catch {
+    return false;
+  }
+  return true;
+}
+
 // src/account-transcript.ts
 import { randomUUID as randomUUID6 } from "crypto";
 import { constants as fsConstants } from "fs";
@@ -13384,13 +13559,13 @@ function dedupe2(dirs) {
 }
 
 // src/prompts.ts
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync9 } from "fs";
-import { homedir as homedir13 } from "os";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync10 } from "fs";
+import { homedir as homedir14 } from "os";
 import { randomUUID as randomUUID7 } from "crypto";
-import { basename as basename2, dirname as dirname6, isAbsolute as isAbsolute3, join as join16 } from "path";
+import { basename as basename2, dirname as dirname6, isAbsolute as isAbsolute3, join as join17 } from "path";
 function readPromptFileIfPresent(path15) {
   try {
-    const content = readFileSync10(path15, "utf8").trim();
+    const content = readFileSync11(path15, "utf8").trim();
     return content || void 0;
   } catch {
     return void 0;
@@ -13399,7 +13574,7 @@ function readPromptFileIfPresent(path15) {
 function nearestWorkspaceAgentsPrompt(cwd) {
   let dir = cwd;
   while (true) {
-    const content = readPromptFileIfPresent(join16(dir, "AGENTS.md"));
+    const content = readPromptFileIfPresent(join17(dir, "AGENTS.md"));
     if (content) return content;
     const parent = dirname6(dir);
     if (parent === dir) return void 0;
@@ -13510,7 +13685,7 @@ var CLAUDE_NATIVE_INSTRUCTION_FILES = /* @__PURE__ */ new Set(["CLAUDE.md", "CLA
 function userAuthoredInstructions(forwarded, opts = {}) {
   const readFile3 = opts.readFile ?? ((path15) => {
     try {
-      return readFileSync10(path15, "utf8");
+      return readFileSync11(path15, "utf8");
     } catch {
       return null;
     }
@@ -13551,8 +13726,8 @@ ${options.compressionSummary.trim()}`
   for (const s of extraSystemContent) {
     if (s.trim()) parts.push(s.trim());
   }
-  const configRoot = process.env.XDG_CONFIG_HOME ?? join16(homedir13(), ".config");
-  const globalAgents = readPromptFileIfPresent(join16(configRoot, "opencode", "AGENTS.md"));
+  const configRoot = process.env.XDG_CONFIG_HOME ?? join17(homedir14(), ".config");
+  const globalAgents = readPromptFileIfPresent(join17(configRoot, "opencode", "AGENTS.md"));
   const workspaceAgents = nearestWorkspaceAgentsPrompt(cwd);
   const forwarded = extraSystemContent.join("\n\n");
   const pushGlobal = !!globalAgents && !forwarded.includes(globalAgents);
@@ -13568,9 +13743,9 @@ ${options.compressionSummary.trim()}`
   if (includeMultiStepHint) parts.push(MULTI_STEP_TASK_HINT);
   const content = parts.join("\n\n");
   if (!content) return void 0;
-  const path15 = join16(pluginTmpDir(), `opencode-cc-sys-${randomUUID7()}.md`);
+  const path15 = join17(pluginTmpDir(), `opencode-cc-sys-${randomUUID7()}.md`);
   try {
-    writeFileSync9(path15, content, { encoding: "utf8", mode: 384 });
+    writeFileSync10(path15, content, { encoding: "utf8", mode: 384 });
     return path15;
   } catch (err) {
     log.warn("failed to write system prompt file", { error: String(err) });
@@ -16712,6 +16887,7 @@ var ClaudeCodeLanguageModel = class {
     const autoSwitch = accountRun?.switchTo;
     if (accountRun) accountRun.switchTo = void 0;
     const turnAbort = watchTurnAbort(options.abortSignal);
+    const turnStartedAt = Date.now();
     const abortedBeforeWork = (stage) => {
       log.info("abort before the turn asked claude for work; nothing spawned", {
         stage,
@@ -16971,8 +17147,12 @@ var ClaudeCodeLanguageModel = class {
       recordSessionSpawn(affinity, {
         model: stripAccountSuffix(failover.modelId),
         effort: reasoningEffort,
-        account: (this.config.failoverAccounts?.length ?? 0) > 1 ? failover.target ?? sourceAccount : void 0
+        account: (this.config.failoverAccounts?.length ?? 0) > 1 ? failover.target ?? sourceAccount : void 0,
+        agent: this.getOpencodeAgent(options)
       });
+      if (startsTurn(options.prompt)) {
+        markTurnStart(sk, turnStartedAt, newestPromptChars(options.prompt));
+      }
     }
     const hasPriorConversation = options.prompt.filter((m) => m.role === "user" || m.role === "assistant").length > 1;
     if (!hasPriorConversation && !autoSwitch) {
@@ -17262,7 +17442,7 @@ var ClaudeCodeLanguageModel = class {
     let replayReason = "no-session-for-key";
     if (this.config.resumeAfterRestart !== false && includeHistoryContext && !compactionMode && !forkFromClaudeSessionId && failoverAnswer?.kind !== "switch") {
       const configDir = resolveConfigDir(this.config.configDir);
-      const transcriptPath2 = (id, dir) => join17(dir ?? configDir, "projects", encodeCwd(cwd), `${id}.jsonl`);
+      const transcriptPath2 = (id, dir) => join18(dir ?? configDir, "projects", encodeCwd(cwd), `${id}.jsonl`);
       const resumePoint = findResumePoint({
         sessionKey: sk,
         prompt: options.prompt,
@@ -18325,6 +18505,18 @@ var ClaudeCodeLanguageModel = class {
               state.resultFailure ??= "usage_limit";
             }
             if (runAutoContinue(state, msg)) return;
+            if (!compactionMode && affinity !== "default" && msg.is_error !== true && state.resultFailure === void 0) {
+              const start = takeTurnStart(sk);
+              if (start) {
+                const endedAt = Date.now();
+                recordTurnSample(turnHistoryKey(self.getOpencodeAgent(options), stripAccountSuffix(failover.modelId)), {
+                  ms: endedAt - start.at,
+                  chars: start.chars,
+                  effort: reasoningEffort,
+                  at: endedAt
+                });
+              }
+            }
             for (const [idx, reasoningId] of state.reasoningIds) {
               if (state.reasoningStarted.get(idx)) {
                 controller.enqueue({
@@ -18775,7 +18967,7 @@ var ClaudeCodeLanguageModel = class {
 };
 
 // src/account-tier.ts
-import { readFileSync as readFileSync11 } from "fs";
+import { readFileSync as readFileSync12 } from "fs";
 import path14 from "path";
 var ORGANIZATION_TYPE_LABELS = {
   claude_max: "Max",
@@ -18818,7 +19010,7 @@ function readTierFromConfigDir(configDir, allowLegacyFallback) {
 function readOauthAccount(file) {
   let raw;
   try {
-    raw = readFileSync11(file, "utf8");
+    raw = readFileSync12(file, "utf8");
   } catch {
     return void 0;
   }
@@ -18842,18 +19034,27 @@ function tierLabel(oauthAccount) {
   const multiple = typeof rateLimitTier === "string" ? RATE_LIMIT_TIER_LABELS[rateLimitTier] : void 0;
   return multiple ? `${base} ${multiple}` : base;
 }
+function registerSidebarAccounts(accounts) {
+  const list2 = accounts && accounts.length > 0 ? accounts : [DEFAULT_ACCOUNT];
+  registerKnownAccounts(
+    list2.map((account) => ({
+      account: normalizeAccountName(account) || DEFAULT_ACCOUNT,
+      tier: readAccountTier(account)
+    }))
+  );
+}
 
 // src/cleanup-stale.ts
 import {
   existsSync as existsSync5,
-  mkdirSync as mkdirSync8,
-  readFileSync as readFileSync12,
+  mkdirSync as mkdirSync9,
+  readFileSync as readFileSync13,
   realpathSync as realpathSync4,
   rmSync as rmSync3,
-  writeFileSync as writeFileSync10
+  writeFileSync as writeFileSync11
 } from "fs";
-import { homedir as homedir14 } from "os";
-import { dirname as dirname7, join as join18, resolve as resolve6 } from "path";
+import { homedir as homedir15 } from "os";
+import { dirname as dirname7, join as join19, resolve as resolve6 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 var STALE_PACKAGE_NAME = "opencode-claude-code-plugin";
 var SUSPECT_DESCRIPTION_TOKEN = "Claude Code";
@@ -18861,20 +19062,20 @@ var alreadyRan = false;
 function candidateCacheRoots() {
   const xdg = process.env.XDG_CACHE_HOME;
   return [
-    xdg ? join18(xdg, "opencode") : null,
-    join18(homedir14(), ".cache", "opencode"),
-    join18(homedir14(), "Library", "Caches", "opencode")
+    xdg ? join19(xdg, "opencode") : null,
+    join19(homedir15(), ".cache", "opencode"),
+    join19(homedir15(), "Library", "Caches", "opencode")
   ].filter((p) => Boolean(p));
 }
 function userOpencodeJsonPath() {
-  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join18(homedir14(), ".config");
-  return join18(xdgConfig, "opencode", "opencode.json");
+  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join19(homedir15(), ".config");
+  return join19(xdgConfig, "opencode", "opencode.json");
 }
 function userIntendsToUseUnscoped() {
   const cfg = userOpencodeJsonPath();
   if (!existsSync5(cfg)) return false;
   try {
-    const json = JSON.parse(readFileSync12(cfg, "utf8"));
+    const json = JSON.parse(readFileSync13(cfg, "utf8"));
     const plugins = json.plugin;
     if (!Array.isArray(plugins)) return false;
     return plugins.some(
@@ -18895,19 +19096,19 @@ function ourLoadedDir() {
 function ourVersion(dir) {
   if (!dir) return null;
   try {
-    const pkg = JSON.parse(readFileSync12(join18(dir, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync13(join19(dir, "package.json"), "utf8"));
     return typeof pkg.version === "string" && pkg.version ? pkg.version : null;
   } catch {
     return null;
   }
 }
 function markerPath() {
-  const stateRoot = process.env.XDG_STATE_HOME ?? join18(homedir14(), ".local", "state");
-  return join18(stateRoot, "opencode-claude-code-plugin", "cleanup-stale.json");
+  const stateRoot = process.env.XDG_STATE_HOME ?? join19(homedir15(), ".local", "state");
+  return join19(stateRoot, "opencode-claude-code-plugin", "cleanup-stale.json");
 }
 function markerVersion() {
   try {
-    const marker = JSON.parse(readFileSync12(markerPath(), "utf8"));
+    const marker = JSON.parse(readFileSync13(markerPath(), "utf8"));
     return typeof marker.version === "string" ? marker.version : null;
   } catch {
     return null;
@@ -18916,8 +19117,8 @@ function markerVersion() {
 function writeMarker(version) {
   const file = markerPath();
   try {
-    mkdirSync8(dirname7(file), { recursive: true, mode: 448 });
-    writeFileSync10(
+    mkdirSync9(dirname7(file), { recursive: true, mode: 448 });
+    writeFileSync11(
       file,
       JSON.stringify({ version, at: (/* @__PURE__ */ new Date()).toISOString() }, null, 2) + "\n",
       "utf8"
@@ -18952,7 +19153,7 @@ function cleanupStaleUnscopedInstall() {
 }
 function cleanupOne(cacheRoot, ourDir) {
   if (!existsSync5(cacheRoot)) return;
-  const stalePath = join18(cacheRoot, "node_modules", STALE_PACKAGE_NAME);
+  const stalePath = join19(cacheRoot, "node_modules", STALE_PACKAGE_NAME);
   if (!existsSync5(stalePath)) return;
   let realStalePath = stalePath;
   try {
@@ -18960,11 +19161,11 @@ function cleanupOne(cacheRoot, ourDir) {
   } catch {
   }
   if (ourDir && realStalePath === ourDir) return;
-  const pkgJsonPath = join18(stalePath, "package.json");
+  const pkgJsonPath = join19(stalePath, "package.json");
   if (!existsSync5(pkgJsonPath)) return;
   let pkg = {};
   try {
-    pkg = JSON.parse(readFileSync12(pkgJsonPath, "utf8"));
+    pkg = JSON.parse(readFileSync13(pkgJsonPath, "utf8"));
   } catch {
     return;
   }
@@ -18980,13 +19181,13 @@ function cleanupOne(cacheRoot, ourDir) {
     });
     return;
   }
-  const cachePkgJson = join18(cacheRoot, "package.json");
+  const cachePkgJson = join19(cacheRoot, "package.json");
   if (!existsSync5(cachePkgJson)) return;
   try {
-    const cfg = JSON.parse(readFileSync12(cachePkgJson, "utf8"));
+    const cfg = JSON.parse(readFileSync13(cachePkgJson, "utf8"));
     if (cfg?.dependencies?.[STALE_PACKAGE_NAME]) {
       delete cfg.dependencies[STALE_PACKAGE_NAME];
-      writeFileSync10(cachePkgJson, JSON.stringify(cfg, null, 2) + "\n");
+      writeFileSync11(cachePkgJson, JSON.stringify(cfg, null, 2) + "\n");
       log.info("cleanup-stale: pruned dep from cache package.json");
     }
   } catch (err) {
@@ -19413,6 +19614,7 @@ function createV2Setup(deps) {
           )
         };
         const plans = planV2Providers(seedSettings, deps.defaultProxyTools);
+        registerSidebarAccounts(resolveAccounts(seedSettings.accounts));
         planned.clear();
         for (const plan of plans) {
           planned.set(plan.info.id, plan.info.settings ?? {});
@@ -19954,6 +20156,7 @@ var server = async (input) => {
       registerBundledSkillPath(config);
       config.provider ??= {};
       await buildAgentRegistry(config);
+      registerSidebarAccounts(resolveAccounts(config.provider[PROVIDER_ID2]?.options?.accounts));
       const expanded = await expandAccountProviders(config);
       if (expanded) {
         logStartupDiagnostics(