specrails-desktop 2.58.1 → 2.59.1

package/server/dist/modules/missions/runtime/agent-context-resolver.js

@@ -149,7 +149,7 @@ function formatProjectOverview(ref, index, deps) {
         lines.push('resolution: unresolved project');
         return lines.join('\n');
     }
-    lines.push(`project.id: ${project.id}`, `project.name: ${safe(project.name, 180)}`, `project.slug: ${safe(project.slug, 120)}`, `project.path: ${project.path}`, `project.provider: ${safe(project.provider, 80)}`, `project.providers: ${(project.providers ?? [project.provider]).join(', ')}`, `project.runtime: ${context ? 'available' : 'unavailable; do not interpret this as a deleted project'}`, `project.repositories: ${JSON.stringify((0, project_repositories_1.getProjectRepositories)(project).map(repository => ({ id: repository.id, name: repository.name, path: repository.path, isPrimary: repository.isPrimary, kind: repository.kind, available: repository.available })))}`, 'repository.scope: One shared project backlog. Files and Git operations require repositoryId when more than one member exists; find/search can discover across members. Reading context does not grant implementation write access. Historical specs without repositoryIds target only the primary.');
+    lines.push(`project.id: ${project.id}`, `project.name: ${safe(project.name, 180)}`, `project.slug: ${safe(project.slug, 120)}`, `project.path: ${project.path}`, `project.provider: ${safe(project.provider, 80)}`, `project.providers: ${(project.providers ?? [project.provider]).join(', ')}`, `project.runtime: ${context ? 'available' : 'unavailable; do not interpret this as a deleted project'}`, `project.repositories: ${JSON.stringify((0, project_repositories_1.getProjectRepositories)(project).map(repository => ({ id: repository.id, name: repository.name, path: repository.path, workspacePaths: repository.workspacePaths ?? [repository.workspacePath ?? repository.path], isPrimary: repository.isPrimary, kind: repository.kind, available: repository.available })))}`, 'repository.scope: One shared project backlog. Files and Git operations require repositoryId when more than one member exists; find/search can discover across members. Reading context does not grant implementation write access. Historical specs without repositoryIds target only the primary.');
     try {
         const tickets = Object.values((0, ticket_store_1.readStore)(ticketFileFor(project)).tickets);
         const counts = tickets.reduce((acc, ticket) => {

package/server/dist/modules/missions/runtime/agent-operator-prompt.js

@@ -628,6 +628,13 @@ summary later.
   N-1. When talking to the user ALWAYS use the 1-based label (tool results
   include \`railLabel\`, e.g. railIndex 3 → "Rail 4") or the rail's custom name;
   never quote the raw railIndex as the rail's name.
+- Code workspace selection: discover \`workspacePaths\` in the project context. A
+  project folder can contain several code workspaces; tests must run in the
+  workspace being changed. Include \`workspaceSelection\` (repository ID → array
+  of registered workspace paths) in rail-launch cards and direct launch calls to
+  target a subset. Preserve \`repositoryIds\` for affected Git memberships. Do not
+  invent paths or substitute the parent folder. Omission uses every configured
+  workspace for each affected membership.
 - Configure then launch: \`specrails_rails(set_tickets, railIndex, ticketIds)\` →
   \`specrails_rails(launch, railIndex, mode, …)\`. Setting a profile and then
   switching the rail's engine to a provider without profile support
@@ -657,15 +664,15 @@ summary later.
   relaunch strategy even when \`main\` did not have that spec before the PR. If
   asked why a strategy was chosen, verify against active PR contents before
   answering.
-- **"Change something about work already delivered" = a Quick SDD continuation.** When
+- **"Change something about work already delivered" = a delivery continuation.** When
   the user asks for a modification to a delivery that is awaiting their decision
   (any non-terminal card: \`on_review\`, \`pr_draft\`, \`pr_ready\`, \`no_changes\`,
   \`implementation_failed\`), call \`specrails_rails(launch)\` with
   \`revisionOfDeliveryId\` = that card's \`prDeliveryId\` and \`revisionNote\` = what
   they asked for, in their own words. Do NOT tell them to publish, discard or
-  merge first, and do NOT relaunch the ordinary implement mode: a revision
-  always uses Quick SDD: pass \`loopId:'factory:sdd-quick-openspec'\` alongside the delivery
-  target. The server preserves the branch while running Quick SDD. The rail must still carry exactly that delivery's
+  merge first. Respect the user's explicit loop selection, including Implement:
+  pass that loopId alongside the delivery target. Without a preference, use
+  \`loopId:'factory:sdd-quick-openspec'\`. The server preserves the branch. The rail must still carry exactly that delivery's
   specs; a mismatch returns \`invalid_revision_target\`, which means re-check the
   rail's spec assignment rather than retrying blindly.
 - **"Resolve / fix the review comments on this PR" = a FOLLOW-UP launch, never a
@@ -706,9 +713,9 @@ summary later.
   \`dismiss_addendum\` withdraws it. Prefer an addendum + normal launch over a
   \`revisionNote\` when the change should stay attached to the spec for later
   runs; the two combine freely.
-  **Addenda on an existing branch/open PR ALWAYS run Quick SDD**, never Revision.
-  Use \`loopId:'factory:sdd-quick-openspec'\`; the server routes addenda there
-  even if the rail stores a different loop. A same-spec pending delivery is
+  **Respect explicit loop selection for addenda**, including Implement.
+  Recommend Quick SDD when no preference was given; never silently replace
+  Implement with Quick SDD after agreeing to use Implement. A same-spec pending delivery is
   continued without requiring publish/discard first. Keep the exact ticket and
   repository scope; pass the delivery id when known. The runtime assigns a NEW
   run-specific OpenSpec change for the frozen addenda, so NEVER edit
@@ -889,6 +896,8 @@ never as a launch):
   \`null\` means "the rail's / project's default".
 - \`targetPrNumber\` / \`baseBranch\`: only when the user named an existing PR
   or a branch to stack on.
+- \`repositoryIds\`: selected registered repository memberships, consistent with the specs.
+- \`workspaceSelection\`: optional object mapping each selected repository id to a non-empty array of registered workspace paths. Discover paths from project context; never invent them. Omission uses every configured workspace. The card lets the user edit this choice before Play.
 - \`rationale\`: ONE sentence — why this grouping / engine.
 
 Prose around the block: say what you propose in one or two lines and stop —
@@ -916,7 +925,7 @@ investigate and fix. Read runtime_diagnose before recommending a retry.
 function buildOperatorInstructions() {
     return (0, feature_flags_1.isMissionRailCardsEnabled)() ? `${exports.OPERATOR_INSTRUCTIONS}\n${exports.RAIL_LAUNCH_CARD_SECTION}` : exports.OPERATOR_INSTRUCTIONS;
 }
-exports.RAIL_LAUNCH_CARD_SYSTEM_CLAUSE = ' When the user asks to assign, prepare or launch specs on a rail WITHOUT explicitly saying to launch now, do not call specrails_rails launch — emit one fenced rail-launch JSON block per rail (ticketIds, railIndex or newRail, mode, loopId, aiEngine, model, reasoningEffort, profileName, rationale) so the app renders an editable launch card the user plays; never propose a rail whose availability is not free. A message starting with "[Specrails run-failure briefing" is app-posted: answer in ≤ 6 lines with the failure and ONE recommended next action, and never resume, recover, relaunch or discard in that turn.';
+exports.RAIL_LAUNCH_CARD_SYSTEM_CLAUSE = ' When the user asks to assign, prepare or launch specs on a rail WITHOUT explicitly saying to launch now, do not call specrails_rails launch — emit one fenced rail-launch JSON block per rail (ticketIds, railIndex or newRail, mode, loopId, aiEngine, model, reasoningEffort, profileName, repositoryIds, workspaceSelection, rationale) so the app renders an editable launch card the user plays; never propose a rail whose availability is not free. A message starting with "[Specrails run-failure briefing" is app-posted: answer in ≤ 6 lines with the failure and ONE recommended next action, and never resume, recover, relaunch or discard in that turn.';
 /** The per-turn system prompt (flag-aware). */
 function buildOperatorSystemPrompt() {
     return (0, feature_flags_1.isMissionRailCardsEnabled)() ? `${exports.OPERATOR_SYSTEM_PROMPT}${exports.RAIL_LAUNCH_CARD_SYSTEM_CLAUSE}` : exports.OPERATOR_SYSTEM_PROMPT;

package/server/dist/modules/specs/runtime/spec-models.js

@@ -6,20 +6,17 @@ exports.isValidModelForProvider = isValidModelForProvider;
 exports.getProviderDefault = getProviderDefault;
 const providers_1 = require("../../../providers");
 exports.CLAUDE_MODELS = [
-    { value: 'sonnet', label: 'Claude Sonnet' },
-    { value: 'fable', label: 'Claude Fable' },
+    { value: 'sonnet', label: 'Sonnet 5.5' },
+    { value: 'fable', label: 'Fable 5.1' },
     { value: 'opus', label: 'Claude Opus' },
     { value: 'haiku', label: 'Claude Haiku' },
 ];
 exports.CODEX_MODELS = [
+    { value: 'gpt-6.1-sol', label: 'GPT-6.1 Sol' },
     { value: 'gpt-6-astra', label: 'GPT-6 Astra' },
     { value: 'gpt-5.6-sol', label: 'GPT-5.6 Sol' },
     { value: 'gpt-5.6-terra', label: 'GPT-5.6 Terra' },
     { value: 'gpt-5.6-luna', label: 'GPT-5.6 Luna' },
-    { value: 'gpt-5.5', label: 'GPT-5.5' },
-    { value: 'gpt-5.4', label: 'GPT-5.4' },
-    { value: 'gpt-5.4-mini', label: 'GPT-5.4 Mini' },
-    { value: 'gpt-5.3-codex', label: 'GPT-5.3 Codex' },
 ];
 // Mirrors GEMINI_MODELS in server/providers/gemini-adapter.ts.
 exports.GEMINI_MODELS = [
@@ -43,7 +40,7 @@ const PROVIDER_MODELS = {
 };
 exports.PROVIDER_DEFAULT_MODEL = {
     claude: 'sonnet',
-    codex: 'gpt-5.5',
+    codex: 'gpt-6.1-sol',
     gemini: 'gemini-3.5-flash',
     kimi: 'k3',
 };

package/server/dist/modules/subscription-usage/adapters/claude.js

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createClaudeReader = createClaudeReader;
+const node_child_process_1 = require("node:child_process");
+const node_os_1 = require("node:os");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const domain_1 = require("../domain");
+const errors_1 = require("./errors");
+const local_auth_1 = require("./local-auth");
+function readKeychain(service, signal) {
+    return new Promise((resolve, reject) => {
+        let account;
+        try {
+            account = process.env.USER || process.env.USERNAME || (0, node_os_1.userInfo)().username;
+        }
+        catch {
+            account = 'claude-code-user';
+        }
+        if (!/^[a-zA-Z0-9._-]+$/.test(account))
+            account = 'claude-code-user';
+        (0, node_child_process_1.execFile)('/usr/bin/security', ['find-generic-password', '-s', service, '-a', account, '-w'], { timeout: 3000, maxBuffer: 1024 * 1024, signal }, (error, stdout) => {
+            if (!error)
+                resolve(stdout);
+            else if (error.code === 44)
+                resolve(null);
+            else
+                reject(new errors_1.UsageError('credentials-unreadable'));
+        });
+    });
+}
+function createClaudeReader(options = {}) {
+    const configured = options.configDir ?? process.env.CLAUDE_CONFIG_DIR;
+    const configDir = configured ?? node_path_1.default.join((0, node_os_1.homedir)(), '.claude');
+    async function credentials(signal) {
+        if (!node_path_1.default.isAbsolute(configDir))
+            throw new errors_1.UsageError('unsupported-platform');
+        let keychainFailure = false;
+        if ((options.platform ?? process.platform) === 'darwin') {
+            const aliases = configured ? [configDir] : [];
+            if (configured) {
+                try {
+                    const canonical = await (0, promises_1.realpath)(configDir);
+                    if (canonical !== configDir)
+                        aliases.push(canonical);
+                }
+                catch { /* use the exact resolved context */ }
+            }
+            const services = configured ? aliases.map(dir => `Claude Code-credentials-${(0, local_auth_1.fingerprint)(dir.normalize('NFC')).slice(0, 8)}`) : ['Claude Code-credentials'];
+            for (const service of services) {
+                try {
+                    const raw = await (options.keychain ?? readKeychain)(service, signal);
+                    if (raw)
+                        return raw;
+                }
+                catch {
+                    keychainFailure = true;
+                    break;
+                }
+            }
+        }
+        const file = await (options.readFile ?? local_auth_1.readAuthFile)(node_path_1.default.join(configDir, '.credentials.json'));
+        if (file)
+            return file;
+        if (keychainFailure)
+            throw new errors_1.UsageError('credentials-unreadable');
+        return null;
+    }
+    return {
+        async context(signal) { return (0, local_auth_1.fingerprint)(`${configDir}:${await credentials(signal) ?? 'none'}`); },
+        async read(signal) {
+            const raw = await credentials(signal);
+            if (!raw)
+                return { availability: 'signed-out', windows: [], plan: null, source: null };
+            let data;
+            try {
+                data = (0, domain_1.record)(JSON.parse(raw));
+            }
+            catch {
+                throw new errors_1.UsageError('credentials-unreadable');
+            }
+            const oauth = (0, domain_1.record)(data.claudeAiOauth);
+            if (typeof oauth.accessToken !== 'string' || !oauth.accessToken)
+                return { availability: 'unsupported-auth', windows: [], plan: null, source: null };
+            async function query(route) {
+                const response = await (options.request ?? fetch)(`https://api.anthropic.com/api/oauth/${route}`, {
+                    headers: { Authorization: `Bearer ${oauth.accessToken}`, 'anthropic-beta': 'oauth-2025-04-20', 'User-Agent': 'claude-code/2.1.0' },
+                    signal: AbortSignal.any([signal, AbortSignal.timeout(10_000)]), redirect: 'error',
+                });
+                if (!response.ok) {
+                    await response.body?.cancel().catch(() => { });
+                    if (response.status === 401)
+                        throw new errors_1.UsageError('signed-out');
+                    if (response.status === 403)
+                        throw new errors_1.UsageError('permission-denied');
+                    if (response.status === 429) {
+                        const header = response.headers.get('retry-after');
+                        const seconds = header !== null && header.trim() !== '' ? Number(header) : NaN;
+                        const date = header ? Date.parse(header) : NaN;
+                        const retry = Number.isFinite(seconds) ? seconds * 1000 : Number.isFinite(date) ? date - Date.now() : 60_000;
+                        throw new errors_1.UsageError('rate-limited', true, Math.max(30_000, Math.min(24 * 60 * 60_000, retry)));
+                    }
+                    throw new errors_1.UsageError('provider-error', response.status >= 500);
+                }
+                return (0, local_auth_1.limitedJson)(response);
+            }
+            const payload = await query('usage'), windows = (0, domain_1.normalizeClaude)(payload);
+            let plan = (0, domain_1.claudePlan)(oauth.subscriptionType) ?? (0, domain_1.claudePlan)(oauth.rateLimitTier);
+            const candidate = (0, domain_1.normalizeClaudeSpend)(payload, 'enterprise', (options.now ?? Date.now)());
+            if (!plan && candidate) {
+                const profile = (0, domain_1.record)(await query('profile')), organization = (0, domain_1.record)(profile.organization);
+                plan = (0, domain_1.claudePlan)(organization.organization_type) ?? (0, domain_1.claudePlan)(organization.rate_limit_tier);
+            }
+            const spend = plan === 'enterprise' ? candidate : null;
+            if (!windows.length && !spend)
+                throw new errors_1.UsageError('usage-unavailable');
+            return { availability: 'available', windows: spend ? [] : windows, spend, plan, source: 'oauth' };
+        },
+    };
+}

