@vantran-se/openchamber-web 2.1.1 → 2.2.0

package/server/lib/project-context/runtime.test.js

@@ -1,5 +1,6 @@
 import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
 import fsPromises from 'node:fs/promises';
+import { readFileSync } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 
@@ -284,8 +285,57 @@ describe('todos', () => {
   });
 
   test('clamps oversized todo text', async () => {
-    await runtime.saveTodos(PROJECT_ID, [{ id: 't1', text: 'z'.repeat(300), createdAt: 1 }]);
-    expect((await runtime.readContext(PROJECT_ID)).todos[0].text).toHaveLength(120);
+    await runtime.saveTodos(PROJECT_ID, [{ id: 't1', text: 'z'.repeat(1500), createdAt: 1 }]);
+    expect((await runtime.readContext(PROJECT_ID)).todos[0].text).toHaveLength(1000);
+  });
+});
+
+describe('committed changes', () => {
+  test('announces the owner only after note and todo changes reach disk', async () => {
+    const changes = [];
+    const announcing = createProjectContextRuntime({
+      fsPromises,
+      path,
+      projectsDirPath,
+      createId: () => `note-${++idCounter}`,
+      onChanged: (projectId) => {
+        changes.push({ projectId, context: JSON.parse(readFileSync(announcing.contextPathFor(projectId), 'utf8')) });
+      },
+    });
+    await announcing.readContext(PROJECT_ID);
+    expect(changes).toEqual([]);
+    const { note } = await announcing.createNote(PROJECT_ID, { body: 'peer note' });
+    expect(changes.map(change => change.projectId)).toEqual([PROJECT_ID]);
+    expect(changes[0].context.notes[0].body).toBe('peer note');
+
+    await announcing.updateNote(PROJECT_ID, note.id, { body: 'peer edit' });
+    await announcing.saveTodos(PROJECT_ID, [{ id: 't1', text: 'peer todo', completed: true, createdAt: 1 }]);
+    expect(changes.map(change => change.projectId)).toEqual([PROJECT_ID, PROJECT_ID, PROJECT_ID]);
+    expect(changes[1].context.notes[0].body).toBe('peer edit');
+    expect(changes[2].context.todos[0].completed).toBe(true);
+
+    await announcing.deleteNote(PROJECT_ID, note.id);
+    expect(changes.at(-1).context.notes).toEqual([]);
+    const count = changes.length;
+    await announcing.deleteNote(PROJECT_ID, 'missing');
+    await expect(announcing.createNote(PROJECT_ID, { body: ' ' })).rejects.toThrow('body is required');
+    expect(changes).toHaveLength(count);
+  });
+
+  test('a failed atomic write does not announce or replace the last committed context', async () => {
+    await runtime.createNote(PROJECT_ID, { body: 'kept' });
+    const changes = [];
+    const failing = createProjectContextRuntime({
+      fsPromises: { ...fsPromises, rename: async () => { throw new Error('disk full'); } },
+      path,
+      projectsDirPath,
+      onChanged: (projectId) => changes.push(projectId),
+    });
+    await expect(failing.saveTodos(PROJECT_ID, [{ id: 't1', text: 'not saved' }])).rejects.toThrow('disk full');
+    expect(changes).toEqual([]);
+    const context = await runtime.readContext(PROJECT_ID);
+    expect(context.notes[0].body).toBe('kept');
+    expect(context.todos).toEqual([]);
   });
 });
 
