@selesai/code 0.10.1 → 0.10.2

package/dist/extensions/pi-intercom/broker/paths.ts

@@ -1,134 +1,134 @@
-import { chmodSync, mkdirSync, readFileSync } from "fs";
-import { isAbsolute, join, resolve } from "path";
-import { getAgentDir } from "@selesai/code";
-
-export const INTERCOM_DIR_MODE = 0o700;
-export const INTERCOM_RUNTIME_FILE_MODE = 0o600;
-export const INTERCOM_TCP_HOST = "127.0.0.1";
-export const INTERCOM_PROTOCOL_NAME = "pi-intercom";
-export const INTERCOM_PROTOCOL_VERSION = 1;
-
-export interface BrokerTcpEndpoint {
-  transport: "tcp";
-  host: string;
-  port: number;
-  stateId?: string;
-}
-
-export type BrokerConnectTarget = string | BrokerTcpEndpoint;
-
-function sanitizePipeSegment(value: string): string {
-  return value
-    .replace(/[^a-zA-Z0-9]+/g, "-")
-    .replace(/^-+|-+$/g, "")
-    .toLowerCase() || "default";
-}
-
-export function getAgentDirPath(
-  env: NodeJS.ProcessEnv = process.env,
-  cwd: string = process.cwd(),
-): string {
-  const configured = env.SELESAI_CODING_AGENT_DIR?.trim();
-  if (!configured) {
-    return getAgentDir();
-  }
-
-  return isAbsolute(configured) ? configured : resolve(cwd, configured);
-}
-
-export function getIntercomDirPath(agentDir: string = getAgentDirPath()): string {
-  return join(agentDir, "intercom");
-}
-
-export function shouldUseWindowsTcpTransport(
-  platform: NodeJS.Platform = process.platform,
-  env: NodeJS.ProcessEnv = process.env,
-): boolean {
-  if (platform !== "win32") {
-    return false;
-  }
-
-  const transport = env.PI_INTERCOM_TRANSPORT?.trim().toLowerCase();
-  if (transport === "tcp") {
-    return true;
-  }
-
-  const legacyOptIn = env.PI_INTERCOM_TCP?.trim().toLowerCase();
-  return legacyOptIn === "1" || legacyOptIn === "true";
-}
-
-export function getBrokerPortFilePath(intercomDir: string = getIntercomDirPath()): string {
-  return join(intercomDir, "broker.port.json");
-}
-
-export function getBrokerSocketPath(
-  platform: NodeJS.Platform = process.platform,
-  agentDir: string = getAgentDirPath(),
-): string {
-  if (platform === "win32") {
-    return `\\\\.\\pipe\\pi-intercom-${sanitizePipeSegment(agentDir)}`;
-  }
-
-  return join(getIntercomDirPath(agentDir), "broker.sock");
-}
-
-export function getBrokerConnectTarget(
-  platform: NodeJS.Platform = process.platform,
-  env: NodeJS.ProcessEnv = process.env,
-  intercomDir: string = getIntercomDirPath(getAgentDirPath(env)),
-): BrokerConnectTarget {
-  if (shouldUseWindowsTcpTransport(platform, env)) {
-    const endpointFile = getBrokerPortFilePath(intercomDir);
-    const raw = readFileSync(endpointFile, "utf-8");
-    const parsed: unknown = JSON.parse(raw);
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-      throw new Error(`Invalid intercom TCP endpoint at ${endpointFile}: expected a JSON object`);
-    }
-    const endpoint = parsed as Record<string, unknown>;
-    if (
-      endpoint.transport !== "tcp"
-      || endpoint.host !== INTERCOM_TCP_HOST
-      || typeof endpoint.port !== "number"
-      || !Number.isSafeInteger(endpoint.port)
-      || endpoint.port <= 0
-      || endpoint.port > 65535
-      || typeof endpoint.stateId !== "string"
-      || endpoint.stateId.length === 0
-    ) {
-      throw new Error(`Invalid intercom TCP endpoint at ${endpointFile}`);
-    }
-    return { transport: "tcp", host: endpoint.host, port: endpoint.port, stateId: endpoint.stateId };
-  }
-
-  return getBrokerSocketPath(platform, getAgentDirPath(env));
-}
-
-export function getBrokerListenTarget(
-  platform: NodeJS.Platform = process.platform,
-  env: NodeJS.ProcessEnv = process.env,
-): BrokerConnectTarget {
-  if (shouldUseWindowsTcpTransport(platform, env)) {
-    return { transport: "tcp", host: INTERCOM_TCP_HOST, port: 0 };
-  }
-
-  return getBrokerSocketPath(platform, getAgentDirPath(env));
-}
-
-export function ensureIntercomRuntimeDir(
-  intercomDir: string = getIntercomDirPath(),
-  platform: NodeJS.Platform = process.platform,
-): void {
-  mkdirSync(intercomDir, { recursive: true, mode: INTERCOM_DIR_MODE });
-  if (platform !== "win32") {
-    chmodSync(intercomDir, INTERCOM_DIR_MODE);
-  }
-}
-
-export function restrictIntercomRuntimeFile(
-  filePath: string,
-  platform: NodeJS.Platform = process.platform,
-): void {
-  if (platform !== "win32") {
-    chmodSync(filePath, INTERCOM_RUNTIME_FILE_MODE);
-  }
-}
+import { chmodSync, mkdirSync, readFileSync } from "fs";
+import { isAbsolute, join, resolve } from "path";
+import { getAgentDir } from "@selesai/code";
+
+export const INTERCOM_DIR_MODE = 0o700;
+export const INTERCOM_RUNTIME_FILE_MODE = 0o600;
+export const INTERCOM_TCP_HOST = "127.0.0.1";
+export const INTERCOM_PROTOCOL_NAME = "pi-intercom";
+export const INTERCOM_PROTOCOL_VERSION = 1;
+
+export interface BrokerTcpEndpoint {
+  transport: "tcp";
+  host: string;
+  port: number;
+  stateId?: string;
+}
+
+export type BrokerConnectTarget = string | BrokerTcpEndpoint;
+
+function sanitizePipeSegment(value: string): string {
+  return value
+    .replace(/[^a-zA-Z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .toLowerCase() || "default";
+}
+
+export function getAgentDirPath(
+  env: NodeJS.ProcessEnv = process.env,
+  cwd: string = process.cwd(),
+): string {
+  const configured = env.SELESAI_CODING_AGENT_DIR?.trim();
+  if (!configured) {
+    return getAgentDir();
+  }
+
+  return isAbsolute(configured) ? configured : resolve(cwd, configured);
+}
+
+export function getIntercomDirPath(agentDir: string = getAgentDirPath()): string {
+  return join(agentDir, "intercom");
+}
+
+export function shouldUseWindowsTcpTransport(
+  platform: NodeJS.Platform = process.platform,
+  env: NodeJS.ProcessEnv = process.env,
+): boolean {
+  if (platform !== "win32") {
+    return false;
+  }
+
+  const transport = env.PI_INTERCOM_TRANSPORT?.trim().toLowerCase();
+  if (transport === "tcp") {
+    return true;
+  }
+
+  const legacyOptIn = env.PI_INTERCOM_TCP?.trim().toLowerCase();
+  return legacyOptIn === "1" || legacyOptIn === "true";
+}
+
+export function getBrokerPortFilePath(intercomDir: string = getIntercomDirPath()): string {
+  return join(intercomDir, "broker.port.json");
+}
+
+export function getBrokerSocketPath(
+  platform: NodeJS.Platform = process.platform,
+  agentDir: string = getAgentDirPath(),
+): string {
+  if (platform === "win32") {
+    return `\\\\.\\pipe\\pi-intercom-${sanitizePipeSegment(agentDir)}`;
+  }
+
+  return join(getIntercomDirPath(agentDir), "broker.sock");
+}
+
+export function getBrokerConnectTarget(
+  platform: NodeJS.Platform = process.platform,
+  env: NodeJS.ProcessEnv = process.env,
+  intercomDir: string = getIntercomDirPath(getAgentDirPath(env)),
+): BrokerConnectTarget {
+  if (shouldUseWindowsTcpTransport(platform, env)) {
+    const endpointFile = getBrokerPortFilePath(intercomDir);
+    const raw = readFileSync(endpointFile, "utf-8");
+    const parsed: unknown = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new Error(`Invalid intercom TCP endpoint at ${endpointFile}: expected a JSON object`);
+    }
+    const endpoint = parsed as Record<string, unknown>;
+    if (
+      endpoint.transport !== "tcp"
+      || endpoint.host !== INTERCOM_TCP_HOST
+      || typeof endpoint.port !== "number"
+      || !Number.isSafeInteger(endpoint.port)
+      || endpoint.port <= 0
+      || endpoint.port > 65535
+      || typeof endpoint.stateId !== "string"
+      || endpoint.stateId.length === 0
+    ) {
+      throw new Error(`Invalid intercom TCP endpoint at ${endpointFile}`);
+    }
+    return { transport: "tcp", host: endpoint.host, port: endpoint.port, stateId: endpoint.stateId };
+  }
+
+  return getBrokerSocketPath(platform, getAgentDirPath(env));
+}
+
+export function getBrokerListenTarget(
+  platform: NodeJS.Platform = process.platform,
+  env: NodeJS.ProcessEnv = process.env,
+): BrokerConnectTarget {
+  if (shouldUseWindowsTcpTransport(platform, env)) {
+    return { transport: "tcp", host: INTERCOM_TCP_HOST, port: 0 };
+  }
+
+  return getBrokerSocketPath(platform, getAgentDirPath(env));
+}
+
+export function ensureIntercomRuntimeDir(
+  intercomDir: string = getIntercomDirPath(),
+  platform: NodeJS.Platform = process.platform,
+): void {
+  mkdirSync(intercomDir, { recursive: true, mode: INTERCOM_DIR_MODE });
+  if (platform !== "win32") {
+    chmodSync(intercomDir, INTERCOM_DIR_MODE);
+  }
+}
+
+export function restrictIntercomRuntimeFile(
+  filePath: string,
+  platform: NodeJS.Platform = process.platform,
+): void {
+  if (platform !== "win32") {
+    chmodSync(filePath, INTERCOM_RUNTIME_FILE_MODE);
+  }
+}

package/dist/extensions/pi-intercom/broker/runtime-claim.test.ts

@@ -1,34 +1,34 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import path from "node:path";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { assertNoLiveBroker } from "./runtime-claim.ts";
-
-test("broker startup refuses to replace a live broker PID", () => {
-  const directory = mkdtempSync(path.join(tmpdir(), "pi-intercom-runtime-"));
-  const pidPath = path.join(directory, "broker.pid");
-  try {
-    writeFileSync(pidPath, `${process.pid}\n`);
-    assert.throws(
-      () => assertNoLiveBroker(pidPath),
-      new RegExp(`Refusing to replace live intercom broker process ${process.pid}`),
-    );
-  } finally {
-    rmSync(directory, { recursive: true, force: true });
-  }
-});
-
-test("broker startup tolerates absent, invalid, and stale PID files", () => {
-  const directory = mkdtempSync(path.join(tmpdir(), "pi-intercom-runtime-"));
-  const pidPath = path.join(directory, "broker.pid");
-  try {
-    assert.doesNotThrow(() => assertNoLiveBroker(pidPath));
-    writeFileSync(pidPath, "invalid\n");
-    assert.doesNotThrow(() => assertNoLiveBroker(pidPath));
-    writeFileSync(pidPath, "2147483647\n");
-    assert.doesNotThrow(() => assertNoLiveBroker(pidPath));
-  } finally {
-    rmSync(directory, { recursive: true, force: true });
-  }
-});
+import test from "node:test";
+import assert from "node:assert/strict";
+import path from "node:path";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { assertNoLiveBroker } from "./runtime-claim.ts";
+
+test("broker startup refuses to replace a live broker PID", () => {
+  const directory = mkdtempSync(path.join(tmpdir(), "pi-intercom-runtime-"));
+  const pidPath = path.join(directory, "broker.pid");
+  try {
+    writeFileSync(pidPath, `${process.pid}\n`);
+    assert.throws(
+      () => assertNoLiveBroker(pidPath),
+      new RegExp(`Refusing to replace live intercom broker process ${process.pid}`),
+    );
+  } finally {
+    rmSync(directory, { recursive: true, force: true });
+  }
+});
+
+test("broker startup tolerates absent, invalid, and stale PID files", () => {
+  const directory = mkdtempSync(path.join(tmpdir(), "pi-intercom-runtime-"));
+  const pidPath = path.join(directory, "broker.pid");
+  try {
+    assert.doesNotThrow(() => assertNoLiveBroker(pidPath));
+    writeFileSync(pidPath, "invalid\n");
+    assert.doesNotThrow(() => assertNoLiveBroker(pidPath));
+    writeFileSync(pidPath, "2147483647\n");
+    assert.doesNotThrow(() => assertNoLiveBroker(pidPath));
+  } finally {
+    rmSync(directory, { recursive: true, force: true });
+  }
+});

package/dist/extensions/pi-intercom/broker/runtime-claim.ts

@@ -1,21 +1,21 @@
-import { existsSync, readFileSync } from "node:fs";
-
-export function assertNoLiveBroker(pidPath: string): void {
-  if (!existsSync(pidPath)) return;
-
-  let pid: number;
-  try {
-    pid = Number.parseInt(readFileSync(pidPath, "utf8").trim(), 10);
-  } catch {
-    return;
-  }
-  if (!Number.isSafeInteger(pid) || pid <= 0) return;
-
-  try {
-    process.kill(pid, 0);
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === "ESRCH") return;
-    throw error;
-  }
-  throw new Error(`Refusing to replace live intercom broker process ${pid}`);
-}
+import { existsSync, readFileSync } from "node:fs";
+
+export function assertNoLiveBroker(pidPath: string): void {
+  if (!existsSync(pidPath)) return;
+
+  let pid: number;
+  try {
+    pid = Number.parseInt(readFileSync(pidPath, "utf8").trim(), 10);
+  } catch {
+    return;
+  }
+  if (!Number.isSafeInteger(pid) || pid <= 0) return;
+
+  try {
+    process.kill(pid, 0);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ESRCH") return;
+    throw error;
+  }
+  throw new Error(`Refusing to replace live intercom broker process ${pid}`);
+}