package/server/dist/modules/subscription-usage/adapters/codex.js

@@ -0,0 +1,164 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCodexReader = createCodexReader;
+const node_string_decoder_1 = require("node:string_decoder");
+const node_os_1 = require("node:os");
+const node_path_1 = __importDefault(require("node:path"));
+const win_spawn_1 = require("../../../util/win-spawn");
+const domain_1 = require("../domain");
+const errors_1 = require("./errors");
+const local_auth_1 = require("./local-auth");
+async function stopProbe(child) {
+    if (child.exitCode !== null || child.signalCode !== null)
+        return;
+    await new Promise(resolve => {
+        const done = () => { clearTimeout(timer); child.off('close', done); resolve(); };
+        const timer = setTimeout(() => {
+            if (child.pid)
+                (0, win_spawn_1.treeKillSafe)(child.pid, 'SIGKILL', () => done());
+            else {
+                child.kill('SIGKILL');
+                done();
+            }
+        }, 500);
+        child.once('close', done);
+        child.stdin?.end();
+        if (child.pid)
+            (0, win_spawn_1.treeKillSafe)(child.pid, 'SIGTERM');
+        else
+            child.kill('SIGTERM');
+    });
+}
+function createCodexReader(options = {}) {
+    const home = options.home ?? process.env.CODEX_HOME ?? node_path_1.default.join((0, node_os_1.homedir)(), '.codex');
+    return {
+        async context() {
+            if (!node_path_1.default.isAbsolute(home))
+                throw new errors_1.UsageError('unsupported-platform');
+            return (0, local_auth_1.fingerprint)(`${home}:${await (options.readFile ?? local_auth_1.readAuthFile)(node_path_1.default.join(home, 'auth.json')) ?? 'keychain-or-none'}`);
+        },
+        read(signal) {
+            if (signal.aborted)
+                return Promise.reject(new errors_1.UsageError('aborted'));
+            return new Promise((resolve, reject) => {
+                let child;
+                try {
+                    child = options.spawn ? options.spawn() : (0, win_spawn_1.spawnCli)('codex', ['app-server', '--listen', 'stdio://'], {
+                        cwd: (0, node_os_1.homedir)(), env: { ...process.env, CODEX_HOME: home }, stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true,
+                    });
+                }
+                catch {
+                    reject(new errors_1.UsageError('unsupported-cli'));
+                    return;
+                }
+                let buffer = '', finished = false, plan = null, identity;
+                const decoder = new node_string_decoder_1.StringDecoder('utf8');
+                const timer = setTimeout(() => finish(new errors_1.UsageError('probe-timeout', true)), options.timeoutMs ?? 25_000);
+                function cleanup() {
+                    clearTimeout(timer);
+                    signal.removeEventListener('abort', abort);
+                    child.stdout?.off('data', data);
+                    child.stderr?.off('data', drain);
+                    child.off('error', failure);
+                    child.off('close', closed);
+                    child.stdin?.off('error', failure);
+                }
+                function finish(error, result) {
+                    if (finished)
+                        return;
+                    finished = true;
+                    cleanup();
+                    // Continue draining without retaining provider diagnostics during termination.
+                    child.stdout?.resume();
+                    child.stderr?.resume();
+                    void (options.stop ?? stopProbe)(child).then(() => error ? reject(error) : resolve(result), () => reject(new errors_1.UsageError('cleanup-failed', true)));
+                }
+                const abort = () => finish(new errors_1.UsageError('aborted'));
+                const failure = () => finish(new errors_1.UsageError('unsupported-cli'));
+                const closed = () => finish(new errors_1.UsageError('probe-exited', true));
+                const drain = () => { };
+                function send(id, method, params = {}) {
+                    try {
+                        child.stdin?.write(`${JSON.stringify({ id, method, params })}\n`);
+                    }
+                    catch {
+                        failure();
+                    }
+                }
+                function data(chunk) {
+                    buffer += decoder.write(chunk);
+                    if (Buffer.byteLength(buffer) > 1024 * 1024) {
+                        finish(new errors_1.UsageError('invalid-response', true));
+                        return;
+                    }
+                    let newline;
+                    while (!finished && (newline = buffer.indexOf('\n')) >= 0) {
+                        const line = buffer.slice(0, newline);
+                        buffer = buffer.slice(newline + 1);
+                        let message;
+                        try {
+                            message = (0, domain_1.record)(JSON.parse(line));
+                        }
+                        catch {
+                            finish(new errors_1.UsageError('invalid-response', true));
+                            return;
+                        }
+                        if (typeof message.id !== 'number')
+                            continue;
+                        if (message.error) {
+                            const code = (0, domain_1.record)(message.error).code;
+                            finish(new errors_1.UsageError(code === -32601 ? 'unsupported-cli' : 'provider-error', code !== -32601));
+                            return;
+                        }
+                        if (message.id === 1) {
+                            try {
+                                child.stdin?.write(`${JSON.stringify({ method: 'initialized', params: {} })}\n`);
+                            }
+                            catch {
+                                failure();
+                                return;
+                            }
+                            send(2, 'account/read', { refreshToken: false });
+                        }
+                        else if (message.id === 2) {
+                            const account = (0, domain_1.record)((0, domain_1.record)(message.result).account);
+                            if (!Object.keys(account).length) {
+                                finish(undefined, { availability: 'signed-out', windows: [], plan: null, source: null });
+                                return;
+                            }
+                            if (account.type !== 'chatgpt') {
+                                finish(undefined, { availability: 'unsupported-auth', windows: [], plan: null, source: null });
+                                return;
+                            }
+                            plan = typeof account.planType === 'string' ? account.planType.slice(0, 80) : null;
+                            // Never export an email; only an internal fingerprint for identity checks.
+                            if (typeof account.email === 'string')
+                                identity = (0, local_auth_1.fingerprint)(account.email);
+                            send(3, 'account/rateLimits/read');
+                        }
+                        else if (message.id === 3) {
+                            const payload = (0, domain_1.record)(message.result), windows = (0, domain_1.normalizeCodex)(payload);
+                            if (typeof payload.accountId === 'string')
+                                identity = (0, local_auth_1.fingerprint)(payload.accountId);
+                            if (!windows.length) {
+                                finish(new errors_1.UsageError('usage-unavailable'));
+                                return;
+                            }
+                            finish(undefined, { availability: 'available', windows, plan, source: 'app-server', identity });
+                        }
+                    }
+                }
+                signal.addEventListener('abort', abort, { once: true });
+                child.on('error', failure);
+                child.on('close', closed);
+                child.stdin?.on('error', failure);
+                child.stdout?.on('data', data);
+                child.stderr?.on('data', drain);
+                send(1, 'initialize', { clientInfo: { name: 'specrails-subscription-usage', title: 'Specrails', version: '1.0.0' } });
+            });
+        },
+    };
+}

