frizz-server 0.15.20 → 0.15.23

package/dist/claude-agent-broker.js

@@ -2,8 +2,9 @@ import { createRequire as __frizzCreateRequire } from "node:module"; const requi
 
 // packages/server/src/backend/claude-agent-broker.ts
 import net from "node:net";
-import { readFileSync as readFileSync6, realpathSync as realpathSync2, unlinkSync as unlinkSync3, writeFileSync as writeFileSync4 } from "node:fs";
-import { join as join8 } from "node:path";
+import { readFileSync as readFileSync8, realpathSync as realpathSync3, unlinkSync as unlinkSync3, writeFileSync as writeFileSync4 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { join as join11 } from "node:path";
 import { randomUUID } from "node:crypto";
 import { fileURLToPath } from "node:url";
 
@@ -26081,11 +26082,6 @@ var LEGACY_DIR_NAME = ".frizz";
 function legacyFrizzRoot(home = homedir()) {
   return join2(home, LEGACY_DIR_NAME);
 }
-function isLegacyStateRoot(root, exists) {
-  if (!exists(root)) return false;
-  if (!exists(join2(root, ".id")) && !exists(join2(root, ".gitignore"))) return true;
-  return exists(join2(root, "projects")) || exists(join2(root, "registry.json"));
-}
 function xdg(env, name) {
   const value = env[name];
   return value && (value.startsWith("/") || /^[A-Za-z]:[\\/]/u.test(value)) ? value : void 0;
@@ -26128,7 +26124,7 @@ function frizzPaths(options = {}) {
   const home = options.home ?? homedir();
   const exists = options.exists ?? existsSync2;
   const legacyRoot = legacyFrizzRoot(home);
-  if (isLegacyStateRoot(legacyRoot, exists)) {
+  if (exists(legacyRoot)) {
     return { data: legacyRoot, state: legacyRoot, cache: legacyRoot, legacy: true };
   }
   const explicit = {
@@ -26505,7 +26501,7 @@ var BoundedAsyncQueue = class {
     if (value !== void 0) return Promise.resolve({ done: false, value });
     if (this.failure) return Promise.reject(this.failure);
     if (this.ended) return Promise.resolve({ done: true, value: void 0 });
-    return new Promise((resolve3, reject) => this.waiters.push({ resolve: resolve3, reject }));
+    return new Promise((resolve4, reject) => this.waiters.push({ resolve: resolve4, reject }));
   }
   [Symbol.asyncIterator]() {
     return this;
@@ -26587,6 +26583,7 @@ var RealClaudeQueryHandle = class {
   sdkQuery;
   input;
   diagnostic;
+  rateLimit;
   lifecycleAbort;
   // id → the main-thread turn count at the moment it was sent. A Map rather than a Set plus a
   // parallel order array because insertion order IS send order, which is all the oldest-first
@@ -26596,15 +26593,16 @@ var RealClaudeQueryHandle = class {
   mainThreadResults = 0;
   providerProgressCovered = false;
   closePromise;
-  constructor(sdkQuery, input, sessionId, lifecycleAbort, redactor, diagnostic) {
+  constructor(sdkQuery, input, sessionId, lifecycleAbort, redactor, diagnostic, rateLimit) {
     this.sdkQuery = sdkQuery;
     this.input = input;
     this.sessionId = sessionId;
     this.lifecycleAbort = lifecycleAbort;
     this.redactor = redactor;
     this.diagnostic = diagnostic;
-    this.readyPromise = new Promise((resolve3, reject) => {
-      this.resolveReady = resolve3;
+    this.rateLimit = rateLimit;
+    this.readyPromise = new Promise((resolve4, reject) => {
+      this.resolveReady = resolve4;
       this.rejectReady = reject;
     });
     void this.readyPromise.catch(() => void 0);
@@ -26836,6 +26834,9 @@ var RealClaudeQueryHandle = class {
   async pump() {
     try {
       for await (const raw of this.sdkQuery) {
+        if (this.rateLimit && raw.type === "rate_limit_event") {
+          this.rateLimit(raw.rate_limit_info);
+        }
         let event;
         try {
           event = mapSdkMessage(raw);
@@ -26972,6 +26973,7 @@ function startClaudeQuery(executablePath, options) {
   const environment = buildEnvironment(options.env);
   const redact = createClaudeDiagnosticRedactor(environment);
   const diagnostic = guardDiagnosticCallback(options.onDiagnostic);
+  const rateLimit = guardObserverCallback(options.onRateLimit);
   const permissionMode = validatePermissionMode(options.permissionMode ?? "default");
   const lifecycleAbort = new AbortController();
   const permissionRequests = new BoundedIdempotencyCache(MAX_PERMISSION_REQUESTS, "Claude permission request cache");
@@ -27085,7 +27087,7 @@ function startClaudeQuery(executablePath, options) {
       }
     }
   });
-  const handle = new RealClaudeQueryHandle(raw, input, sessionId, lifecycleAbort, redact, diagnostic);
+  const handle = new RealClaudeQueryHandle(raw, input, sessionId, lifecycleAbort, redact, diagnostic, rateLimit);
   if (mcpConfigFile) {
     const drop = () => {
       try {
@@ -27778,13 +27780,13 @@ function canonicalFingerprint(value) {
 }
 function abortableCallback(promise, signal, label) {
   if (signal.aborted) return Promise.reject(new ClaudeAgentSdkProtocolError(`${label} aborted`));
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const abort = () => reject(new ClaudeAgentSdkProtocolError(`${label} aborted`));
     signal.addEventListener("abort", abort, { once: true });
     promise.then(
       (value) => {
         signal.removeEventListener("abort", abort);
-        resolve3(value);
+        resolve4(value);
       },
       (error) => {
         signal.removeEventListener("abort", abort);
@@ -27802,6 +27804,15 @@ function guardDiagnosticCallback(callback) {
     }
   };
 }
+function guardObserverCallback(callback) {
+  if (!callback) return void 0;
+  return (value) => {
+    try {
+      callback(value);
+    } catch {
+    }
+  };
+}
 function validateExecutablePath(value) {
   const path = validateAbsolutePath(value, "executablePath");
   try {
@@ -28237,14 +28248,14 @@ data: ${JSON.stringify(message)}
   }
   internalRequest(method, params) {
     const id2 = `frizz-lazy-${++this.nextInternalId}`;
-    return new Promise((resolve3) => {
-      this.internal.set(id2, resolve3);
+    return new Promise((resolve4) => {
+      this.internal.set(id2, resolve4);
       this.send({ jsonrpc: "2.0", id: id2, method, ...params === void 0 ? {} : { params } });
     });
   }
   forward(message) {
-    return new Promise((resolve3) => {
-      this.forwarded.set(JSON.stringify(message.id), resolve3);
+    return new Promise((resolve4) => {
+      this.forwarded.set(JSON.stringify(message.id), resolve4);
       this.send(message);
     });
   }
@@ -28280,18 +28291,18 @@ data: ${JSON.stringify(message)}
     const child = this.child;
     if (!child) return;
     this.child = void 0;
-    await new Promise((resolve3) => {
+    await new Promise((resolve4) => {
       const timer = setTimeout(() => {
         try {
           child.kill("SIGKILL");
         } catch {
         }
         ;
-        resolve3();
+        resolve4();
       }, 2e3);
       child.once("exit", () => {
         clearTimeout(timer);
-        resolve3();
+        resolve4();
       });
       try {
         child.stdin?.end();
@@ -28305,7 +28316,7 @@ data: ${JSON.stringify(message)}
   }
 };
 function readBody(request) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     let size = 0;
     const chunks = [];
     request.on("data", (chunk) => {
@@ -28317,7 +28328,7 @@ function readBody(request) {
       }
       chunks.push(chunk);
     });
-    request.on("end", () => resolve3(Buffer.concat(chunks).toString("utf8")));
+    request.on("end", () => resolve4(Buffer.concat(chunks).toString("utf8")));
     request.on("error", reject);
   });
 }
@@ -28368,13 +28379,13 @@ function startLazyMcpHost(options) {
     })();
   });
   httpServer.requestTimeout = 0;
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     httpServer.once("error", reject);
     httpServer.listen(0, "127.0.0.1", () => {
       httpServer.off("error", reject);
       const address = httpServer.address();
       const port = typeof address === "object" && address ? address.port : 0;
-      resolve3({
+      resolve4({
         port,
         mount(stdio, context) {
           mkdirSync4(options.cacheDir, { recursive: true, mode: 448 });
@@ -28401,7 +28412,6 @@ function startLazyMcpHost(options) {
 // packages/server/src/backend/types.ts
 var CLAUDE_WORKER_ENV = {
   CLAUDE_CODE_TOTAL_TOKENS_REMINDER: "infinite",
-  BASH_DEFAULT_TIMEOUT_MS: "60000",
   BASH_MAX_TIMEOUT_MS: String(24 * 60 * 60 * 1e3)
 };
 var CLAUDE_AUTO_COMPACT_WINDOW_ENV = "CLAUDE_CODE_AUTO_COMPACT_WINDOW";
@@ -28466,9 +28476,292 @@ function createClaudeBrokerExitWriter(path, meta, now = () => /* @__PURE__ */ ne
   };
 }
 
+// packages/server/src/backend/claude-plugin-sync.ts
+import { createHash as createHash4 } from "node:crypto";
+import { readFileSync as readFileSync7, readdirSync as readdirSync4, statSync as statSync5 } from "node:fs";
+import { join as join9 } from "node:path";
+
+// packages/server/src/stable-plugin-path.ts
+import { createHash as createHash3 } from "node:crypto";
+import { cpSync, lstatSync as lstatSync3, mkdirSync as mkdirSync6, readFileSync as readFileSync6, readdirSync as readdirSync3, readlinkSync as readlinkSync2, realpathSync as realpathSync2, renameSync as renameSync4, rmSync as rmSync4, statSync as statSync4, symlinkSync } from "node:fs";
+import { dirname as dirname4, isAbsolute as isAbsolute4, join as join8, resolve as resolve3 } from "node:path";
+var LINK_TYPE = process.platform === "win32" ? "junction" : void 0;
+function pluginFiles(root) {
+  const files = [];
+  const walk = (dir, prefix) => {
+    for (const name of readdirSync3(dir).sort()) {
+      const rel = prefix ? `${prefix}/${name}` : name;
+      if (statSync4(join8(dir, name)).isDirectory()) walk(join8(dir, name), rel);
+      else files.push(rel);
+    }
+  };
+  walk(root, "");
+  return files;
+}
+function pluginFingerprint(dir) {
+  try {
+    const root = realpathSync2(dir);
+    const hash = createHash3("sha1").update(root);
+    for (const rel of pluginFiles(root)) {
+      const stat = statSync4(join8(root, rel));
+      hash.update(`\0${rel}\0${stat.size}\0${stat.mtimeMs}`);
+    }
+    return hash.digest("hex");
+  } catch {
+    return void 0;
+  }
+}
+
+// packages/server/src/backend/claude-plugin-sync.ts
+function claudePluginSyncEnabled(env = process.env) {
+  return env.FRIZZ_PLUGIN_SYNC_OFF !== "1";
+}
+var RELOAD_DEADLINE_MS = 8e3;
+var RELOAD_ATTEMPTS = 2;
+var ClosureUnreadable = class extends Error {
+};
+function claudeDirEntries(root, entries) {
+  const stamp = (path) => {
+    try {
+      const stat = statSync5(path);
+      if (stat.isFile()) entries.push(`${path}\0${stat.size}\0${stat.mtimeMs}`);
+    } catch {
+    }
+  };
+  const list = (dir) => {
+    try {
+      return readdirSync4(dir).sort();
+    } catch {
+      return [];
+    }
+  };
+  for (const name of list(join9(root, "skills"))) stamp(join9(root, "skills", name, "SKILL.md"));
+  const markdownUnder = (dir, depth) => {
+    for (const name of list(dir)) {
+      const path = join9(dir, name);
+      if (name.endsWith(".md")) stamp(path);
+      else if (depth < 4) markdownUnder(path, depth + 1);
+    }
+  };
+  markdownUnder(join9(root, "agents"), 0);
+  markdownUnder(join9(root, "commands"), 0);
+  for (const file of ["settings.json", "settings.local.json"]) {
+    let raw;
+    try {
+      raw = readFileSync7(join9(root, file), "utf8");
+    } catch {
+      continue;
+    }
+    let enabled;
+    try {
+      enabled = JSON.parse(raw)?.enabledPlugins;
+    } catch {
+      throw new ClosureUnreadable(file);
+    }
+    entries.push(`${join9(root, file)}\0${JSON.stringify(enabled ?? null)}`);
+  }
+  stamp(join9(root, "plugins", "installed_plugins.json"));
+}
+function claudeClosureFingerprint(closure) {
+  const plugin = closure.pluginDir ? pluginFingerprint(closure.pluginDir) : "";
+  if (plugin === void 0) return void 0;
+  const entries = [plugin];
+  try {
+    claudeDirEntries(join9(closure.projectDir, ".claude"), entries);
+    claudeDirEntries(closure.configDir, entries);
+  } catch {
+    return void 0;
+  }
+  return createHash4("sha1").update(entries.join("\n")).digest("hex");
+}
+function createClaudePluginSync(deps) {
+  let loaded = deps.fingerprint();
+  let busy = false;
+  let inFlight = null;
+  let failed;
+  const say = (message) => {
+    try {
+      deps.log(message);
+    } catch {
+    }
+  };
+  const reloadWithinDeadline = () => new Promise((resolve4, reject) => {
+    const timer = setTimeout(() => reject(new Error("the session did not answer in time")), deps.deadlineMs ?? RELOAD_DEADLINE_MS);
+    timer.unref?.();
+    deps.reload().then(
+      (result) => {
+        clearTimeout(timer);
+        resolve4(result);
+      },
+      (error) => {
+        clearTimeout(timer);
+        reject(error);
+      }
+    );
+  });
+  const check = () => {
+    if (inFlight) return;
+    const current = deps.fingerprint();
+    if (current === void 0 || current === loaded) return;
+    if (failed?.fingerprint === current && failed.attempts >= RELOAD_ATTEMPTS) return;
+    const attempt = reloadWithinDeadline().then(
+      (result) => {
+        loaded = current;
+        failed = void 0;
+        say(`plugin closure changed on disk; reloaded in place${result.errorCount ? ` with ${result.errorCount} load error(s)` : ""}`);
+      },
+      (error) => {
+        failed = { fingerprint: current, attempts: failed?.fingerprint === current ? failed.attempts + 1 : 1 };
+        say(`plugin closure changed on disk but the reload failed (attempt ${failed.attempts}/${RELOAD_ATTEMPTS}): ${error instanceof Error ? error.message : String(error)}`);
+      }
+    ).catch(() => void 0).finally(() => {
+      if (inFlight === attempt) inFlight = null;
+    });
+    inFlight = attempt;
+  };
+  return {
+    beforeInput(startsTurn) {
+      if (startsTurn) {
+        if (!busy) check();
+        busy = true;
+      }
+      return inFlight;
+    },
+    beforeRead() {
+      if (!busy) check();
+      return inFlight;
+    },
+    turnActive() {
+      busy = true;
+    },
+    turnEnded() {
+      busy = false;
+      check();
+    }
+  };
+}
+
+// packages/server/src/backend/claude-quota-observed.ts
+import { createHash as createHash5 } from "node:crypto";
+import { mkdir, readFile, rename, rm as rm2, writeFile } from "node:fs/promises";
+import { join as join10 } from "node:path";
+var WINDOW_IDENTITY = {
+  five_hour: ["5h", "5h"],
+  seven_day: ["weekly", "Weekly"],
+  seven_day_opus: ["weekly-opus", "Opus wk"],
+  seven_day_sonnet: ["weekly-sonnet", "Sonnet wk"]
+};
+var OBSERVED_MAX_AGE_MS = 24 * 60 * 6e4;
+var REWRITE_INTERVAL_MS = 3e4;
+function finite(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function toWindow(name, utilization, resetsAt) {
+  const identity = WINDOW_IDENTITY[name];
+  const fraction = finite(utilization);
+  if (!identity || fraction === void 0 || fraction < 0) return void 0;
+  const resets = finite(resetsAt);
+  return {
+    key: identity[0],
+    label: identity[1],
+    // 0..1 → the endpoint's 0..100, without the binary-float tail (0.65 * 100 is 65.00000000000001).
+    usedPercent: Math.round(fraction * 1e4) / 100,
+    ...resets !== void 0 && resets > 0 ? { resetsAt: Math.round(resets) } : {}
+  };
+}
+function windowsFromRateLimitInfo(info) {
+  if (!info || typeof info !== "object") return [];
+  const raw = info;
+  const windows = /* @__PURE__ */ new Map();
+  if (raw.unifiedWindows && typeof raw.unifiedWindows === "object") {
+    for (const [name, value] of Object.entries(raw.unifiedWindows)) {
+      if (!value || typeof value !== "object") continue;
+      const w = value;
+      const window = toWindow(name, w.utilization, w.resetsAt);
+      if (window) windows.set(window.key, window);
+    }
+  }
+  if (typeof raw.rateLimitType === "string") {
+    const window = toWindow(raw.rateLimitType, raw.utilization, raw.resetsAt);
+    if (window && !windows.has(window.key)) windows.set(window.key, window);
+    const identity = WINDOW_IDENTITY[raw.rateLimitType];
+    if (raw.status === "rejected" && identity) {
+      const standing = windows.get(identity[0]);
+      const resets = finite(raw.resetsAt);
+      windows.set(identity[0], {
+        key: identity[0],
+        label: identity[1],
+        usedPercent: Math.max(100, standing?.usedPercent ?? 0),
+        ...standing?.resetsAt !== void 0 ? { resetsAt: standing.resetsAt } : resets !== void 0 && resets > 0 ? { resetsAt: Math.round(resets) } : {}
+      });
+    }
+  }
+  return [...windows.values()];
+}
+function observedQuotaPath(cacheDir, configDir) {
+  const profile = createHash5("sha256").update(configDir).digest("hex").slice(0, 12);
+  return join10(cacheDir, `claude-observed-${profile}.json`);
+}
+function live(window, now) {
+  if (now - window.at >= OBSERVED_MAX_AGE_MS) return false;
+  return window.resetsAt === void 0 || window.resetsAt * 1e3 > now;
+}
+async function readObservedClaudeQuota(cacheDir, configDir, now = Date.now()) {
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile(observedQuotaPath(cacheDir, configDir), "utf8"));
+  } catch {
+    return void 0;
+  }
+  const list = parsed?.windows;
+  if (!Array.isArray(list)) return void 0;
+  const windows = [];
+  for (const entry of list) {
+    if (!entry || typeof entry !== "object") continue;
+    const w = entry;
+    const at2 = finite(w.at);
+    const usedPercent = finite(w.usedPercent);
+    const resetsAt = finite(w.resetsAt);
+    if (typeof w.key !== "string" || typeof w.label !== "string" || at2 === void 0 || usedPercent === void 0) continue;
+    const window = { key: w.key, label: w.label, usedPercent, at: at2, ...resetsAt === void 0 ? {} : { resetsAt } };
+    if (live(window, now)) windows.push(window);
+  }
+  if (windows.length === 0) return void 0;
+  return { at: Math.max(...windows.map((w) => w.at)), windows };
+}
+var lastWritten = /* @__PURE__ */ new Map();
+async function recordObservedClaudeQuota(info, where) {
+  try {
+    const now = where.now ?? Date.now();
+    const reported = windowsFromRateLimitInfo(info);
+    if (reported.length === 0) return false;
+    const path = observedQuotaPath(where.cacheDir, where.configDir);
+    const signature = JSON.stringify(reported);
+    const last = lastWritten.get(path);
+    if (last && last.signature === signature && now - last.at < REWRITE_INTERVAL_MS) return false;
+    const standing = await readObservedClaudeQuota(where.cacheDir, where.configDir, now);
+    const windows = new Map((standing?.windows ?? []).map((w) => [w.key, w]));
+    for (const window of reported) windows.set(window.key, { ...window, at: now });
+    await mkdir(where.cacheDir, { recursive: true, mode: 448 });
+    const tmp = `${path}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+    try {
+      await writeFile(tmp, JSON.stringify({ at: now, windows: [...windows.values()] }), { mode: 384 });
+      await rename(tmp, path);
+    } finally {
+      await rm2(tmp, { force: true }).catch(() => {
+      });
+    }
+    lastWritten.set(path, { at: now, signature });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 // packages/server/src/backend/claude-agent-broker.ts
 var BROKER_CAPABILITIES = [CLAUDE_BROKER_CAPABILITY_SUBAGENT_STEER, CLAUDE_BROKER_CAPABILITY_CANCEL_INPUT, CLAUDE_BROKER_CAPABILITY_STOP_TASK, CLAUDE_BROKER_CAPABILITY_RELOAD_PLUGINS, CLAUDE_BROKER_CAPABILITY_RENAME, CLAUDE_BROKER_CAPABILITY_LIST_SKILLS, CLAUDE_BROKER_CAPABILITY_INPUT_ACK];
 var IDLE_EXIT_MS = 6 * 60 * 60 * 1e3;
+var PERMISSION_SHOW_HOLD_MS = 250;
 var REACHABILITY_CHECK_MS = 3e4;
 var REACHABILITY_STRIKES = 2;
 var EVENT_ERROR_TOLERANCE = 5;
@@ -28511,6 +28804,17 @@ function runClaudeBroker(config, options = {}) {
   const releaseRuntimeLease = leaseRuntime(config.executablePath, "claude-broker");
   const factory = createClaudeQueryFactory({ enabled: true, executablePath: config.executablePath });
   const env = { ...inheritWorkerEnvironment(config.env), ...config.workerEnv ?? {} };
+  const closure = {
+    pluginDir: config.pluginDir,
+    projectDir: config.cwd,
+    // Where claude itself will look, from the environment it is about to be started with.
+    configDir: env.CLAUDE_CONFIG_DIR?.trim() || join11(env.HOME || homedir3(), ".claude")
+  };
+  const pluginSync = claudePluginSyncEnabled() ? createClaudePluginSync({
+    fingerprint: () => claudeClosureFingerprint(closure),
+    reload: () => handle.reloadPlugins(),
+    log: (message) => writeDiagnostic?.({ kind: "stderr", message: `[plugin-sync] ${message}`, truncated: false })
+  }) : void 0;
   const handle = factory.start({
     cwd: config.cwd,
     session: config.resume ? { kind: "resume", sessionId: config.sessionId } : { kind: "new", sessionId: config.sessionId },
@@ -28549,20 +28853,40 @@ function runClaudeBroker(config, options = {}) {
     // and unwinds the tool call (see retirePendingFor in the bridge), so a parked turn is still steerable.
     canUseTool: async (request, context) => {
       const requestId = `perm-${++permSeq}`;
-      return await new Promise((resolve3) => {
+      return await new Promise((resolve4) => {
         let settled = false;
+        let showTimer;
+        const entry = { request, shown: false, resolve: (decision) => settle(decision) };
         const settle = (decision) => {
           if (settled) return;
           settled = true;
+          clearTimeout(showTimer);
           pendingPermissions.delete(requestId);
-          resolve3(decision);
+          resolve4(decision);
+        };
+        const withdraw = () => {
+          const wasShown = entry.shown;
+          settle({ behavior: "deny", message: "The turn was interrupted before this was answered." });
+          if (wasShown && client) write(client, { t: "permission-withdrawn", requestId });
         };
-        pendingPermissions.set(requestId, { request, resolve: settle });
-        if (context.signal.aborted) settle({ behavior: "deny", message: "The turn was interrupted before this was answered." });
-        else context.signal.addEventListener("abort", () => settle({ behavior: "deny", message: "The turn was interrupted before this was answered." }), { once: true });
-        if (!settled && client) write(client, { t: "permission-request", requestId, request });
+        pendingPermissions.set(requestId, entry);
+        if (context.signal.aborted) withdraw();
+        else context.signal.addEventListener("abort", withdraw, { once: true });
+        if (!settled) {
+          showTimer = setTimeout(() => {
+            if (settled || entry.shown || !client) return;
+            entry.shown = true;
+            write(client, { t: "permission-request", requestId, request });
+          }, PERMISSION_SHOW_HOLD_MS);
+        }
       });
     },
+    // The account's plan windows, as every API response reports them to this session. Written by THIS
+    // process because it is the one that sees the stream and it outlives the Frizz server; the server
+    // only reads the file (claude-quota-observed.ts). Fire-and-forget: the recorder never rejects.
+    onRateLimit: (info) => {
+      void recordObservedClaudeQuota(info, { cacheDir: join11(frizzRoots().cache, "quota-cache"), configDir: closure.configDir });
+    },
     onDiagnostic: (diagnostic) => {
       writeDiagnostic?.(diagnostic);
       if (client) write(client, { t: "diagnostic", diagnostic });
@@ -28598,6 +28922,8 @@ function runClaudeBroker(config, options = {}) {
       consecutiveErrors = 0;
       if (next.done) return { reason: "session-stream-ended" };
       emitEvent(next.value);
+      if (next.value.kind === "result") pluginSync?.turnEnded();
+      else if (next.value.kind === "assistant" || next.value.kind === "user") pluginSync?.turnActive();
     }
   })().then(
     (end) => shutdown(0, end.reason, end.detail),
@@ -28612,7 +28938,10 @@ function runClaudeBroker(config, options = {}) {
     client = sock;
     clearTimeout(idleTimer);
     write(sock, { t: "hello", sessionId: handle.sessionId, generation });
-    for (const [requestId, { request }] of pendingPermissions) write(sock, { t: "permission-request", requestId, request });
+    for (const [requestId, entry] of pendingPermissions) {
+      entry.shown = true;
+      write(sock, { t: "permission-request", requestId, request: entry.request });
+    }
     while (eventBacklog.length) sock.write(eventBacklog.shift());
     eventBacklogBytes = 0;
     let buf = "";
@@ -28636,7 +28965,7 @@ function runClaudeBroker(config, options = {}) {
             message: `input received: id=${message?.id ?? "?"} chars=${typeof message?.text === "string" ? message.text.length : 0}${message?.parentToolUseId ? ` addressed=${message.parentToolUseId}` : ""}`,
             truncated: false
           });
-          void handle.send(message).then(() => {
+          const forward = () => void handle.send(message).then(() => {
             if (requestId) write(sock, { t: "input-result", requestId });
           }, (error) => {
             const detail = error instanceof Error ? error.message : String(error);
@@ -28646,6 +28975,9 @@ function runClaudeBroker(config, options = {}) {
             writeDiagnostic?.(diagnostic);
             if (client) write(client, { t: "diagnostic", diagnostic });
           });
+          const reloading = pluginSync?.beforeInput(!message?.parentToolUseId);
+          if (reloading) void reloading.then(forward);
+          else forward();
           seedSessionTitle(message);
         } else if (msg.t === "permission") {
           const e13 = pendingPermissions.get(msg.requestId);
@@ -28684,7 +29016,7 @@ function runClaudeBroker(config, options = {}) {
           );
         } else if (msg.t === "list-skills") {
           const requestId = msg.requestId;
-          void handle.listSkills().then(
+          void (pluginSync?.beforeRead() ?? Promise.resolve()).then(() => handle.listSkills()).then(
             (skills) => write(sock, { t: "skills-result", requestId, skills }),
             (error) => write(sock, { t: "skills-result", requestId, error: error instanceof Error ? error.message : String(error) })
           );
@@ -28705,7 +29037,7 @@ function runClaudeBroker(config, options = {}) {
   const recordOwner = () => {
     if (!config.recordPath) return null;
     try {
-      return JSON.parse(readFileSync6(config.recordPath, "utf8")).daemonPid;
+      return JSON.parse(readFileSync8(config.recordPath, "utf8")).daemonPid;
     } catch {
       return null;
     }
@@ -28800,7 +29132,7 @@ function startedAsProcessEntry() {
   const entry = process.argv[1];
   if (!entry) return false;
   try {
-    return realpathSync2(fileURLToPath(import.meta.url)) === realpathSync2(entry);
+    return realpathSync3(fileURLToPath(import.meta.url)) === realpathSync3(entry);
   } catch {
     return false;
   }
@@ -28831,7 +29163,7 @@ ${error.stack ?? ""}`.slice(0, 2e3) : String(error));
 ${reason.stack ?? ""}`.slice(0, 2e3) : String(reason));
     process.exit(1);
   });
-  const lazyMcpHost = lazyMcpEnabled() ? startLazyMcpHost({ cacheDir: join8(frizzRoots().data, "mcp-cache") }) : Promise.resolve(void 0);
+  const lazyMcpHost = lazyMcpEnabled() ? startLazyMcpHost({ cacheDir: join11(frizzRoots().data, "mcp-cache") }) : Promise.resolve(void 0);
   void lazyMcpHost.catch(() => void 0).then((host) => {
     running = runClaudeBroker(config, { lazyMcpHost: host });
   });