@hicaru/pi-rlm 0.3.19 → 0.3.21

package/src/text/tokens.ts

@@ -7,6 +7,9 @@
  */
 
 const CHARS_PER_TOKEN = 4;
+// CJK ideographs/kana/hangul encode ~1.5 chars per token — the flat /4 heuristic under-counts
+// CJK-heavy content ~2.7x, delaying compaction and budget walls until near overflow.
+const CJK_CHARS_PER_TOKEN = 1.5;
 
 /** Rough token count for a character length (≈4 chars/token). Always ≥ 1 for non-empty text. */
 export function estimateTokens(charCount: number): number {
@@ -14,11 +17,43 @@ export function estimateTokens(charCount: number): number {
   return Math.ceil(charCount / CHARS_PER_TOKEN);
 }
 
-/** Rough token count for a list of role/content messages. */
+/** CJK codepoints (kana, ideographs, hangul, compatibility forms) in `text`. */
+function cjkChars(text: string): number {
+  let n = 0;
+  for (let i = 0; i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    if (
+      (c >= 0x3040 && c <= 0x30ff) || // kana
+      (c >= 0x3400 && c <= 0x9fff) || // ideograph extensions + unified ideographs
+      (c >= 0xac00 && c <= 0xd7af) || // hangul syllables
+      (c >= 0xf900 && c <= 0xfaff) // compatibility ideographs
+    ) {
+      n += 1;
+    }
+  }
+  return n;
+}
+
+/** Blended token estimate for actual TEXT: ASCII at 4 chars/token, CJK at 1.5. Pure-ASCII
+ *  input is byte-identical to estimateTokens(length) — only non-English content moves. */
+export function estimateTextTokens(text: string): number {
+  const cjk = cjkChars(text);
+  if (cjk === 0) return estimateTokens(text.length);
+  const ascii = text.length - cjk;
+  return Math.ceil(ascii / CHARS_PER_TOKEN + cjk / CJK_CHARS_PER_TOKEN);
+}
+
+/** Rough token count for a list of role/content messages (script-aware — see estimateTextTokens). */
 export function estimateMessageTokens(messages: { content: string }[]): number {
-  let chars = 0;
-  for (const m of messages) chars += m.content.length + 8; // small per-message overhead
-  return estimateTokens(chars);
+  let ascii = 0;
+  let cjk = 0;
+  for (const m of messages) {
+    ascii += m.content.length + 8; // small per-message overhead
+    cjk += cjkChars(m.content);
+  }
+  if (cjk === 0) return estimateTokens(ascii);
+  const nonCjk = ascii - cjk;
+  return nonCjk <= 0 ? 0 : Math.ceil(nonCjk / CHARS_PER_TOKEN + cjk / CJK_CHARS_PER_TOKEN);
 }
 
 /**

package/src/tool/repl-details.ts

@@ -18,8 +18,8 @@ export interface ReplDetails {
   readonly executionTimeMs: number;
   /** Sub-calls triggered during this execution (llm_query, rlm_query, etc.). */
   readonly subcalls: readonly RlmSubcall[];
-  /** Running totals for this repl() call (cost + tokens from sub-LLM calls). */
-  readonly totals: { readonly costUsd: number; readonly tokens: number };
+  /** Running totals for this repl() call (tokens from sub-LLM calls). */
+  readonly totals: { readonly tokens: number };
   /** Final answer submitted through answer["ready"] without echoing it to the model. */
   readonly finalAnswer?: string;
   /** Detached spawn() sub-calls still running when this call returned. Absent when none. */

package/src/tool/repl-render.ts

@@ -1,14 +1,37 @@
-/** repl() tool TUI views — the single-line card and the expanded output view.
+/** repl() tool TUI views — call card (code payload), collapsed/expanded result views.
  * Sub-call trees are not rendered here; the live tree widget owns agent visualization. */
 
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { Container, Spacer, Text } from "@earendil-works/pi-tui";
+import { CALL_PREVIEW_CHARS, previewText } from "../text/preview.ts";
 import type { ReplDetails } from "./repl-details.ts";
+import { highlightPython } from "../ui/python-highlight.ts";
 import { cardHeader, cardStatsLine, renderCollapsedCard } from "./subcall-render.ts";
 
 /** Chars of stdout/stderr shown in the expanded view. */
 const EXPANDED_STDOUT_CHARS = 2_000;
 const EXPANDED_STDERR_CHARS = 500;
+/** Lines of Python source shown on the collapsed card before the "+N more lines" cut. */
+const CODE_PREVIEW_LINES = 40;
+
+// ── Call card ──
+
+/**
+ * The tool-call row. The collapsed card's payload IS the source — expanding swaps it for the
+ * result view (context.expanded). While args still stream in (context.argsComplete false),
+ * keep the one-line preview: half-arrived code reads as garbage.
+ */
+export function replCallView(
+  args: { readonly code: string },
+  theme: Theme,
+  context?: { readonly expanded?: boolean; readonly argsComplete?: boolean },
+): Text {
+  const header = theme.fg("toolTitle", theme.bold("repl ")) + theme.fg("dim", previewText(args.code, CALL_PREVIEW_CHARS));
+  if (context?.expanded === true || context?.argsComplete === false) {
+    return new Text(header, 0, 0);
+  }
+  return new Text([header, "", renderReplCode(args.code, theme)].join("\n"), 0, 0);
+}
 
 // ── Collapsed view ──
 
@@ -18,7 +41,20 @@ function replStats(details: ReplDetails, theme: Theme): string {
 }
 
 export function renderReplCollapsed(details: ReplDetails, theme: Theme): Text {
-  return renderCollapsedCard("REPL", details.status, replStats(details, theme), theme);
+  // Collapsed shows the CODE (replCallView); expanding reveals the result — say so.
+  return renderCollapsedCard("REPL", details.status, replStats(details, theme), theme, "to show result");
+}
+
+/**
+ * The collapsed card's payload — the cell's Python source, capped. Full source lives in the
+ * session args; expanding swaps this block for the result view (see replCallView). Sliced
+ * BEFORE highlighting so a triple-quoted string cut by the cap can only fall back to plain.
+ */
+export function renderReplCode(code: string, theme: Theme): string {
+  const lines = code.split("\n");
+  const shown = highlightPython(lines.slice(0, CODE_PREVIEW_LINES).join("\n"), theme);
+  const rest = lines.length - CODE_PREVIEW_LINES;
+  return rest > 0 ? `${shown}\n${theme.fg("muted", `… +${String(rest)} more lines`)}` : shown;
 }
 
 // ── Expanded view ──

package/src/tool/repl-tool.ts

@@ -23,6 +23,7 @@ import type { ModelRegistry } from "@earendil-works/pi-coding-agent";
 import { buildAddContextHandler, type AddContextHandlerBundle } from "../bridge/add-context.ts";
 import { contextPrefixesIn } from "../context/namespace.ts";
 import type { SubcallGates } from "../util/concurrency.ts";
+import { raceAbort } from "../util/abort.ts";
 import { LimitGuard, limitsFromConfig } from "../core/limits.ts";
 import type { RlmConfig, RlmInput, RlmResult } from "../core/types.ts";
 import { SandboxManager } from "../sandbox/sandbox-manager.ts";
@@ -40,7 +41,7 @@ import { createEngine } from "../core/engine.ts";
 import type { RunState } from "../core/run-state.ts";
 import { modelRef } from "../config/settings.ts";
 import { spinnerFrame } from "../ui/theme.ts";
-import { CALL_PREVIEW_CHARS, previewText } from "../text/preview.ts";
+import { previewText } from "../text/preview.ts";
 import { errorMessage } from "../util/errors.ts";
 import {
   groundLeafPrompt,
@@ -49,7 +50,7 @@ import {
 } from "../config/skillstate.ts";
 import { createProgressNotifier, validateToolParams } from "./tool-utils.ts";
 import { buildReplResultText, collectReplWarnings } from "./repl-result.ts";
-import { renderReplCollapsed, renderReplExpanded } from "./repl-render.ts";
+import { renderReplCollapsed, renderReplExpanded, replCallView } from "./repl-render.ts";
 import { attachTracer, trace, traceEnabled } from "../util/trace.ts";
 
 /** Last non-empty line of a Python traceback — the `TypeError: …` line, not the frames. */
@@ -129,7 +130,12 @@ interface ReplToolDeps {
   readonly getSkillBlock?: (task: string) => string | undefined;
   /** Session tree panel index; omitted → runs don't appear in the widget. */
   readonly runRegistry?: RunRegistry;
-  readonly signal?: AbortSignal;
+  /**
+   * Live abort signal accessor — read per child engine / sub-call / exec, NOT captured at
+   * registration. /rlm-stop aborts and ROTATES the session controller, so a stale signal
+   * must never outlive the call that started it.
+   */
+  readonly getSignal?: () => AbortSignal | undefined;
   readonly onUsage?: (usage: Usage, role: "sub") => void;
   readonly ensureContext?: () => Promise<void>;
   /** Register a reset hook for sandbox death/dispose (e.g. add_context prefix cache). */
@@ -142,7 +148,9 @@ interface ReplToolDeps {
 }
 
 export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplToolParams, ReplDetails> {
-  const { sandboxManager, llmModel, registry, getConfig, signal, onUsage, background } = deps;
+  const { sandboxManager, llmModel, registry, getConfig, onUsage, background } = deps;
+  // Read per use, never captured: see ReplToolDeps.getSignal.
+  const currentSignal = (): AbortSignal | undefined => deps.getSignal?.();
   const bridgeState = new NativeBridgeState(background);
   // v5: one session-wide blackboard for the native repl() path — the same claim/coalesce/
   // demote logic the engine gets per run, shared by every turn and every child it spawns.
@@ -177,7 +185,7 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
       llmModel: getLlmModel(),
       registry,
       config: getConfig(),
-      signal,
+      signal: currentSignal(),
       gates: currentGates(),
       // Same emitter the parent subcall node lives on — see SubcallHandlerDeps.runChild.
       emitter: inv.emitter,
@@ -202,7 +210,9 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
     getLlmModel,
     getModel,
     getConfig,
-    signal,
+    get signal() {
+      return currentSignal();
+    },
     onUsage,
     runChild,
     // The session sandbox's context is the child's world. Read lazily so an add_context from an
@@ -224,7 +234,9 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
         // committed for an append that did not happen.
         getContext: () => sandboxManager.contextPayload,
         parentId: undefined,
-        signal,
+        get signal() {
+          return currentSignal();
+        },
         // Keep the manager's replay copy in step with the worker's live `context`, and with it
         // whatever a child spawned after this load will inherit.
         onLoaded: (payload) => { sandboxManager.appendContext(payload); },
@@ -270,7 +282,7 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
         stderr: errors,
         executionTimeMs: 0,
         subcalls: [],
-        totals: { costUsd: 0, tokens: 0 },
+        totals: { tokens: 0 },
       }));
       if (!validation.ok) return validation.error;
       const params = validation.value;
@@ -318,7 +330,7 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
             stderr: capturedStderr,
             executionTimeMs: Date.now() - startedAt,
             subcalls: live.length > 0 ? [...store.getSubcalls(), ...live] : store.getSubcalls(),
-            totals: { costUsd: own.costUsd + bg.costUsd, tokens: own.tokens + bg.tokens },
+            totals: { tokens: own.tokens + bg.tokens },
             backgroundPending: background.pending > 0 ? background.pending : undefined,
           };
         },
