cartethyia 2.7.5 → 2.7.6

package/src/console/cli-tools/injectors/driver.ts

@@ -6,25 +6,15 @@ import type {
   ApplyResult,
   DownloadResult,
   InjectorSpec,
-  ToolDef,
   ToolId,
   ToolInjector,
   ToolStatus,
 } from "../contracts";
-import { TOOL_IDS, TOOL_REGISTRY } from "../contracts";
-import { checkBinaryInstalled, ensureDir, ensureV1Suffix, fileExists, keyPrefix } from "../fs-ops";
+import { TOOL_IDS } from "../contracts";
+import { checkBinaryInstalled, ensureDir, fileExists, keyPrefix } from "../fs-ops";
 import { claudeSpec } from './claude';
-import { clineSpec } from './cline';
 import { codexSpec } from './codex';
-import { copilotSpec } from './copilot';
-import { coworkSpec } from './cowork';
-import { deepseekTuiSpec } from './deepseek-tui';
-import { droidSpec } from './droid';
-import { grokBuildSpec } from './grok-build';
-import { hermesSpec } from './hermes';
-import { jcodeSpec } from './jcode';
 import { kiloSpec } from './kilo';
-import { openclawSpec } from './openclaw';
 import { opencodeSpec } from './opencode';
 
 // ── injectors/driver.ts ──
@@ -92,11 +82,12 @@ export function createFileInjector(spec: InjectorSpec): ToolInjector {
       const path = spec.resolvePath();
       const dir = spec.resolveDir ? spec.resolveDir() : dirname(path);
       await ensureDir(dir);
-      await spec.apply(input, path);
+      const warnings = await spec.apply(input, path);
       return {
         success: true,
         settingsPath: path,
         message: spec.messages?.applied ?? `${spec.displayName ?? spec.toolId} settings applied`,
+        ...(Array.isArray(warnings) && warnings.length > 0 ? { warnings } : {}),
       };
     },
 
@@ -131,114 +122,26 @@ export function createFileInjector(spec: InjectorSpec): ToolInjector {
   };
 }
 
