pi-spark 0.11.2 → 0.13.0

package/src/features/credits/providers/fireworks.ts

@@ -0,0 +1,111 @@
+import { fileURLToPath } from "node:url";
+
+import { credentials, loadPackageDefinition, Metadata } from "@grpc/grpc-js";
+import { loadSync } from "@grpc/proto-loader";
+
+import { toNumber } from "../../../utils/format";
+
+import type { ClientUnaryCall, ServiceClientConstructor, ServiceError } from "@grpc/grpc-js";
+import type { Credits, CreditsProvider } from "../types";
+
+type GatewayClient = InstanceType<ServiceClientConstructor>;
+
+const PROVIDER = "fireworks";
+
+/**
+ * The control-plane gateway is a gRPC service, distinct from the inference API at
+ * `api.fireworks.ai`. Credit balance lives here, behind the `x-api-key` header.
+ */
+const TARGET = "gateway.fireworks.ai:443";
+const DEADLINE_MS = 20_000;
+
+interface Money {
+  currency_code?: string;
+  units?: string | number;
+  nanos?: string | number;
+}
+
+interface Balance {
+  money?: Money | null;
+}
+
+interface Account {
+  name?: string;
+}
+
+interface ListAccountsResponse {
+  accounts?: Account[] | null;
+}
+
+/** gRPC clients are reusable and multiplex over one connection, so build once. */
+let client: GatewayClient | undefined;
+
+/** The API key maps to a fixed account, so cache the resolved resource name. */
+const accountByKey = new Map<string, string>();
+
+function getClient(): GatewayClient {
+  if (client) return client;
+
+  const protoPath = fileURLToPath(new URL("./fireworks.proto", import.meta.url));
+  const definition = loadSync(protoPath, { keepCase: true, longs: String, defaults: true });
+  const proto = loadPackageDefinition(definition) as unknown as { gateway: { Gateway: ServiceClientConstructor } };
+  client = new proto.gateway.Gateway(TARGET, credentials.createSsl());
+
+  return client;
+}
+
+async function unary<T>(method: string, request: object, apiKey: string, signal: AbortSignal): Promise<T> {
+  return new Promise<T>((resolve, reject) => {
+    const metadata = new Metadata();
+    metadata.set("x-api-key", apiKey);
+
+    const deadline = new Date(Date.now() + DEADLINE_MS);
+    const gateway = getClient();
+    const invoke = gateway[method] as (
+      request: object,
+      metadata: Metadata,
+      options: { deadline: Date },
+      callback: (error: ServiceError | null, response: T) => void,
+    ) => ClientUnaryCall;
+
+    const call = invoke.call(gateway, request, metadata, { deadline }, (error, response) => {
+      if (error) reject(new Error(error.details || error.message));
+      else resolve(response);
+    });
+
+    if (signal.aborted) call.cancel();
+    else signal.addEventListener("abort", () => call.cancel(), { once: true });
+  });
+}
+
+async function resolveAccount(apiKey: string, signal: AbortSignal): Promise<string> {
+  const cached = accountByKey.get(apiKey);
+  if (cached) return cached;
+
+  const response = await unary<ListAccountsResponse>("ListAccounts", {}, apiKey, signal);
+  const name = response.accounts?.[0]?.name;
+  if (!name) throw new Error("no account found");
+
+  accountByKey.set(apiKey, name);
+  return name;
+}
+
+function moneyToNumber(money: Money | null | undefined): number | undefined {
+  if (!money) return undefined;
+
+  const units = toNumber(money.units) ?? 0;
+  const nanos = toNumber(money.nanos) ?? 0;
+  return units + nanos / 1e9;
+}
+
+export const fireworksProvider: CreditsProvider = {
+  id: PROVIDER,
+  label: "Fireworks",
+
+  async fetch(_ctx, apiKey, signal): Promise<Credits> {
+    const name = await resolveAccount(apiKey, signal);
+    const balance = await unary<Balance>("GetBalance", { name }, apiKey, signal);
+
+    return { type: "balance", remaining: moneyToNumber(balance.money) };
+  },
+};

package/src/features/credits/providers/index.ts