@@ -368,12 +380,19 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
         // spawns claim against an empty stack, so an originator can never echo against
         // itself. Duplicates are caught by the ledger's claim store (exact/near
         // coalescing + rlmBudget demotion), never by silent suppression.
-        const result: ReplResult = await sandboxManager.execWithSetup(params.code, () => {
-          // Wire per-invocation mutable state only after the serialized exec slot
-          // is active. Swapping earlier would let queued repl() calls overwrite
-          // emitter/limits for the currently running REPL execution.
-          bridgeState.swap({ emitter, parentId: undefined, depth: 0, limits });
-        }, execSignal);
+        // The cell races pi's per-call signal (esc) against /rlm-stop's session signal.
+        const cellAbort = raceAbort(execSignal, currentSignal());
+        let result: ReplResult;
+        try {
+          result = await sandboxManager.execWithSetup(params.code, () => {
+            // Wire per-invocation mutable state only after the serialized exec slot
+            // is active. Swapping earlier would let queued repl() calls overwrite
+            // emitter/limits for the currently running REPL execution.
+            bridgeState.swap({ emitter, parentId: undefined, depth: 0, limits });
+          }, cellAbort.signal);
+        } finally {
+          cellAbort.dispose();
+        }
         const elapsed = Date.now() - start;
         capturedStdout = result.stdout;
         capturedStderr = result.stderr;