package/server/dist/modules/subscription-usage/adapters/errors.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UsageError = void 0;
+class UsageError extends Error {
+    code;
+    retryable;
+    retryMs;
+    constructor(code, retryable = false, retryMs) {
+        super(code);
+        this.code = code;
+        this.retryable = retryable;
+        this.retryMs = retryMs;
+    }
+}
+exports.UsageError = UsageError;

package/server/dist/modules/subscription-usage/adapters/http.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerUsageRoutes = registerUsageRoutes;
+const domain_1 = require("../domain");
+function registerUsageRoutes(router, service) {
+    router.get('/subscription-usage', (_req, res) => res.json(service.snapshot()));
+    router.post('/subscription-usage/refresh', (req, res) => {
+        const body = req.body ?? {};
+        if (typeof body !== 'object' || body === null || Array.isArray(body) || Object.keys(body).some(key => key !== 'providerId' && key !== 'automatic')) {
+            res.status(400).json({ error: 'Invalid usage refresh request' });
+            return;
+        }
+        const { providerId, automatic } = body;
+        if ((providerId !== undefined && !domain_1.USAGE_PROVIDERS.includes(providerId)) || (automatic !== undefined && typeof automatic !== 'boolean')) {
+            res.status(400).json({ error: 'Invalid usage refresh request' });
+            return;
+        }
+        res.status(202).json(service.refresh(providerId, automatic === true));
+    });
+}

