@dexto/tui 1.15.0-beta.0 → 1.15.0-beta.1

package/dist/utils/chatgpt-rate-limit.js

@@ -3,6 +3,7 @@ import {
   getModelDisplayName,
   isModelValidForProvider
 } from "@dexto/llm";
+import { parseCodexBaseURL } from "@dexto/core";
 const CHATGPT_RATE_LIMIT_WARNING_THRESHOLD = 80;
 function shouldShowChatGPTRateLimitHint(status) {
   if (!status) {
@@ -10,6 +11,13 @@ function shouldShowChatGPTRateLimitHint(status) {
   }
   return status.exceeded || status.usedPercent >= CHATGPT_RATE_LIMIT_WARNING_THRESHOLD;
 }
+function resolveChatGPTRateLimitHint(llmConfig, status, form) {
+  const isChatGPTLogin = llmConfig?.provider === "openai-compatible" && parseCodexBaseURL(llmConfig.baseURL)?.authMode === "chatgpt";
+  if (!isChatGPTLogin || !status || !shouldShowChatGPTRateLimitHint(status)) return null;
+  if (form === "full") return getChatGPTRateLimitHint(status);
+  if (status.exceeded) return "cap reached";
+  return `cap ${Math.max(0, Math.min(100, Math.round(status.usedPercent)))}%`;
+}
 function formatResetTime(resetsAt) {
   if (!resetsAt) {
     return null;
@@ -45,5 +53,6 @@ export {
   CHATGPT_RATE_LIMIT_WARNING_THRESHOLD,
   getChatGPTRateLimitHint,
   resolveChatGPTFallbackModel,
+  resolveChatGPTRateLimitHint,
   shouldShowChatGPTRateLimitHint
 };

package/dist/utils/chatgpt-rate-limit.test.cjs

@@ -1,5 +1,6 @@
 "use strict";
 var import_vitest = require("vitest");
+var import_core = require("@dexto/core");
 var import_chatgpt_rate_limit = require("./chatgpt-rate-limit.js");
 (0, import_vitest.describe)("chatgpt-rate-limit utils", () => {
   (0, import_vitest.it)("shows footer hints when ChatGPT usage is approaching the cap", () => {
@@ -18,6 +19,15 @@ var import_chatgpt_rate_limit = require("./chatgpt-rate-limit.js");
       })
     ).toBe("ChatGPT cap 82% used");
   });
+  (0, import_vitest.it)("gives a short form for tight status lines, and nothing for other providers", () => {
+    const chatgpt = { provider: "openai-compatible", baseURL: (0, import_core.createCodexBaseURL)("chatgpt") };
+    const near = { source: "chatgpt-login", usedPercent: 95, exceeded: false };
+    const capped = { source: "chatgpt-login", usedPercent: 100, exceeded: true };
+    (0, import_vitest.expect)((0, import_chatgpt_rate_limit.resolveChatGPTRateLimitHint)(chatgpt, near, "short")).toBe("cap 95%");
+    (0, import_vitest.expect)((0, import_chatgpt_rate_limit.resolveChatGPTRateLimitHint)(chatgpt, capped, "short")).toBe("cap reached");
+    (0, import_vitest.expect)((0, import_chatgpt_rate_limit.resolveChatGPTRateLimitHint)(chatgpt, near, "full")).toBe("ChatGPT cap 95% used");
+    (0, import_vitest.expect)((0, import_chatgpt_rate_limit.resolveChatGPTRateLimitHint)({ provider: "openai" }, near, "short")).toBeNull();
+  });
   (0, import_vitest.it)("formats a hard cap state without showing fake reset data", () => {
     (0, import_vitest.expect)(
       (0, import_chatgpt_rate_limit.getChatGPTRateLimitHint)({

package/dist/utils/chatgpt-rate-limit.test.js

@@ -1,6 +1,8 @@
 import { describe, expect, it } from "vitest";
+import { createCodexBaseURL } from "@dexto/core";
 import {
   getChatGPTRateLimitHint,
+  resolveChatGPTRateLimitHint,
   resolveChatGPTFallbackModel,
   shouldShowChatGPTRateLimitHint
 } from "./chatgpt-rate-limit.js";
@@ -21,6 +23,15 @@ describe("chatgpt-rate-limit utils", () => {
       })
     ).toBe("ChatGPT cap 82% used");
   });
+  it("gives a short form for tight status lines, and nothing for other providers", () => {
+    const chatgpt = { provider: "openai-compatible", baseURL: createCodexBaseURL("chatgpt") };
+    const near = { source: "chatgpt-login", usedPercent: 95, exceeded: false };
+    const capped = { source: "chatgpt-login", usedPercent: 100, exceeded: true };
+    expect(resolveChatGPTRateLimitHint(chatgpt, near, "short")).toBe("cap 95%");
+    expect(resolveChatGPTRateLimitHint(chatgpt, capped, "short")).toBe("cap reached");
+    expect(resolveChatGPTRateLimitHint(chatgpt, near, "full")).toBe("ChatGPT cap 95% used");
+    expect(resolveChatGPTRateLimitHint({ provider: "openai" }, near, "short")).toBeNull();
+  });
   it("formats a hard cap state without showing fake reset data", () => {
     expect(
       getChatGPTRateLimitHint({

package/dist/utils/deck-state.cjs

@@ -0,0 +1,107 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var deck_state_exports = {};
+__export(deck_state_exports, {
+  deckCollapsed: () => deckCollapsed,
+  deckCredits: () => deckCredits,
+  deckMode: () => deckMode,
+  deckModelId: () => deckModelId,
+  deckReadout: () => deckReadout,
+  keepsTurnSpend: () => keepsTurnSpend,
+  nextTurnBaseline: () => nextTurnBaseline,
+  permissionLabel: () => permissionLabel
+});
+module.exports = __toCommonJS(deck_state_exports);
+var import_overlayPresentation = require("./overlayPresentation.js");
+function deckMode(a) {
+  if (a.awaitingUser) return "wait";
+  if (a.isCancelling) return "stop";
+  if (!a.isProcessing) return a.lastRunFailed ? "fault" : "idle";
+  if (a.steerCount > 0) return "steer";
+  if (a.isThinking) return "think";
+  if (a.toolRunning || a.isCompacting) return "tool";
+  return "stream";
+}
+function join(parts) {
+  const kept = parts.filter((p) => p !== null && p !== "");
+  return kept.length > 0 ? kept.join(" \xB7 ") : null;
+}
+function deckReadout(mode, r) {
+  switch (mode) {
+    case "wait":
+      return `paused ${r.elapsed}`;
+    case "steer":
+      return join([
+        r.permission,
+        `${r.steerCount} steer${r.steerCount === 1 ? "" : "s"} queued`
+      ]);
+    case "stop":
+      return "stopping";
+    case "think":
+    case "stream":
+    case "tool":
+    case "cloud":
+      return join([r.permission, r.compacting ? "compacting" : r.tokens, r.elapsed]);
+    default:
+      return join([
+        r.permission,
+        r.rateLimitHint,
+        r.reasoning === null ? null : `r:${r.reasoning}`
+      ]);
+  }
+}
+function deckModelId(provider, model) {
+  if (provider === null) return model;
+  return `${provider === "dexto-nova" ? "dexto" : provider}/${model}`;
+}
+function deckCredits(c) {
+  if (!c.signedIn) return { kind: "signed-out" };
+  if (c.balance === null) return { kind: "signed-in" };
+  if (c.balance <= 0) return { kind: "out" };
+  const spent = c.turnStartBalance === null ? 0 : Math.round((c.turnStartBalance - c.balance) * 100) / 100;
+  return { kind: "balance", balance: c.balance, spend: spent > 0 ? spent : null };
+}
+function keepsTurnSpend(previous, next) {
+  return previous === null && next !== null;
+}
+function nextTurnBaseline(prev, now) {
+  const switched = prev.sessionId !== now.sessionId && !keepsTurnSpend(prev.sessionId, now.sessionId);
+  let balance = switched || prev.account !== now.account ? null : prev.balance;
+  if (now.isProcessing && !prev.isProcessing) balance = now.balance;
+  return { ...now, balance };
+}
+function deckCollapsed(activeOverlay) {
+  return (0, import_overlayPresentation.getOverlayPresentation)(activeOverlay, null) === "focus";
+}
+function permissionLabel(p) {
+  const session = p.isShellMode ? "shell mode" : p.planModeActive ? "plan mode" : p.autoApproveEdits ? "accept edits" : null;
+  const auto = p.bypassPermissions || p.configuredMode === "auto-approve";
+  return join([session, auto ? "auto-approve" : null]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  deckCollapsed,
+  deckCredits,
+  deckMode,
+  deckModelId,
+  deckReadout,
+  keepsTurnSpend,
+  nextTurnBaseline,
+  permissionLabel
+});

package/dist/utils/deck-state.d.ts

@@ -0,0 +1,79 @@
+/**
+ * What the Signal deck shows, worked out from the CLI's own state. Pure, so each rule is
+ * tested on its own; `useDeckState` gathers the inputs.
+ */
+import type { DeckCredits, DeckMode } from '../signal/index.js';
+import type { OverlayType } from '../state/types.js';
+export interface DeckActivity {
+    isProcessing: boolean;
+    isCancelling: boolean;
+    isThinking: boolean;
+    isCompacting: boolean;
+    /** An approval or a question is waiting on the user. */
+    awaitingUser: boolean;
+    /** A tool call is executing. */
+    toolRunning: boolean;
+    /** Steer messages waiting for the current step to finish. */
+    steerCount: number;
+    /** The last run ended on an error. Cleared when the next run starts. */
+    lastRunFailed: boolean;
+}
+/** Highest first: what needs the user, then what the agent is doing. */
+export declare function deckMode(a: DeckActivity): DeckMode;
+export interface DeckReadoutInput {
+    /** Formatted elapsed time of the run, or of the wait. */
+    elapsed: string;
+    /** Formatted token count; '' when too small to show. */
+    tokens: string;
+    compacting: boolean;
+    steerCount: number;
+    /** "plan mode", "accept edits", "auto-approve"; null in the default mode. */
+    permission: string | null;
+    /** The reasoning variant beside the model ("high"); null when the model has none. */
+    reasoning: string | null;
+    /** ChatGPT plan usage in short form ("cap 95%"), when it is worth showing. */
+    rateLimitHint: string | null;
+}
+export declare function deckReadout(mode: DeckMode, r: DeckReadoutInput): string | null;
+/** "dexto/…" for Dexto credits, "provider/model" for an own key. */
+export declare function deckModelId(provider: string | null, model: string): string;
+export interface DeckCreditsInput {
+    signedIn: boolean;
+    /** Current balance in USD, null when not known. */
+    balance: number | null;
+    /** Balance when the current or last turn started, to show what it spent. */
+    turnStartBalance: number | null;
+}
+export declare function deckCredits(c: DeckCreditsInput): DeckCredits;
+/**
+ * Whether the turn's spend baseline survives a session id change. The first turn creates its
+ * session after it starts, so null to an id is the same turn; anything else is a real switch.
+ */
+export declare function keepsTurnSpend(previous: string | null, next: string | null): boolean;
+/** The balance a turn's spend is measured from, and what it was worked out from. */
+export interface TurnBaseline {
+    sessionId: string | null;
+    /** Who is signed in; null when no one is. */
+    account: string | null;
+    isProcessing: boolean;
+    balance: number | null;
+}
+/** Cleared by a session switch or an account change; set when a turn starts. */
+export declare function nextTurnBaseline(prev: TurnBaseline, now: TurnBaseline): TurnBaseline;
+/** Focused overlays size themselves to the screen, so the deck's rows would overflow it. */
+export declare function deckCollapsed(activeOverlay: OverlayType): boolean;
+export interface PermissionInput {
+    isShellMode: boolean;
+    planModeActive: boolean;
+    autoApproveEdits: boolean;
+    bypassPermissions: boolean;
+    /** The agent's configured permissions mode, under any session override. */
+    configuredMode: string;
+}
+/**
+ * The approval policy in force, for the idle readout; null for manual approvals. The session
+ * mode (Shift+Tab) comes first. Auto-approval is always named when it applies: the session
+ * flags don't narrow an agent configured to auto-approve.
+ */
+export declare function permissionLabel(p: PermissionInput): string | null;
+//# sourceMappingURL=deck-state.d.ts.map

package/dist/utils/deck-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deck-state.d.ts","sourceRoot":"","sources":["../../src/utils/deck-state.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAChE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGrD,MAAM,WAAW,YAAY;IACzB,YAAY,EAAE,OAAO,CAAC;IACtB,YAAY,EAAE,OAAO,CAAC;IACtB,UAAU,EAAE,OAAO,CAAC;IACpB,YAAY,EAAE,OAAO,CAAC;IACtB,wDAAwD;IACxD,YAAY,EAAE,OAAO,CAAC;IACtB,gCAAgC;IAChC,WAAW,EAAE,OAAO,CAAC;IACrB,6DAA6D;IAC7D,UAAU,EAAE,MAAM,CAAC;IACnB,wEAAwE;IACxE,aAAa,EAAE,OAAO,CAAC;CAC1B;AAED,wEAAwE;AACxE,wBAAgB,QAAQ,CAAC,CAAC,EAAE,YAAY,GAAG,QAAQ,CASlD;AAED,MAAM,WAAW,gBAAgB;IAC7B,yDAAyD;IACzD,OAAO,EAAE,MAAM,CAAC;IAChB,wDAAwD;IACxD,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,OAAO,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,6EAA6E;IAC7E,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,qFAAqF;IACrF,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,8EAA8E;IAC9E,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;CAChC;AAOD,wBAAgB,WAAW,CAAC,IAAI,EAAE,QAAQ,EAAE,CAAC,EAAE,gBAAgB,GAAG,MAAM,GAAG,IAAI,CAyB9E;AAED,oEAAoE;AACpE,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAG1E;AAED,MAAM,WAAW,gBAAgB;IAC7B,QAAQ,EAAE,OAAO,CAAC;IAClB,mDAAmD;IACnD,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,4EAA4E;IAC5E,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;CACnC;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,gBAAgB,GAAG,WAAW,CAO5D;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAEpF;AAED,oFAAoF;AACpF,MAAM,WAAW,YAAY;IACzB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,6CAA6C;IAC7C,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,YAAY,EAAE,OAAO,CAAC;IACtB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAED,gFAAgF;AAChF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,YAAY,EAAE,GAAG,EAAE,YAAY,GAAG,YAAY,CAMpF;AAED,4FAA4F;AAC5F,wBAAgB,aAAa,CAAC,aAAa,EAAE,WAAW,GAAG,OAAO,CAEjE;AAED,MAAM,WAAW,eAAe;IAC5B,WAAW,EAAE,OAAO,CAAC;IACrB,cAAc,EAAE,OAAO,CAAC;IACxB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,iBAAiB,EAAE,OAAO,CAAC;IAC3B,2EAA2E;IAC3E,cAAc,EAAE,MAAM,CAAC;CAC1B;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,eAAe,GAAG,MAAM,GAAG,IAAI,CAUjE"}

package/dist/utils/deck-state.js

@@ -0,0 +1,76 @@
+import { getOverlayPresentation } from "./overlayPresentation.js";
+function deckMode(a) {
+  if (a.awaitingUser) return "wait";
+  if (a.isCancelling) return "stop";
+  if (!a.isProcessing) return a.lastRunFailed ? "fault" : "idle";
+  if (a.steerCount > 0) return "steer";
+  if (a.isThinking) return "think";
+  if (a.toolRunning || a.isCompacting) return "tool";
+  return "stream";
+}
+function join(parts) {
+  const kept = parts.filter((p) => p !== null && p !== "");
+  return kept.length > 0 ? kept.join(" \xB7 ") : null;
+}
+function deckReadout(mode, r) {
+  switch (mode) {
+    case "wait":
+      return `paused ${r.elapsed}`;
+    case "steer":
+      return join([
+        r.permission,
+        `${r.steerCount} steer${r.steerCount === 1 ? "" : "s"} queued`
+      ]);
+    case "stop":
+      return "stopping";
+    case "think":
+    case "stream":
+    case "tool":
+    case "cloud":
+      return join([r.permission, r.compacting ? "compacting" : r.tokens, r.elapsed]);
+    default:
+      return join([
+        r.permission,
+        r.rateLimitHint,
+        r.reasoning === null ? null : `r:${r.reasoning}`
+      ]);
+  }
+}
+function deckModelId(provider, model) {
+  if (provider === null) return model;
+  return `${provider === "dexto-nova" ? "dexto" : provider}/${model}`;
+}
+function deckCredits(c) {
+  if (!c.signedIn) return { kind: "signed-out" };
+  if (c.balance === null) return { kind: "signed-in" };
+  if (c.balance <= 0) return { kind: "out" };
+  const spent = c.turnStartBalance === null ? 0 : Math.round((c.turnStartBalance - c.balance) * 100) / 100;
+  return { kind: "balance", balance: c.balance, spend: spent > 0 ? spent : null };
+}
+function keepsTurnSpend(previous, next) {
+  return previous === null && next !== null;
+}
+function nextTurnBaseline(prev, now) {
+  const switched = prev.sessionId !== now.sessionId && !keepsTurnSpend(prev.sessionId, now.sessionId);
+  let balance = switched || prev.account !== now.account ? null : prev.balance;
+  if (now.isProcessing && !prev.isProcessing) balance = now.balance;
+  return { ...now, balance };
+}
+function deckCollapsed(activeOverlay) {
+  return getOverlayPresentation(activeOverlay, null) === "focus";
+}
+function permissionLabel(p) {
+  const session = p.isShellMode ? "shell mode" : p.planModeActive ? "plan mode" : p.autoApproveEdits ? "accept edits" : null;
+  const auto = p.bypassPermissions || p.configuredMode === "auto-approve";
+  return join([session, auto ? "auto-approve" : null]);
+}
+export {
+  deckCollapsed,
+  deckCredits,
+  deckMode,
+  deckModelId,
+  deckReadout,
+  keepsTurnSpend,
+  nextTurnBaseline,
+  permissionLabel
+};

package/dist/utils/deck-state.test.cjs

@@ -0,0 +1,208 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_deck_state = require("./deck-state.js");
+const idle = {
+  isProcessing: false,
+  isCancelling: false,
+  isThinking: false,
+  isCompacting: false,
+  awaitingUser: false,
+  toolRunning: false,
+  steerCount: 0,
+  lastRunFailed: false
+};
+(0, import_vitest.describe)("deckMode", () => {
+  (0, import_vitest.it)("is READY when nothing runs", () => {
+    (0, import_vitest.expect)((0, import_deck_state.deckMode)(idle)).toBe("idle");
+  });
+  (0, import_vitest.it)("is FAULT after a run that failed, until the next one starts", () => {
+    (0, import_vitest.expect)((0, import_deck_state.deckMode)({ ...idle, lastRunFailed: true })).toBe("fault");
+    (0, import_vitest.expect)((0, import_deck_state.deckMode)({ ...idle, lastRunFailed: true, isProcessing: true })).toBe("stream");
+  });
+  (0, import_vitest.it)("puts waiting on you above everything the agent is doing", () => {
+    const busy = { ...idle, isProcessing: true, isThinking: true, toolRunning: true };
+    (0, import_vitest.expect)((0, import_deck_state.deckMode)({ ...busy, awaitingUser: true })).toBe("wait");
+  });
+  (0, import_vitest.it)("shows STOPPED while a cancel lands", () => {
+    (0, import_vitest.expect)((0, import_deck_state.deckMode)({ ...idle, isCancelling: true })).toBe("stop");
+    (0, import_vitest.expect)((0, import_deck_state.deckMode)({ ...idle, isCancelling: true, lastRunFailed: true })).toBe("stop");
+  });
+  (0, import_vitest.it)("shows STEERING while a steer waits for the current step", () => {
+    (0, import_vitest.expect)((0, import_deck_state.deckMode)({ ...idle, isProcessing: true, toolRunning: true, steerCount: 1 })).toBe(
+      "steer"
+    );
+  });
+  (0, import_vitest.it)("tells thinking, tools and streaming apart", () => {
+    const run = { ...idle, isProcessing: true };
+    (0, import_vitest.expect)((0, import_deck_state.deckMode)({ ...run, isThinking: true })).toBe("think");
+    (0, import_vitest.expect)((0, import_deck_state.deckMode)({ ...run, toolRunning: true })).toBe("tool");
+    (0, import_vitest.expect)((0, import_deck_state.deckMode)({ ...run, isCompacting: true })).toBe("tool");
+    (0, import_vitest.expect)((0, import_deck_state.deckMode)(run)).toBe("stream");
+  });
+});
+(0, import_vitest.describe)("deckReadout", () => {
+  const base = {
+    elapsed: "12s",
+    tokens: "1.9K tokens",
+    compacting: false,
+    steerCount: 0,
+    permission: null,
+    reasoning: null,
+    rateLimitHint: null
+  };
+  (0, import_vitest.it)("reads tokens and time while the agent works", () => {
+    (0, import_vitest.expect)((0, import_deck_state.deckReadout)("stream", base)).toBe("1.9K tokens \xB7 12s");
+    (0, import_vitest.expect)((0, import_deck_state.deckReadout)("think", { ...base, tokens: "" })).toBe("12s");
+  });
+  (0, import_vitest.it)("says what it is doing when it compacts", () => {
+    (0, import_vitest.expect)((0, import_deck_state.deckReadout)("tool", { ...base, compacting: true })).toBe("compacting \xB7 12s");
+  });
+  (0, import_vitest.it)("counts queued steers", () => {
+    (0, import_vitest.expect)((0, import_deck_state.deckReadout)("steer", { ...base, steerCount: 2 })).toBe("2 steers queued");
+  });
+  (0, import_vitest.it)("leads with the permission mode during a run, since Shift+Tab still changes it", () => {
+    const auto = { ...base, permission: "auto-approve" };
+    (0, import_vitest.expect)((0, import_deck_state.deckReadout)("stream", auto)).toBe("auto-approve \xB7 1.9K tokens \xB7 12s");
+    (0, import_vitest.expect)((0, import_deck_state.deckReadout)("tool", { ...auto, compacting: true })).toBe(
+      "auto-approve \xB7 compacting \xB7 12s"
+    );
+    (0, import_vitest.expect)((0, import_deck_state.deckReadout)("steer", { ...auto, steerCount: 1 })).toBe(
+      "auto-approve \xB7 1 steer queued"
+    );
+  });
+  (0, import_vitest.it)("shows how long it has waited on you", () => {
+    (0, import_vitest.expect)((0, import_deck_state.deckReadout)("wait", base)).toBe("paused 12s");
+  });
+  (0, import_vitest.it)("shows the permission mode, then a rate-limit hint, when idle", () => {
+    (0, import_vitest.expect)((0, import_deck_state.deckReadout)("idle", base)).toBeNull();
+    (0, import_vitest.expect)((0, import_deck_state.deckReadout)("idle", { ...base, permission: "plan mode" })).toBe("plan mode");
+    (0, import_vitest.expect)(
+      (0, import_deck_state.deckReadout)("idle", { ...base, permission: "plan mode", rateLimitHint: "91% used" })
+    ).toBe("plan mode \xB7 91% used");
+  });
+  (0, import_vitest.it)("puts the usage warning before the reasoning variant, since the end truncates first", () => {
+    (0, import_vitest.expect)(
+      (0, import_deck_state.deckReadout)("idle", {
+        ...base,
+        permission: "auto-approve",
+        reasoning: "medium",
+        rateLimitHint: "cap 95%"
+      })
+    ).toBe("auto-approve \xB7 cap 95% \xB7 r:medium");
+  });
+  (0, import_vitest.it)("shows the reasoning variant when idle, so Tab has visible feedback", () => {
+    (0, import_vitest.expect)((0, import_deck_state.deckReadout)("idle", { ...base, reasoning: "high" })).toBe("r:high");
+    (0, import_vitest.expect)((0, import_deck_state.deckReadout)("idle", { ...base, permission: "plan mode", reasoning: "low" })).toBe(
+      "plan mode \xB7 r:low"
+    );
+  });
+});
+(0, import_vitest.describe)("deckModelId", () => {
+  (0, import_vitest.it)("names Dexto models dexto/\u2026 and own-key models by provider", () => {
+    (0, import_vitest.expect)((0, import_deck_state.deckModelId)("dexto-nova", "anthropic/claude-sonnet-4.5")).toBe(
+      "dexto/anthropic/claude-sonnet-4.5"
+    );
+    (0, import_vitest.expect)((0, import_deck_state.deckModelId)("openai", "gpt-5")).toBe("openai/gpt-5");
+    (0, import_vitest.expect)((0, import_deck_state.deckModelId)(null, "gpt-5")).toBe("gpt-5");
+  });
+});
+(0, import_vitest.describe)("deckCredits", () => {
+  (0, import_vitest.it)("is signed out without an account", () => {
+    (0, import_vitest.expect)((0, import_deck_state.deckCredits)({ signedIn: false, balance: null, turnStartBalance: null })).toEqual({
+      kind: "signed-out"
+    });
+  });
+  (0, import_vitest.it)("is out at or below zero", () => {
+    (0, import_vitest.expect)((0, import_deck_state.deckCredits)({ signedIn: true, balance: 0, turnStartBalance: null })).toEqual({
+      kind: "out"
+    });
+  });
+  (0, import_vitest.it)("reports what this turn spent", () => {
+    (0, import_vitest.expect)((0, import_deck_state.deckCredits)({ signedIn: true, balance: 12.5, turnStartBalance: 12.81 })).toEqual({
+      kind: "balance",
+      balance: 12.5,
+      spend: 0.31
+    });
+    (0, import_vitest.expect)((0, import_deck_state.deckCredits)({ signedIn: true, balance: 12.5, turnStartBalance: 12.5 })).toEqual({
+      kind: "balance",
+      balance: 12.5,
+      spend: null
+    });
+  });
+});
+(0, import_vitest.describe)("permissionLabel", () => {
+  const none = {
+    isShellMode: false,
+    planModeActive: false,
+    autoApproveEdits: false,
+    bypassPermissions: false,
+    configuredMode: "manual"
+  };
+  (0, import_vitest.it)("is null for manual approvals", () => {
+    (0, import_vitest.expect)((0, import_deck_state.permissionLabel)(none)).toBeNull();
+  });
+  (0, import_vitest.it)("shows an agent configured to auto-approve, with no session override", () => {
+    (0, import_vitest.expect)((0, import_deck_state.permissionLabel)({ ...none, configuredMode: "auto-approve" })).toBe("auto-approve");
+  });
+  (0, import_vitest.it)("names the session mode first and keeps configured auto-approval beside it", () => {
+    const configured = { ...none, configuredMode: "auto-approve" };
+    (0, import_vitest.expect)((0, import_deck_state.permissionLabel)({ ...configured, planModeActive: true })).toBe(
+      "plan mode \xB7 auto-approve"
+    );
+    (0, import_vitest.expect)((0, import_deck_state.permissionLabel)({ ...configured, autoApproveEdits: true })).toBe(
+      "accept edits \xB7 auto-approve"
+    );
+    (0, import_vitest.expect)((0, import_deck_state.permissionLabel)({ ...none, autoApproveEdits: true })).toBe("accept edits");
+    (0, import_vitest.expect)((0, import_deck_state.permissionLabel)({ ...none, bypassPermissions: true })).toBe("auto-approve");
+    (0, import_vitest.expect)((0, import_deck_state.permissionLabel)({ ...configured, isShellMode: true })).toBe(
+      "shell mode \xB7 auto-approve"
+    );
+  });
+});
+(0, import_vitest.describe)("keepsTurnSpend", () => {
+  (0, import_vitest.it)("keeps the spend when the first turn creates its session", () => {
+    (0, import_vitest.expect)((0, import_deck_state.keepsTurnSpend)(null, "s1")).toBe(true);
+  });
+  (0, import_vitest.it)("clears the spend on a switch to another session", () => {
+    (0, import_vitest.expect)((0, import_deck_state.keepsTurnSpend)("s1", "s2")).toBe(false);
+    (0, import_vitest.expect)((0, import_deck_state.keepsTurnSpend)("s1", null)).toBe(false);
+  });
+});
+(0, import_vitest.describe)("nextTurnBaseline", () => {
+  const before = { sessionId: "s1", account: "ada", isProcessing: false, balance: 12.84 };
+  const now = { sessionId: "s1", account: "ada", isProcessing: false, balance: 12.5 };
+  (0, import_vitest.it)("takes the balance when a turn starts and holds it through the turn", () => {
+    const started = (0, import_deck_state.nextTurnBaseline)(before, { ...now, isProcessing: true });
+    (0, import_vitest.expect)(started.balance).toBe(12.5);
+    const later = (0, import_deck_state.nextTurnBaseline)(started, { ...now, isProcessing: true, balance: 12.1 });
+    (0, import_vitest.expect)(later.balance).toBe(12.5);
+  });
+  (0, import_vitest.it)("keeps the baseline while the first turn creates its session", () => {
+    const prev = { sessionId: null, account: "ada", isProcessing: true, balance: 12.84 };
+    const next = (0, import_deck_state.nextTurnBaseline)(prev, { ...now, isProcessing: true });
+    (0, import_vitest.expect)(next).toEqual({
+      sessionId: "s1",
+      account: "ada",
+      isProcessing: true,
+      balance: 12.84
+    });
+  });
+  (0, import_vitest.it)("clears the baseline on a session switch", () => {
+    (0, import_vitest.expect)((0, import_deck_state.nextTurnBaseline)(before, { ...now, sessionId: "s2" }).balance).toBeNull();
+  });
+  (0, import_vitest.it)("clears the baseline on sign-out, so it never carries to another account", () => {
+    (0, import_vitest.expect)((0, import_deck_state.nextTurnBaseline)(before, { ...now, account: null }).balance).toBeNull();
+  });
+  (0, import_vitest.it)("clears the baseline when another account signs in without a sign-out", () => {
+    (0, import_vitest.expect)((0, import_deck_state.nextTurnBaseline)(before, { ...now, account: "grace" }).balance).toBeNull();
+  });
+});
+(0, import_vitest.describe)("deckCollapsed", () => {
+  (0, import_vitest.it)("collapses under focused overlays, which budget for the whole screen", () => {
+    (0, import_vitest.expect)((0, import_deck_state.deckCollapsed)("model-selector")).toBe(true);
+  });
+  (0, import_vitest.it)("stays up with no overlay and under inline ones", () => {
+    (0, import_vitest.expect)((0, import_deck_state.deckCollapsed)("none")).toBe(false);
+    (0, import_vitest.expect)((0, import_deck_state.deckCollapsed)("slash-autocomplete")).toBe(false);
+  });
+});

package/dist/utils/deck-state.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=deck-state.test.d.ts.map

package/dist/utils/deck-state.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deck-state.test.d.ts","sourceRoot":"","sources":["../../src/utils/deck-state.test.ts"],"names":[],"mappings":""}