package/dist/extensions/pi-intercom/cwd.test.ts

@@ -1,40 +1,40 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, symlinkSync, mkdirSync, realpathSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { normalizeCwd, sameCwd } from "./cwd.ts";
-
-test("sameCwd collapses a trailing slash", () => {
-  assert.equal(sameCwd("/usr/local", "/usr/local/"), true);
-});
-
-test("sameCwd collapses lexical '.' and '..' segments", () => {
-  assert.equal(sameCwd("/usr/local/../local/./bin", "/usr/local/bin"), true);
-});
-
-test("sameCwd treats genuinely different directories as different", () => {
-  assert.equal(sameCwd("/usr/local", "/usr/lib"), false);
-});
-
-test("sameCwd collapses a symlink to its real target", () => {
-  const base = mkdtempSync(join(tmpdir(), "cwd-symlink-"));
-  try {
-    const real = join(base, "real");
-    const link = join(base, "link");
-    mkdirSync(real);
-    symlinkSync(real, link);
-    // Reached via the symlink vs its canonical path — must compare equal.
-    assert.equal(sameCwd(link, real), true);
-    // And normalizeCwd resolves the link to the real path.
-    assert.equal(normalizeCwd(link), realpathSync(real));
-  } finally {
-    rmSync(base, { recursive: true, force: true });
-  }
-});
-
-test("normalizeCwd falls back to the resolved path for a nonexistent dir", () => {
-  // realpathSync throws for a missing dir; normalizeCwd must still collapse the
-  // lexical variants rather than throw.
-  assert.equal(normalizeCwd("/no/such/dir/../dir"), "/no/such/dir");
-});
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, symlinkSync, mkdirSync, realpathSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { normalizeCwd, sameCwd } from "./cwd.ts";
+
+test("sameCwd collapses a trailing slash", () => {
+  assert.equal(sameCwd("/usr/local", "/usr/local/"), true);
+});
+
+test("sameCwd collapses lexical '.' and '..' segments", () => {
+  assert.equal(sameCwd("/usr/local/../local/./bin", "/usr/local/bin"), true);
+});
+
+test("sameCwd treats genuinely different directories as different", () => {
+  assert.equal(sameCwd("/usr/local", "/usr/lib"), false);
+});
+
+test("sameCwd collapses a symlink to its real target", () => {
+  const base = mkdtempSync(join(tmpdir(), "cwd-symlink-"));
+  try {
+    const real = join(base, "real");
+    const link = join(base, "link");
+    mkdirSync(real);
+    symlinkSync(real, link);
+    // Reached via the symlink vs its canonical path — must compare equal.
+    assert.equal(sameCwd(link, real), true);
+    // And normalizeCwd resolves the link to the real path.
+    assert.equal(normalizeCwd(link), realpathSync(real));
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("normalizeCwd falls back to the resolved path for a nonexistent dir", () => {
+  // realpathSync throws for a missing dir; normalizeCwd must still collapse the
+  // lexical variants rather than throw.
+  assert.equal(normalizeCwd("/no/such/dir/../dir"), "/no/such/dir");
+});

package/dist/extensions/pi-intercom/cwd.ts

@@ -1,31 +1,31 @@
-import { resolve } from "node:path";
-import { realpathSync } from "node:fs";
-
-// Normalize a cwd for same-directory comparison. A raw string match ("a === b")
-// hides genuine same-directory peers when two cwd strings differ only by a
-// trailing slash, a "."/".." segment, or a symlink (e.g. macOS /tmp <->
-// /private/tmp). resolve() collapses the lexical variants; realpathSync()
-// collapses symlinks (best-effort: falls back to the resolved path if the
-// directory no longer exists). Memoized — the set of distinct cwd strings is
-// small and stable, so repeat comparisons are free after warmup.
-const normalizeCache = new Map<string, string>();
-
-export function normalizeCwd(cwd: string): string {
-  const cached = normalizeCache.get(cwd);
-  if (cached !== undefined) {
-    return cached;
-  }
-  const resolved = resolve(cwd);
-  let normalized: string;
-  try {
-    normalized = realpathSync(resolved);
-  } catch {
-    normalized = resolved;
-  }
-  normalizeCache.set(cwd, normalized);
-  return normalized;
-}
-
-export function sameCwd(a: string, b: string): boolean {
-  return normalizeCwd(a) === normalizeCwd(b);
-}
+import { resolve } from "node:path";
+import { realpathSync } from "node:fs";
+
+// Normalize a cwd for same-directory comparison. A raw string match ("a === b")
+// hides genuine same-directory peers when two cwd strings differ only by a
+// trailing slash, a "."/".." segment, or a symlink (e.g. macOS /tmp <->
+// /private/tmp). resolve() collapses the lexical variants; realpathSync()
+// collapses symlinks (best-effort: falls back to the resolved path if the
+// directory no longer exists). Memoized — the set of distinct cwd strings is
+// small and stable, so repeat comparisons are free after warmup.
+const normalizeCache = new Map<string, string>();
+
+export function normalizeCwd(cwd: string): string {
+  const cached = normalizeCache.get(cwd);
+  if (cached !== undefined) {
+    return cached;
+  }
+  const resolved = resolve(cwd);
+  let normalized: string;
+  try {
+    normalized = realpathSync(resolved);
+  } catch {
+    normalized = resolved;
+  }
+  normalizeCache.set(cwd, normalized);
+  return normalized;
+}
+
+export function sameCwd(a: string, b: string): boolean {
+  return normalizeCwd(a) === normalizeCwd(b);
+}

package/dist/extensions/pi-intercom/format-context.test.ts

@@ -1,31 +1,31 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { formatTokenCount, formatContextUsage } from "./format-context.ts";
-import type { SessionInfo } from "./types.ts";
-
-const base: SessionInfo = { id: "s1", cwd: "/w", model: "m", pid: 1, startedAt: 0, lastActivity: 0 };
-
-test("formatTokenCount compacts thousands", () => {
-  assert.equal(formatTokenCount(0), "0");
-  assert.equal(formatTokenCount(999), "999");
-  assert.equal(formatTokenCount(1432), "1.4k");
-  assert.equal(formatTokenCount(144000), "144k");
-  assert.equal(formatTokenCount(200000), "200k");
-});
-
-test("formatContextUsage renders percent + token detail when all known", () => {
-  assert.equal(
-    formatContextUsage({ ...base, contextPct: 72, contextTokens: 144000, contextWindow: 200000 }),
-    " · 72% ctx (144k/200k)",
-  );
-});
-
-test("formatContextUsage shows percent only when token counts are absent", () => {
-  assert.equal(formatContextUsage({ ...base, contextPct: 30 }), " · 30% ctx");
-});
-
-test("formatContextUsage renders nothing when percent is unknown (never a stale %)", () => {
-  assert.equal(formatContextUsage(base), "");
-  // Tokens present but no percent (e.g. right after a compaction) still renders nothing.
-  assert.equal(formatContextUsage({ ...base, contextTokens: 100, contextWindow: 200 }), "");
-});
+import test from "node:test";
+import assert from "node:assert/strict";
+import { formatTokenCount, formatContextUsage } from "./format-context.ts";
+import type { SessionInfo } from "./types.ts";
+
+const base: SessionInfo = { id: "s1", cwd: "/w", model: "m", pid: 1, startedAt: 0, lastActivity: 0 };
+
+test("formatTokenCount compacts thousands", () => {
+  assert.equal(formatTokenCount(0), "0");
+  assert.equal(formatTokenCount(999), "999");
+  assert.equal(formatTokenCount(1432), "1.4k");
+  assert.equal(formatTokenCount(144000), "144k");
+  assert.equal(formatTokenCount(200000), "200k");
+});
+
+test("formatContextUsage renders percent + token detail when all known", () => {
+  assert.equal(
+    formatContextUsage({ ...base, contextPct: 72, contextTokens: 144000, contextWindow: 200000 }),
+    " · 72% ctx (144k/200k)",
+  );
+});
+
+test("formatContextUsage shows percent only when token counts are absent", () => {
+  assert.equal(formatContextUsage({ ...base, contextPct: 30 }), " · 30% ctx");
+});
+
+test("formatContextUsage renders nothing when percent is unknown (never a stale %)", () => {
+  assert.equal(formatContextUsage(base), "");
+  // Tokens present but no percent (e.g. right after a compaction) still renders nothing.
+  assert.equal(formatContextUsage({ ...base, contextTokens: 100, contextWindow: 200 }), "");
+});

package/dist/extensions/pi-intercom/format-context.ts

@@ -1,32 +1,32 @@
-import type { SessionInfo } from "./types.ts";
-
-// Compact token count for display: 1432 -> "1.4k", 144000 -> "144k". Keeps list
-// rows short while staying legible.
-export function formatTokenCount(tokens: number): string {
-  if (tokens < 1000) {
-    return String(Math.max(0, Math.round(tokens)));
-  }
-  const k = tokens / 1000;
-  const value = k >= 100 ? String(Math.round(k)) : k.toFixed(1).replace(/\.0$/, "");
-  return `${value}k`;
-}
-
-// Render a session's context-window usage to sit beside its model, e.g.
-// " · 72% ctx (144k/200k)". The token detail is appended only when both counts
-// are known. Unknown percent (e.g. right after a compaction, before the next
-// assistant response) renders nothing, so a frozen value is never shown as a
-// stale percentage.
-export function formatContextUsage(session: SessionInfo): string {
-  if (typeof session.contextPct !== "number") {
-    return "";
-  }
-  let out = ` · ${session.contextPct}% ctx`;
-  if (
-    typeof session.contextTokens === "number"
-    && typeof session.contextWindow === "number"
-    && session.contextWindow > 0
-  ) {
-    out += ` (${formatTokenCount(session.contextTokens)}/${formatTokenCount(session.contextWindow)})`;
-  }
-  return out;
-}
+import type { SessionInfo } from "./types.ts";
+
+// Compact token count for display: 1432 -> "1.4k", 144000 -> "144k". Keeps list
+// rows short while staying legible.
+export function formatTokenCount(tokens: number): string {
+  if (tokens < 1000) {
+    return String(Math.max(0, Math.round(tokens)));
+  }
+  const k = tokens / 1000;
+  const value = k >= 100 ? String(Math.round(k)) : k.toFixed(1).replace(/\.0$/, "");
+  return `${value}k`;
+}
+
+// Render a session's context-window usage to sit beside its model, e.g.
+// " · 72% ctx (144k/200k)". The token detail is appended only when both counts
+// are known. Unknown percent (e.g. right after a compaction, before the next
+// assistant response) renders nothing, so a frozen value is never shown as a
+// stale percentage.
+export function formatContextUsage(session: SessionInfo): string {
+  if (typeof session.contextPct !== "number") {
+    return "";
+  }
+  let out = ` · ${session.contextPct}% ctx`;
+  if (
+    typeof session.contextTokens === "number"
+    && typeof session.contextWindow === "number"
+    && session.contextWindow > 0
+  ) {
+    out += ` (${formatTokenCount(session.contextTokens)}/${formatTokenCount(session.contextWindow)})`;
+  }
+  return out;
+}