@@ -0,0 +1,22 @@
+import { deepseekProvider } from "./deepseek";
+import { fireworksProvider } from "./fireworks";
+import { moonshotProvider, moonshotCnProvider } from "./moonshot";
+import { openaiCodexProvider } from "./openai-codex";
+import { openrouterProvider } from "./openrouter";
+import { vercelAiGatewayProvider } from "./vercel-ai-gateway";
+
+import type { CreditsProvider } from "../types";
+
+const PROVIDERS: CreditsProvider[] = [
+  deepseekProvider,
+  fireworksProvider,
+  moonshotProvider,
+  moonshotCnProvider,
+  openaiCodexProvider,
+  openrouterProvider,
+  vercelAiGatewayProvider,
+];
+
+export function findProvider(provider?: string): CreditsProvider | undefined {
+  return PROVIDERS.find((entry) => entry.id === provider);
+}

package/src/features/credits/providers/moonshot.ts

@@ -0,0 +1,39 @@
+import { convertToUSD, toNumber } from "../../../utils/format";
+
+import type { Credits, CreditsProvider } from "../types";
+
+interface MoonshotBalanceResponse {
+  data?: {
+    available_balance?: string | number;
+  } | null;
+}
+
+/**
+ * For Moonshot, the international and China-mainland accounts live on separate hosts and bill in
+ * different currencies (USD vs CNY), which the endpoint does not report, so each pi provider ID
+ * fixes both host and currency.
+ */
+function createMoonshotProvider(id: string, host: string, currency: string): CreditsProvider {
+  return {
+    id,
+    label: "Moonshot",
+
+    async fetch(_ctx, apiKey, signal): Promise<Credits> {
+      const headers: Record<string, string> = {
+        Accept: "application/json",
+        Authorization: `Bearer ${apiKey}`,
+      };
+
+      const response = await fetch(`https://${host}/v1/users/me/balance`, { headers, signal });
+      if (!response.ok) throw new Error("request failed");
+
+      const payload = (await response.json()) as MoonshotBalanceResponse;
+      const remaining = await convertToUSD(toNumber(payload.data?.available_balance), currency, signal);
+
+      return { type: "balance", remaining };
+    },
+  };
+}
+
+export const moonshotProvider = createMoonshotProvider("moonshotai", "api.moonshot.ai", "USD");
+export const moonshotCnProvider = createMoonshotProvider("moonshotai-cn", "api.moonshot.cn", "CNY");

package/src/features/credits/providers/openai-codex.ts

@@ -0,0 +1,62 @@
+import { toNumber } from "../../../utils/format";
+
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { Credits, CreditsProvider } from "../types";
+
+const PROVIDER = "openai-codex";
+const URL = "https://chatgpt.com/backend-api/wham/usage";
+
+interface CodexUsageResponse {
+  rate_limit?: {
+    primary_window?: CodexRateWindow | null;
+    secondary_window?: CodexRateWindow | null;
+  } | null;
+  credits?: {
+    unlimited?: boolean;
+  } | null;
+}
+
+interface CodexRateWindow {
+  used_percent?: number | string;
+}
+
+export function getAccountId(ctx: ExtensionContext): string | undefined {
+  const credential = ctx.modelRegistry.authStorage.get(PROVIDER) as { accountId?: string } | undefined;
+  const accountId = credential?.accountId;
+
+  return typeof accountId === "string" && accountId.trim() ? accountId.trim() : undefined;
+}
+
+function parseUsedPercent(window?: CodexRateWindow | null): number | undefined {
+  const value = toNumber(window?.used_percent);
+  return typeof value === "number" ? Math.min(100, Math.max(0, value)) : undefined;
+}
+
+export const openaiCodexProvider: CreditsProvider = {
+  id: PROVIDER,
+  label: "Codex",
+
+  async fetch(ctx, apiKey, signal): Promise<Credits> {
+    const headers: Record<string, string> = {
+      Accept: "application/json",
+      Authorization: `Bearer ${apiKey}`,
+    };
+
+    const accountId = getAccountId(ctx);
+    if (accountId) headers["ChatGPT-Account-Id"] = accountId;
+
+    const response = await fetch(URL, { headers, signal });
+    if (!response.ok) throw new Error("request failed");
+
+    const payload = (await response.json()) as CodexUsageResponse;
+
+    return {
+      type: "windows",
+      unlimited: payload.credits?.unlimited === true,
+      lanes: [
+        { label: "5h", percent: parseUsedPercent(payload.rate_limit?.primary_window) },
+        { label: "7d", percent: parseUsedPercent(payload.rate_limit?.secondary_window) },
+      ],
+    };
+  },
+};