-/** Create a guide injector for a specific tool definition (any `configType: "guide"` entry). */
-function guideInjectorFor(def: ToolDef): ToolInjector {
-  return {
-    toolId: def.id,
-
-    async getStatus(): Promise<ToolStatus> {
-      // Guide tools are always "not installed" from an injection standpoint —
-      // we can't detect the binary reliably, and config is manual.
-      return {
-        toolId: def.id,
-        installed: false,
-        configured: false,
-        settingsPath: null,
-        currentEndpoint: null,
-        currentApiKeyPrefix: null,
-        currentModels: null,
-        message: "Guide-only tool — use Download Config to get setup instructions",
-      };
-    },
-
-    async apply(): Promise<ApplyResult> {
-      return { success: false, message: `${def.name} is a guide-only tool — use Download Config` };
-    },
-
-    async reset(): Promise<ApplyResult> {
-      return { success: true, message: `${def.name} has no injected config to reset` };
-    },
-
-    async download(input: ApplyInput): Promise<DownloadResult> {
-      const baseUrl = ensureV1Suffix(input.endpoint);
-      const model = input.activeModel ?? input.modelIds[0] ?? "";
-      const apiKey = input.apiKey;
-      const codeBlock = def.codeBlock;
-
-      if (codeBlock) {
-        const content = codeBlock.code
-          .replace(/\{\{baseUrl\}\}/g, baseUrl)
-          .replace(/\{\{apiKey\}\}/g, apiKey)
-          .replace(/\{\{model\}\}/g, model);
-        const ext =
-          codeBlock.language === "json" ? "json" : codeBlock.language === "bash" ? "sh" : "txt";
-        return {
-          content,
-          filename: `${def.id}-config.${ext}`,
-          mimeType: codeBlock.language === "json" ? "application/json" : "text/plain",
-        };
-      }
-
-      // No code block — generate a simple guide summary.
-      const steps = def.guideSteps ?? [];
-      const lines = [`# ${def.name} — Setup Guide`, ""];
-      for (const step of steps) {
-        lines.push(`## Step ${step.step}: ${step.title}`);
-        if (step.desc) lines.push(step.desc);
-        if (step.value) {
-          lines.push("```");
-          lines.push(
-            step.value
-              .replace(/\{\{baseUrl\}\}/g, baseUrl)
-              .replace(/\{\{apiKey\}\}/g, apiKey)
-              .replace(/\{\{model\}\}/g, model),
-          );
-          lines.push("```");
-        }
-        lines.push("");
-      }
-      lines.push(`Endpoint: ${baseUrl}`);
-      lines.push(`API Key: ${apiKey}`);
-      lines.push(`Model: ${model}`);
-      return { content: lines.join("\n"), filename: `${def.id}-guide.txt`, mimeType: "text/plain" };
-    },
-  };
-}
-
 // ── injectors/index.ts ──
 /**
  * Single dispatch point for CliToolService: given a toolId, look up the
  * injector and call getStatus/apply/reset/download.
  *
  * File-based injectors are driven by a generic driver (createFileInjector)
- * configured via declarative specs. Guide-only tools (registry `configType:
- * "guide"`) are all built from `guideInjectorFor` — no per-tool constant
- * needed; the registry itself is the single source of the list. The map is
- * built exhaustively from that registry so a non-guide tool without an
- * injector fails loudly at import, never silently at lookup time.
+ * configured via declarative specs. The map is built exhaustively from that
+ * registry so a tool without an injector fails loudly at import, never
+ * silently at lookup time.
  */
 const FILE_INJECTORS: Partial<Record<ToolId, ToolInjector>> = {
   claude: createFileInjector(claudeSpec),
   codex: createFileInjector(codexSpec),
-  cline: createFileInjector(clineSpec),
   opencode: createFileInjector(opencodeSpec),
-  droid: createFileInjector(droidSpec),
-  hermes: createFileInjector(hermesSpec),
-  "grok-build": createFileInjector(grokBuildSpec),
-  copilot: createFileInjector(copilotSpec),
-  "deepseek-tui": createFileInjector(deepseekTuiSpec),
-  jcode: createFileInjector(jcodeSpec),
   kilo: createFileInjector(kiloSpec),
-  openclaw: createFileInjector(openclawSpec),
-  cowork: createFileInjector(coworkSpec),
 };
 
 export const INJECTORS: Record<ToolId, ToolInjector> = Object.fromEntries(
   TOOL_IDS.map((id) => {
-    const injector =
-      TOOL_REGISTRY[id].configType === "guide"
-        ? guideInjectorFor(TOOL_REGISTRY[id])
-        : FILE_INJECTORS[id];
+    const injector = FILE_INJECTORS[id];
     if (injector === undefined) {
       throw new Error(`No injector registered for tool: ${id}`);
     }

package/src/console/cli-tools/injectors/kilo.ts

@@ -1,13 +1,36 @@
 import { platform } from "node:os";
 import type {} from "../contracts";
-import { resolveApplyTarget, jsonDownload } from "../contracts";
-import { homeDir, isLocalEndpoint, join, readJsonFile, writeJsonFile } from "../fs-ops";
+import { jsonDownload } from "../contracts";
+import { homeDir, isLocalEndpoint, join, readJsonFile, writeJsonFileWithBackup } from "../fs-ops";
 import type { InjectorSpec } from "../contracts";
 
 const IS_WIN = platform() === "win32";
 const IS_MAC = platform() === "darwin";
 
 // Kilo Code injector spec.
+//
+// Kilo Code is a fork of OpenCode, but it now reads its own config file —
+// `~/.config/kilo/kilo.jsonc` (Windows: `%USERPROFILE%\.config\kilo\kilo.jsonc`)
+// — with the same provider shape as OpenCode: `provider.<id>.npm/options/models`
+// plus a top-level `model`. Unlike OpenCode, Kilo runs on the AI SDK, so the
+// `npm` value must be an `@ai-sdk/*` package (default `@ai-sdk/openai-compatible`).
+//
+// The older VS Code extension also keeps a credential store at
+// `~/.local/share/kilo/auth.json`; we still write the endpoint there for
+// backward compatibility, but the canonical config is now `kilo.jsonc`.
+
+const KILO_PROVIDER_ID = "cartethyia";
+
+function resolveKiloConfigDirectory(): string {
+  if (IS_WIN) return join(process.env.USERPROFILE ?? homeDir(), ".config", "kilo");
+  if (IS_MAC) return join(homeDir(), ".config", "kilo");
+  return join(homeDir(), ".config", "kilo");
+}
+
+function kiloConfigPath(): string {
+  return join(resolveKiloConfigDirectory(), "kilo.jsonc");
+}
+
 function resolveKiloDataDirectory(): string {
   if (IS_WIN) return join(process.env.LOCALAPPDATA ?? homeDir(), "kilo");
   if (IS_MAC) return join(homeDir(), "Library", "Application Support", "kilo");
@@ -21,15 +44,52 @@ function kiloVscodeSettingsPath(): string {
   return join(homeDir(), ".config", "Code", "User", "settings.json");
 }
 
+function kiloModelDef(model: string): unknown {
+  return {
+    name: model,
+    limit: { context: 128000, output: 64000 },
+  };
+}
+
+function buildKiloModels(models: readonly string[]): Record<string, unknown> {
+  const map: Record<string, unknown> = {};
+  for (const m of models) {
+    if (!m) continue;
+    map[m] = kiloModelDef(m);
+  }
+  return map;
+}
+
 export const kiloSpec: InjectorSpec = {
   toolId: "kilo",
   displayName: "Kilo Code",
   binary: "kilo",
-  resolveDir: resolveKiloDataDirectory,
-  resolvePath: () => join(resolveKiloDataDirectory(), "auth.json"),
+  resolveDir: resolveKiloConfigDirectory,
+  resolvePath: kiloConfigPath,
 
   async readStatus(path) {
-    const auth = (await readJsonFile(path)) as Record<
+    const config = (await readJsonFile(path)) as {
+      provider?: Record<string, { npm?: string; options?: { baseURL?: string; apiKey?: string }; models?: Record<string, unknown> }>;
+      model?: string;
+    } | null;
+    const provider = config?.provider?.[KILO_PROVIDER_ID];
+    const endpoint = provider?.options?.baseURL ?? null;
+    const models = provider?.models ? Object.keys(provider.models) : null;
+    const active =
+      typeof config?.model === "string" && config.model.startsWith(`${KILO_PROVIDER_ID}/`)
+        ? config.model.split("/").slice(1).join("/")
+        : null;
+    if (endpoint) {
+      return {
+        configured: isLocalEndpoint(endpoint),
+        currentEndpoint: endpoint,
+        rawApiKey: provider?.options?.apiKey ?? null,
+        currentModels: active && models ? [active, ...models.filter((m) => m !== active)] : models,
+      };
+    }
+
+    // Fallback to the legacy auth.json store (older VS Code extension).
+    const auth = (await readJsonFile(join(resolveKiloDataDirectory(), "auth.json"))) as Record<
       string,
       { baseUrl?: string; baseURL?: string; apiKey?: string; model?: string }
     > | null;
@@ -47,22 +107,77 @@ export const kiloSpec: InjectorSpec = {
   },
 
   async apply(input, path) {
-    const { model, baseUrl } = resolveApplyTarget(input);
-    const auth = ((await readJsonFile(path)) as Record<string, unknown> | null) ?? {};
-    auth["openai-compatible"] = { baseUrl, apiKey: input.apiKey, model };
-    await writeJsonFile(path, auth);
+    // Canonical config: ~/.config/kilo/kilo.jsonc
+    const existing = (await readJsonFile(path)) as Record<string, unknown> | null;
+    const config: Record<string, unknown> = (existing ?? {}) as Record<string, unknown>;
+    if (!config.provider || typeof config.provider !== "object") config.provider = {};
+    const providers = config.provider as Record<string, unknown>;
+    const prior = (providers[KILO_PROVIDER_ID] as Record<string, unknown> | undefined) ?? {};
+    const priorModels = (prior.models as Record<string, unknown> | undefined) ?? {};
+    const otherProviders = Object.keys(providers).filter((id) => id !== KILO_PROVIDER_ID);
+    providers[KILO_PROVIDER_ID] = {
+      npm: input.sdk ?? (prior as { npm?: string }).npm ?? "@ai-sdk/openai-compatible",
+      options: {
+        ...((prior.options as Record<string, unknown> | undefined) ?? {}),
+        baseURL: input.endpoint,
+        apiKey: input.apiKey,
+      },
+      models: { ...priorModels, ...buildKiloModels(input.modelIds) },
+    };
+    const activeModel = input.activeModel ?? input.modelIds[0] ?? "";
+    config.model = activeModel === "" ? "" : `${KILO_PROVIDER_ID}/${activeModel}`;
+
+    // YOLO mode: auto-approve shell/read/write.
+    if (input.bypassPermissions === true) {
+      config.permissions = [
+        { action: "shell", resource: "*", effect: "allow" },
+        { action: "external_directory", resource: "*", effect: "allow" },
+        { action: "question", resource: "*", effect: "deny" },
+      ];
+    } else if (input.bypassPermissions === false) {
+      delete config.permissions;
+    }
+
+    await writeJsonFileWithBackup(path, config);
+
+    // Legacy credential store for the older VS Code extension.
+    const authPath = join(resolveKiloDataDirectory(), "auth.json");
+    const auth = ((await readJsonFile(authPath)) as Record<string, unknown> | null) ?? {};
+    auth["openai-compatible"] = { baseUrl: input.endpoint, apiKey: input.apiKey, model: activeModel };
+    await writeJsonFileWithBackup(authPath, auth);
 
     const settings =
       ((await readJsonFile(kiloVscodeSettingsPath())) as Record<string, unknown> | null) ?? {};
     settings["kilo.code.authProviderOverride"] = "openai-compatible";
-    await writeJsonFile(kiloVscodeSettingsPath(), settings);
+    await writeJsonFileWithBackup(kiloVscodeSettingsPath(), settings);
+
+    return otherProviders.length > 0
+      ? [
+          `Config already has other provider(s): ${otherProviders.join(", ")}. They were kept as-is — only ${KILO_PROVIDER_ID} was written/updated.`,
+        ]
+      : undefined;
   },
 
   async reset(path) {
-    const auth = (await readJsonFile(path)) as Record<string, unknown> | null;
-    if (!auth) return false;
-    delete auth["openai-compatible"];
-    await writeJsonFile(path, auth);
+    const config = (await readJsonFile(path)) as Record<string, unknown> | null;
+    if (config && config.provider && typeof config.provider === "object") {
+      const providers = config.provider as Record<string, unknown>;
+      delete providers[KILO_PROVIDER_ID];
+      if (Object.keys(providers).length === 0) delete config.provider;
+    }
+    if (typeof config?.model === "string" && config.model.startsWith(`${KILO_PROVIDER_ID}/`)) {
+      delete config.model;
+    }
+    if (config) await writeJsonFileWithBackup(path, config);
+
+    const auth = (await readJsonFile(join(resolveKiloDataDirectory(), "auth.json"))) as Record<
+      string,
+      unknown
+    > | null;
+    if (auth) {
+      delete auth["openai-compatible"];
+      await writeJsonFileWithBackup(join(resolveKiloDataDirectory(), "auth.json"), auth);
+    }
 
     const settings = (await readJsonFile(kiloVscodeSettingsPath())) as Record<
       string,
@@ -70,21 +185,31 @@ export const kiloSpec: InjectorSpec = {
     > | null;
     if (settings && "kilo.code.authProviderOverride" in settings) {
       delete settings["kilo.code.authProviderOverride"];
-      await writeJsonFile(kiloVscodeSettingsPath(), settings);
+      await writeJsonFileWithBackup(kiloVscodeSettingsPath(), settings);
     }
   },
 
   download(input) {
-    const { model, baseUrl } = resolveApplyTarget(input);
-    return jsonDownload({ "openai-compatible": { baseUrl, apiKey: input.apiKey, model } }, {
-      filename: "auth.json",
-    });
+    const activeModel = input.activeModel ?? input.modelIds[0] ?? "";
+    const config: Record<string, unknown> = {
+      provider: {
+        [KILO_PROVIDER_ID]: {
+          npm: input.sdk ?? "@ai-sdk/openai-compatible",
+          options: {
+            baseURL: input.endpoint,
+            apiKey: input.apiKey,
+          },
+          models: buildKiloModels(input.modelIds),
+        },
+      },
+      model: activeModel === "" ? "" : `${KILO_PROVIDER_ID}/${activeModel}`,
+    };
+    return jsonDownload(config, { filename: "kilo.jsonc" });
   },
 
   messages: {
     applied: "Kilo Code settings applied",
     reset: "Cartethyia settings removed from Kilo Code",
-    resetMissing: "No auth file to reset",
+    resetMissing: "No config file to reset",
   },
 };
-

package/src/console/cli-tools/injectors/opencode.ts

@@ -1,6 +1,7 @@
 import type {} from "../contracts";
-import { ensureV1Suffix, homeDir, join, readJsonFile, writeJsonFile } from "../fs-ops";
+import { ensureV1Suffix, homeDir, join, readJsonFile, writeJsonFileWithBackup } from "../fs-ops";
 import type { InjectorSpec } from "../contracts";
+import { DEFAULT_SDK } from "../contracts";
 
 
 // OpenCode injector spec.
@@ -71,8 +72,9 @@ export const opencodeSpec: InjectorSpec = {
 
     if (!config.provider) config.provider = {};
     const prior = config.provider.cartethyia;
+    const otherProviders = Object.keys(config.provider).filter((id) => id !== "cartethyia");
     config.provider.cartethyia = {
-      npm: "@ai-sdk/openai-compatible",
+      npm: input.sdk ?? prior?.npm ?? DEFAULT_SDK,
       options: {
         ...(prior?.options ?? {}),
         baseURL: ensureV1Suffix(input.endpoint),
@@ -84,6 +86,22 @@ export const opencodeSpec: InjectorSpec = {
     const activeModel = input.activeModel ?? input.modelIds[0] ?? "";
     config.model = activeModel === "" ? "" : `cartethyia/${activeModel}`;
 
+    if (input.websearch !== undefined) {
+      config.websearch = { provider: input.websearch };
+    }
+
+    // YOLO mode: auto-approve shell/read/write. When on, write OpenCode's
+    // permission rules; when off, leave whatever the user had (or nothing).
+    if (input.bypassPermissions === true) {
+      config.permissions = [
+        { action: "shell", resource: "*", effect: "allow" },
+        { action: "external_directory", resource: "*", effect: "allow" },
+        { action: "question", resource: "*", effect: "deny" },
+      ];
+    } else if (input.bypassPermissions === false) {
+      delete config.permissions;
+    }
+
     if (!config.agent) config.agent = {};
     const subagentModel = input.subagentModel ?? input.modelIds[0] ?? activeModel;
     config.agent.explorer = {
@@ -92,7 +110,12 @@ export const opencodeSpec: InjectorSpec = {
       model: `cartethyia/${subagentModel}`,
     };
 
-    await writeJsonFile(path, config);
+    await writeJsonFileWithBackup(path, config);
+    return otherProviders.length > 0
+      ? [
+          `Config already has other provider(s): ${otherProviders.join(", ")}. They were kept as-is — only cartethyia was written/updated.`,
+        ]
+      : undefined;
   },
 
   async reset(path) {
@@ -113,7 +136,7 @@ export const opencodeSpec: InjectorSpec = {
       if (Object.keys(config.agent).length === 0) delete config.agent;
     }
 
-    await writeJsonFile(path, config);
+    await writeJsonFileWithBackup(path, config);
   },
 
   download(input) {
@@ -122,7 +145,7 @@ export const opencodeSpec: InjectorSpec = {
     const config: OpencodeConfig = {
       provider: {
         cartethyia: {
-          npm: "@ai-sdk/openai-compatible",
+          npm: input.sdk ?? DEFAULT_SDK,
           options: {
             baseURL: ensureV1Suffix(input.endpoint),
             apiKey: input.apiKey,

package/src/console/cli-tools/routes.ts

@@ -102,6 +102,10 @@ function parseApplyInput(
     ...(value.mode === "file" || value.mode === "remote" || value.mode === "both"
       ? { mode: value.mode }
       : {}),
+    ...(typeof value.sdk === "string" && value.sdk.length > 0 ? { sdk: value.sdk } : {}),
+    ...(typeof value.websearch === "string" && value.websearch.length > 0
+      ? { websearch: value.websearch }
+      : {}),
   };
 }
 
@@ -128,6 +132,8 @@ const applyBody = t.Object({
     }),
   ),
   bypassPermissions: t.Optional(t.Boolean()),
+  sdk: t.Optional(t.String()),
+  websearch: t.Optional(t.String()),
 });
 
 const mappingBody = t.Object({

package/src/console/cli-tools/service.ts

@@ -44,8 +44,6 @@ function toToolRegistryEntry(def: ToolDef): ToolRegistryEntry {
     ...(def.settingsFile === undefined ? {} : { settingsFile: def.settingsFile }),
     ...(def.docsUrl === undefined ? {} : { docsUrl: def.docsUrl }),
     ...(def.notes === undefined ? {} : { notes: def.notes }),
-    ...(def.guideSteps === undefined ? {} : { guideSteps: def.guideSteps }),
-    ...(def.codeBlock === undefined ? {} : { codeBlock: def.codeBlock }),
   };
 }
 
@@ -64,8 +62,8 @@ function applyMessage(outcome: ApplyOutcome, toolId: string, fileMessage: string
     case "remote":
       return `Saved the remote route for ${toolId}. No config file was written.`;
     case "none":
-      // A guide tool has no config to inject; the injector's own message says
-      // what to do instead (download the guide), so surface it verbatim.
+      // Nothing was written and no remote route was saved; surface the
+      // injector's own message verbatim.
       return fileMessage.length > 0 ? fileMessage : `Nothing to apply for ${toolId}.`;
   }
 }
@@ -274,8 +272,8 @@ export class CliToolService {
    *
    * `mode` defaults to `both` so the common single-machine case does the
    * obviously-right thing without the operator choosing. A tool that has no
-   * injectable config (a guide tool) reports `remote` honestly instead of
-   * claiming a file write it never performed.
+   * injectable config reports `remote` honestly instead of claiming a file
+   * write it never performed.
    */
   async applyConfig(
     tenantId: string,
@@ -292,12 +290,14 @@ export class CliToolService {
     let wroteFile = false;
     let settingsPath: string | undefined;
     let fileMessage = "";
+    let fileWarnings: readonly string[] | undefined;
 
     if (wantsFile) {
       const result: ApplyResult = await injector.apply(input);
       wroteFile = result.success;
       if (result.settingsPath !== undefined) settingsPath = result.settingsPath;
       fileMessage = result.message;
+      fileWarnings = result.warnings;
     }
 
     let savedRemoteRoute = false;
@@ -321,6 +321,7 @@ export class CliToolService {
       savedRemoteRoute,
       ...(settingsPath === undefined ? {} : { settingsPath }),
       message: applyMessage(outcome, toolId, fileMessage),
+      ...(fileWarnings && fileWarnings.length > 0 ? { warnings: fileWarnings } : {}),
     };
   }
 

package/src/console/observability/contracts.ts

@@ -232,6 +232,12 @@ export interface UsageRequestItem {
    * written before the column existed.
    */
   payloadCaptureState?: string;
+  /**
+   * True for a completed request whose output was far smaller than the model's
+   * ceiling and which ended with an ordinary `stop` (a "degenerate stop").
+   * Absent for everything else — including rows written before the column.
+   */
+  degenerateStop?: boolean;
   /**
    * Bitmask of the payload stages captured for this request: 1 request,
    * 2 provider request, 4 provider response, 8 client response. Read from the

package/src/console/observability/store.ts

@@ -165,6 +165,9 @@ function mapUsageRequestItem(
     // Why the drawer is empty for this request — see the contract field. This is
     // what makes the blank panels diagnosable without server logs.
     ...(event.payloadCaptureState ? { payloadCaptureState: event.payloadCaptureState } : {}),
+    // Degenerate stop (short output ended by an ordinary `stop`) — carried so
+    // the request detail can flag the pattern.
+    ...(event.degenerateStop ? { degenerateStop: true } : {}),
   };
 }
 async function resolveProxyLabel(

package/src/console/share/share-stats.ts

@@ -371,11 +371,9 @@ async function computeFamilyStatsBody(
       .where(eq(apiKeys.id, templateKeyId))
       .limit(1),
   ]);
-  // Cumulative family spend: the template's own counter plus the telemetry
-  // total. The counter is a manually-configured seed (an operator limit), not
-  // traffic, and it is never reset; azmetry rows for revoked/deleted children
-  // likewise stay counted, so the running total is monotonic and consistent
-  // across the overview, the share dialog, and this page.
+  // Cumulative family spend: the template's own counter is the live
+  // accumulator (updated by every recipient commit), so it IS the total.
+  // Telemetry still drives the bounded daily/monthly windows below.
   const templateLifetime = Number(template[0]?.lifetime ?? 0);
 
   // The ranked tables need real events, bounded to the 24-hour window. The
@@ -398,10 +396,10 @@ async function computeFamilyStatsBody(
   });
   rollup.totals = {
     ...rollup.totals,
-    // The template counter is the seed on the running total, not a distinct
-    // bucket: daily/monthly windows are telemetry-only (the counter has no
-    // time axis), so those keep their own sums.
-    totalTokens: templateLifetime + kpi.tokens,
+    // The template counter IS the running family total (live accumulator).
+    // Daily/monthly windows stay telemetry-only (the counter has no time
+    // axis), so those keep their own sums.
+    totalTokens: templateLifetime,
     todayTokens,
     monthTokens,
     // Lifetime counts come from the durable rollup, not the page: a family

package/src/observability/event-log.ts

@@ -57,6 +57,12 @@ export interface TelemetryEventRecord {
   readonly lastEventAtMs: number | null;
   /** Why the drawer payloads are empty, or `captured`; absent when unrecorded. */
   readonly payloadCaptureState?: string | null;
+  /**
+   * True for a completed request whose output was far smaller than the model's
+   * ceiling and which ended with an ordinary `stop` (a "degenerate stop").
+   * NULL/unset for everything else.
+   */
+  readonly degenerateStop?: boolean;
 }
 
 function asString(value: unknown): string | null {
@@ -109,6 +115,7 @@ function normalize(raw: Record<string, unknown>): TelemetryEventRecord | undefin
     tokensPerSec: asNumber(raw["tokensPerSec"]),
     firstContentDeltaAtMs: asNumber(raw["firstContentDeltaAtMs"]),
     lastEventAtMs: asNumber(raw["lastEventAtMs"]),
+    ...(raw["degenerateStop"] === true ? { degenerateStop: true } : {}),
   };
 }
 

package/src/observability/event-query.ts

@@ -184,6 +184,7 @@ function eventRecordFromRow(row: {
   readonly firstContentDeltaAtMs: number | null;
   readonly lastEventAtMs: number | null;
   readonly payloadCaptureState: string | null;
+  readonly degenerateStop: boolean | null;
 }): TelemetryEventRecord {
   return {
     id: row.id ?? row.requestId,
@@ -219,6 +220,7 @@ function eventRecordFromRow(row: {
     firstContentDeltaAtMs: row.firstContentDeltaAtMs,
     lastEventAtMs: row.lastEventAtMs,
     payloadCaptureState: row.payloadCaptureState,
+    ...(row.degenerateStop === true ? { degenerateStop: true } : {}),
   };
 }
 

package/src/observability/telemetry-buffer.ts

@@ -65,6 +65,12 @@ export interface TelemetryEventInput {
    * list instead of needing the server's logs.
    */
   readonly payloadCaptureState?: string;
+  /**
+   * True for a completed request whose output was far smaller than the model's
+   * ceiling and which ended with an ordinary `stop` (a "degenerate stop").
+   * Carried onto the telemetry row so this pattern can be measured.
+   */
+  readonly degenerateStop?: boolean;
 }
 
 function tokenCountToInt(value: number | "unavailable" | undefined): number | undefined {
@@ -155,6 +161,7 @@ function telemetryEventRow(event: TelemetryEventInput) {
     firstContentDeltaAtMs: event.firstContentDeltaAtMs ?? null,
     lastEventAtMs: event.lastEventAtMs ?? null,
     payloadCaptureState: event.payloadCaptureState ?? null,
+    degenerateStop: event.degenerateStop ?? null,
   };
 }
 

package/src/persistence/schema.ts

@@ -1483,6 +1483,14 @@ export const telemetryEvents = pgTable(
      * tell "not configured" from "broken".
      */
     payloadCaptureState: text("payload_capture_state"),
+    /**
+     * Set for a completed request whose output is far smaller than what the
+     * model can produce AND which the model ended with an ordinary `stop`
+     * (a "degenerate stop"). Introduced to measure how often a model
+     * truncates itself on a cached prefix — the pattern that surfaced as
+     * short, cut-off chat replies. NULL/unset for everything else.
+     */
+    degenerateStop: boolean("degenerate_stop"),
   },
   (table) => [
     index("telemetry_events_created_at_idx").on(table.createdAt),