@@ -404,6 +454,8 @@ describe('plans', () => {
     expect(read.title).toBe('My Plan');
     expect(read.body).toBe('step one');
     expect(read.raw).toBe('# My Plan\n\nstep one');
+    // Where the file lives, so a comment on the plan can point an agent at it.
+    expect(read.path).toBe(path.join(plansDir(), plan.file));
   });
 
   test('newest plan is listed first', async () => {
@@ -567,6 +619,7 @@ describe('shared plans', () => {
     const read = await sharedRuntime.readPlan(PROJECT_ID, 'shared:roadmap.md');
     expect(read.title).toBe('Roadmap');
     expect(read.raw).toBe('# Roadmap\n\n- ship it\n');
+    expect(read.path).toBe(path.join(sharedDir, 'roadmap.md'));
     expect(await sharedRuntime.readPlan(PROJECT_ID, 'shared:missing.md')).toBeNull();
     expect(await sharedRuntime.readPlan(PROJECT_ID, 'shared:../escape.md')).toBeNull();
   });
@@ -592,6 +645,29 @@ describe('shared plans', () => {
     expect((await sharedRuntime.deletePlan(PROJECT_ID, 'shared:a.md')).deleted).toBe(false);
   });
 
+  test('announces shared plan updates and deletes, and stays quiet for missing files', async () => {
+    const changes = [];
+    const notifyingRuntime = createProjectContextRuntime({
+      fsPromises,
+      path,
+      projectsDirPath,
+      createId: () => `plan-${++idCounter}`,
+      resolveSharedPlansDir: async () => sharedDir,
+      onChanged: (projectId) => changes.push(projectId),
+    });
+    await fsPromises.mkdir(sharedDir, { recursive: true });
+    await fsPromises.writeFile(path.join(sharedDir, 'a.md'), '# A\n');
+
+    await notifyingRuntime.updatePlan(PROJECT_ID, 'shared:a.md', { raw: '# Renamed\n' });
+    expect(changes).toEqual([PROJECT_ID]);
+    await notifyingRuntime.deletePlan(PROJECT_ID, 'shared:a.md');
+    expect(changes).toEqual([PROJECT_ID, PROJECT_ID]);
+
+    await notifyingRuntime.updatePlan(PROJECT_ID, 'shared:a.md', { raw: 'x' });
+    await notifyingRuntime.deletePlan(PROJECT_ID, 'shared:a.md');
+    expect(changes).toEqual([PROJECT_ID, PROJECT_ID]);
+  });
+
   test('share moves a personal plan into the shared folder and unshare brings it back, avoiding name collisions', async () => {
     const { plan } = await sharedRuntime.createPlan(PROJECT_ID, { title: 'Mine', body: 'body' });
     const shared = await sharedRuntime.sharePlan(PROJECT_ID, plan.id);

package/server/lib/projects/project-config.js

@@ -38,7 +38,7 @@ const clampLength = (value, maxLength) => {
 };
 
 const normalizeStatus = (value) => {
-  if (value === 'running' || value === 'success' || value === 'error' || value === 'idle') {
+  if (value === 'running' || value === 'success' || value === 'error' || value === 'idle' || value === 'queued' || value === 'sent' || value === 'skipped' || value === 'failed' || value === 'cancelled') {
     return value;
   }
   return 'idle';
@@ -218,7 +218,7 @@ const normalizeSchedule = (value, existingSchedule) => {
   return { kind, cron, timezone };
 };
 
-const normalizeExecution = (value) => {
+const normalizeExecution = (value, targetSessionId) => {
   if (!value || typeof value !== 'object') {
     throw new Error('execution is required');
   }
@@ -230,6 +230,9 @@ const normalizeExecution = (value) => {
   const agent = asNonEmptyString(value.agent);
   const goalEnabled = value.goalEnabled === true;
   const permissionAutoAccept = value.permissionAutoAccept === true;
+  // Model, thinking level and agent come from the session defaults at run
+  // time; the stored ones are kept only for when this is turned off.
+  const useDefaults = value.useDefaults === true;
   const goalTokenBudget = typeof value.goalTokenBudget === 'number'
     && Number.isFinite(value.goalTokenBudget)
     && value.goalTokenBudget > 0
@@ -239,17 +242,18 @@ const normalizeExecution = (value) => {
   if (!prompt) {
     throw new Error('execution.prompt is required');
   }
-  if (!providerID) {
+  if (!useDefaults && !targetSessionId && !providerID) {
     throw new Error('execution.providerID is required');
   }
-  if (!modelID) {
+  if (!useDefaults && !targetSessionId && !modelID) {
     throw new Error('execution.modelID is required');
   }
+  if (targetSessionId && Boolean(providerID) !== Boolean(modelID)) throw new Error('execution providerID and modelID are required together');
 
   return {
     prompt,
-    providerID,
-    modelID,
+    ...(providerID && modelID ? { providerID, modelID } : {}),
+    ...(useDefaults ? { useDefaults: true } : {}),
     ...(variant ? { variant } : {}),
     ...(agent ? { agent } : {}),
     ...(goalEnabled ? { goalEnabled: true } : {}),
@@ -333,7 +337,10 @@ const normalizeTaskForStorage = (value, options) => {
     : (existingTask?.enabled ?? true);
 
   const schedule = normalizeSchedule(value.schedule, existingTask?.schedule);
-  const execution = normalizeExecution(value.execution);
+  const targetSessionId = asNonEmptyString(value.targetSessionId);
+  if (value.targetSessionId != null && value.targetSessionId !== '' && !targetSessionId) throw new Error('targetSessionId is invalid');
+  if (targetSessionId && !/^[A-Za-z0-9_-]{4,128}$/.test(targetSessionId)) throw new Error('targetSessionId is invalid');
+  const execution = normalizeExecution(value.execution, targetSessionId);
 
   // Loop provenance: absolute path of the `.agents/loops/*.md` file driving
   // this task, when any. Preserved on every write so the scheduler can detect
@@ -348,7 +355,7 @@ const normalizeTaskForStorage = (value, options) => {
     updatedAt: refreshUpdatedAt ? nowMs : baseState.updatedAt ?? nowMs,
   };
 
-  return {
+  const storedTask = {
     id,
     name,
     enabled,
@@ -357,6 +364,8 @@ const normalizeTaskForStorage = (value, options) => {
     state,
     ...(loopFile ? { loopFile } : {}),
   };
+  if (targetSessionId) storedTask.targetSessionId = targetSessionId;
+  return storedTask;
 };
 
 // `loopApprovals`: loop file path -> fingerprint of the version the user
@@ -865,12 +874,16 @@ export const createProjectConfigRuntime = (deps) => {
       // A project loop comes with the repository: `enabled: true` in its file
       // is the author's suggestion. It runs here only once the user enabled
       // this version of it on this machine (see setLoopApproval); a change to
-      // what it runs or when needs a new approval.
-      loops = loops.map((loop) => (
-        loop?.scope === 'project' && loop.definition?.enabled === true && approvals[loop.filePath] !== loop.fingerprint
-          ? { ...loop, definition: { ...loop.definition, enabled: false } }
-          : loop
-      ));
+      // what it runs or when needs a new approval. The returned task says
+      // which of the two held it back (`loopApproval`); it is never stored.
+      const heldBack = new Map();
+      loops = loops.map((loop) => {
+        if (loop?.scope !== 'project' || loop.definition?.enabled !== true || approvals[loop.filePath] === loop.fingerprint) {
+          return loop;
+        }
+        heldBack.set(loop.filePath, approvals[loop.filePath] ? 'outdated' : 'required');
+        return { ...loop, definition: { ...loop.definition, enabled: false } };
+      });
 
       const activeLoopFilePaths = new Set();
       const pendingLoops = new Map();
@@ -967,7 +980,9 @@ export const createProjectConfigRuntime = (deps) => {
         scheduledTasks: toStoredTasks(current, nextTasks, { replacedIDs }),
       });
 
-      return nextTasks;
+      return nextTasks.map((task) => (
+        task.loopFile && heldBack.has(task.loopFile) ? { ...task, loopApproval: heldBack.get(task.loopFile) } : task
+      ));
     });
   };
 

package/server/lib/projects/project-config.test.js

@@ -23,6 +23,19 @@ const createRuntime = async () => {
 };
 
 describe('project-config runtime', () => {
+  it('round-trips target tasks, terminal states and agent-only overrides without changing legacy model requirements', async () => {
+    const { runtime, cleanup } = await createRuntime();
+    try {
+      const input = { name: 'Reuse', enabled: true, targetSessionId: 'ses_target', schedule: { kind: 'daily', time: '09:00' }, execution: { prompt: 'Continue', agent: 'plan' } };
+      const saved = await runtime.upsertScheduledTask('project-test', input);
+      for (const lastStatus of ['queued', 'sent', 'skipped', 'failed', 'cancelled']) {
+        await runtime.updateScheduledTaskState('project-test', saved.task.id, { lastStatus, lastSessionId: 'ses_target' });
+        expect((await runtime.listScheduledTasks('project-test'))[0]).toMatchObject({ targetSessionId: 'ses_target', state: { lastStatus, lastSessionId: 'ses_target' } });
+      }
+      await expect(runtime.upsertScheduledTask('project-test', { ...input, targetSessionId: '../bad' })).rejects.toThrow('targetSessionId is invalid');
+      await expect(runtime.upsertScheduledTask('project-test', { ...input, targetSessionId: '' })).rejects.toThrow('execution.providerID is required');
+    } finally { await cleanup(); }
+  });
   it('creates and persists a scheduled task', async () => {
     const { runtime, cleanup } = await createRuntime();
     try {
@@ -53,6 +66,23 @@ describe('project-config runtime', () => {
     }
   });
 
+  it('accepts a task that follows the session defaults without a model, and still needs one when pinned', async () => {
+    const { runtime, cleanup } = await createRuntime();
+    const task = (execution) => ({
+      name: 'Follow defaults',
+      enabled: true,
+      schedule: { kind: 'daily', time: '09:30', timezone: 'UTC' },
+      execution: { prompt: 'Summarize', ...execution },
+    });
+    try {
+      const result = await runtime.upsertScheduledTask('project-test', task({ useDefaults: true }));
+      expect(result.task.execution).toEqual({ prompt: 'Summarize', useDefaults: true });
+      await expect(runtime.upsertScheduledTask('project-test', task({}))).rejects.toThrow('execution.providerID is required');
+    } finally {
+      await cleanup();
+    }
+  });
+
   it('rejects invalid cron expressions', async () => {
     const { runtime, cleanup } = await createRuntime();
     try {

package/server/lib/projects/project-setup.js

@@ -12,6 +12,7 @@
 // this file) use the same code paths so a value reads back the same on every
 // surface.
 
+import { isRecord as isObjectRecord } from '../shared/guards.js';
 import crypto from 'node:crypto';
 
 const ACTION_NAME_MAX_LENGTH = 80;
@@ -24,8 +25,6 @@ const SETUP_COMMANDS_MAX = 50;
 const ACTION_PLATFORMS = new Set(['macos', 'linux', 'windows']);
 const SETUP_WORKTREE_MODES = new Set(['append', 'replace']);
 
-const isObjectRecord = (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value);
-
 const clamp = (value, maxLength) => (value.length > maxLength ? value.slice(0, maxLength) : value);
 
 const trimmedString = (value) => (typeof value === 'string' ? value.trim() : '');

package/server/lib/projects/routes.js

@@ -11,13 +11,12 @@
  * `req.body` is parsed here without a per-route parser.
  */
 
+import { isRecord as isObjectRecord } from '../shared/guards.js';
 import path from 'node:path';
 import { z } from 'zod';
 import { createProjectIdFromPath } from './project-id.js';
 import { isProjectSetupValidationError } from './project-setup.js';
 
-const isObjectRecord = (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value);
-
 const directoryRequestSchema = z.object({
   path: z.string().trim().catch(''),
   create: z.literal(true).catch(false),

package/server/lib/quota/DOCUMENTATION.md

@@ -51,7 +51,7 @@ asked, `/api/quota/providers` answers 500 instead of an empty list.
 | `minimax-cn-coding-plan` | MiniMax Coding Plan (minimaxi.com) | `providers/minimax-cn-coding-plan.js` / `providers/minimax-shared.js` | `minimax-cn-coding-plan` |
 | `ollama-cloud` | Ollama Cloud | `providers/ollama-cloud.js` | Manual cookie pasted into Settings (`aid=...; __Secure-session=...` from `ollama.com`), stored under `~/.config/openchamber/quota/` |
 | `wafer` | Wafer.ai | `providers/wafer.js` | `wafer`, `wafer-ai`, `wafer_ai`, `wafer.ai` |
-| `opencode-go` | OpenCode Go | `providers/opencode-go.js` | `opencode-go` API key from OpenCode `auth.json` |
+| `opencode-go` | OpenCode Go | `providers/opencode-go.js` | `opencode-go` API key from OpenCode `auth.json`, or an OpenCode Console OAuth sign-in on the shared `opencode` integration |
 | `neuralwatt` | NeuralWatt | `providers/neuralwatt.js` | `neuralwatt` (API key under `key` or `token`) |
 | `kilo` | Kilo Code | `providers/kilo.js` | `kilo`, `kilocode`, `kilo-code` (API key under `key`, `token`, or OAuth `access`; organization id under `kilocodeOrganizationId`, `organizationId`, or OAuth `accountId`, else OpenCode `provider.kilo.options.kilocodeOrganizationId`) |
 | `zenmux` | ZenMux | `providers/zenmux.js` | Optional Platform API key stored under `~/.config/openchamber/quota/zenmux.json` (`platformApiKey`). The OpenCode chat key is not used. |
@@ -69,10 +69,21 @@ All providers should return results via shared helpers to preserve API shape:
 Provider modules must export `providerId`, `providerName`, `aliases`, `isConfigured(auth?)`, and `fetchQuota()`.
 `fetchQuota()` should return a quota result with `usage.windows` keyed by window name (for example `5h`, `7d`, `daily`) and optional provider-specific `usage.models` data.
 
-exe.dev, Ollama Cloud, Cursor, and ZenMux credentials are explicitly managed through Settings. exe.dev usage uses a separately generated HTTPS API token restricted to `billing credits usage` and aggregates every `exe-*` model provider into one monthly credit window. Generate the token with `ssh exe.dev "ssh-key generate-api-key --label=openchamber --exp=30d --cmds='billing credits usage'"`. ZenMux usage uses an optional Platform API key pasted on the Usage page; the OpenCode chat key is never used, and a missing Platform API key means ZenMux quota is not fetched. OpenCode Go usage uses `GET https://opencode.ai/zen/go/v1/usage` with the `opencode-go` API key from OpenCode `auth.json` as a bearer token and the stable `x-opencode-session: openchamber-usage` workload id. The server validates managed credentials before atomic `0600` writes and never returns secrets through its API. OpenChamber never scans browser cookie stores or automatically reads Cursor storage; Cursor import is an explicit one-time user action and never modifies Cursor's database.
+exe.dev, Ollama Cloud, Cursor, and ZenMux credentials are explicitly managed through Settings. exe.dev usage uses a separately generated HTTPS API token restricted to `billing credits usage` and aggregates every `exe-*` model provider into one monthly credit window. Generate the token with `ssh exe.dev "ssh-key generate-api-key --label=openchamber --exp=30d --cmds='billing credits usage'"`. ZenMux usage uses an optional Platform API key pasted on the Usage page; the OpenCode chat key is never used, and a missing Platform API key means ZenMux quota is not fetched. The server validates managed credentials before atomic `0600` writes and never returns secrets through its API. OpenChamber never scans browser cookie stores or automatically reads Cursor storage; Cursor import is an explicit one-time user action and never modifies Cursor's database.
 
 Command Code usage resolves account scope through `GET /alpha/whoami`, then reads server-backed credit balances and five-hour/weekly limits from `GET /alpha/billing/credits?orgId=...`. Personal accounts return `org: null` and use `/alpha/billing/credits` without an `orgId`; organization accounts include their organization id. Web/Electron and VS Code read the standard `command-code` OpenCode auth entry (including OAuth `access`) or `COMMAND_CODE_API_KEY`; credentials remain in the owning runtime and are never returned to shared UI.
 
+## OpenCode Go credential and quota semantics
+
+OpenCode Go has two credential shapes and they are not interchangeable. A service-account key stored under the `opencode-go` integration is a bearer token for `GET https://opencode.ai/zen/go/v1/usage` with the stable `x-opencode-session: openchamber-usage` workload id. A Console sign-in lives on the shared `opencode` integration as OAuth; its access token is a user session, not that key, and it is sent to `GET https://opencode.ai/console/api/go/status` with `x-org-id: <selected organization ID>`. That status endpoint is what the current Console Go page itself reads; it is not publicly documented, so re-check it against the live Console page before assuming it is still current.
+
+- **Credential selection**: OpenCode marks exactly one credential active per integration and credentials are global, so the active `opencode` OAuth credential is the selected account and organization. The reader carries only the Console `server` and `orgID` metadata; a credential whose `server` is not `https://opencode.ai/console`, whose `orgID` is missing or malformed, or that is an API key does not count as a Console sign-in. When both exist, the Console sign-in serves Go and the `opencode-go` key is the fallback, both when there is no Console sign-in and when the Console read fails; the Console error surfaces only when there is no key.
+- **Read-only and per-call**: the access token is read through `../opencode/auth.js` on every fetch, so switching accounts drops the previous account instead of showing stale numbers. OpenChamber never refreshes the token itself: OpenCode owns that, and an expired access token (local `expires`, or a 401/403) is surfaced as "sign in again" rather than a competing refresh.
+- **Meters**: the response's `product` must be `go` or `go-plus`; anything else is an absent subscription. `access.meters.fiveHour` / `week` / `month` map to the existing `5h` / `weekly` / `monthly` windows. `limitMicroCents` and `usedMicroCents` are decimal strings; the percentage is `used / limit`, never a hardcoded plan limit. A missing meter, a non-positive or unparseable limit, or an invalid reset timestamp skips that window alone; no usable window is a failed refresh, not zero usage.
+- **Trusted origin**: requests go only to the fixed Console status URL with `redirect: 'error'`, so the bearer token is never forwarded to another origin.
+- **Failure classes stay distinct**: not configured (no credential), expired sign-in (expired local token or 401/403), absent subscription (unexpected `product`), malformed response, and temporary request failure each return their own configured flag and message.
+- Keep `packages/web/server/lib/quota/providers/opencode-go.js` and `packages/vscode/src/opencodeGoQuota.ts` in sync — the VS Code extension duplicates this logic rather than importing the web provider.
+
 On the first OpenCode Go usage refresh after upgrading, OpenChamber deletes the obsolete `quota/opencode-go.json` credential file without reading its cookie value.
 
 ## Codex credit balance semantics
@@ -149,13 +160,30 @@ Web and VS Code accept finite numeric balances and non-empty numeric strings. Mi
 
 ## Kimi for Coding field semantics
 
-`GET https://api.kimi.com/coding/v1/usages` is inconsistent about which field carries consumption:
-- The weekly `usage` block returns `used` (consumed) with no `remaining` field.
-- Each `limits[].detail` rate-limit block returns `remaining` (available) with no `used` field.
+`GET https://api.kimi.com/coding/v1/usages` has two payload shapes and the provider supports both. Which one arrives depends on whether the account's plan has been migrated; in 2026-10 Kimi moved its newer plans from a weekly allowance to a monthly one. The endpoint is not in Kimi's public Open Platform reference. Its contract is defined by Kimi's own CLI, `MoonshotAI/kimi-code`, in `packages/oauth/src/managed-usage.ts` and `apps/kimi-code/src/utils/usage/usage-format.ts`.
+
+**Ratio payload.** A top-level `usages` object keyed by limit name, each entry `{ used_ratio, reset_time }`, where `used_ratio` is a 0-1 fraction and `reset_time` is RFC3339. Kimi documents its client as rendering whichever entries are served, so an absent key means the plan has no such window rather than missing data. An entry with no finite `used_ratio` is skipped instead of shown as an unknown percentage.
+
+| `usages` key | Window | Notes |
+| --- | --- | --- |
+| `limit_5h` | `5h` | Rolling five-hour frequency window |
+| `limit_7d` | `weekly` | Served only by plans that still have a weekly allowance |
+| `limit_month_total` | `monthly` | The plan's monthly allowance; `reset_time` is the subscription anchor, not a calendar month boundary |
+| `limit_month_code` | not shown | The code-typed share of `limit_month_total`, not a second allowance |
+
+`limit_month_code` is not surfaced. As its own row it would read as a second monthly allowance. As a `valueLabel` on the monthly row it would replace the row's percent with fixed used figures, so the row would ignore the used/remaining display setting that every other row follows.
+
+When `usages` is present the provider does not read `limits[]`. Its 300-minute entry describes the same five-hour window as `limit_5h`, carrying the same ratio rounded to a whole percentage against a fixed `limit` of `100`, and Kimi's own client ignores `limits[]` altogether.
+
+The payload may also carry `boosterWallet`, the pay-as-you-go top-up wallet that Kimi's client reads as `extraUsage`. OpenChamber does not surface it.
+
+**Counted payload.** Plans that have not migrated return a single weekly `usage` block plus `limits[]` rate-limit entries. This shape is inconsistent about which field carries consumption: the `usage` block returns `used` (consumed) with no `remaining` field, while each `limits[].detail` block returns `remaining` (available) with no `used` field. The provider computes `usedPercent` from whichever of the two is present, `used` taking precedence when both exist, rather than assuming one field name. A `limits[]` entry whose window is exactly five hours is labeled `Rate Limit (<raw duration>)` to set it apart from a plain duration.
+
+Credentials resolve in alias order, first match wins. OpenCode's China plan id `kimi-code-plan-cn` (kimi.com) comes before the pre-split `kimi-for-coding` and `kimi` ids, because a leftover pre-split key can hold a dead credential that would otherwise shadow the live China plan key and return 401. The global plan id `kimi-code-plan-global` (kimi.ai) stays last. Kimi's client uses `https://api.kimi.ai/coding/v1/usages` for global accounts, while this provider calls `api.kimi.com` for every alias, so a global-only key gets a 401 here. That gap is known and unfixed.
 
-Credentials resolve in alias order, first match wins. OpenCode's China plan id `kimi-code-plan-cn` (kimi.com) comes before the pre-split `kimi-for-coding` and `kimi` ids, because a leftover pre-split key can hold a dead credential that would otherwise shadow the live China plan key and return 401. The global plan id `kimi-code-plan-global` (kimi.ai, API base `api.kimi.ai`) stays last: it is not verified that a global key works at the `api.kimi.com` usage address, so it must not outrank a working pre-split key.
+Many Kimi users hold a pay-as-you-go Moonshot platform key (prepaid vouchers, no Kimi Code subscription) under `KIMI_API_KEY`. The Kimi Code usage address refuses such a key with 401. On a 401 or 403 the provider therefore asks `GET https://api.moonshot.ai/v1/users/me/balance` with the same key and, when that answers with a numeric `data.available_balance`, reports it as a `credits_balance` window (USD, remaining only). If the balance read also fails, the original `API error: <status>` is returned; other HTTP errors never try the balance address.
 
-The provider computes `usedPercent` from whichever of `used`/`remaining` is present (`used` takes precedence when both exist) rather than assuming one field name. Both `packages/web/server/lib/quota/providers/kimi.js` and `packages/vscode/src/quotaProviders.ts` (`fetchKimiQuota`) must stay in sync — the VS Code extension duplicates this parsing logic rather than importing it.
+Both `packages/web/server/lib/quota/providers/kimi.js` and `packages/vscode/src/quotaProviders.ts` (`fetchKimiQuota`) must stay in sync — the VS Code extension duplicates this parsing logic rather than importing it.
 
 ## Ollama Cloud settings-page shapes
 

package/server/lib/quota/index.js

@@ -5,6 +5,7 @@
  * @module quota
  */
 
+/** @public */
 export {
   listConfiguredQuotaProviders,
   fetchQuotaForProvider,

package/server/lib/quota/providers/claude/index.js

@@ -16,7 +16,7 @@ import { toClaudeUsage } from './transforms.js';
 
 export const providerId = 'claude';
 export const providerName = 'Claude';
-export const aliases = ['anthropic', 'claude'];
+const aliases = ['anthropic', 'claude'];
 
 const USAGE_URL = 'https://api.anthropic.com/api/oauth/usage';
 const OAUTH_BETA_HEADER = 'oauth-2025-04-20';

package/server/lib/quota/providers/cline-pass.js

@@ -12,7 +12,7 @@ import {
 
 export const providerId = 'cline-pass';
 export const providerName = 'ClinePass';
-export const aliases = ['cline-pass'];
+const aliases = ['cline-pass'];
 const CLINE_USAGE_URL = 'https://api.cline.bot/api/v1/users/me/plan/usage-limits';
 
 // Cline reports a rolling five-hour window, a rolling weekly window, and a

package/server/lib/quota/providers/exe-dev.js

@@ -3,7 +3,7 @@ import { asObject, buildResult, formatMoney, toNumber, toTimestamp, toUsageWindo
 
 export const providerId = 'exe-dev';
 export const providerName = 'exe.dev';
-export const aliases = ['exe-dev'];
+const aliases = ['exe-dev'];
 const EXEC_URL = 'https://exe.dev/exec';
 const USAGE_COMMAND = 'billing credits usage --group=day --json';
 

package/server/lib/quota/providers/google/index.js

@@ -16,7 +16,7 @@ export { resolveGoogleAuthSources } from './auth.js';
 
 export const providerId = 'google';
 export const providerName = 'Google';
-export const aliases = ['google', 'google.oauth'];
+const aliases = ['google', 'google.oauth'];
 
 export const isConfigured = (auth) => resolveGoogleAuthSources(auth).length > 0;
 

package/server/lib/quota/providers/hyper.js

@@ -12,7 +12,7 @@ import {
 
 export const providerId = 'hyper';
 export const providerName = 'Charm Hyper';
-export const aliases = ['hyper'];
+const aliases = ['hyper'];
 const HYPER_QUOTA_URL = 'https://hyper.charm.land/v1/credits';
 const CREDIT_TO_USD = 0.05;
 

package/server/lib/quota/providers/kimi.js

@@ -8,9 +8,40 @@ import {
   toTimestamp,
   durationToLabel,
   durationToSeconds,
-  asNonEmptyString
+  asNonEmptyString,
+  formatMoney,
+  asObject
 } from '../utils/index.js';
 
+const MOONSHOT_BALANCE_URL = 'https://api.moonshot.ai/v1/users/me/balance';
+
+// A pay-as-you-go Moonshot platform key (prepaid vouchers, no Kimi Code
+// subscription) is refused by the Kimi Code usage address. Its balance is read
+// from the platform instead: USD, what remains, with no spent figure.
+// Resolves to the credits_balance windows, or null when they cannot be read.
+const fetchMoonshotBalanceWindows = async (apiKey, fetchImpl) => {
+  try {
+    const response = await fetchImpl(MOONSHOT_BALANCE_URL, {
+      method: 'GET',
+      headers: { Authorization: `Bearer ${apiKey}` },
+      signal: AbortSignal.timeout(15_000)
+    });
+    if (!response.ok) return null;
+    const balance = asObject(asObject(await response.json())?.data)?.available_balance;
+    if (!Number.isFinite(balance)) return null;
+    return {
+      credits_balance: toUsageWindow({
+        usedPercent: null,
+        windowSeconds: null,
+        resetAt: null,
+        valueLabel: `$${formatMoney(balance)}`
+      })
+    };
+  } catch {
+    return null;
+  }
+};
+
 export const providerId = 'kimi-for-coding';
 export const providerName = 'Kimi for Coding';
 // OpenCode stores the Kimi For Coding plans as `kimi-code-plan-cn` (kimi.com)
@@ -18,11 +49,47 @@ export const providerName = 'Kimi for Coding';
 // works at the api.kimi.com usage address, and a pre-split `kimi-for-coding`
 // key left behind with a dead credential must not shadow it. The global plan
 // stays last, as before, since its key is not known to work at that address.
-export const aliases = ['kimi-code-plan-cn', 'kimi-for-coding', 'kimi', 'kimi-code-plan-global'];
+const aliases = ['kimi-code-plan-cn', 'kimi-for-coding', 'kimi', 'kimi-code-plan-global'];
+
+// The ratio-based `usages` block, in the order Kimi's own CLI renders it.
+// `limit_month_code` is not read: it is the code-typed share of
+// `limit_month_total`, not a second allowance, and a value label carrying it
+// would replace the monthly percent and stay a used figure when the panel shows
+// what remains. `limit_7d` arrives only on plans that still have a weekly
+// quota, and Kimi documents the client as rendering whichever entries are served.
+const RATIO_WINDOWS = [
+  { key: 'limit_5h', label: '5h', windowSeconds: 5 * 60 * 60 },
+  { key: 'limit_7d', label: 'weekly', windowSeconds: 7 * 24 * 60 * 60 },
+  { key: 'limit_month_total', label: 'monthly', windowSeconds: null }
+];
+
+// `used_ratio` is a 0-1 fraction. An entry without a finite ratio carries no
+// information, so it is skipped rather than shown as an unknown percentage.
+const toRatioPercent = (entry) => {
+  const ratio = toNumber(entry?.used_ratio);
+  return ratio === null ? null : Math.max(0, Math.min(100, ratio * 100));
+};
+
+const ratioWindows = (usages) => {
+  const windows = {};
+  for (const { key, label, windowSeconds } of RATIO_WINDOWS) {
+    const entry = asObject(usages[key]);
+    const usedPercent = toRatioPercent(entry);
+    if (usedPercent === null) continue;
+    windows[label] = toUsageWindow({
+      usedPercent,
+      windowSeconds,
+      resetAt: toTimestamp(entry.reset_time)
+    });
+  }
+  return windows;
+};
 
-// Kimi's weekly `usage` block reports `used`; its rate-limit `limits[].detail`
-// blocks report `remaining` instead. Neither field is guaranteed present, so
-// derive usedPercent from whichever one the API actually returned.
+// The pre-ratio payload: one counted weekly `usage` block plus `limits[]`
+// rate-limit entries. Plans that have not migrated still answer this way. Its
+// `usage` block reports `used`; the `limits[].detail` blocks report `remaining`
+// instead. Neither field is guaranteed present, so derive usedPercent from
+// whichever one the API actually returned.
 const computeUsedPercent = (total, used, remaining) => {
   if (!total) return null;
   if (used !== null) {
@@ -34,6 +101,33 @@ const computeUsedPercent = (total, used, remaining) => {
   return null;
 };
 
+const legacyWindows = (payload) => {
+  const windows = {};
+  const usage = asObject(payload?.usage);
+  if (usage) {
+    windows.weekly = toUsageWindow({
+      usedPercent: computeUsedPercent(toNumber(usage.limit), toNumber(usage.used), toNumber(usage.remaining)),
+      windowSeconds: null,
+      resetAt: toTimestamp(usage.resetTime)
+    });
+  }
+
+  const limits = Array.isArray(payload?.limits) ? payload.limits : [];
+  for (const limit of limits) {
+    const window = limit?.window;
+    const detail = limit?.detail;
+    const rawLabel = durationToLabel(window?.duration, window?.timeUnit);
+    const windowSeconds = durationToSeconds(window?.duration, window?.timeUnit);
+    const label = windowSeconds === 5 * 60 * 60 ? `Rate Limit (${rawLabel})` : rawLabel;
+    windows[label] = toUsageWindow({
+      usedPercent: computeUsedPercent(toNumber(detail?.limit), toNumber(detail?.used), toNumber(detail?.remaining)),
+      windowSeconds,
+      resetAt: toTimestamp(detail?.resetTime)
+    });
+  }
+  return windows;
+};
+
 const getApiKey = (auth) => {
   const entry = normalizeAuthEntry(getAuthEntry(auth, aliases));
   return asNonEmptyString(entry?.key) ?? asNonEmptyString(entry?.token);
@@ -64,6 +158,18 @@ export const fetchQuota = async ({ readAuth = readOpenCodeCredentials, fetchImpl
     });
 
     if (!response.ok) {
+      if (response.status === 401 || response.status === 403) {
+        const balanceWindows = await fetchMoonshotBalanceWindows(apiKey, fetchImpl);
+        if (balanceWindows) {
+          return buildResult({
+            providerId,
+            providerName,
+            ok: true,
+            configured: true,
+            usage: { windows: balanceWindows }
+          });
+        }
+      }
       return buildResult({
         providerId,
         providerName,
@@ -74,37 +180,11 @@ export const fetchQuota = async ({ readAuth = readOpenCodeCredentials, fetchImpl
     }
 
     const payload = await response.json();
-    const windows = {};
-    const usage = payload?.usage ?? null;
-    if (usage) {
-      const limit = toNumber(usage.limit);
-      const used = toNumber(usage.used);
-      const remaining = toNumber(usage.remaining);
-      const usedPercent = computeUsedPercent(limit, used, remaining);
-      windows.weekly = toUsageWindow({
-        usedPercent,
-        windowSeconds: null,
-        resetAt: toTimestamp(usage.resetTime)
-      });
-    }
-
-    const limits = Array.isArray(payload?.limits) ? payload.limits : [];
-    for (const limit of limits) {
-      const window = limit?.window;
-      const detail = limit?.detail;
-      const rawLabel = durationToLabel(window?.duration, window?.timeUnit);
-      const windowSeconds = durationToSeconds(window?.duration, window?.timeUnit);
-      const label = windowSeconds === 5 * 60 * 60 ? `Rate Limit (${rawLabel})` : rawLabel;
-      const total = toNumber(detail?.limit);
-      const used = toNumber(detail?.used);
-      const remaining = toNumber(detail?.remaining);
-      const usedPercent = computeUsedPercent(total, used, remaining);
-      windows[label] = toUsageWindow({
-        usedPercent,
-        windowSeconds,
-        resetAt: toTimestamp(detail?.resetTime)
-      });
-    }
+    // Kimi replaced the counted payload with a ratio-based `usages` map. Its own
+    // client reads only `usages`, so when that block is present the `limits[]`
+    // entry for the same 5-hour window is a coarser duplicate and is not read.
+    const usages = asObject(asObject(payload)?.usages);
+    const windows = usages ? ratioWindows(usages) : legacyWindows(payload);
 
     return buildResult({
       providerId,