package/src/features/credits/providers/openrouter.ts

@@ -0,0 +1,35 @@
+import { toNumber } from "../../../utils/format";
+
+import type { Credits, CreditsProvider } from "../types";
+
+const PROVIDER = "openrouter";
+const URL = "https://openrouter.ai/api/v1/credits";
+
+interface OpenRouterCreditsResponse {
+  data?: {
+    total_credits?: number | null;
+    total_usage?: number | null;
+  } | null;
+}
+
+export const openrouterProvider: CreditsProvider = {
+  id: PROVIDER,
+  label: "OpenRouter",
+
+  async fetch(_ctx, apiKey, signal): Promise<Credits> {
+    const headers: Record<string, string> = {
+      Accept: "application/json",
+      Authorization: `Bearer ${apiKey}`,
+    };
+
+    const response = await fetch(URL, { headers, signal });
+    if (!response.ok) throw new Error("request failed");
+
+    const payload = (await response.json()) as OpenRouterCreditsResponse;
+    const totalCredits = toNumber(payload.data?.total_credits);
+    const totalUsage = toNumber(payload.data?.total_usage);
+    const remaining = typeof totalCredits === "number" && typeof totalUsage === "number" ? totalCredits - totalUsage : undefined;
+
+    return { type: "balance", remaining };
+  },
+};

package/src/features/credits/providers/vercel-ai-gateway.ts

@@ -0,0 +1,30 @@
+import { toNumber } from "../../../utils/format";
+
+import type { Credits, CreditsProvider } from "../types";
+
+const PROVIDER = "vercel-ai-gateway";
+const URL = "https://ai-gateway.vercel.sh/v1/credits";
+
+interface VercelCreditsResponse {
+  balance?: string | number;
+}
+
+export const vercelAiGatewayProvider: CreditsProvider = {
+  id: PROVIDER,
+  label: "Vercel",
+
+  async fetch(_ctx, apiKey, signal): Promise<Credits> {
+    const headers: Record<string, string> = {
+      Accept: "application/json",
+      Authorization: `Bearer ${apiKey}`,
+    };
+
+    const response = await fetch(URL, { headers, signal });
+    if (!response.ok) throw new Error("request failed");
+
+    const payload = (await response.json()) as VercelCreditsResponse;
+    const remaining = toNumber(payload.balance);
+
+    return { type: "balance", remaining };
+  },
+};

package/src/features/credits/status.ts

@@ -0,0 +1,43 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import type { Credits, CreditsLane } from "./types";
+
+const WINDOWS_WARNING = 70;
+const WINDOWS_ERROR = 90;
+const BALANCE_WARNING = 10;
+const BALANCE_ERROR = 5;
+
+export function renderCredits(theme: Theme, label: string, credits: Credits): string {
+  const styledLabel = theme.fg("dim", label);
+
+  if (credits.type === "windows") return `${styledLabel} ${renderWindows(theme, credits)}`;
+  return `${styledLabel} ${renderBalance(theme, credits)}`;
+}
+
+export function renderError(theme: Theme, label: string, message: string): string {
+  return theme.fg("error", `${label} credits unavailable: ${message}`);
+}
+
+function renderWindows(theme: Theme, credits: Extract<Credits, { type: "windows" }>): string {
+  const unlimited = credits.unlimited || credits.lanes.every((lane) => lane.percent === undefined);
+  if (unlimited) return theme.fg("success", "unlimited");
+
+  return credits.lanes.map((lane) => renderLane(theme, lane)).join(" ");
+}
+
+function renderLane(theme: Theme, lane: CreditsLane): string {
+  const text = `${lane.label} ${lane.percent === undefined ? "?" : lane.percent.toFixed(0)}%`;
+
+  if (lane.percent && lane.percent > WINDOWS_ERROR) return theme.fg("error", text);
+  if (lane.percent && lane.percent > WINDOWS_WARNING) return theme.fg("warning", text);
+  return theme.fg("success", text);
+}
+
+function renderBalance(theme: Theme, credits: Extract<Credits, { type: "balance" }>): string {
+  if (credits.remaining === undefined) return theme.fg("dim", "$?");
+
+  const text = `$${credits.remaining.toFixed(2)}`;
+
+  if (credits.remaining < BALANCE_ERROR) return theme.fg("error", text);
+  if (credits.remaining < BALANCE_WARNING) return theme.fg("warning", text);
+  return theme.fg("success", text);
+}

