talon-agent 3.14.0 → 3.15.1

package/src/frontend/terminal/commands.ts

@@ -18,7 +18,13 @@ import {
 import {
   buildCacheDisplay,
   buildContextDisplay,
+  buildContextBreakdown,
+  estimateContextTokens,
+  apportionCells,
+  type ContextBreakdown,
+  type ContextSegmentKey,
 } from "../shared/status-context.js";
+import { getRecentHistory } from "../../storage/history.js";
 import {
   formatDuration,
   formatTokenCount,
@@ -113,6 +119,63 @@ export function clearCommands(): void {
   nameIndex.clear();
 }
 
+// ── /context rendering ───────────────────────────────────────────────────────
+
+/** Each used segment gets its own colour; free is a dim hatch. */
+const CONTEXT_SEGMENT_COLOR: Record<ContextSegmentKey, (s: string) => string> =
+  {
+    system: pc.blue,
+    tools: pc.yellow,
+    conversation: pc.cyan,
+  };
+
+const CONTEXT_BAR_WIDTH = 42;
+
+/**
+ * The segmented bar: one coloured run per segment (proportional to the window),
+ * then the free space as a dim `░` hatch. Cell counts come from
+ * `apportionCells`, so the runs always sum to exactly the bar width.
+ */
+function renderContextBar(bd: ContextBreakdown): string {
+  const weights = bd.segments.map((s) => s.tokens);
+  if (bd.windowKnown) weights.push(bd.free);
+  const cells = apportionCells(weights, CONTEXT_BAR_WIDTH);
+  let bar = "";
+  bd.segments.forEach((s, i) => {
+    bar += CONTEXT_SEGMENT_COLOR[s.key]("█".repeat(cells[i] ?? 0));
+  });
+  if (bd.windowKnown) {
+    bar += pc.dim("░".repeat(cells[bd.segments.length] ?? 0));
+  }
+  return bar;
+}
+
+/** One aligned legend row per segment (and Free), colour-matched to the bar. */
+function renderContextLegend(bd: ContextBreakdown): string[] {
+  const rows = bd.segments.map((s) => ({
+    dot: CONTEXT_SEGMENT_COLOR[s.key]("●"),
+    label: s.label,
+    tokens: s.tokens,
+    pct: s.pct,
+  }));
+  if (bd.windowKnown) {
+    rows.push({
+      dot: pc.dim("░"),
+      label: "Free",
+      tokens: bd.free,
+      pct: bd.freePct,
+    });
+  }
+  const labelW = Math.max(...rows.map((r) => r.label.length));
+  const tokW = Math.max(...rows.map((r) => formatTokenCount(r.tokens).length));
+  return rows.map((r) => {
+    const label = r.label.padEnd(labelW);
+    const tok = formatTokenCount(r.tokens).padStart(tokW);
+    const pct = `${r.pct}%`.padStart(6);
+    return `${r.dot} ${label}  ${pc.dim(tok)}  ${pc.dim(pct)}`;
+  });
+}
+
 // ── Built-in commands ────────────────────────────────────────────────────────
 
 export function registerBuiltinCommands(): void {
@@ -393,6 +456,95 @@ export function registerBuiltinCommands(): void {
     },
   });
 
+  registerCommand({
+    name: "context",
+    aliases: ["ctx"],
+    description: "Context-window usage, broken down",
+    async handler(_args, ctx) {
+      const chatId = ctx.chatId();
+      const u = getSessionInfo(chatId).usage;
+      const be = ctx.backend;
+      const activeModel = getChatSettings(chatId).model ?? ctx.config.model;
+
+      // Window + a friendly model name, enriched from the backend like /status.
+      let contextWindow = u.contextWindow;
+      let modelName = resolveModelName(activeModel);
+      if (be?.models?.getRawModelInfo) {
+        const mi = await be.models
+          .getRawModelInfo(activeModel)
+          .catch(() => undefined);
+        if (mi) {
+          if (mi.contextWindow) contextWindow ||= mi.contextWindow;
+          if (mi.displayName) modelName = mi.displayName;
+        }
+      }
+
+      // System = the actual frozen prompt the model is running with. Measure
+      // it directly rather than rebuilding, so the number matches what was
+      // really sent (the prompt is frozen per session by design).
+      const parts = ctx.config.systemPromptParts;
+      const systemText = parts
+        ? [parts.staticText, parts.dynamicText].filter(Boolean).join("\n")
+        : (ctx.config.systemPrompt ?? "");
+      const systemTokens = estimateContextTokens(systemText);
+
+      // Conversation = stored history for this chat. An estimate: the model's
+      // real in-window history may be smaller after compaction, which the
+      // breakdown clamps against the authoritative fill.
+      const history = getRecentHistory(chatId, 2000);
+      const conversationTokens = estimateContextTokens(
+        history.map((m) => m.text ?? "").join("\n"),
+      );
+
+      const bd = buildContextBreakdown({
+        contextTokens: u.contextTokens,
+        contextWindow,
+        systemTokens,
+        conversationTokens,
+      });
+
+      ctx.renderer.writeln();
+      if (!bd.known) {
+        ctx.renderer.writeln(
+          `  ${pc.bold("Context")}  ${pc.dim("no usage yet — send a message first")}`,
+        );
+        ctx.reprompt();
+        return;
+      }
+
+      const windowStr = bd.windowKnown
+        ? `${formatTokenCount(bd.max)} window`
+        : pc.dim("window unknown");
+      ctx.renderer.writeln(
+        `  ${pc.bold("Context")}  ${modelName}  ·  ${windowStr}`,
+      );
+
+      const usedStr = bd.windowKnown
+        ? `${formatTokenCount(bd.used)} / ${formatTokenCount(bd.max)}  ·  ${bd.usedPct}% used`
+        : `${formatTokenCount(bd.used)} used`;
+      ctx.renderer.writeln(
+        `  ${bd.warn ? pc.yellow(usedStr) : pc.dim(usedStr)}${bd.warn ? pc.yellow("  · nearing limit") : ""}`,
+      );
+      ctx.renderer.writeln();
+      ctx.renderer.writeln(`  ${renderContextBar(bd)}`);
+      ctx.renderer.writeln();
+      for (const line of renderContextLegend(bd)) {
+        ctx.renderer.writeln(`  ${line}`);
+      }
+      // Explain only what's on screen: Tools is derivable (and shown) only
+      // when the backend reported a real fill.
+      const hasTools = bd.segments.some((s) => s.key === "tools");
+      ctx.renderer.writeln(
+        `  ${pc.dim(
+          hasTools
+            ? "System measured; Conversation estimated; Tools is the remainder."
+            : "System measured; Conversation estimated from stored history.",
+        )}`,
+      );
+      ctx.reprompt();
+    },
+  });
+
   registerCommand({
     name: "reset",
     description: "Start a fresh session",

package/src/util/respawn.ts

@@ -3,8 +3,7 @@
  *
  * Spawns a fresh copy of the current process — same Node binary,
  * same `execArgv` (preserving the tsx loader so `.ts` entrypoints
- * still resolve), same script + user args, same cwd + env — then
- * triggers a graceful shutdown of the current process. The new
+ * still resolve), same script + user args, same cwd + env. The new
  * child is detached with stdio:"ignore" so it survives the parent's
  * exit; calling `unref()` lets the parent exit without waiting on
  * it.
@@ -16,59 +15,88 @@
  * debugger. Respawning from our own `process.argv` works regardless
  * of launch method.
  *
- * Shutdown is done by raising SIGTERM on ourselves rather than
- * `process.exit(0)` so the existing graceful-shutdown handler runs
- * (`await frontend.stop()`, flush sessions, remove PID file). The
- * brief overlap between the new child binding Telegram's long-poll
- * and the old one releasing it is benign — grammy retries on 409
- * Conflict and the new child takes over within a few seconds.
+ * Ordering matters. `respawnSelf()` only *arms* the handoff and
+ * raises SIGTERM; the successor is spawned by `spawnSuccessor()` at
+ * the tail of graceful shutdown, once the frontends have stopped.
+ * Spawning up-front (the previous behaviour) left the successor
+ * long-polling `getUpdates` while the outgoing process was still
+ * draining in-flight queries — up to DRAIN_TIMEOUT_MS of two live
+ * pollers. Telegram answers only one of them and re-delivers the
+ * unconfirmed updates to the other, so a restart mid-turn produced
+ * a 409 Conflict on the way out and duplicate replies on the way in.
+ * Releasing the poll before the successor binds it removes the
+ * overlap rather than relying on grammy's 409 retry to paper over it.
  */
 
 import { spawn } from "node:child_process";
 import { log, logError } from "./log.js";
 
+let pendingReason: string | null = null;
+
 /**
- * Respawn the current process with identical argv + flags, then
- * raise SIGTERM on ourselves so the existing graceful-shutdown path
- * cleanly stops the frontend, flushes state, and exits.
+ * Arm a respawn and raise SIGTERM on ourselves so the existing
+ * graceful-shutdown path cleanly stops the frontends, flushes state,
+ * and hands off via `spawnSuccessor()`.
  *
  * `reason` is logged for operator visibility (e.g. "telegram
- * /restart"). The function returns immediately; the actual exit
- * happens asynchronously once the child has spawned (or failed).
+ * /restart"). The function returns immediately; the successor starts
+ * only after shutdown has released the Telegram long-poll.
  */
 export function respawnSelf(reason: string): void {
   log("shutdown", `Respawn requested (${reason})`);
+  pendingReason = reason;
+  // SIGTERM triggers the graceful-shutdown handler in src/app.ts,
+  // which stops the frontends, flushes state, spawns the successor,
+  // and calls process.exit(0). Don't exit here directly — that would
+  // skip the flush and leave the PID file dangling.
+  process.kill(process.pid, "SIGTERM");
+}
 
-  const child = spawn(
-    process.argv[0],
-    [...process.execArgv, ...process.argv.slice(1)],
-    {
-      cwd: process.cwd(),
-      detached: true,
-      stdio: "ignore",
-      env: { ...process.env },
-    },
-  );
+/** True when a `/restart` or `/update` armed a handoff. */
+export function respawnRequested(): boolean {
+  return pendingReason !== null;
+}
 
-  child.once("spawn", () => {
-    log("shutdown", `Respawn child started (pid ${child.pid}) — exiting self`);
-    child.unref();
-    // SIGTERM triggers the existing graceful-shutdown handler in
-    // src/index.ts, which stops the frontend, flushes state, and
-    // calls process.exit(0). Don't exit here directly — that would
-    // skip the flush and leave the PID file dangling.
-    process.kill(process.pid, "SIGTERM");
-  });
+/**
+ * Spawn the successor process. Called at the end of graceful
+ * shutdown, after the frontends have stopped — so the incoming
+ * process binds Telegram's long-poll only once this one has let go
+ * of it. No-op unless `respawnSelf()` armed a handoff.
+ *
+ * Never throws: a failed handoff must not prevent this process from
+ * exiting. An external supervisor (systemd, pm2, the user's
+ * terminal) can pick things up.
+ */
+export function spawnSuccessor(): void {
+  if (pendingReason === null) return;
+  const reason = pendingReason;
+  pendingReason = null;
 
-  child.once("error", (err) => {
+  try {
+    const child = spawn(
+      process.argv[0],
+      [...process.execArgv, ...process.argv.slice(1)],
+      {
+        cwd: process.cwd(),
+        detached: true,
+        stdio: "ignore",
+        env: { ...process.env },
+      },
+    );
+    child.once("error", (err) => {
+      logError(
+        "shutdown",
+        `Respawn failed; exiting without a successor — restart manually`,
+        err,
+      );
+    });
+    child.unref();
+    log("shutdown", `Respawn child started (pid ${child.pid}) — ${reason}`);
+  } catch (err) {
     logError(
       "shutdown",
       `Respawn failed; exiting without a successor — restart manually`,
       err,
     );
-    // The child never started, so we can't hand off. Still exit so
-    // any external supervisor (systemd, pm2, the user's terminal)
-    // can pick things up.
-    process.kill(process.pid, "SIGTERM");
-  });
+  }
 }