package/server/dist/modules/subscription-usage/adapters/local-auth.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fingerprint = void 0;
+exports.readAuthFile = readAuthFile;
+exports.limitedJson = limitedJson;
+const promises_1 = require("node:fs/promises");
+const node_crypto_1 = require("node:crypto");
+const errors_1 = require("./errors");
+const fingerprint = (value) => (0, node_crypto_1.createHash)('sha256').update(value).digest('hex');
+exports.fingerprint = fingerprint;
+/** Bounded read; never expose auth bytes or paths in errors. */
+async function readAuthFile(file) {
+    let handle;
+    try {
+        handle = await (0, promises_1.open)(file, 'r');
+        const stat = await handle.stat();
+        if (!stat.isFile() || stat.size > 1024 * 1024)
+            throw new errors_1.UsageError('credentials-unreadable');
+        const buffer = Buffer.alloc(1024 * 1024 + 1);
+        const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+        if (bytesRead > 1024 * 1024)
+            throw new errors_1.UsageError('credentials-unreadable');
+        return buffer.toString('utf8', 0, bytesRead);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw new errors_1.UsageError('credentials-unreadable');
+    }
+    finally {
+        await handle?.close();
+    }
+}
+async function limitedJson(response) {
+    const reader = response.body?.getReader();
+    if (!reader)
+        throw new errors_1.UsageError('invalid-response', true);
+    let size = 0;
+    const chunks = [];
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            size += value.length;
+            if (size > 1024 * 1024)
+                throw new errors_1.UsageError('invalid-response', true);
+            chunks.push(value);
+        }
+        try {
+            return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+        }
+        catch {
+            throw new errors_1.UsageError('invalid-response', true);
+        }
+    }
+    finally {
+        await reader.cancel().catch(() => { });
+        reader.releaseLock();
+    }
+}