package/src/features/credits/types.ts

@@ -0,0 +1,24 @@
+import type { Provider } from "@earendil-works/pi-ai";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+/**
+ * Normalized credits/usage for a provider.
+ *
+ * - `balance` providers (e.g., OpenRouter, Vercel AI Gateway) report a remaining dollar balance.
+ * - `windows` providers (e.g., OpenAI Codex) report rate-limit windows as used percentages.
+ */
+export type Credits =
+  | { type: "balance"; remaining?: number | undefined }
+  | { type: "windows"; lanes: CreditsLane[]; unlimited?: boolean | undefined };
+
+export interface CreditsLane {
+  label: string;
+  percent: number | undefined;
+}
+
+/** A credits source for a pi provider, shown in the status line while that provider is active. */
+export interface CreditsProvider {
+  readonly id: Provider;
+  readonly label: string;
+  fetch(ctx: ExtensionContext, apiKey: string, signal: AbortSignal): Promise<Credits>;
+}

package/{extensions → src/features}/editor/index.ts

@@ -1,13 +1,14 @@
 import { CustomEditor } from "@earendil-works/pi-coding-agent";
 
 import { Spinner } from "./spinner";
-import { SplitLine } from "../shared/components/split-line";
-import { loadConfig } from "../shared/config";
-import { autoCollectEvents, PRESET_CHANGE, parsePresetChange } from "../shared/events";
-import { formatModel } from "../shared/format";
+import { SplitLine } from "../../components/split-line";
+import { loadConfig } from "../../config";
+import { PRESET_CHANGE, parsePresetChange } from "../../events";
+import { formatModel } from "../../utils/format";
 
 import type { ExtensionAPI, ExtensionContext, KeybindingsManager } from "@earendil-works/pi-coding-agent";
 import type { TUI, EditorTheme } from "@earendil-works/pi-tui";
+import type { EventCollector } from "../../events";
 
 class Editor extends CustomEditor {
   private pi: ExtensionAPI;
@@ -81,18 +82,14 @@ class Editor extends CustomEditor {
   }
 }
 
