quotacap 0.0.41 → 0.0.43

package/dist/config.d.ts

@@ -1,35 +1,18 @@
 import { z } from "zod";
 export declare function getConfigPath(p?: string): string;
 export declare function getDbPath(p?: string): string;
-export declare const ProviderDisplayNameSchema: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+export declare const ProviderDisplayNameSchema: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
 declare const ConfigSchema: z.ZodObject<{
     port: z.ZodDefault<z.ZodNumber>;
     pollMinutes: z.ZodDefault<z.ZodNumber>;
     catalogTtlHours: z.ZodDefault<z.ZodNumber>;
-    enabledProviders: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
-    knownProviders: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
-    providerNames: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>>;
+    enabledProviders: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    knownProviders: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    providerNames: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>>;
     opencodeGoConsentAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
     experimentalIngest: z.ZodOptional<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    port: number;
-    pollMinutes: number;
-    catalogTtlHours: number;
-    enabledProviders: string[];
-    knownProviders: string[];
-    providerNames: Record<string, string>;
-    opencodeGoConsentAt: string | null;
-    experimentalIngest?: boolean | undefined;
-}, {
-    port?: number | undefined;
-    pollMinutes?: number | undefined;
-    catalogTtlHours?: number | undefined;
-    enabledProviders?: string[] | undefined;
-    knownProviders?: string[] | undefined;
-    providerNames?: Record<string, string> | undefined;
-    opencodeGoConsentAt?: string | null | undefined;
-    experimentalIngest?: boolean | undefined;
-}>;
+    debugFailureBundles: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
 export type Config = z.infer<typeof ConfigSchema>;
 /**
  * Manual ingest (CLI `ingest`, POST /api/ingest) is off unless this returns
@@ -37,6 +20,12 @@ export type Config = z.infer<typeof ConfigSchema>;
  * config key. Do not document this as a supported product flag.
  */
 export declare function isExperimentalIngestEnabled(config?: Pick<Config, "experimentalIngest">, env?: NodeJS.Dict<string>): boolean;