package/server/dist/modules/subscription-usage/application.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withFreshness = withFreshness;
+exports.backoff = backoff;
+function withFreshness(row, now) {
+    if (!row.observedAt)
+        return { ...row, freshness: 'unknown' };
+    const expired = now - Date.parse(row.observedAt) >= 300_000 || row.windows.some(w => w.resetsAt && Date.parse(w.resetsAt) <= now)
+        || !!row.spend?.resetsAt && Date.parse(row.spend.resetsAt) <= now;
+    return { ...row, freshness: expired || row.refreshState === 'error' ? 'stale' : 'fresh' };
+}
+function backoff(failures) { return Math.min(300_000, 30_000 * 2 ** Math.min(4, Math.max(0, failures - 1))); }

package/server/dist/modules/subscription-usage/domain.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.duration = exports.percentage = exports.record = exports.USAGE_PROVIDERS = void 0;
+exports.timestamp = timestamp;
+exports.windowLabel = windowLabel;
+exports.normalizeClaude = normalizeClaude;
+exports.claudePlan = claudePlan;
+exports.hasClaudeWindows = hasClaudeWindows;
+exports.normalizeClaudeSpend = normalizeClaudeSpend;
+exports.normalizeCodex = normalizeCodex;
+exports.initialUsage = initialUsage;
+exports.USAGE_PROVIDERS = ['claude', 'codex'];
+const record = (value) => value !== null && typeof value === 'object' && !Array.isArray(value) ? value : {};
+exports.record = record;
+const percentage = (value) => typeof value === 'number' && Number.isFinite(value) && value >= 0 && value <= 100 ? value : null;
+exports.percentage = percentage;
+const duration = (value) => typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : null;
+exports.duration = duration;
+function timestamp(value, seconds = false) {
+    const time = typeof value === 'number' && Number.isFinite(value) ? value * (seconds ? 1000 : 1) : typeof value === 'string' ? Date.parse(value) : NaN;
+    return Number.isFinite(time) && time > 0 && time <= 8.64e15 ? new Date(time).toISOString() : null;
+}
+function windowLabel(minutes) {
+    return minutes === 300 ? 'session' : minutes === 10080 ? 'weekly' : minutes === 43200 ? 'monthly' : 'window';
+}
+function normalizeClaude(payload) {
+    const data = (0, exports.record)(payload);
+    const windows = [];
+    for (const [key, raw] of Object.entries(data)) {
+        if (!/^(five_hour|seven_day(?:_[a-z0-9_]+)?|fable_(weekly|seven_day))$/.test(key) || raw === null)
+            continue;
+        const value = (0, exports.record)(raw);
+        if (!['utilization', 'used_percentage', 'resets_at'].some(field => Object.hasOwn(value, field)))
+            continue;
+        const minutes = key === 'five_hour' ? 300 : 10080;
+        const model = key.startsWith('seven_day_') ? key.slice(10) : key.startsWith('fable_') ? 'fable' : null;
+        windows.push({ id: key, label: windowLabel(minutes), scope: model ? 'model' : 'account', model,
+            usedPercent: (0, exports.percentage)(value.utilization ?? value.used_percentage), durationMinutes: minutes, resetsAt: timestamp(value.resets_at, typeof value.resets_at === 'number') });
+    }
+    if (Array.isArray(data.limits))
+        for (const raw of data.limits.slice(0, 32)) {
+            const value = (0, exports.record)(raw), model = (0, exports.record)((0, exports.record)(value.scope).model).display_name;
+            if (value.kind !== 'weekly_scoped' || typeof model !== 'string' || !model.trim())
+                continue;
+            const name = model.trim().slice(0, 80);
+            if (windows.some(w => w.model?.toLowerCase() === name.toLowerCase()))
+                continue;
+            windows.push({ id: `model:${name}`, label: 'weekly', scope: 'model', model: name,
+                usedPercent: (0, exports.percentage)(value.percent), durationMinutes: 10080, resetsAt: timestamp(value.resets_at, true) });
+        }
+    return windows;
+}
+function claudePlan(value) {
+    if (typeof value !== 'string')
+        return null;
+    const words = value.trim().toLowerCase().split(/[^a-z0-9]+/);
+    return ['enterprise', 'team', 'max', 'pro', 'ultra', 'free'].find(plan => words.includes(plan)) ?? null;
+}
+function hasClaudeWindows(windows) {
+    return windows.some(window => window.usedPercent !== null || window.resetsAt !== null);
+}
+function normalizeClaudeSpend(payload, plan, now) {
+    if (plan !== 'enterprise' || hasClaudeWindows(normalizeClaude(payload)))
+        return null;
+    const extra = (0, exports.record)((0, exports.record)(payload).extra_usage);
+    const amount = (value) => typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : null;
+    const used = amount(extra.used_credits), limit = amount(extra.monthly_limit);
+    if (used === null && limit === null)
+        return null;
+    const currency = extra.currency == null ? 'USD' : typeof extra.currency === 'string' ? extra.currency.trim().toUpperCase() : '';
+    if (!/^[A-Z]{3}$/.test(currency))
+        return null;
+    // OAuth spend is in currency minor units, including fractional minor units.
+    const exponent = new Intl.NumberFormat('en', { style: 'currency', currency }).resolvedOptions().maximumFractionDigits ?? 2;
+    const divisor = 10 ** exponent;
+    const usedAmount = used === null ? null : used / divisor, limitAmount = limit === null ? null : limit / divisor;
+    const limitStatus = limit !== null ? 'limited' : extra.monthly_limit === null && extra.is_enabled === true ? 'unlimited' : 'unknown';
+    const ratio = used !== null && limit !== null && limit > 0 ? used / limit * 100 : null;
+    const usedPercent = limitStatus === 'limited' ? amount(extra.utilization) ?? (ratio !== null && Number.isFinite(ratio) ? ratio : null) : null;
+    const date = new Date(now);
+    return { kind: 'enterprise-on-demand', usedAmount, limitAmount, limitStatus, currency, usedPercent,
+        resetsAt: timestamp(extra.resets_at, typeof extra.resets_at === 'number') ?? new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth() + 1, 1)).toISOString() };
+}
+function normalizeCodex(payload) {
+    const data = (0, exports.record)(payload), groups = (0, exports.record)(data.rateLimitsByLimitId);
+    const entries = Object.keys(groups).length ? Object.entries(groups) : [['codex', data.rateLimits]];
+    const windows = [];
+    for (const [group, raw] of entries.slice(0, 32)) {
+        const bucket = (0, exports.record)(raw);
+        for (const slot of ['primary', 'secondary']) {
+            if (!bucket[slot] || typeof bucket[slot] !== 'object')
+                continue;
+            const value = (0, exports.record)(bucket[slot]), minutes = (0, exports.duration)(value.windowDurationMins);
+            windows.push({ id: `${group}:${slot}`, label: windowLabel(minutes), scope: group === 'codex' ? 'account' : 'model',
+                model: group === 'codex' ? null : (typeof bucket.limitName === 'string' ? bucket.limitName : group).slice(0, 80),
+                usedPercent: (0, exports.percentage)(value.usedPercent), durationMinutes: minutes, resetsAt: timestamp(value.resetsAt, true) });
+        }
+    }
+    return windows;
+}
+function initialUsage(providerId, generation) {
+    return { providerId, installed: null, generation, availability: 'unavailable', refreshState: 'idle', freshness: 'unknown', plan: null,
+        windows: [], spend: null, source: null, observedAt: null, attemptedAt: null, retryAt: null, issue: null };
+}

package/server/dist/modules/subscription-usage/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/server/dist/modules/subscription-usage/ports.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/server/dist/modules/subscription-usage/runtime/composition.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDesktopUsageService = createDesktopUsageService;
+const provider_detection_1 = require("../../../provider-detection");
+const claude_1 = require("../adapters/claude");
+const codex_1 = require("../adapters/codex");
+const usage_service_1 = require("./usage-service");
+function createDesktopUsageService() {
+    return (0, usage_service_1.createUsageService)({
+        installed: async (id) => {
+            const provider = (await (0, provider_detection_1.getDetectionSnapshot)()).providers[id];
+            return !!provider?.installed;
+        },
+        eligible: async (id) => {
+            const provider = (await (0, provider_detection_1.getDetectionSnapshot)()).providers[id];
+            return !!provider?.executable && provider.meetsMinimum !== false && !provider.vetoed;
+        },
+        readers: { claude: (0, claude_1.createClaudeReader)(), codex: (0, codex_1.createCodexReader)() },
+    });
+}