-export default function (pi: ExtensionAPI) {
-  const events = autoCollectEvents(pi);
-
+export function registerEditor(pi: ExtensionAPI, events: EventCollector): void {
   let editor: Editor | undefined = undefined;
   let spinner: Spinner | undefined = undefined;
   let runningToolCallIds = new Set<string>();
 
   pi.on("session_start", (_event, ctx) => {
-    if (!ctx.hasUI) return;
-
-    const config = loadConfig(ctx, "editor");
-    if (!config) return;
+    const config = loadConfig(ctx).editor;
+    if (!ctx.hasUI || !config) return;
 
     spinner = new Spinner(config.spinner);
 

package/{extensions → src/features}/footer/index.ts

@@ -2,10 +2,10 @@ import { homedir } from "node:os";
 import { resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 
-import { SplitLine } from "../shared/components/split-line";
-import { loadConfig } from "../shared/config";
-import { formatContextUsage, formatCost, formatCwd, linkText, sanitizeText } from "../shared/format";
-import { getEntryUsage } from "../shared/usage";
+import { SplitLine } from "../../components/split-line";
+import { loadConfig } from "../../config";
+import { formatContextUsage, formatCost, formatCwd, linkText, sanitizeText } from "../../utils/format";
+import { getEntryUsage } from "../../utils/usage";
 
 import type { ExtensionContext, ExtensionAPI, ReadonlyFooterDataProvider, Theme } from "@earendil-works/pi-coding-agent";
 import type { Component } from "@earendil-works/pi-tui";
@@ -80,12 +80,10 @@ class FooterComponent implements Component {
   }
 }
 
-export default function (pi: ExtensionAPI) {
+export function registerFooter(pi: ExtensionAPI): void {
   pi.on("session_start", (_event, ctx) => {
-    if (!ctx.hasUI) return;
-
-    const config = loadConfig(ctx, "footer");
-    if (!config) return;
+    const config = loadConfig(ctx).footer;
+    if (!ctx.hasUI || !config) return;
 
     ctx.ui.setFooter((_tui, theme, footerData) => new FooterComponent(ctx, theme, footerData));
   });

package/{extensions → src/features}/fullscreen/index.ts

@@ -1,12 +1,11 @@
 import { VERSION } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth } from "@earendil-works/pi-tui";
 
 import { BottomFiller } from "./filler";
-import { loadConfig } from "../shared/config";
-import { sanitizeText } from "../shared/format";
+import { loadConfig } from "../../config";
+import { sanitizeText } from "../../utils/format";
 
 import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
-import { truncateToWidth } from "@earendil-works/pi-tui";
-
 import type { TUI } from "@earendil-works/pi-tui";
 import type { UserMessage } from "@earendil-works/pi-ai";
 
@@ -33,16 +32,14 @@ function extractText(message: UserMessage): string {
   return content.filter((block) => block.type === "text").map((block) => block.text).join(" ");
 }
 
-export default function (pi: ExtensionAPI) {
+export function registerFullscreen(pi: ExtensionAPI): void {
   let tui: TUI | undefined;
   let enabled = false;
   let pendingClear = false;
 
   pi.on("session_start", (_event, ctx) => {
-    if (!ctx.hasUI) return;
-
-    const config = loadConfig(ctx, "fullscreen");
-    if (!config) return;
+    const config = loadConfig(ctx).fullscreen;
+    if (!ctx.hasUI || !config) return;
 
     enabled = true;
     pendingClear = true;

package/src/features/model/config.ts

@@ -0,0 +1,3 @@
+import * as z from "zod";
+
+export const modelConfigSchema = z.object({});

package/{extensions/models → src/features/model}/index.ts

@@ -4,8 +4,8 @@ import { Container, Spacer, Text } from "@earendil-works/pi-tui";
 import { filter, parse } from "liqe";
 import { Type } from "typebox";
 
-import { loadConfig } from "../shared/config";
-import { formatModel, formatTokens } from "../shared/format";
+import { loadConfig } from "../../config";
+import { formatModel, formatTokens } from "../../utils/format";
 
 import type { Api, Model, ModelThinkingLevel } from "@earendil-works/pi-ai";
 import type { ExtensionAPI, TruncationResult } from "@earendil-works/pi-coding-agent";
@@ -72,9 +72,9 @@ function formatListNotice(truncated: boolean, startIndex: number, endDisplay: nu
   return undefined;
 }
 
-export default function (pi: ExtensionAPI) {
+export function registerModel(pi: ExtensionAPI): void {
   pi.on("session_start", (_event, ctx) => {
-    const config = loadConfig(ctx, "models");
+    const config = loadConfig(ctx).model;
     if (!config) return;
 
     pi.registerTool({
@@ -89,7 +89,7 @@ export default function (pi: ExtensionAPI) {
       promptSnippet: "Show the active model or list pi models",
       promptGuidelines: [
         "Use the model tool when you need pi model metadata, the active model, or the thinking level, rather than guessing.",
-        "When listing models with the model tool, include available:true in the query unless unavailable models are explicitly needed.",
+        "Use the model tool with `available:true` in the query unless unavailable models are explicitly needed.",
       ],
       parameters: Type.Object({
         action: StringEnum(["active", "list"] as const, {

package/{extensions → src/features}/name/index.ts

@@ -1,25 +1,23 @@
 import { Container, Spacer, Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 
-import { loadConfig } from "../shared/config";
-import { sanitizeText } from "../shared/format";
+import { loadConfig } from "../../config";
+import { sanitizeText } from "../../utils/format";
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
-export default function (pi: ExtensionAPI) {
+export function registerName(pi: ExtensionAPI): void {
   pi.on("session_start", (_event, ctx) => {
-    if (!ctx.hasUI) return;
-
-    const config = loadConfig(ctx, "name");
+    const config = loadConfig(ctx).name;
     if (!config) return;
 
     pi.registerTool({
       name: "name",
       label: "name",
       description:
-        "Name or rename the current session. The name is a concise label shown in the session " +
+        "Set or update the current session's name. The name is a concise label shown in the session " +
         "selector instead of the first-message preview.",
-      promptSnippet: "Name or rename the current session",
+      promptSnippet: "Set or update the current session's name",
       promptGuidelines: [
         "Use the name tool when the session needs a concise, recognizable label, especially after a long, vague, or pasted opening prompt.",
         "Use the name tool to rename the session only after a substantial shift in the conversation's focus, not for minor follow-ups.",

package/{extensions → src/features}/presets/config.ts

@@ -1,6 +1,6 @@
 import * as z from "zod";
 
-import { modelSchema } from "../shared/config/model";
+import { modelSchema } from "../../config/model";
 
 export const presetsConfigSchema = z.record(z.string().min(1), modelSchema);
 

package/{extensions → src/features}/presets/index.ts

@@ -2,11 +2,11 @@ import { Key } from "@earendil-works/pi-tui";
 
 import { PresetManager } from "./manager";
 import { showPresetSelector } from "./selector";
-import { loadConfig } from "../shared/config";
+import { loadConfig } from "../../config";
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
-export default function (pi: ExtensionAPI) {
+export function registerPresets(pi: ExtensionAPI): void {
   let presetManager: PresetManager | undefined = undefined;
 
   pi.registerFlag("preset", {
@@ -14,10 +14,10 @@ export default function (pi: ExtensionAPI) {
     type: "string",
   });
 
-  pi.on("session_start", async (event, ctx) => {
+  pi.on("session_start", async (_event, ctx) => {
+    const config = loadConfig(ctx).presets;
     const presetFlag = pi.getFlag("preset");
 
-    const config = loadConfig(ctx, "presets");
     if (!config || Object.keys(config).length === 0) {
       if (presetFlag) ctx.ui.notify("No presets defined in spark.json", "warning");
       return;

package/{extensions → src/features}/presets/manager.ts

@@ -1,5 +1,5 @@
-import { PRESET_CHANGE } from "../shared/events";
-import { formatModel } from "../shared/format";
+import { PRESET_CHANGE } from "../../events";
+import { formatModel } from "../../utils/format";
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { PresetsConfig, PresetConfig } from "./config";

package/{extensions → src/features}/recap/config.ts

@@ -1,7 +1,7 @@
 import * as z from "zod";
 
 import { idleTimeoutSchema } from "./idle";
-import { optionalModelSchema } from "../shared/config/model";
+import { optionalModelSchema } from "../../config/model";
 
 export const recapConfigSchema = optionalModelSchema.extend({
   idle: idleTimeoutSchema.optional(),

package/{extensions → src/features}/recap/index.ts

@@ -1,18 +1,16 @@
 import { IdleListener } from "./idle";
 import { RecapManager } from "./manager";
-import { loadConfig } from "../shared/config";
+import { loadConfig } from "../../config";
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 
-export default function (pi: ExtensionAPI) {
+export function registerRecap(pi: ExtensionAPI): void {
   let idleListener: IdleListener<ExtensionContext> | undefined = undefined;
   let recapManager: RecapManager | undefined = undefined;
 
   pi.on("session_start", (event, ctx) => {
-    if (!ctx.hasUI) return;
-
-    const config = loadConfig(ctx, "recap");
-    if (!config) return;
+    const config = loadConfig(ctx).recap;
+    if (!ctx.hasUI || !config) return;
 
     recapManager = new RecapManager(pi, config);
 

package/{extensions → src/features}/recap/manager.ts

@@ -3,22 +3,22 @@ import { convertToLlm, serializeConversation } from "@earendil-works/pi-coding-a
 
 import { resolveRecapModelSettings } from "./model";
 import { clearRecapWidget, setRecapLoadingWidget, setRecapTextWidget } from "./widget";
-import { sanitizeText } from "../shared/format";
+import { sanitizeText } from "../../utils/format";
 
 import type { Api, Model, ModelThinkingLevel, SimpleStreamOptions, Usage } from "@earendil-works/pi-ai";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { RecapConfig } from "./config";
 
 const SYSTEM_PROMPT = [
-  "You write concise idle-session recaps for a terminal coding agent.",
+  "You write concise idle session recaps for a terminal coding agent.",
   "Use only transcript-supported facts; do not invent progress, intent, files, or next steps.",
   "Prefer the latest active task if the session changed direction.",
   "Summarize the user's goal, what was done, current state, and any clearly supported next step.",
-  "Respond in the conversation's primary language.",
-  "Output 1-2 plain-text sentences under 80 words. No heading, markdown, bullets, or quotes.",
+  "Respond in the conversation's primary language. Address the user in the second person.",
+  "Output 1-2 plain-text sentences under 40 words. No heading, markdown, bullets, or quotes.",
 ].join("\n");
 
-const MAX_TOKENS = 100;
+const MAX_TOKENS = 80;
 const MAX_CONVERSATION_CHARS = 8_000;
 
 export class RecapManager {