@@ -400,12 +419,11 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
           ? [...store.getSubcalls(), ...adopted.subcalls]
           : store.getSubcalls();
         const totals = {
-          costUsd: store.getTotals().costUsd + adopted.totals.costUsd,
           tokens: store.getTotals().tokens + adopted.totals.tokens,
         };
         const subUsage: Usage = {
           input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: totals.tokens,
-          cost: { total: totals.costUsd, input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+          cost: { total: 0, input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
         };
         onUsage?.(subUsage, "sub");
 
@@ -453,7 +471,6 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
           executionTimeMs: 0,
           subcalls: [...store.getSubcalls(), ...adopted.subcalls],
           totals: {
-            costUsd: store.getTotals().costUsd + adopted.totals.costUsd,
             tokens: store.getTotals().tokens + adopted.totals.tokens,
           },
           backgroundPending: background.pending > 0 ? background.pending : undefined,
@@ -472,11 +489,8 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
       }
     },
 
-    renderCall(args, theme) {
-      return new Text(
-        theme.fg("toolTitle", theme.bold("repl ")) + theme.fg("dim", previewText(args.code, CALL_PREVIEW_CHARS)),
-        0, 0,
-      );
+    renderCall(args, theme, context) {
+      return replCallView(args, theme, context);
     },
 
     renderResult(result, { expanded }, theme) {

package/src/tool/rlm-aggregator.ts

@@ -55,7 +55,7 @@ export class RlmEventAggregator extends EmitterListener {
   }
 
   private handleRootUsage(event: RootUsageEvent): void {
-    this.store.addRootUsage(event.costUsd, event.tokens, event.tokensIn, event.tokensOut);
+    this.store.addRootUsage(event.tokens, event.tokensIn, event.tokensOut);
     this.notify();
   }
 

package/src/tool/rlm-details.ts

@@ -31,7 +31,6 @@ export interface RlmSubcall {
   readonly resultPreview?: string;
   readonly startedAt: number;
   readonly endedAt?: number;
-  readonly costUsd: number;
   readonly tokens: number;
   /** In/out split (input / output) — mirrors tokens. */
   readonly tokensIn: number;
@@ -49,7 +48,7 @@ export interface RlmDetails {
   readonly rootPrompt: string;
   readonly turns: { readonly current: number; readonly max: number };
   readonly subcalls: readonly RlmSubcall[];
-  readonly totals: { readonly costUsd: number; readonly tokens: number; readonly tokensIn: number; readonly tokensOut: number };
+  readonly totals: { readonly tokens: number; readonly tokensIn: number; readonly tokensOut: number };
   readonly answer?: string;
 }
 

package/src/tool/rlm-events.ts

@@ -38,8 +38,6 @@ export interface SubcallUpdatedEvent {
   readonly args?: string;
   readonly resultPreview?: string;
   /** Delta — additive on both the subcall and running totals. */
-  readonly costUsd?: number;
-  /** Delta — additive on both the subcall and running totals. */
   readonly tokens?: number;
   /** Deltas for the in/out split shown in the tree (input / output). Additive like tokens. */
   readonly tokensIn?: number;
@@ -56,7 +54,6 @@ export interface TurnEvent {
 }
 
 export interface RootUsageEvent {
-  readonly costUsd: number;
   readonly tokens: number;
   readonly tokensIn?: number;
   readonly tokensOut?: number;
@@ -108,7 +105,7 @@ export class RlmEmitter {
     return id;
   }
 
-  /** Update an existing sub-call. All fields are partial. costUsd/tokens are additive. */
+  /** Update an existing sub-call. All fields are partial. tokens are additive. */
   emitSubcallUpdated(event: SubcallUpdatedEvent): void {
     this.ee.emit("subcall:updated", event);
   }
@@ -119,8 +116,8 @@ export class RlmEmitter {
   }
 
   /** Accumulate usage directly to root-level totals. */
-  emitRootUsage(costUsd: number, tokens: number, tokensIn?: number, tokensOut?: number): void {
-    this.ee.emit("root-usage", { costUsd, tokens, tokensIn, tokensOut } satisfies RootUsageEvent);
+  emitRootUsage(tokens: number, tokensIn?: number, tokensOut?: number): void {
+    this.ee.emit("root-usage", { tokens, tokensIn, tokensOut } satisfies RootUsageEvent);
   }
 
   /** Set the final answer text (root-only). */

package/src/tool/rlm-tool.ts

@@ -51,7 +51,7 @@ export function createRlmTool(controller: RlmController, runRegistry?: RunRegist
         rootPrompt: "",
         turns: { current: 0, max: 0 },
         subcalls: [],
-        totals: { costUsd: 0, tokens: 0, tokensIn: 0, tokensOut: 0 },
+        totals: { tokens: 0, tokensIn: 0, tokensOut: 0 },
       }));
       if (!validation.ok) return validation.error;
       const params = validation.value;

package/src/tool/subcall-render.ts

@@ -64,21 +64,24 @@ export function cardHeader(
  * Deliberately `keyText` + the injected theme rather than pi's `keyHint`: `keyHint` colours via
  * pi's module-global theme, which throws when that global is uninitialized — the same jiti
  * hazard `ui/theme-adapter.ts` exists to avoid. `keyText` only reads the keybinding registry.
+ * Shared by tool cards AND the [rlm.stage] transcript cards (ui/stage-cards.ts).
  */
-function expandHint(theme: Theme): string {
+export function expandHint(theme: Theme, action = "to expand"): string {
   // Empty outside a live pi session (the app installs the real binding registry at startup) —
   // the phrase stays the same, only the key prefix drops out.
   const key = keyText("app.tools.expand");
-  return theme.fg("muted", key ? `${key} to expand` : "to expand");
+  return theme.fg("muted", key ? `${key} ${action}` : action);
 }
 
-/** The collapsed card: header line, then the expand hint once settled. */
+/** The collapsed card: header line, then the expand hint once settled. `action` labels what
+ * expanding reveals — the repl card says "to show result" (collapsed shows the code instead). */
 export function renderCollapsedCard(
   title: string,
   status: SubcallStatus | "aborted" | "done",
   stats: string,
   theme: Theme,
+  action = "to expand",
 ): Text {
-  const hint = status === "running" ? "" : `\n${expandHint(theme)}`;
+  const hint = status === "running" ? "" : `\n${expandHint(theme, action)}`;
   return new Text(`${cardHeader(title, status, stats, theme)}${hint}`, 0, 0);
 }

package/src/tool/subcall-store.ts

@@ -14,9 +14,8 @@ type MutableSubcall = {
   -readonly [Key in keyof RlmSubcall]: RlmSubcall[Key];
 };
 
-/** Accumulated cost/tokens, shared by getTotals() and takeSettledSubtrees(). */
+/** Accumulated tokens, shared by getTotals() and takeSettledSubtrees(). */
 export interface SubcallTotals {
-  readonly costUsd: number;
   readonly tokens: number;
   /** In/out split (input / output) — mirrors tokens, shown separately in the tree. */
   readonly tokensIn: number;
@@ -26,11 +25,9 @@ export interface SubcallTotals {
 export class SubcallStore extends EmitterListener {
   private readonly subcalls = new Map<string, MutableSubcall>();
 
-  private totalCostUsd = 0;
   private totalTokens = 0;
   private totalTokensIn = 0;
   private totalTokensOut = 0;
-  private rootCostUsd = 0;
   private rootTokens = 0;
   private rootTokensIn = 0;
   private rootTokensOut = 0;
@@ -57,7 +54,6 @@ export class SubcallStore extends EmitterListener {
       detail: event.detail,
       args: event.args,
       startedAt: Date.now(),
-      costUsd: 0,
       tokens: 0,
       tokensIn: 0,
       tokensOut: 0,
@@ -76,10 +72,6 @@ export class SubcallStore extends EmitterListener {
     if (event.detail !== undefined) sc.detail = event.detail;
     if (event.args !== undefined) sc.args = event.args;
     if (event.resultPreview !== undefined) sc.resultPreview = event.resultPreview;
-    if (event.costUsd !== undefined) {
-      sc.costUsd += event.costUsd;
-      this.totalCostUsd += event.costUsd;
-    }
     if (event.tokens !== undefined) {
       sc.tokens += event.tokens;
       this.totalTokens += event.tokens;
@@ -105,7 +97,7 @@ export class SubcallStore extends EmitterListener {
 
   /** Snapshot running totals. O(1). */
   getTotals(): SubcallTotals {
-    return { costUsd: this.totalCostUsd, tokens: this.totalTokens, tokensIn: this.totalTokensIn, tokensOut: this.totalTokensOut };
+    return { tokens: this.totalTokens, tokensIn: this.totalTokensIn, tokensOut: this.totalTokensOut };
   }
 
   /**
@@ -141,7 +133,6 @@ export class SubcallStore extends EmitterListener {
     };
 
     const taken: RlmSubcall[] = [];
-    let costUsd = 0;
     let tokens = 0;
     let tokensIn = 0;
     let tokensOut = 0;
@@ -149,7 +140,6 @@ export class SubcallStore extends EmitterListener {
       const subtree = settledSubtree(root);
       if (subtree === undefined) continue;
       for (const node of subtree) {
-        costUsd += node.costUsd;
         tokens += node.tokens;
         tokensIn += node.tokensIn;
         tokensOut += node.tokensOut;
@@ -157,22 +147,19 @@ export class SubcallStore extends EmitterListener {
         this.subcalls.delete(node.id);
       }
     }
-    this.totalCostUsd -= costUsd;
     this.totalTokens -= tokens;
     this.totalTokensIn -= tokensIn;
     this.totalTokensOut -= tokensOut;
-    return { subcalls: taken, totals: { costUsd, tokens, tokensIn, tokensOut } };
+    return { subcalls: taken, totals: { tokens, tokensIn, tokensOut } };
   }
 
   // ── Root usage (delegated from RlmEventAggregator) ──
 
   /** Accumulate root-level usage into shared totals. Called by aggregator. */
-  addRootUsage(costUsd: number, tokens: number, tokensIn = 0, tokensOut = 0): void {
-    this.totalCostUsd += costUsd;
+  addRootUsage(tokens: number, tokensIn = 0, tokensOut = 0): void {
     this.totalTokens += tokens;
     this.totalTokensIn += tokensIn;
     this.totalTokensOut += tokensOut;
-    this.rootCostUsd += costUsd;
     this.rootTokens += tokens;
     this.rootTokensIn += tokensIn;
     this.rootTokensOut += tokensOut;
@@ -180,6 +167,6 @@ export class SubcallStore extends EmitterListener {
 
   /** Root engine's OWN spend (driver-model turns only) — never blends sub-call models. */
   getRootUsage(): SubcallTotals {
-    return { costUsd: this.rootCostUsd, tokens: this.rootTokens, tokensIn: this.rootTokensIn, tokensOut: this.rootTokensOut };
+    return { tokens: this.rootTokens, tokensIn: this.rootTokensIn, tokensOut: this.rootTokensOut };
   }
 }

package/src/ui/config-panel.ts

@@ -9,7 +9,7 @@ import { THINKING_LEVELS } from "../config/settings.ts";
 
 const CHOICES = Object.freeze({
   maxDepth: Object.freeze(["1", "2", "3", "4"]),
-  maxIterations: Object.freeze(["10", "20", "30", "50"]),
+  maxIterations: Object.freeze(["100", "200", "500", "1000"]),
   execTimeoutS: Object.freeze(["30", "60", "120", "300"]),
   maxConcurrentSubcalls: Object.freeze(["2", "4", "8", "16", "32"]),
   maxConcurrentChildren: Object.freeze(["1", "2", "3", "4", "6", "8"]),
@@ -20,7 +20,6 @@ const CHOICES = Object.freeze({
   compaction: Object.freeze(["on", "off"]),
   compactionThresholdPct: Object.freeze(["50", "65", "80", "90"]),
   rootSamplingMaxTokens: Object.freeze(["4096", "8192", "16384", "32768"]),
-  rootSamplingTemperature: Object.freeze(["0", "0.3", "0.7", "1.0", "default"]),
   smartReasoning: Object.freeze(["default", ...Object.keys(THINKING_LEVELS)]),
   subSamplingMaxTokens: Object.freeze(["1024", "2048", "4096", "8192"]),
   subSamplingTemperature: Object.freeze(["0", "0.3", "0.7", "1.0", "default"]),
@@ -43,7 +42,7 @@ export async function showConfigPanel(ctx: ExtensionContext, config: RlmConfig):
   let edited = config;
   const items: SettingItem[] = [
     item("maxDepth", "Max recursion depth", String(config.maxDepth), CHOICES.maxDepth, "rlm_query past this depth degrades to plain llm_query (1 = no recursion)."),
-    item("maxIterations", "Max iterations", String(config.maxIterations), CHOICES.maxIterations, "Maximum root REPL turns before RLM asks the model for a final answer."),
+    item("maxIterations", "Max iterations", String(config.maxIterations), CHOICES.maxIterations, "Maximum root REPL turns before RLM asks the model for a final answer. Large by design — runs end on FINAL/errors/wall-clock first."),
     item("execTimeoutS", "REPL block timeout (s)", String(config.execTimeoutS), CHOICES.execTimeoutS, "Wall-clock limit for one model-authored Python REPL block."),
     item("maxConcurrentSubcalls", "Max concurrent sub-calls", String(config.maxConcurrentSubcalls), CHOICES.maxConcurrentSubcalls, "Concurrency pool size for llm_batch and rlm_batch."),
     item("maxConcurrentChildren", "Max concurrent children", String(config.maxConcurrentChildren), CHOICES.maxConcurrentChildren, "Concurrent rlm_query child engines per depth. Each is a Python process holding its own copy of the inherited context."),
@@ -54,8 +53,6 @@ export async function showConfigPanel(ctx: ExtensionContext, config: RlmConfig):
     item("compaction", "Trajectory compaction", config.compaction ? "on" : "off", CHOICES.compaction, "Summarize old turns when history approaches the model context window."),
     item("compactionThresholdPct", "Compaction threshold (%)", String(Math.round(config.compactionThresholdPct * 100)), CHOICES.compactionThresholdPct, "DEPRECATED — ignored: compaction uses the absolute 256k ceiling (COMPACTION_CEILING_TOKENS)."),
     item("rootSamplingMaxTokens", "Root model output cap (tok)", String(config.rootSampling?.maxTokens ?? 16384), CHOICES.rootSamplingMaxTokens, "Max output tokens per root-model turn. Lower values keep each turn lean."),
-    item("rootSamplingTemperature", "Root sampling temperature", config.rootSampling?.temperature === undefined ? "default" : String(config.rootSampling?.temperature), CHOICES.rootSamplingTemperature,
-      "Sampling temperature for RLM root turns, finalize included — 0 = deterministic (the r3 reproducibility setting); 'default' = provider default. Applies to RLM-mode runs, rlm() delegation and child recursion; the native Pi agent loop follows Pi's own session settings."),
     item("smartReasoning", "Root reasoning effort", config.smartReasoning ?? "default", CHOICES.smartReasoning,
       "Thinking effort for the root model ('default' = none). Only models whose registry entry supports reasoning will think; others silently run without it. Reasoning tokens share the output cap — raise the root output cap when thinking is on."),
     item("subSamplingMaxTokens", "Worker output cap (tok)", String(config.subSampling?.maxTokens ?? 8192), CHOICES.subSamplingMaxTokens,
@@ -68,17 +65,11 @@ export async function showConfigPanel(ctx: ExtensionContext, config: RlmConfig):
       "Allow add_context() to pull an external dir, file, document, or git repo into context."),
     item("autoSeedCwd", "Auto-seed cwd", config.autoSeedCwd ? "on" : "off", CHOICES.autoSeedCwd,
       "Seed the working directory into context on the first repl() call (otherwise starts empty)."),
-    // R0 (/tmp/ROOT_FULL_SKILLSTATE_PLAN.md): the SKILL.state / Root Σ paradigm flags are
-    // ENFORCED — rendered as a read-only badge so the truth is visible instead of hidden.
-    // No toggle exists: applySetting has no case for them and the validator forces true.
-    item("__sigma_enforced__", "SKILL.state / Root Σ", "enforced", ["enforced"],
-      "ENFORCED (no opt-out): run state, skill state + distill, root context transform, state fences, digest compaction. " +
-        "Override attempts in rlm.json are traced (skillstate.override-ignored) and ignored; RLM_BENCH_NO_ROOTCONTEXT=1 is the dev-only measurement hatch."),
     // R5: the window calibrations are rlm.json-only knobs — shown read-only with live values.
     item("__sigma_window__", "Root Σ window (calibration)",
-      `keepTurns=${config.rootContextKeepTurns} · elide=${config.rootContextElideChars} · snapshot=${config.rootContextSnapshot ? "on" : "off"}`,
+      `keepTurns=${config.rootContextKeepTurns} · elide=${config.rootContextElideChars} · snapshot=${config.rootContextSnapshot ? "on" : "off"} · archive=${config.rootArchiveMaxChars > 0 ? `${Math.round(config.rootArchiveMaxChars / 1000)}k` : "off"}`,
       ["rlm.json"],
-      "Query-time window calibrations, rlm.json only: rootContextKeepTurns (1 = strict: Σ + current turn; 2 = default), rootContextElideChars, rootContextSnapshot. " +
+      "Query-time window calibrations, rlm.json only: rootContextKeepTurns (4 = default), rootContextElideChars, rootContextSnapshot, rootArchiveMaxChars (0 = archive off; elided turns are otherwise unrecoverable). " +
         "Session resume/fork: the tracker is reborn lazily and Σ re-grows from live observations — the first call after a resume has an empty Σ by design."),
     item("__save__", "Save & close", "↵", ["↵"], "Save these settings and close (Esc also saves)."),
   ];
@@ -138,12 +129,6 @@ export function applySetting(config: RlmConfig, id: string, value: string): RlmC
     case "compactionThresholdPct": return Object.freeze({ ...config, compactionThresholdPct: Number(value) / 100 });
     case "rootSamplingMaxTokens":
       return Object.freeze({ ...config, rootSampling: Object.freeze({ ...config.rootSampling, maxTokens: Number(value) }) });
-    case "rootSamplingTemperature": {
-      const t = optionalTemperature(value);
-      // Reject invalid values (NaN / out of range) — keep the current setting.
-      if (t === undefined && value !== "default") return config;
-      return Object.freeze({ ...config, rootSampling: Object.freeze({ ...config.rootSampling, temperature: t }) });
-    }
     case "smartReasoning":
       if (value === "default") return Object.freeze({ ...config, smartReasoning: undefined });
       return Object.hasOwn(THINKING_LEVELS, value)

package/src/ui/intro.ts

@@ -14,7 +14,7 @@ const RLM_GUIDE = `# RLM mode
 - \`/rlm-llm\` — pin the LLM model for llm_query / llm_batch / map_files
 - \`/rlm-rlm\` — pin the model for rlm_query / rlm_batch child engines (default: session model)
 - \`/rlm-config\` — run limits and engine settings
-- \`/rlm-stop\` — cancel the current run but stay in RLM mode (use /rlm or Ctrl+Shift+R to leave)
+- \`/rlm-stop\` — abort all in-flight RLM work: RLM runs, native repl cells and background tasks (use /rlm or Ctrl+Shift+R to leave RLM mode)
 
 ## Live tree
 

package/src/ui/panel/run-registry.ts

@@ -20,7 +20,7 @@ interface RunRegistration {
   readonly label: string;
   readonly emitter: RlmEmitter;
   readonly subcalls: () => readonly RlmSubcall[];
-  readonly totals: () => { readonly costUsd: number; readonly tokens: number };
+  readonly totals: () => { readonly tokens: number };
   /** Live root state; defaults: running, no phase, no turns. */
   readonly rootStatus?: () => RlmRunStatus;
   readonly rootPhase?: () => SubcallPhase | undefined;
@@ -40,7 +40,7 @@ export interface RunEntry {
   readonly label: string;
   readonly timeline: TimelineStore;
   readonly subcalls: () => readonly RlmSubcall[];
-  readonly totals: () => { readonly costUsd: number; readonly tokens: number };
+  readonly totals: () => { readonly tokens: number };
   readonly rootStatus: () => RlmRunStatus;
   readonly rootPhase: () => SubcallPhase | undefined;
   readonly turns: () => { readonly current: number; readonly max: number };

package/src/ui/python-highlight.ts

@@ -0,0 +1,49 @@
+/**
+ * python-highlight — minimal Python syntax coloring for the repl card's code payload.
+ *
+ * Deliberately NOT pi's highlightCode(): that closes over the module-global theme,
+ * which is unreliable inside a jiti-loaded plugin (see ui/theme-adapter.ts). The
+ * grammar here is a small, honest subset — comments, strings (triple-quoted and
+ * prefixed), keywords, numbers, decorators — enough to read a cell at a glance.
+ * Colors come from the theme pi hands each render pass.
+ */
+
+import type { Theme } from "@earendil-works/pi-coding-agent";
+
+/**
+ * Master pattern; alternation order is priority — a `#` comment consumes to end-of-line
+ * before strings can match, leftmost match wins everywhere else. Group indices:
+ * 1 comment, 2 triple-quoted string, 3 single-line string (optional prefix), 4 decorator,
+ * 5 number, 6 keyword. Module-level snapshot: a regex is immutable state, not session state.
+ */
+const TOKEN_RE = new RegExp(
+  [
+    "(#[^\\n]*)",                                                                                       // 1
+    '("""[\\s\\S]*?"""|\'\'\'[\\s\\S]*?\'\'\')',                                                        // 2
+    '([fFrRbBuU]{0,2}"(?:\\\\.|[^"\\\\\\n])*"|[fFrRbBuU]{0,2}\'(?:\\\\.|[^\'\\\\\\n])*\')',             // 3
+    "(@[A-Za-z_][\\w.]*)",                                                                              // 4
+    "\\b(\\d[\\d_]*(?:\\.\\d+)?(?:[eE][+-]?\\d+)?j?)\\b",                                               // 5
+    "\\b(False|None|True|and|as|assert|async|await|break|class|continue|def|del|elif|else|except|" +
+      "finally|for|from|global|if|import|in|is|lambda|nonlocal|not|or|pass|raise|return|try|while|with|yield)\\b", // 6
+  ].join("|"),
+  "g",
+);
+
+/** The whole code colored in one pass; spans never overlap, text content is preserved byte-for-byte. */
+export function highlightPython(code: string, theme: Theme): string {
+  const out: string[] = [];
+  let last = 0;
+  for (const m of code.matchAll(TOKEN_RE)) {
+    const at = m.index ?? 0;
+    if (at > last) out.push(code.slice(last, at));
+    const [raw = "", comment, triple, str, decorator, num, keyword] = m;
+    if (comment !== undefined) out.push(theme.fg("muted", comment));
+    else if (triple !== undefined || str !== undefined) out.push(theme.fg("mdCode", raw));
+    else if (decorator !== undefined) out.push(theme.fg("mdHeading", decorator));
+    else if (num !== undefined) out.push(theme.fg("warning", num));
+    else out.push(theme.fg("accent", keyword));
+    last = at + raw.length;
+  }
+  if (last < code.length) out.push(code.slice(last));
+  return out.join("");
+}