subconscious-cli 7.0.0 → 8.0.0

package/bin/agent-spawn.js

@@ -3,7 +3,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { RUNBOOK_DIR } from './agent-data.js';
 import { modelIds } from './launch-values.js';
-import { visionModelList } from './model-capabilities.js';
+import { visionModelListFromMetadata } from './model-capabilities.js';
 
 /** Resolve a script inside the agent's own runbook directory. */
 export function runbookScriptPath(agent, relativeScript) {
@@ -95,7 +95,7 @@ export function scriptEnv(env, { strict = true } = {}) {
   return {
     ...env,
     ...(ids === undefined ? {} : { SUBC_MODEL_IDS: ids }),
-    SUBC_VISION_MODELS: visionModelList(),
+    SUBC_VISION_MODELS: visionModelListFromMetadata(env.SUBC_MODEL_METADATA),
   };
 }
 

package/bin/agents.js

@@ -327,6 +327,7 @@ export function runbookEnv(
   profile,
   agent,
   models = PACKAGED_MODELS,
+  entries = [],
 ) {
   const ctx = buildContext(apiKey, model, profile);
   const extraDirs = [binDir, ...candidateBinDirs()].filter(Boolean);
@@ -343,6 +344,7 @@ export function runbookEnv(
       ...(keyName ? { [keyName]: apiKey } : {}),
       MODEL: model,
       SUBCONSCIOUS_MODELS: models.join('\n'),
+      SUBC_MODEL_METADATA: JSON.stringify(entries),
       ...(claude
         ? {
             SUBC_CLAUDE_SETTINGS: JSON.stringify(
@@ -378,7 +380,11 @@ async function resolvedModelsForLaunch(profile, apiKey, selectedModel) {
 }
 
 export function selectLaunchModel(requestedModel, modelSource, catalog) {
-  const first = catalog.models[0] || requestedModel || DEFAULTS.model;
+  const first =
+    catalog.defaultModels?.[0] ||
+    catalog.models[0] ||
+    requestedModel ||
+    DEFAULTS.model;
   if (modelSource === 'catalog' || !requestedModel) {
     return first;
   }
@@ -427,7 +433,15 @@ async function runRunbookSetup(agent, argv, profile) {
   // Setup scripts read no strict-choice setting; only the model list matters.
   const env = resolveInputs(
     agent,
-    runbookEnv(apiKey, model, undefined, profile, agent, catalog.models),
+    runbookEnv(
+      apiKey,
+      model,
+      undefined,
+      profile,
+      agent,
+      catalog.defaultModels,
+      catalog.entries,
+    ),
     {},
     { strict: false },
   );
@@ -542,7 +556,15 @@ async function launchAgent(agent, argv, profile, headless) {
   (headless ? console.error : console.log)(
     `  ${c.dim}Launching ${c.reset}${c.bold}${agent.name}${c.reset} ${c.dim}on Subconscious ${c.reset}${c.dim}(${model})${c.reset}\n`,
   );
-  const env = runbookEnv(apiKey, model, binDir, profile, agent, catalog.models);
+  const env = runbookEnv(
+    apiKey,
+    model,
+    binDir,
+    profile,
+    agent,
+    catalog.defaultModels,
+    catalog.entries,
+  );
   // The headless endpoint is the one endpoint for every harness, Claude too.
   const launchEnv = headless ? { ...env, CLAUDE_GATEWAY_URL: '' } : env;
   const plan = launchPlan(agent, { env: launchEnv, ...headlessParts(rest) });

package/bin/cli.js

@@ -542,6 +542,7 @@ async function main() {
     });
     modelsCommand(catalog.models, {
       selectedModel,
+      entries: catalog.entries,
       error: catalog.error,
       source: catalog.source,
       hasApiKey: Boolean(auth?.key),

package/bin/model-capabilities.js

@@ -1,8 +1,16 @@
 import { MODEL_CAPABILITIES } from './agent-data.js';
 
-// The models endpoint supplies IDs, not modality metadata, so capabilities
-// are listed by exact model ID: similarly named models inherit nothing.
-export function modelSupportsVision(modelId) {
+// Capabilities are listed by exact model ID: similarly named models inherit
+// nothing. The canonical catalog's per-model modality metadata is preferred
+// when a launch carries it; the packaged map is the offline fallback.
+export function modelSupportsVision(modelId, entries = []) {
+  const entry = entries.find((candidate) => candidate?.id === modelId);
+  if (entry?.modalities) {
+    const input = Array.isArray(entry.modalities.input)
+      ? entry.modalities.input
+      : [];
+    return input.includes('image');
+  }
   return (
     Object.hasOwn(MODEL_CAPABILITIES, modelId) &&
     MODEL_CAPABILITIES[modelId].vision === true
@@ -10,6 +18,38 @@ export function modelSupportsVision(modelId) {
 }
 
 /** Vision model IDs, newline-separated, for the runbooks' shell lookup. */
-export function visionModelList() {
-  return Object.keys(MODEL_CAPABILITIES).filter(modelSupportsVision).join('\n');
+export function visionModelList(entries = []) {
+  const ids = entries.length
+    ? entries
+        .map((entry) => entry.id)
+        .filter((id) => modelSupportsVision(id, entries))
+    : Object.keys(MODEL_CAPABILITIES).filter((id) =>
+        modelSupportsVision(id, entries),
+      );
+  return ids.join('\n');
+}
+
+/**
+ * Canonical catalog entries from the launch env's SUBC_MODEL_METADATA (a
+ * JSON array), or an empty list when discovery did not run, was skipped,
+ * or wrote malformed JSON.
+ */
+export function catalogEntriesFromMetadata(metadataJson) {
+  if (typeof metadataJson !== 'string' || !metadataJson.trim()) return [];
+  try {
+    const entries = JSON.parse(metadataJson);
+    return Array.isArray(entries) ? entries : [];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * The vision list for a runbook script, from the launch env's catalog
+ * metadata with the packaged map as the fallback when discovery did not
+ * run or failed.
+ */
+export function visionModelListFromMetadata(metadataJson) {
+  const entries = catalogEntriesFromMetadata(metadataJson);
+  return entries.length ? visionModelList(entries) : visionModelList();
 }

package/bin/models.js

@@ -1,23 +1,24 @@
 /**
  * Resolve the model catalog exposed by an OpenAI-compatible gateway.
  *
- * When a profile (or agent) API key is present, prefer the key-scoped
- * /v1/models/available list. If that request fails, fall back to the public
- * /v1/models fleet catalog. Launches keep working with the packaged registry
- * when the gateway is offline or returns nothing usable.
+ * A key-scoped GET /v1/models is the canonical source: the gateway filters
+ * it by the key's model access and describes each model (lifecycle, limits,
+ * modalities, capabilities). Older gateways without the canonical catalog
+ * answer with a minimal list, which still names the fleet. Launches keep
+ * working with the packaged registry when the gateway is offline or returns
+ * nothing usable.
  */
 
 import { proxyAwareFetch } from './network.js';
 
 const MODEL_ID_PATTERN = /^[-A-Za-z0-9._:/+]+$/;
 export const DEFAULT_MODEL_FETCH_TIMEOUT_MS = 3000;
-export const AVAILABLE_MODELS_PATH = '/v1/models/available';
 export const PUBLIC_MODELS_PATH = '/v1/models';
 export const PUBLIC_CATALOG_FALLBACK_MESSAGE =
   'Provisioned catalog unavailable; showing the public model list.';
 
 export function isLiveModelSource(source) {
-  return source === 'available' || source === 'public';
+  return source === 'catalog' || source === 'public';
 }
 
 export function isAbortError(error) {
@@ -60,6 +61,34 @@ export function normalizeModelIds(modelIds = [], selectedModel) {
   return models;
 }
 
+/**
+ * Rich entry fields from a canonical /v1/models response: lifecycle
+ * (status, deprecation_date, replacement), limits, modalities, and
+ * capabilities. Minimal legacy responses produce entries that carry only
+ * the id; every optional field is absent, never guessed.
+ */
+export function parseCatalogEntries(data = []) {
+  const entries = [];
+  for (const model of data) {
+    if (model == null || typeof model !== 'object') continue;
+    const id = typeof model.id === 'string' ? model.id.trim() : '';
+    if (!id || !MODEL_ID_PATTERN.test(id)) continue;
+    entries.push({
+      id,
+      lifecycle: model.lifecycle ?? null,
+      limits: model.limits ?? null,
+      modalities: model.modalities ?? null,
+      capabilities: model.capabilities ?? null,
+    });
+  }
+  return entries;
+}
+
+/** True when the response is the canonical catalog, not a minimal list. */
+function isCanonicalResponse(data = []) {
+  return data.some((model) => model?.schema_version === '1');
+}
+
 function gatewayOrigin(baseUrl) {
   if (!baseUrl?.trim()) throw new Error('Gateway URL is not configured');
   return baseUrl.trim().replace(/\/+$/, '');
@@ -70,12 +99,12 @@ function modelsEndpoint(baseUrl, path) {
   return `${gatewayOrigin(baseUrl)}${normalizedPath}`;
 }
 
-export async function fetchGatewayModels({
+async function fetchModelsPayload({
   baseUrl,
   apiKey,
-  path = PUBLIC_MODELS_PATH,
-  fetchImpl = proxyAwareFetch,
-  timeoutMs = DEFAULT_MODEL_FETCH_TIMEOUT_MS,
+  path,
+  fetchImpl,
+  timeoutMs,
   signal,
 }) {
   if (typeof fetchImpl !== 'function') {
@@ -125,7 +154,7 @@ export async function fetchGatewayModels({
         throw new Error('Model discovery returned an invalid response');
       }
 
-      return normalizeModelIds(payload.data.map((model) => model?.id));
+      return payload.data;
     };
     return await Promise.race([discover(), aborted]);
   } catch (error) {
@@ -140,16 +169,35 @@ export async function fetchGatewayModels({
   }
 }
 
-async function fetchPublicModels({ baseUrl, fetchImpl, timeoutMs, signal }) {
-  const models = await fetchGatewayModels({
+/**
+ * Fetch one models listing. Returns the id list, the parsed catalog
+ * entries, and whether the gateway answered with the canonical catalog.
+ */
+export async function fetchGatewayCatalog({
+  baseUrl,
+  apiKey,
+  path = PUBLIC_MODELS_PATH,
+  fetchImpl = proxyAwareFetch,
+  timeoutMs = DEFAULT_MODEL_FETCH_TIMEOUT_MS,
+  signal,
+}) {
+  const data = await fetchModelsPayload({
     baseUrl,
-    path: PUBLIC_MODELS_PATH,
+    apiKey,
+    path,
     fetchImpl,
     timeoutMs,
     signal,
   });
+  const entries = parseCatalogEntries(data);
+  const models = normalizeModelIds(entries.map((entry) => entry.id));
   if (!models.length)
     throw new Error('Model discovery returned no usable model IDs');
+  return { models, entries, canonical: isCanonicalResponse(data) };
+}
+
+export async function fetchGatewayModels(args) {
+  const { models } = await fetchGatewayCatalog(args);
   return models;
 }
 
@@ -159,14 +207,33 @@ function packagedCatalog(selectedModel, fallbackModels, error) {
       [selectedModel, ...fallbackModels],
       selectedModel,
     ),
+    defaultModels: normalizeModelIds(
+      [selectedModel, ...fallbackModels],
+      selectedModel,
+    ),
+    entries: [],
     source: 'packaged',
     error,
   };
 }
 
-function liveCatalog(models, selectedModel, source) {
+/**
+ * Assemble the catalog views. `models` is everything the caller can invoke,
+ * deprecated models included. `defaultModels` drops models the gateway
+ * marked deprecated or retired, so new sessions pick a current model while
+ * existing configurations that name a deprecated model keep working.
+ */
+function liveCatalog(models, selectedModel, source, entries = []) {
+  const normalized = normalizeModelIds(models, selectedModel);
+  const entryById = new Map(entries.map((entry) => [entry.id, entry]));
+  const defaults = normalized.filter((id) => {
+    const status = entryById.get(id)?.lifecycle?.status;
+    return status !== 'deprecated' && status !== 'retired';
+  });
   return {
-    models: normalizeModelIds(models, selectedModel),
+    models: normalized,
+    defaultModels: defaults.length ? defaults : normalized,
+    entries,
     source,
     error: null,
   };
@@ -188,6 +255,8 @@ export async function resolveModelCatalog({
   if (pinned?.length) {
     return {
       models: normalizeModelIds(pinned, selectedModel),
+      defaultModels: normalizeModelIds(pinned, selectedModel),
+      entries: [],
       source: 'pinned',
       error: null,
     };
@@ -196,41 +265,60 @@ export async function resolveModelCatalog({
   const key = apiKey?.trim() || '';
 
   if (key) {
+    let catalogError;
     try {
-      const discovered = await fetchGatewayModels({
+      // The canonical catalog is key-scoped and access-filtered by the
+      // gateway, so no second request is needed when it answers.
+      const discovered = await fetchGatewayCatalog({
         baseUrl,
         apiKey: key,
-        path: AVAILABLE_MODELS_PATH,
+        path: PUBLIC_MODELS_PATH,
         fetchImpl,
         timeoutMs,
         signal,
       });
-      return liveCatalog(discovered, selectedModel, 'available');
-    } catch (availableError) {
-      if (isAbortError(availableError) || signal?.aborted) throw availableError;
-      try {
-        const discovered = await fetchPublicModels({
-          baseUrl,
-          fetchImpl,
-          timeoutMs,
-          signal,
-        });
-        return liveCatalog(discovered, selectedModel, 'public');
-      } catch (publicError) {
-        if (isAbortError(publicError) || signal?.aborted) throw publicError;
-        return packagedCatalog(selectedModel, fallbackModels, availableError);
-      }
+      // An older gateway answers /v1/models with a minimal public list;
+      // those ids still name the fleet, so use them rather than the
+      // packaged registry.
+      return discovered.canonical
+        ? liveCatalog(
+            discovered.models,
+            selectedModel,
+            'catalog',
+            discovered.entries,
+          )
+        : liveCatalog(discovered.models, selectedModel, 'public');
+    } catch (error) {
+      if (isAbortError(error) || signal?.aborted) throw error;
+      catalogError = error;
+    }
+
+    try {
+      const discovered = await fetchGatewayCatalog({
+        baseUrl,
+        fetchImpl,
+        timeoutMs,
+        signal,
+      });
+      return liveCatalog(discovered.models, selectedModel, 'public');
+    } catch (publicError) {
+      if (isAbortError(publicError) || signal?.aborted) throw publicError;
+      return packagedCatalog(
+        selectedModel,
+        fallbackModels,
+        catalogError ?? publicError,
+      );
     }
   }
 
   try {
-    const discovered = await fetchPublicModels({
+    const discovered = await fetchGatewayCatalog({
       baseUrl,
       fetchImpl,
       timeoutMs,
       signal,
     });
-    return liveCatalog(discovered, selectedModel, 'public');
+    return liveCatalog(discovered.models, selectedModel, 'public');
   } catch (error) {
     if (isAbortError(error) || signal?.aborted) throw error;
     return packagedCatalog(selectedModel, fallbackModels, error);

package/bin/opencode-provider.js

@@ -1,6 +1,9 @@
 import { fileURLToPath } from 'node:url';
 import { modelIds, positiveInteger } from './launch-values.js';
-import { modelSupportsVision } from './model-capabilities.js';
+import {
+  catalogEntriesFromMetadata,
+  modelSupportsVision,
+} from './model-capabilities.js';
 
 export const OPENCODE_PROVIDER_ID = 'subconscious';
 const OPENCODE_IMAGE_WINDOW_PLUGIN = fileURLToPath(
@@ -40,15 +43,22 @@ export function opencodeModelDisplayName(modelId) {
   return slug.split(/[-_]/).filter(Boolean).map(formatToken).join(' ');
 }
 
-export function buildOpenCodeModels(modelIds, { context, output }) {
+export function buildOpenCodeModels(
+  modelIds,
+  { context, output, entries = [] },
+) {
+  const entryById = new Map(entries.map((entry) => [entry.id, entry]));
   return Object.fromEntries(
     modelIds.map((id) => [
       id,
       {
         name: opencodeModelDisplayName(id),
         tools: true,
-        limit: { context, output },
-        ...(modelSupportsVision(id)
+        limit: {
+          context: entryById.get(id)?.limits?.context_length ?? context,
+          output: entryById.get(id)?.limits?.max_output_tokens ?? output,
+        },
+        ...(modelSupportsVision(id, entries)
           ? {
               attachment: true,
               modalities: { input: ['text', 'image'], output: ['text'] },
@@ -65,6 +75,7 @@ export function buildOpenCodeConfig({
   modelIds,
   context,
   output,
+  entries = [],
 }) {
   return {
     $schema: 'https://opencode.ai/config.json',
@@ -82,7 +93,7 @@ export function buildOpenCodeConfig({
           headers: { 'x-subconscious-client': 'opencode' },
           modelsDiscovery: { enabled: false },
         },
-        models: buildOpenCodeModels(modelIds, { context, output }),
+        models: buildOpenCodeModels(modelIds, { context, output, entries }),
       },
     },
     model: `${OPENCODE_PROVIDER_ID}/${model}`,
@@ -100,5 +111,6 @@ export function openCodeConfigFromEnv(env) {
       'OPENCODE_CONTEXT_LIMIT',
     ),
     output: positiveInteger(env.OPENCODE_OUTPUT_LIMIT, 'OPENCODE_OUTPUT_LIMIT'),
+    entries: catalogEntriesFromMetadata(env.SUBC_MODEL_METADATA),
   });
 }

package/bin/profiles.js

@@ -566,11 +566,49 @@ export async function configCommand(
 export function modelsCommand(models = SUPPORTED_MODELS, options = {}) {
   const selectedModel =
     options.selectedModel || models[0] || RUNBOOK_DEFAULTS.MODEL;
+  const entryById = new Map(
+    (options.entries ?? []).map((entry) => [entry.id, entry]),
+  );
+  const lifecycleNote = (model) => {
+    const lifecycle = entryById.get(model)?.lifecycle;
+    if (!lifecycle) return '';
+    const date = lifecycle.deprecation_date
+      ? ` until ${lifecycle.deprecation_date}`
+      : '';
+    const replacement = lifecycle.replacement
+      ? ` ${c.dim}-> ${lifecycle.replacement}${c.reset}`
+      : '';
+    if (lifecycle.status === 'deprecated') {
+      return `  ${c.yellow}[deprecated${date}]${c.reset}${replacement}`;
+    }
+    if (lifecycle.status === 'retired') {
+      return `  ${c.red}[retired${date}]${c.reset}${replacement}`;
+    }
+    return '';
+  };
   console.log(`\n  ${c.bold}Available models${c.reset}\n`);
   for (const model of models) {
     const suffix =
       model === selectedModel ? ` ${c.dim}(default)${c.reset}` : '';
-    console.log(`  ${c.cyan}${model}${c.reset}${suffix}`);
+    console.log(
+      `  ${c.cyan}${model}${c.reset}${suffix}${lifecycleNote(model)}`,
+    );
+  }
+  const selectedLifecycle = entryById.get(selectedModel)?.lifecycle;
+  if (selectedLifecycle?.status === 'deprecated') {
+    const when = selectedLifecycle.deprecation_date
+      ? ` on ${selectedLifecycle.deprecation_date}`
+      : '';
+    const to = selectedLifecycle.replacement
+      ? ` Migrate to ${selectedLifecycle.replacement}.`
+      : '';
+    console.error(
+      `\n  ${c.yellow}Selected model ${selectedModel} is deprecated${when}.${to}${c.reset}`,
+    );
+  } else if (selectedLifecycle?.status === 'retired') {
+    console.error(
+      `\n  ${c.yellow}Selected model ${selectedModel} is retired and may stop serving without notice.${c.reset}`,
+    );
   }
   if (options.source === 'public' && options.hasApiKey) {
     console.error(`\n  ${c.dim}${PUBLIC_CATALOG_FALLBACK_MESSAGE}${c.reset}`);

package/bin/tui.js

@@ -330,7 +330,7 @@ export async function loadRemoteTuiUpdates(state, options = {}) {
       });
       if (signal?.aborted) return;
       await enqueuePatch({
-        models: catalog.models,
+        models: catalog.defaultModels,
         modelError: catalog.error?.message || '',
         modelSource: catalog.source,
         modelsLoading: false,

package/bin/usage.js

@@ -55,15 +55,6 @@ export function shortModelSlug(slug) {
     : text;
 }
 
-export function isLegacyUsagePayload(data) {
-  if (!data || typeof data !== 'object') return true;
-  if ('credits' in data && data.plan && typeof data.plan === 'object')
-    return false;
-  return (
-    'dailyTokenCeiling' in data || 'consumedToday' in data || !('plan' in data)
-  );
-}
-
 export function meterColor(percentage) {
   if (percentage >= 100) return c.red;
   if (percentage >= 80) return c.yellow;
@@ -91,27 +82,25 @@ export function formatAllowancePercent(percent) {
   return `${whole}%`;
 }
 
-/** New percent payloads, or the pre-basis token shape (consumed / amount). */
+/** Percent-only allowance payloads from the current platform. */
 export function describeDailyAllowance(allowance) {
   if (!allowance || typeof allowance !== 'object') return null;
   if (allowance.basis === 'unavailable') return { kind: 'unavailable' };
   if (allowance.basis === 'credit' || allowance.basis === 'tokens') {
     return { kind: allowance.basis, percent: Number(allowance.percent) || 0 };
   }
-
-  const consumed = Number(allowance.consumed) || 0;
-  const amount = Number(allowance.amount) || 0;
-  if (amount <= 0) return null;
-  return { kind: 'tokens', percent: (consumed / amount) * 100 };
+  return null;
 }
 
 export function formatUsageDisplay(data) {
   const lines = [];
   lines.push(`\n  ${c.bold}Subconscious Usage${c.reset}\n`);
 
-  const billingMode = data.billingMode ?? null;
+  const billingTerms = data.billingTerms ?? null;
+  const invoiced = billingTerms === 'invoiced';
   const plan = data.plan ?? {};
   const credits = data.credits ?? {};
+  const invoice = invoiced ? (data.invoice ?? {}) : {};
   const models = Array.isArray(data.models) ? data.models : [];
 
   const planLabel = plan.label || 'No plan';
@@ -119,55 +108,81 @@ export function formatUsageDisplay(data) {
   const planLine = planStatus ? `${planLabel} · ${planStatus}` : planLabel;
 
   lines.push(`  ${c.dim}Plan${c.reset}            ${planLine}`);
-  if (billingMode) {
-    lines.push(`  ${c.dim}Billing${c.reset}         ${billingMode}`);
+  if (invoiced) {
+    lines.push(`  ${c.dim}Billing${c.reset}         Invoiced monthly (net 30)`);
   }
 
   const allowance = plan.dailyAllowance;
-  const unlimitedComp = Boolean(plan.isUnlimitedComp);
 
-  if (unlimitedComp) {
+  // Invoiced orgs bill against the spend limit, not a daily grant, so the
+  // daily allowance does not pertain to them and is never shown.
+  const described = invoiced ? null : describeDailyAllowance(allowance);
+  if (described) {
     lines.push('');
     lines.push(`  ${c.dim}Daily allowance${c.reset}`);
-    lines.push(`  ${c.green}Unlimited${c.reset} ${c.dim}(comp)${c.reset}`);
-  } else {
-    const described = describeDailyAllowance(allowance);
-    if (described) {
-      lines.push('');
-      lines.push(`  ${c.dim}Daily allowance${c.reset}`);
-      if (described.kind === 'unavailable') {
-        lines.push(`  ${c.dim}Daily credit unavailable${c.reset}`);
-        lines.push(
-          `  ${c.dim}Today's credit usage could not be read just now. Your plan and access are unaffected, and the figure returns on its own.${c.reset}`,
-        );
-      } else {
-        const label =
-          described.kind === 'credit'
-            ? 'of daily credit used'
-            : 'of daily tokens used';
+    if (described.kind === 'unavailable') {
+      lines.push(`  ${c.dim}Daily credit unavailable${c.reset}`);
+      lines.push(
+        `  ${c.dim}Today's credit usage could not be read just now. Your plan and access are unaffected, and the figure returns on its own.${c.reset}`,
+      );
+    } else {
+      const label =
+        described.kind === 'credit'
+          ? 'of daily credit used'
+          : 'of daily tokens used';
+      lines.push(
+        `  ${renderProgressBar(described.percent)}  ${formatAllowancePercent(described.percent)} ${label}`,
+      );
+      lines.push(`  ${c.dim}Resets midnight UTC${c.reset}`);
+      if (described.kind === 'credit' && described.percent >= 100) {
         lines.push(
-          `  ${renderProgressBar(described.percent)}  ${formatAllowancePercent(described.percent)} ${label}`,
+          `  ${c.yellow}Past today's allowance - further usage bills from your balance.${c.reset}`,
         );
-        lines.push(`  ${c.dim}Resets midnight UTC${c.reset}`);
-        if (described.kind === 'credit' && described.percent >= 100) {
-          lines.push(
-            `  ${c.yellow}Past today's allowance - further usage bills from your balance.${c.reset}`,
-          );
-        }
       }
     }
   }
 
-  lines.push('');
-  lines.push(
-    `  ${c.dim}Credits${c.reset}         ${formatCurrency(credits.balanceDollars ?? 0)}`,
-  );
-  if (billingMode === 'subscription' || billingMode === 'comp' || allowance) {
-    const overage = Number(credits.overageThisPeriodDollars) || 0;
-    const overageColor = overage > 0 ? c.yellow : c.reset;
+  if (invoiced) {
+    const accrued = invoice.accruedThisPeriodDollars;
+    const limit = invoice.limitDollars;
+    const periodEnd = invoice.periodEnd ? new Date(invoice.periodEnd) : null;
+
+    lines.push('');
+    lines.push(`  ${c.dim}Spend this period${c.reset}`);
+    if (accrued == null) {
+      lines.push(`  ${c.dim}Spend could not be read just now.${c.reset}`);
+      lines.push(
+        `  ${c.dim}Your plan and access are unaffected, and the figure returns on its own.${c.reset}`,
+      );
+    } else {
+      const limitText =
+        limit != null ? ` of ${formatCurrency(limit)} limit` : '';
+      const spendColor = limit != null && accrued >= limit ? c.red : c.reset;
+      lines.push(
+        `  ${spendColor}${formatCurrency(accrued)}${c.reset}${c.dim}${limitText}${c.reset}`,
+      );
+      if (periodEnd && !Number.isNaN(periodEnd.getTime())) {
+        const isoDay = periodEnd.toISOString().slice(0, 10);
+        lines.push(`  ${c.dim}Period ends ${isoDay}${c.reset}`);
+      }
+      if (limit != null && accrued >= limit) {
+        lines.push(
+          `  ${c.red}At the spend limit - further requests follow your limit policy.${c.reset}`,
+        );
+      }
+    }
+  } else if (credits.balanceDollars != null || data.credits) {
+    lines.push('');
     lines.push(
-      `  ${c.dim}Overage${c.reset}         ${overageColor}${formatCurrency(overage)} this period${c.reset}`,
+      `  ${c.dim}Credits${c.reset}         ${formatCurrency(credits.balanceDollars ?? 0)}`,
     );
+    const overage = Number(credits.overageThisPeriodDollars) || 0;
+    if (overage > 0 || allowance) {
+      const overageColor = overage > 0 ? c.yellow : c.reset;
+      lines.push(
+        `  ${c.dim}Overage${c.reset}         ${overageColor}${formatCurrency(overage)} this period${c.reset}`,
+      );
+    }
   }
 
   if (models.length > 0) {
@@ -251,14 +266,6 @@ export async function usageCommand(argv = [], options = {}) {
       throw new Error(message);
     }
 
-    if (isLegacyUsagePayload(data)) {
-      console.log(`\n  ${c.yellow}Platform upgrade required.${c.reset}`);
-      console.log(
-        `  ${c.dim}This platform host returns a legacy usage shape. Deploy the latest platform or point PLATFORM_URL at a current host.${c.reset}\n`,
-      );
-      return;
-    }
-
     if (jsonOutput) {
       console.log(JSON.stringify(data, null, 2));
       return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "subconscious-cli",
-  "version": "7.0.0",
+  "version": "8.0.0",
   "description": "CLI for Subconscious — run Subconscious Code, Claude Code, Codex, OpenCode, DeepSeek Harness, Copilot, and Pi",
   "bin": {
     "subc": "bin/cli.js"