@chosengeneration/light-code 0.9.0 → 0.12.1

package/dist/server.js

@@ -49457,7 +49457,45 @@ var expertConfigSchema = external_exports.object({
    * The backstop for when the CLI reports no cost — a spend limit cannot count what it is
    * not told the price of, and an unpriced consultation still costs money.
    */
-  maxConsultations: external_exports.number().int().min(0)
+  maxConsultations: external_exports.number().int().min(0),
+  /**
+   * Whether this plan reports a per-consultation cost.
+   *
+   * Learned rather than configured, and learned from real consultations rather than from a
+   * probe — asking the CLI "do you report cost?" means making a call, and the first call in a
+   * session is the expensive one. So it is recorded the first time a consultation comes back
+   * with or without `total_cost_usd`.
+   *
+   * Absent means not yet known. It matters because a spend cap cannot bind on a plan that
+   * reports no cost: `usd` stays zero, the limit is never reached, and the only control that
+   * actually holds is the consultation count. A cap that silently never fires is worse than no
+   * cap, because it is believed.
+   */
+  reportsCost: external_exports.boolean(),
+  /**
+   * Refresh the expert's cache while a task is open, rather than paying a cold start later.
+   *
+   * The cache is one hour and that TTL is Anthropic's, not ours. A trivial resumed consultation
+   * before it lapses costs about a fiftieth of the cold start it avoids.
+   *
+   * Off by default, and it must stay that way: it spends with nobody at the screen, which is
+   * the one property this product is careful about everywhere else. Its cost is counted in the
+   * meter like anything else.
+   */
+  keepAlive: external_exports.boolean(),
+  /**
+   * What a consultation costs on this plan, measured rather than assumed.
+   *
+   * The published figures came from one plan on one day. An enterprise agreement, a
+   * subscription or a gateway can each report something different — and those numbers are what
+   * the budget is set from and what the expert is told when it plans to fit.
+   */
+  pricing: external_exports.object({
+    coldUsd: external_exports.number().min(0).optional(),
+    resumedUsd: external_exports.number().min(0).optional(),
+    measuredAt: external_exports.number(),
+    reportsCost: external_exports.boolean()
+  })
 }).partial();
 var vectorStoreKindSchema = external_exports.enum(["opensearch", "qdrant", "chroma"]);
 var vectorStoreSchema = external_exports.object({
@@ -49822,6 +49860,21 @@ function describeSubmission(request) {
   ].join("\n");
 }
 
+// ../../packages/core/dist/expert/pricing.js
+var PRICING_PROBE = "Reply with the single word: OK";
+function pricingForPrompt(pricing) {
+  if (pricing === void 0 || !pricing.reportsCost)
+    return void 0;
+  const cold = pricing.coldUsd;
+  const resumed = pricing.resumedUsd;
+  if (cold === void 0 || resumed === void 0)
+    return void 0;
+  return `Measured on this deployment: the first consultation of a task costs about ${money(cold)}, and each one after it about ${money(resumed)} because it resumes the same session. Plan accordingly \u2014 make the first one carry the task, and do not repeat context afterwards.`;
+}
+function money(value) {
+  return value >= 0.01 ? `$${value.toFixed(2)}` : `$${value.toFixed(4)}`;
+}
+
 // ../../packages/core/dist/guide/steps.js
 var GUIDE_STEPS = [
   {
@@ -52647,7 +52700,7 @@ function buildExpertBriefing(input) {
 }
 
 // ../../packages/core/dist/expert/budget.js
-function money(value) {
+function money2(value) {
   return `$${value.toFixed(value < 1 ? 4 : 2)}`;
 }
 function checkExpertBudget(spend, limits) {
@@ -52662,7 +52715,7 @@ function checkExpertBudget(spend, limits) {
   if (maxSpend > 0 && spend.usd >= maxSpend) {
     return {
       allowed: false,
-      message: `The expert spending limit for this task has been reached (${money(spend.usd)} of ${money(maxSpend)}). Continue on your own: use what the expert has already told you, read the code directly, and say plainly if you are stuck rather than guessing. The user can raise the limit in Settings \u2192 Expert, or start a new task to reset it.` + (spend.unpriced > 0 ? ` Note ${String(spend.unpriced)} consultation${spend.unpriced === 1 ? "" : "s"} reported no cost, so the real total is higher than the figure above.` : "")
+      message: `The expert spending limit for this task has been reached (${money2(spend.usd)} of ${money2(maxSpend)}). Continue on your own: use what the expert has already told you, read the code directly, and say plainly if you are stuck rather than guessing. The user can raise the limit in Settings \u2192 Expert, or start a new task to reset it.` + (spend.unpriced > 0 ? ` Note ${String(spend.unpriced)} consultation${spend.unpriced === 1 ? "" : "s"} reported no cost, so the real total is higher than the figure above.` : "")
     };
   }
   return { allowed: true };
@@ -52679,7 +52732,7 @@ function expertBudgetUsage(spend, limits) {
     return void 0;
   return Math.min(1, Math.max(...fractions));
 }
-function describeExpertBudget(spend, limits) {
+function describeExpertBudget(spend, limits, pricing) {
   const parts = [];
   const maxConsultations = limits.maxConsultations ?? 0;
   if (maxConsultations > 0) {
@@ -52688,11 +52741,14 @@ function describeExpertBudget(spend, limits) {
   }
   const maxSpend = limits.maxSpendUsd ?? 0;
   if (maxSpend > 0) {
-    parts.push(`${money(Math.max(0, maxSpend - spend.usd))} of ${money(maxSpend)} left`);
+    parts.push(`${money2(Math.max(0, maxSpend - spend.usd))} of ${money2(maxSpend)} left`);
   }
   if (parts.length === 0)
-    return void 0;
-  return `Budget for this task: ${parts.join(", ")}. Plan the number of checkpoints to fit \u2014 when it runs out the junior finishes alone.`;
+    return pricing;
+  return [
+    `Budget for this task: ${parts.join(", ")}. Plan the number of checkpoints to fit \u2014 when it runs out the junior finishes alone.`,
+    pricing
+  ].filter((line) => line !== void 0).join(" ");
 }
 
 // ../../packages/core/dist/rag/vectorStore.js
@@ -63340,11 +63396,12 @@ function wireChatBridge(services) {
   }
   const pendingPathApprovals = /* @__PURE__ */ new Map();
   const searchLog = new SearchLog(50, () => post({ type: "searchLog", entries: [...searchLog.list()] }));
-  let expertSpend = { usd: 0, consultations: 0, unpriced: 0 };
+  let expertSpend = { usd: 0, consultations: 0, unpriced: 0, keepAlives: 0 };
   let expertSessionId;
   function resetExpertSpend() {
-    expertSpend = { usd: 0, consultations: 0, unpriced: 0 };
+    expertSpend = { usd: 0, consultations: 0, unpriced: 0, keepAlives: 0 };
     expertSessionId = void 0;
+    stopKeepAlive();
     taskExpertLimits = void 0;
     taskExpertEstimate = void 0;
     postExpertSpend();
@@ -63370,9 +63427,24 @@ function wireChatBridge(services) {
     else
       expertSpend.unpriced += 1;
     postExpertSpend();
+    if (info.isError)
+      return;
+    const learned = info.costUsd !== void 0;
+    if (cachedReportsCost === learned)
+      return;
+    cachedReportsCost = learned;
+    void configManager.load().then(async ({ config: config2 }) => {
+      await configManager.save("user", { ...config2, expert: { ...config2.expert, reportsCost: learned } });
+      await postExpert();
+    }).catch(() => {
+    });
   }
   let cachedModeId;
   let cachedCodeGenerator;
+  let cachedReportsCost;
+  let measuringStep;
+  let cachedPricing;
+  let cachedKeepAlive = false;
   let cachedProgrammingProfileId;
   async function loadSettings() {
     const { config: config2 } = await configManager.load();
@@ -63384,6 +63456,11 @@ function wireChatBridge(services) {
     cachedAccentColor = config2.ui?.accentColor ?? "#22C55E";
     cachedExpertColor = config2.ui?.expertColor ?? "#D97757";
     cachedAssessment = config2.expert?.assessment;
+    cachedReportsCost = config2.expert?.reportsCost;
+    cachedPricing = config2.expert?.pricing;
+    cachedKeepAlive = config2.expert?.keepAlive === true;
+    if (!cachedKeepAlive)
+      stopKeepAlive();
     cachedExpertLimits = {
       ...config2.expert?.maxSpendUsd !== void 0 ? { maxSpendUsd: config2.expert.maxSpendUsd } : {},
       ...config2.expert?.maxConsultations !== void 0 ? { maxConsultations: config2.expert.maxConsultations } : {}
@@ -63406,12 +63483,13 @@ function wireChatBridge(services) {
       expertColor: cachedExpertColor,
       readRoots: cachedReadRoots,
       ...cachedProgrammingProfileId !== void 0 ? { programmingProfileId: cachedProgrammingProfileId } : {},
-      ...guideCapability()
+      ...hostCapabilities()
     });
   }
-  function guideCapability() {
+  function hostCapabilities() {
     return {
       nativeGuide: ui.openWalkthrough !== void 0,
+      allowProgrammingProfile: services.allowProgrammingProfile === true,
       ...services.guideMediaBase !== void 0 ? { guideMediaBase: services.guideMediaBase } : {}
     };
   }
@@ -63521,7 +63599,11 @@ function wireChatBridge(services) {
         // Read at call time, not captured: the user can raise the limit mid-task and the very
         // next consultation should honour it, without starting a new task to pick it up.
         budget: () => checkExpertBudget(expertSpend, effectiveExpertLimits()),
-        budgetSummary: () => describeExpertBudget(expertSpend, effectiveExpertLimits()),
+        /*
+         * The measured cost goes with the budget, so the expert plans in this deployment's
+         * units rather than from what it believes consultations cost in general.
+         */
+        budgetSummary: () => describeExpertBudget(expertSpend, effectiveExpertLimits(), pricingForPrompt(cachedPricing)),
         onEstimate: (estimate) => {
           taskExpertEstimate = estimate;
           postExpertSpend();
@@ -63530,6 +63612,8 @@ function wireChatBridge(services) {
           get: () => expertSessionId,
           set: (sessionId) => {
             expertSessionId = sessionId;
+            if (sessionId !== void 0 && cachedKeepAlive)
+              ensureKeepAlive();
           }
         },
         /*
@@ -64097,18 +64181,29 @@ function wireChatBridge(services) {
       logger.warn(`could not check the expert CLI: ${reason}`);
       const settings = await configManager.load().then((loaded) => loaded.config.expert, () => void 0);
       post({
-        type: "expert",
-        enabled: settings?.enabled === true,
+        ...expertMessageFrom(settings),
         available: false,
         path: settings?.path ?? expertCliPath ?? "claude",
-        reason: `Could not check whether the Claude CLI is available: ${reason}`,
-        ...settings?.model !== void 0 ? { model: settings.model } : {},
-        maxSpendUsd: settings?.maxSpendUsd ?? 0,
-        maxConsultations: settings?.maxConsultations ?? 0,
-        ...settings?.assessment !== void 0 ? { assessment: settings.assessment } : {}
+        reason: `Could not check whether the Claude CLI is available: ${reason}`
       });
     }
   }
+  function expertMessageFrom(settings) {
+    return {
+      type: "expert",
+      enabled: settings?.enabled === true,
+      available: false,
+      path: settings?.path ?? expertCliPath ?? "claude",
+      maxSpendUsd: settings?.maxSpendUsd ?? 0,
+      maxConsultations: settings?.maxConsultations ?? 0,
+      keepAlive: settings?.keepAlive === true,
+      ...settings?.model !== void 0 ? { model: settings.model } : {},
+      ...settings?.assessment !== void 0 ? { assessment: settings.assessment } : {},
+      ...settings?.reportsCost !== void 0 ? { reportsCost: settings.reportsCost } : {},
+      ...settings?.pricing !== void 0 ? { pricing: settings.pricing } : {},
+      ...measuringStep !== void 0 ? { measuringStep } : {}
+    };
+  }
   async function postExpertInner(redetect) {
     const { config: config2 } = await configManager.load();
     const configured = config2.expert?.path ?? "claude";
@@ -64116,19 +64211,125 @@ function wireChatBridge(services) {
     expertCli = detected;
     expertCliPath = configured;
     post({
-      type: "expert",
-      enabled: config2.expert?.enabled === true,
+      // Everything from settings comes from one place, so the two paths cannot drift again.
+      ...expertMessageFrom(config2.expert),
       available: detected.available,
       path: configured,
       ...detected.version !== void 0 ? { version: detected.version } : {},
       ...detected.reason !== void 0 ? { reason: detected.reason } : {},
-      ...config2.expert?.model !== void 0 ? { model: config2.expert.model } : {},
-      maxSpendUsd: config2.expert?.maxSpendUsd ?? 0,
-      maxConsultations: config2.expert?.maxConsultations ?? 0,
-      ...config2.expert?.assessment !== void 0 ? { assessment: config2.expert.assessment } : {},
       ...assessmentStep === void 0 ? {} : { assessing: true, assessmentStep }
     });
   }
+  const KEEP_ALIVE_MS = 50 * 60 * 1e3;
+  let keepAliveTimer;
+  function stopKeepAlive() {
+    if (keepAliveTimer === void 0)
+      return;
+    clearInterval(keepAliveTimer);
+    keepAliveTimer = void 0;
+  }
+  function ensureKeepAlive() {
+    if (keepAliveTimer !== void 0)
+      return;
+    keepAliveTimer = setInterval(() => {
+      void runKeepAlive();
+    }, KEEP_ALIVE_MS);
+    keepAliveTimer.unref?.();
+  }
+  async function runKeepAlive() {
+    const session = expertSessionId;
+    if (session === void 0) {
+      stopKeepAlive();
+      return;
+    }
+    try {
+      const { config: config2 } = await configManager.load();
+      if (config2.expert?.keepAlive !== true) {
+        stopKeepAlive();
+        return;
+      }
+      const verdict = checkExpertBudget(expertSpend, effectiveExpertLimits());
+      if (!verdict.allowed) {
+        logger.info("expert keep-alive stopped: the budget for this task is spent");
+        stopKeepAlive();
+        return;
+      }
+      const cli = await resolveExpert(config2);
+      if (cli === void 0) {
+        stopKeepAlive();
+        return;
+      }
+      const answer = await consultExpert(cli, {
+        question: PRICING_PROBE,
+        cwd: workspaceRoot ?? process.cwd(),
+        ...config2.expert?.model !== void 0 ? { model: config2.expert.model } : {},
+        resumeSessionId: session
+      }, logger);
+      expertSpend.keepAlives += 1;
+      if (answer.costUsd !== void 0)
+        expertSpend.usd += answer.costUsd;
+      if (answer.sessionId !== void 0)
+        expertSessionId = answer.sessionId;
+      postExpertSpend();
+      logger.info("expert keep-alive refreshed the session cache");
+    } catch (error51) {
+      logger.warn(`expert keep-alive failed: ${String(error51)}`);
+    }
+  }
+  async function handleMeasureExpertCost() {
+    if (measuringStep !== void 0) {
+      post({ type: "error", message: `Already measuring \u2014 ${measuringStep}` });
+      return;
+    }
+    measuringStep = "Starting\u2026";
+    logger.info("measuring what an expert consultation costs");
+    await postExpert({ redetect: false });
+    try {
+      const { config: config2 } = await configManager.load();
+      const cli = await resolveExpert(config2);
+      if (cli === void 0) {
+        post({
+          type: "error",
+          message: "The Claude CLI could not be found, so there is nothing to measure. Check the path in this tab."
+        });
+        return;
+      }
+      let sessionId;
+      const samples = [];
+      for (const [index, label] of ["first consultation", "follow-up in the same session"].entries()) {
+        measuringStep = `Measuring the ${label} (${String(index + 1)}/2)\u2026`;
+        await postExpert({ redetect: false });
+        const answer = await consultExpert(cli, {
+          question: PRICING_PROBE,
+          cwd: workspaceRoot ?? process.cwd(),
+          ...config2.expert?.model !== void 0 ? { model: config2.expert.model } : {},
+          // Cold on the first pass, resumed on the second. That pair is the measurement.
+          ...sessionId !== void 0 ? { resumeSessionId: sessionId } : {}
+        }, logger);
+        samples.push(answer.costUsd);
+        sessionId = answer.sessionId ?? sessionId;
+      }
+      const [cold, resumed] = samples;
+      const reportsCost = cold !== void 0 || resumed !== void 0;
+      const pricing = {
+        measuredAt: Date.now(),
+        reportsCost,
+        ...cold !== void 0 ? { coldUsd: cold } : {},
+        ...resumed !== void 0 ? { resumedUsd: resumed } : {}
+      };
+      const { config: current } = await configManager.load();
+      await configManager.save("user", {
+        ...current,
+        expert: { ...current.expert, pricing, reportsCost }
+      });
+      logger.info(reportsCost ? `expert pricing measured: cold ${String(cold)} / resumed ${String(resumed)}` : "expert pricing measured: this plan reports no cost per consultation");
+    } catch (error51) {
+      post({ type: "error", message: `Could not measure the expert's cost: ${String(error51)}` });
+    } finally {
+      measuringStep = void 0;
+      await postExpert({ redetect: false });
+    }
+  }
   async function handleAssessJunior() {
     if (assessmentStep !== void 0)
       return;
@@ -64956,6 +65157,8 @@ function wireChatBridge(services) {
     }
   }
   function codeGeneratorFor(config2) {
+    if (services.allowProgrammingProfile !== true)
+      return void 0;
     const id = config2.programmingProfileId;
     if (id === void 0 || id.length === 0)
       return void 0;
@@ -64987,7 +65190,7 @@ function wireChatBridge(services) {
       accentColor: cachedAccentColor,
       expertColor: cachedExpertColor,
       readRoots: cachedReadRoots,
-      ...guideCapability()
+      ...hostCapabilities()
     });
   }
   async function handleAlwaysAllow(id, scope) {
@@ -65390,6 +65593,21 @@ function wireChatBridge(services) {
         ...message.maxConsultations !== void 0 ? { maxConsultations: message.maxConsultations } : {}
       };
       postExpertSpend();
+    } else if (message.type === "setExpertKeepAlive") {
+      void configManager.load().then(async ({ config: config2 }) => {
+        await configManager.save("user", { ...config2, expert: { ...config2.expert, keepAlive: message.enabled } });
+        await postExpert({ redetect: false });
+      }).catch((error51) => post({ type: "error", message: String(error51) }));
+    } else if (message.type === "measureExpertCost") {
+      void handleMeasureExpertCost();
+    } else if (message.type === "clearExpertPricing") {
+      void configManager.load().then(async ({ config: config2 }) => {
+        const expert = { ...config2.expert };
+        delete expert.pricing;
+        delete expert.reportsCost;
+        await configManager.save("user", { ...config2, expert });
+        await postExpert({ redetect: false });
+      }).catch((error51) => post({ type: "error", message: String(error51) }));
     } else if (message.type === "assessJunior") {
       void handleAssessJunior();
     } else if (message.type === "clearAssessment") {
@@ -65859,6 +66077,7 @@ ${entry.content}`);
         clearTimeout(docsReindexTimer);
       if (scheduleTimer !== void 0)
         clearInterval(scheduleTimer);
+      stopKeepAlive();
       unsubscribe();
     }
   };
@@ -67320,6 +67539,12 @@ async function createSession(options) {
      * also survives whatever port the server happened to bind.
      */
     guideMediaBase: "/guide",
+    /*
+     * Offered here and nowhere else. A shared server is where "a cheap model chats, a good one
+     * writes the code" is worth configuring — and where an administrator can set a default for
+     * people who have not chosen.
+     */
+    allowProgrammingProfile: true,
     ...options.submitForReview !== void 0 ? { submitForReview: options.submitForReview } : {},
     /*
      * Resolved per read, so both halves stay live — an administrator's edit and the user's own

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chosengeneration/light-code",
-  "version": "0.9.0",
+  "version": "0.12.1",
   "description": "A minimal agentic coding assistant, served to your browser from a local Node server",
   "license": "MIT",
   "type": "module",