+/**
+ * Failure evidence bundles (per-provider redacted transcripts under
+ * <dataDir>/failures/) are off unless this returns true. Env
+ * `QUOTACAP_DEBUG_FAILURES` wins; otherwise the optional config key.
+ */
+export declare function isFailureBundlesEnabled(config?: Pick<Config, "debugFailureBundles">, env?: NodeJS.Dict<string>): boolean;
 export declare function readConfig(p?: string): Promise<Config>;
 export declare function defaultConfig(): Config;
 export interface EnsureConfigResult {

package/dist/config.js

@@ -41,6 +41,10 @@ const ConfigSchema = z.object({
     // Optional, omitted from defaults and `init` output. Manual ingest stays
     // in-tree but is not a public surface until the product design lands.
     experimentalIngest: z.boolean().optional(),
+    // Opt-in failure forensics: on poll failure, write a redacted evidence
+    // bundle (transcript, error, versions, timings) under <dataDir>/failures/.
+    // Local-only, never uploaded. Env QUOTACAP_DEBUG_FAILURES wins (see below).
+    debugFailureBundles: z.boolean().optional(),
 });
 function envFlag(raw) {
     if (raw === undefined)
@@ -71,6 +75,25 @@ export function isExperimentalIngestEnabled(config, env = process.env) {
         return false;
     }
 }
+/**
+ * Failure evidence bundles (per-provider redacted transcripts under
+ * <dataDir>/failures/) are off unless this returns true. Env
+ * `QUOTACAP_DEBUG_FAILURES` wins; otherwise the optional config key.
+ */
+export function isFailureBundlesEnabled(config, env = process.env) {
+    const fromEnv = envFlag(env.QUOTACAP_DEBUG_FAILURES);
+    if (fromEnv !== undefined)
+        return fromEnv;
+    if (config)
+        return config.debugFailureBundles === true;
+    try {
+        const parsed = JSON.parse(fsSync.readFileSync(getConfigPath(), "utf8"));
+        return parsed?.debugFailureBundles === true;
+    }
+    catch {
+        return false;
+    }
+}
 export async function readConfig(p) {
     try {
         const raw = await fs.readFile(getConfigPath(p), "utf8");
@@ -106,6 +129,7 @@ const ServiceConfigSchema = z.object({
     providerNames: z.record(z.string(), ProviderDisplayNameSchema).default({}),
     opencodeGoConsentAt: z.string().nullable().default(null),
     experimentalIngest: z.boolean().optional(),
+    debugFailureBundles: z.boolean().optional(),
 });
 export function defaultConfig() {
     return ConfigSchema.parse({});

package/dist/diagnostics/bundle.d.ts

@@ -0,0 +1,22 @@
+import { type DiagnosticCode } from "./failure.js";
+export declare const BUNDLE_KEEP_PER_PROVIDER = 5;
+export declare function redactText(s: string): string;
+export declare function providerBin(provider: string, providerPaths?: Record<string, string | null>): string | null;
+/** Best-effort `<bin> --version` first line, or null. Never throws. */
+export declare function getCliVersion(bin: string, timeoutMs?: number): Promise<string | null>;
+export interface FailureBundleInput {
+    dataDir: string;
+    provider: string;
+    attemptedAt: string;
+    reason: unknown;
+    diagnosticCode: DiagnosticCode;
+    summary: string;
+    errorDetail: string;
+    attemptDurationMs?: number;
+    timeoutMs?: number;
+    quotacapVersion?: string;
+    cliBin?: string | null;
+    cliVersion?: string | null;
+}
+/** Write one bundle. Never throws: returns the dir path, or null. */
+export declare function writeFailureBundle(input: FailureBundleInput): Promise<string | null>;

package/dist/diagnostics/bundle.js

@@ -0,0 +1,125 @@
+// Opt-in failure forensics: on a poll failure, persist a redacted evidence
+// bundle under <dataDir>/failures/<provider>-<timestamp>-<rand>/. Bundles
+// are local-only (never uploaded) and exist so the next "bad resets
+// timestamp" arrives with the transcript that explains it. Off by default;
+// enabled via config `debugFailureBundles` or env QUOTACAP_DEBUG_FAILURES.
+import { execFile } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { getErrorEvidence } from "./failure.js";
+import { renderScreen } from "../adapters/vt.js";
+import { isGoldenCovered } from "../adapters/goldens.js";
+export const BUNDLE_KEEP_PER_PROVIDER = 5;
+const RAW_CAP = 64 * 1024;
+const RENDERED_CAP = 32 * 1024;
+const STDERR_CAP = 8 * 1024;
+const MESSAGE_CAP = 2048;
+// Emails, URLs, bearer tokens, and long token-like runs. Percents, dates,
+// and short identifiers pass through: parse debugging needs them.
+export function redactText(s) {
+    return s
+        .replace(/[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g, "[email]")
+        .replace(/https?:\/\/\S+/g, "[url]")
+        .replace(/(bearer\s+)[A-Za-z0-9._~+/-]+/gi, "$1[token]")
+        .replace(/\b[A-Za-z0-9_~+\/=.-]{32,}\b/g, "[token]");
+}
+function cap(s, n) {
+    return s.length > n ? s.slice(0, n) + `\n…[truncated, ${s.length} chars total]` : s;
+}
+// Providers without a version-reporting CLI (credential stores, virtual).
+const NO_CLI_PROVIDERS = new Set(["opencode-go", "manual", "all"]);
+export function providerBin(provider, providerPaths) {
+    if (NO_CLI_PROVIDERS.has(provider))
+        return null;
+    const recorded = providerPaths?.[provider];
+    if (typeof recorded === "string" && recorded.length > 0)
+        return recorded;
+    return provider;
+}
+/** Best-effort `<bin> --version` first line, or null. Never throws. */
+export function getCliVersion(bin, timeoutMs = 3000) {
+    return new Promise((resolve) => {
+        execFile(bin, ["--version"], { timeout: timeoutMs }, (err, stdout, stderr) => {
+            if (err) {
+                resolve(null);
+                return;
+            }
+            const first = `${stdout ?? ""}\n${stderr ?? ""}`
+                .split("\n")
+                .map((l) => l.trim())
+                .find((l) => l.length > 0);
+            resolve(first ? first.slice(0, 120) : null);
+        });
+    });
+}
+async function pruneOldBundles(failuresDir, provider) {
+    try {
+        const entries = await fs.readdir(failuresDir);
+        const ours = entries.filter((e) => e === provider || e.startsWith(`${provider}-`)).sort();
+        const stale = ours.slice(0, Math.max(0, ours.length - BUNDLE_KEEP_PER_PROVIDER));
+        await Promise.all(stale.map((e) => fs.rm(path.join(failuresDir, e), { recursive: true, force: true }).catch(() => { })));
+    }
+    catch { }
+}
+/** Write one bundle. Never throws: returns the dir path, or null. */
+export async function writeFailureBundle(input) {
+    try {
+        const stamp = input.attemptedAt.replace(/[:.]/g, "-");
+        const rand = Math.floor(Math.random() * 0x10000).toString(16).padStart(4, "0");
+        const dir = path.join(input.dataDir, "failures", `${input.provider}-${stamp}-${rand}`);
+        await fs.mkdir(dir, { recursive: true });
+        const evidence = getErrorEvidence(input.reason);
+        const raw = typeof evidence?.stdout === "string" ? evidence.stdout : "";
+        const message = input.reason instanceof Error ? input.reason.message : String(input.reason?.message ?? input.reason);
+        const files = [];
+        if (raw) {
+            files.push(["transcript-raw.txt", redactText(cap(raw, RAW_CAP))]);
+            if (evidence?.source === "pty") {
+                files.push(["transcript.txt", redactText(cap(renderScreen(raw), RENDERED_CAP))]);
+            }
+        }
+        const errLines = [
+            `summary: ${input.summary}`,
+            `code: ${input.diagnosticCode}`,
+            `detail: ${input.errorDetail}`,
+            `message: ${redactText(cap(message, MESSAGE_CAP))}`,
+        ];
+        if (evidence?.checkpoint)
+            errLines.push(`checkpoint: ${evidence.checkpoint}`);
+        if (evidence?.exitCode !== undefined)
+            errLines.push(`exitCode: ${evidence.exitCode}`);
+        if (evidence?.durationMs !== undefined)
+            errLines.push(`durationMs: ${evidence.durationMs}`);
+        if (evidence?.timings)
+            errLines.push(`timings: ${JSON.stringify(evidence.timings)}`);
+        const stderr = typeof evidence?.stderr === "string" ? evidence.stderr.trim() : "";
+        if (stderr)
+            errLines.push(`stderr:\n${redactText(cap(stderr, STDERR_CAP))}`);
+        files.push(["error.txt", errLines.join("\n") + "\n"]);
+        const meta = {
+            provider: input.provider,
+            attemptedAt: input.attemptedAt,
+            quotacapVersion: input.quotacapVersion ?? null,
+            cliBin: input.cliBin ?? null,
+            cliVersion: input.cliVersion ?? null,
+            goldenCovered: input.cliVersion ? isGoldenCovered(input.provider, input.cliVersion) : null,
+            diagnosticCode: input.diagnosticCode,
+            summary: input.summary,
+            errorDetail: input.errorDetail,
+            attemptDurationMs: input.attemptDurationMs ?? null,
+            timeoutMs: input.timeoutMs ?? null,
+            checkpoint: evidence?.checkpoint ?? null,
+            exitCode: evidence?.exitCode ?? null,
+            durationMs: evidence?.durationMs ?? null,
+            timings: evidence?.timings ?? null,
+            hasTranscript: raw.length > 0,
+        };
+        files.push(["meta.json", JSON.stringify(meta, null, 2) + "\n"]);
+        await Promise.all(files.map(([name, content]) => fs.writeFile(path.join(dir, name), content, "utf8")));
+        await pruneOldBundles(path.join(input.dataDir, "failures"), input.provider);
+        return dir;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/diagnostics/failure.d.ts

@@ -7,6 +7,8 @@ export interface FailureEvidence {
     durationMs?: number;
     stdout?: string;
     stderr?: string;
+    /** Phase marks (ms since attempt start): spawn, input, completion, end. */
+    timings?: Record<string, number>;
 }
 export interface SafeDiagnostic {
     diagnosticCode: DiagnosticCode;
@@ -19,8 +21,13 @@ export interface ClassifiedFailure extends SafeDiagnostic {
 }
 export declare class DiagnosticError extends Error {
     readonly diagnostic: SafeDiagnostic;
-    constructor(diagnostic: SafeDiagnostic);
+    /** Raw failure evidence (transcript, timings). Memory-only: classification
+     * and logs use `diagnostic`; bundles read this. */
+    readonly evidence?: FailureEvidence;
+    constructor(diagnostic: SafeDiagnostic, evidence?: FailureEvidence);
 }
+export declare function attachEvidence(error: unknown, evidence: FailureEvidence): void;
+export declare function getErrorEvidence(reason: unknown): FailureEvidence | undefined;
 export declare function formatProviderName(provider: string): string;
 export declare function diagnosticError(reason: unknown, evidence?: FailureEvidence): DiagnosticError;
 export declare function classifyFailure(provider: string, reason: unknown): ClassifiedFailure;

package/dist/diagnostics/failure.js

@@ -1,11 +1,52 @@
 export class DiagnosticError extends Error {
     diagnostic;
-    constructor(diagnostic) {
+    /** Raw failure evidence (transcript, timings). Memory-only: classification
+     * and logs use `diagnostic`; bundles read this. */
+    evidence;
+    constructor(diagnostic, evidence) {
         super(diagnostic.errorDetail);
         this.name = "DiagnosticError";
         this.diagnostic = Object.freeze({ ...diagnostic });
+        // Non-enumerable: evidence must never leak through JSON.stringify or
+        // spreads — serialized errors carry the diagnosis only. Readable via
+        // getErrorEvidence.
+        if (evidence) {
+            Object.defineProperty(this, "evidence", {
+                value: Object.freeze({ ...evidence }),
+                enumerable: false,
+                writable: false,
+            });
+        }
     }
 }
+// Side-channel evidence for plain Errors: adapter polls attach the transcript
+// a parse throw would otherwise discard, without touching the message that
+// classification and existing logs depend on.
+const EVIDENCE_KEY = "__quotacapEvidence";
+export function attachEvidence(error, evidence) {
+    if (typeof error === "object" && error !== null) {
+        try {
+            // Non-enumerable, like DiagnosticError.evidence: serialization-safe.
+            Object.defineProperty(error, EVIDENCE_KEY, {
+                value: evidence,
+                enumerable: false,
+                writable: true,
+                configurable: true,
+            });
+        }
+        catch { }
+    }
+}
+export function getErrorEvidence(reason) {
+    if (reason instanceof DiagnosticError && reason.evidence)
+        return reason.evidence;
+    if (typeof reason === "object" && reason !== null) {
+        const ev = reason[EVIDENCE_KEY];
+        if (ev && typeof ev === "object" && (ev.source === "pty" || ev.source === "exec"))
+            return ev;
+    }
+    return undefined;
+}
 export function formatProviderName(provider) {
     switch (provider) {
         case "claude":
@@ -426,7 +467,7 @@ export function diagnosticError(reason, evidence) {
     return new DiagnosticError({
         diagnosticCode: match.code,
         errorDetail: detail,
-    });
+    }, evidence);
 }
 function mapCategory(code) {
     switch (code) {

package/dist/format/rows.d.ts

@@ -21,7 +21,7 @@ export declare function weeklyPctOf(q: {
     usedPct?: number;
 } | null | undefined): number | undefined;
 export declare function fmtDuration(ms: number): string;
-export declare function weekdayOf(iso: string | undefined): string;
+export declare function dayOf(iso: string | undefined): string;
 export declare function countdownText(ps: ProviderSnapshot, now: Date): string;
 export declare function elapsedPct(ps: ProviderSnapshot, now: Date): number | null;
 export declare function usedPctOf(ps: ProviderSnapshot): number | null;

package/dist/format/rows.js

@@ -23,11 +23,14 @@ export function fmtDuration(ms) {
         return `${Math.floor(ms / HOUR_MS)}h`;
     return `${Math.max(1, Math.floor(ms / MIN_MS))}m`;
 }
-// Short weekday of an ISO instant in the locked English copy, e.g. "Tue".
-// Pinned to en-US: the sentence it feeds ("unused until Tue") is English, so
-// a non-English machine must not print a localized weekday inside it.
-export function weekdayOf(iso) {
-    return new Date(iso ?? "").toLocaleDateString("en-US", { weekday: "short" });
+// Short weekday plus calendar date of an ISO instant in the locked English
+// copy, e.g. "Tue Sep 15". Pinned to en-US: the sentence it feeds
+// ("unused until Tue Sep 15") is English, so a non-English machine must not
+// print localized parts inside it. A bare weekday scans as this coming week,
+// which misreads a monthly reset sitting weeks out.
+export function dayOf(iso) {
+    const when = new Date(iso ?? "");
+    return `${when.toLocaleDateString("en-US", { weekday: "short" })} ${when.toLocaleDateString("en-US", { day: "numeric", month: "short" })}`;
 }
 export function countdownText(ps, now) {
     const resetsMs = msOf(ps.quota?.resetsAt);
@@ -140,7 +143,7 @@ export function forecastText(ps, now) {
         return "no readings yet";
     let text;
     if (adv.bindingWindow === "monthly" && adv.bindingRemaining <= 0) {
-        text = `unused until ${weekdayOf(ps.quota?.monthlyResetsAt)}`;
+        text = `unused until ${dayOf(ps.quota?.monthlyResetsAt)}`;
     }
     else if (adv.bindingWindow === "monthly") {
         text = `${Math.round(adv.bindingRemaining)}% of month left`;

package/dist/mcp/server.d.ts

@@ -29,10 +29,10 @@ export declare const tools: ({
     inputSchema: {
         type: string;
         properties: {
+            task?: undefined;
             provider: {
                 type: string;
             };
-            task?: undefined;
         };
         required?: undefined;
     };
@@ -42,10 +42,10 @@ export declare const tools: ({
     inputSchema: {
         type: string;
         properties: {
+            task?: undefined;
             provider: {
                 type: string;
             };
-            task?: undefined;
         };
         required: string[];
     };

package/dist/runtime/poll.d.ts

@@ -44,6 +44,10 @@ export interface CoordinatorOptions {
     onOwnershipLost?: () => void;
     /** Fired after each scheduled tick settles (success or failure). The daemon refreshes its daily update cache here. */
     onSettled?: () => void;
+    /** Data dir for failure bundles. Required with debugFailureBundles. */
+    dataDir?: string;
+    /** Opt-in forensics: write a redacted evidence bundle per poll failure. */
+    debugFailureBundles?: boolean;
 }
 export interface Coordinator {
     refresh(): Promise<RefreshResult>;

package/dist/runtime/poll.js

@@ -1,7 +1,10 @@
 // Poll coordinator: scheduled and manual refresh share one in-flight poll
 // with a completion-measured cooldown (decisions D3/D4).
-import { pollAll } from "../adapters/index.js";
+import { pollAll, ADAPTER_TIMEOUTS } from "../adapters/index.js";
 import { getAllLatest, upsertQuota } from "../store/quotas.js";
+import { readServiceMetadata } from "../config.js";
+import { writeFailureBundle, providerBin, getCliVersion } from "../diagnostics/bundle.js";
+import { VERSION } from "../version.js";
 import { recordAttempt, getAttempt, } from "../store/attempts.js";
 import { classifyFailure, } from "../diagnostics/failure.js";
 export class ServiceClosing extends Error {
@@ -51,6 +54,8 @@ export function createCoordinator(opts) {
     const ownershipVerify = opts.ownershipVerify;
     const onOwnershipLost = opts.onOwnershipLost ?? (() => process.exit(1));
     const onSettled = opts.onSettled;
+    const dataDir = opts.dataDir;
+    const debugFailureBundles = opts.debugFailureBundles === true;
     let inFlight = null;
     let lastResult = null;
     let lastCompletedPollAt = null;
@@ -171,6 +176,30 @@ export function createCoordinator(opts) {
                     errorDetail: diagnosis.errorDetail,
                 });
                 console.log(`[${completedAt}] [quotacap] [${row.provider}] poll failed (${diagnosis.diagnosticCode}): ${diagnosis.summary}: ${diagnosis.errorDetail}`);
+                if (debugFailureBundles && dataDir) {
+                    try {
+                        const bin = providerBin(row.provider, readServiceMetadata(dataDir)?.providerPaths);
+                        const cliVersion = bin ? await getCliVersion(bin) : null;
+                        const bundleDir = await writeFailureBundle({
+                            dataDir,
+                            provider: row.provider,
+                            attemptedAt,
+                            reason: row.reason,
+                            diagnosticCode: diagnosis.diagnosticCode,
+                            summary: diagnosis.summary,
+                            errorDetail: diagnosis.errorDetail,
+                            attemptDurationMs: new Date(completedAt).getTime() - new Date(attemptedAt).getTime(),
+                            timeoutMs: ADAPTER_TIMEOUTS[row.provider],
+                            quotacapVersion: VERSION,
+                            cliBin: bin,
+                            cliVersion,
+                        });
+                        if (bundleDir) {
+                            console.log(`[${completedAt}] [quotacap] [${row.provider}] failure bundle: ${bundleDir}`);
+                        }
+                    }
+                    catch { }
+                }
             }
         }
         lastResult = result;

package/dist/runtime/service.js

@@ -11,7 +11,7 @@ import { createCoordinator } from "./poll.js";
 import { killAll } from "./spawn.js";
 import { ensureToken } from "./token.js";
 import { openDb, migrate } from "../store/db.js";
-import { autoEnableNewProviders, ensureConfig, getConfigPath, getDbPath, isExperimentalIngestEnabled, readServiceConfig, readServiceMetadata } from "../config.js";
+import { autoEnableNewProviders, ensureConfig, getConfigPath, getDbPath, isExperimentalIngestEnabled, isFailureBundlesEnabled, readServiceConfig, readServiceMetadata } from "../config.js";
 import { buildApp } from "../http/server.js";
 import { detectChannel, refreshUpdateCache } from "./updates.js";
 import { VERSION } from "../version.js";
@@ -183,6 +183,8 @@ export async function startService(opts) {
         coordinator = createCoordinator({
             db,
             enabledProviders: config.enabledProviders,
+            dataDir,
+            debugFailureBundles: isFailureBundlesEnabled(config),
             ownershipVerify: () => claim.verify(),
             // Passive daily update signal: refresh the shared cache on schedule.
             // Background and best-effort — never blocks or fails a poll.

package/dist/version.js

@@ -1,2 +1,2 @@
 // generated by scripts/build-embed.mjs — do not edit
-export const VERSION = "0.0.41";
+export const VERSION = "0.0.43";

package/dist/web/src/App.js

@@ -1,4 +1,4 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useCallback, useEffect, useState } from "react";
 import { createRoot } from "react-dom/client";
 import "./theme.css";

package/dist/web/src/components/AdviceDrawer.js

@@ -1,4 +1,4 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useRef } from "react";
 import { paceBadge, timeLeft } from "./PaceBar.js";
 import { ProviderIcon, providerTint } from "./ProviderIcon.js";

package/dist/web/src/components/OpencodeGoBanner.d.ts

@@ -1,6 +1,6 @@
 import React from "react";
 import type { ProviderView, RuntimeView } from "../state.js";
-export declare const OPENCODE_GO_CONSENT_COPY = "QuotaCap will read the API key OpenCode already stored when you ran `opencode auth login -p opencode-go` (`~/.local/share/opencode/auth.json`, `opencode-go` \u2192 `opencode` fallback). It is read in-memory, read-only once per poll (every 15 minutes by default). It is sent only as `Authorization: Bearer` to `https://opencode.ai/zen/go/v1/usage` to fetch `rolling/weekly/monthly` `percent` + `resetsAt`. It is never used to make chat or model requests, never written or rotated, never stored in the `quotacap` DB, never returned by the API or MCP, and never logged (errors show `[redacted]`). Revoke at `https://opencode.ai/auth` or `opencode providers logout opencode-go` and run `quotacap providers disable opencode-go` to stop polling. If you prefer no file access, set `OPENCODE_API_KEY` instead.";
+export declare const OPENCODE_GO_CONSENT_COPY: string;
 export declare function showOpenCodeGoBanner(runtime: Pick<RuntimeView, "detectedProviders"> | undefined, providers: Array<Pick<ProviderView, "id" | "enabled">>, suppressed: boolean): boolean;
 export declare function OpencodeGoBanner({ onEnable }: {
     onEnable: () => void;

package/dist/web/src/components/OpencodeGoBanner.js

@@ -1,6 +1,13 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect } from "react";
-export const OPENCODE_GO_CONSENT_COPY = "QuotaCap will read the API key OpenCode already stored when you ran `opencode auth login -p opencode-go` (`~/.local/share/opencode/auth.json`, `opencode-go` → `opencode` fallback). It is read in-memory, read-only once per poll (every 15 minutes by default). It is sent only as `Authorization: Bearer` to `https://opencode.ai/zen/go/v1/usage` to fetch `rolling/weekly/monthly` `percent` + `resetsAt`. It is never used to make chat or model requests, never written or rotated, never stored in the `quotacap` DB, never returned by the API or MCP, and never logged (errors show `[redacted]`). Revoke at `https://opencode.ai/auth` or `opencode providers logout opencode-go` and run `quotacap providers disable opencode-go` to stop polling. If you prefer no file access, set `OPENCODE_API_KEY` instead.";
+export const OPENCODE_GO_CONSENT_COPY = [
+    "• What is read: API key OpenCode already stored when you ran `opencode auth login -p opencode-go` (`~/.local/share/opencode/auth.json`, `opencode-go` → `opencode` fallback).",
+    "• Read frequency: in-memory, read-only once per poll (every 15 minutes by default).",
+    "• Request destination: sent only as `Authorization: Bearer` to `https://opencode.ai/zen/go/v1/usage` to fetch `rolling/weekly/monthly` `percent` + `resetsAt`.",
+    "• Never-list: never used to make chat or model requests, never written or rotated, never stored in the `quotacap` DB, never returned by the API or MCP, and never logged (errors show `[redacted]`).",
+    "• Revocation instructions: revoke at `https://opencode.ai/auth` or `opencode providers logout opencode-go` and run `quotacap providers disable opencode-go` to stop polling.",
+    "• Optional environment override: if you prefer no file access, set `OPENCODE_API_KEY` instead.",
+].join("\n");
 export function showOpenCodeGoBanner(runtime, providers, suppressed) {
     const detected = runtime?.detectedProviders?.includes("opencode-go") ?? false;
     const row = providers.find((p) => p.id === "opencode-go");
@@ -32,5 +39,5 @@ export function ConsentModal({ onConfirm, onCancel, busy, }) {
                 padding: "var(--s4) var(--s5)",
                 maxWidth: 560,
                 margin: "var(--s4)",
-            }, children: [_jsx("h2", { id: "opencode-go-consent-title", style: { fontSize: "var(--t-4)", margin: "0 0 var(--s3)" }, children: "Enable OpenCode Go?" }), _jsx("p", { style: { fontSize: "var(--t-2)", color: "var(--ink-soft)", margin: "0 0 var(--s4)" }, children: OPENCODE_GO_CONSENT_COPY }), _jsxs("div", { style: { display: "flex", justifyContent: "flex-end", gap: "var(--s2)" }, children: [_jsx("button", { type: "button", className: "btn btn-quiet", onClick: onCancel, disabled: busy, children: "Cancel" }), _jsx("button", { type: "button", className: "btn btn-primary", onClick: onConfirm, disabled: busy, children: busy ? "Enabling…" : "Enable" })] })] }) }));
+            }, children: [_jsx("h2", { id: "opencode-go-consent-title", style: { fontSize: "var(--t-4)", margin: "0 0 var(--s3)" }, children: "Enable OpenCode Go?" }), _jsx("p", { style: { fontSize: "var(--t-2)", color: "var(--ink-soft)", margin: "0 0 var(--s4)", whiteSpace: "pre-line" }, children: OPENCODE_GO_CONSENT_COPY }), _jsxs("div", { style: { display: "flex", justifyContent: "flex-end", gap: "var(--s2)" }, children: [_jsx("button", { type: "button", className: "btn btn-quiet", onClick: onCancel, disabled: busy, children: "Cancel" }), _jsx("button", { type: "button", className: "btn btn-primary", onClick: onConfirm, disabled: busy, children: busy ? "Enabling…" : "Enable" })] })] }) }));
 }

package/dist/web/src/components/PaceBar.d.ts

@@ -63,10 +63,15 @@ export declare function exclusionDetail(reason: ExclusionReason): string | null;
 export declare function isEstimated(provider: ProviderView): boolean;
 /** Weekday plus 24h clock, e.g. "Thu 21:00". Null when unparseable. */
 export declare function resetClock(resetsAt: string, locale?: string): string | null;
-/** Short weekday in the locked English copy, e.g. "Tue". Mirrors weekdayOf in
- *  src/format/rows.ts, including its pinned en-US locale, so the CLI and the
- *  dashboard word the same sentence identically on any machine. */
-export declare function resetWeekday(iso: string | undefined): string;
+/** Weekday, calendar date and 24h clock, e.g. "Thu Oct 22 23:05". Monthly
+ *  resets sit weeks out, where resetClock's weekday-only reading ("Thu 23:05")
+ *  scans as this coming Thursday. Null when unparseable. */
+export declare function resetDateClock(resetsAt: string, locale?: string): string | null;
+/** Short weekday plus calendar date in the locked English copy, e.g.
+ *  "Tue Sep 15". Mirrors dayOf in src/format/rows.ts, including its pinned
+ *  en-US locale, so the CLI and the dashboard word the same sentence
+ *  identically on any machine. */
+export declare function resetDay(iso: string | undefined): string;
 /** "6d 12h" style time left from server timestamps. Null when unparseable. */
 export declare function timeLeft(resetsAt: string, asOfMs: number): string | null;
 /**

package/dist/web/src/components/PaceBar.js

@@ -1,4 +1,4 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { ageDuration } from "../state.js";
 /**
  * Pace-state badge from the mapping table. Exclusion always wins; a blocked
@@ -112,11 +112,30 @@ export function resetClock(resetsAt, locale) {
     });
     return `${day} ${time}`;
 }
-/** Short weekday in the locked English copy, e.g. "Tue". Mirrors weekdayOf in
- *  src/format/rows.ts, including its pinned en-US locale, so the CLI and the
- *  dashboard word the same sentence identically on any machine. */
-export function resetWeekday(iso) {
-    return new Date(iso ?? "").toLocaleDateString("en-US", { weekday: "short" });
+/** Weekday, calendar date and 24h clock, e.g. "Thu Oct 22 23:05". Monthly
+ *  resets sit weeks out, where resetClock's weekday-only reading ("Thu 23:05")
+ *  scans as this coming Thursday. Null when unparseable. */
+export function resetDateClock(resetsAt, locale) {
+    const ms = Date.parse(resetsAt);
+    if (!Number.isFinite(ms))
+        return null;
+    const when = new Date(ms);
+    const day = when.toLocaleDateString(locale, { weekday: "short" });
+    const date = when.toLocaleDateString(locale, { day: "numeric", month: "short" });
+    const time = when.toLocaleTimeString(locale, {
+        hour: "2-digit",
+        minute: "2-digit",
+        hour12: false,
+    });
+    return `${day} ${date} ${time}`;
+}
+/** Short weekday plus calendar date in the locked English copy, e.g.
+ *  "Tue Sep 15". Mirrors dayOf in src/format/rows.ts, including its pinned
+ *  en-US locale, so the CLI and the dashboard word the same sentence
+ *  identically on any machine. */
+export function resetDay(iso) {
+    const when = new Date(iso ?? "");
+    return `${when.toLocaleDateString("en-US", { weekday: "short" })} ${when.toLocaleDateString("en-US", { day: "numeric", month: "short" })}`;
 }
 /** "6d 12h" style time left from server timestamps. Null when unparseable. */
 export function timeLeft(resetsAt, asOfMs) {
@@ -360,7 +379,7 @@ export function forecastLine(provider) {
     if (!advisory)
         return null;
     if (advisory.bindingWindow === "monthly" && advisory.bindingRemaining <= 0) {
-        return `unused until ${resetWeekday(provider.quota.monthlyResetsAt)}`;
+        return `unused until ${resetDay(provider.quota.monthlyResetsAt)}`;
     }
     if (advisory.bindingWindow === "monthly") {
         return `${Math.round(advisory.bindingRemaining)}% of month left`;