killeros 2.0.11 → 2.0.13

package/CHANGELOG.md

@@ -4,6 +4,22 @@ All notable changes to KillerOS are documented here.
 
 ## [Unreleased]
 
+## [2.0.13] - 2026-08-21
+
+### Added
+
+- Added the process-local bare `/codex-fast` toggle for Codex priority requests, with a bold inline `Fast` footer indicator while an active Codex model uses it.
+
+### Changed
+
+- Converted all tracked test suites from JavaScript to strict TypeScript while keeping Node's built-in test runner.
+
+## [2.0.12] - 2026-08-18
+
+### Fixed
+
+- Resumed active goals exactly once after Pi reports automatic compaction complete.
+
 ## [2.0.11] - 2026-08-17
 
 ### Fixed

package/Killeros.ts

@@ -14,6 +14,7 @@ import {
   registerCompletionNotifications,
   type CompletionNotificationDependencies,
 } from "./killeros/notifications.ts";
+import { registerCodexFastMode } from "./killeros/codex-fast.ts";
 import { registerPersonalInstructions } from "./killeros/personal-instructions.ts";
 import { registerQuestionTool } from "./killeros/question.ts";
 import { createGoalRuntime, createInitRuntime } from "./killeros/runtime.ts";
@@ -42,6 +43,7 @@ export default function Killeros(pi: ExtensionAPI, options: KillerosOptions = {}
   registerSlashAutocomplete(pi, commandResolver);
   registerFooter(pi, goalRuntime);
   registerVariants(pi);
+  registerCodexFastMode(pi);
   registerInitCommand(pi, initRuntime, goalRuntime);
   registerLifecycleHooks(pi);
   const goalCompaction = registerGoalSettlement(pi, goalRuntime, initRuntime);

package/README.md

@@ -1,57 +1,54 @@
 # KillerOS
 
-A production-hardened Pi extension that combines a custom TUI, repository initialization, long-running goals, reasoning controls, interactive questions, and command aliases.
+KillerOS is a TypeScript extension for the Pi coding agent. It adds a custom TUI, repository initialization, long-running goals, reasoning controls, interactive questions, lifecycle hooks, and a small set of command aliases.
 
 ## Requirements
 
 - Node.js `22.19.0` or later
 - Pi `0.84.2` or later
-- Interactive TUI mode for the custom header, editor, footer, `question` tool, and `/init`
+- An interactive TUI session for the custom header, editor, footer, `question`, and `/init`
 
-The extension is strict TypeScript. Pi provides the runtime modules.
+KillerOS ships as TypeScript. Pi supplies the runtime modules listed as peer dependencies.
 
 ## Install
 
-### npm
-
-Install KillerOS:
+Install the current npm release:
 
 ```bash
 pi install npm:killeros
 ```
 
-### Git
-
-Install the latest commit:
+Install from GitHub:
 
 ```bash
 pi install git:github.com/KyrosHendrix/pi-KillerOS
 ```
 
-Pin an install to a release:
+Pin an install to version `v2.0.13`:
 
 ```bash
-pi install git:github.com/KyrosHendrix/pi-KillerOS@v2.0.11
+pi install git:github.com/KyrosHendrix/pi-KillerOS@v2.0.13
 ```
 
-Add `-l` to either command for a project-only install. Restart Pi after installing.
+Add `-l` to either command to install only for the current project. Restart Pi after installing.
 
 ## Features
 
-- 52-column Compact startup card with inline version, polished model/provider identity, adjacent `/model`, directory, conditional Git branch, and a shuffled session-stable tip
-- Cohesive dark theme with coral accents and neutral tool-call containers across pending, success, and error states
-- Animated orange 12-frame activity glyph loop at 120 ms per frame with contextual copy derived from request, tool, result, and response events, plus a quiet hidden-thinking label
-- Frameless multiline editor with one focus-aware `❯`, a shuffled session-stable empty-state suggestion, overflow-only scroll indicators, Shift+Enter support, and slash-command autocomplete; KillerOS preserves an editor factory configured by another extension
-- One compact TUI transcript line reporting truthful `Done`, `Stopped`, or `Failed` settlement with elapsed time while preserving older `✻ Worked for …` entries
-- Compact two-deck footer with session state above workspace state; model, context, and active goals stay prioritized as reasoning, time, cost, branch, and path reduce by available width
-- Proactive turn-boundary context compaction in TUI and RPC modes, with ordinary prompts and active goals continuing safely after a successful summary
-- Optional completion sounds after successful or failed settled requests, excluding manual aborts
-- `/variants` selector and direct reasoning-level arguments
-- Codex-style `/goal` with an interactive status/action panel, durable objectives, immediate pause and clear cancellation, automatic continuation, explicit completion, and durable blocker audits
-- Automatic `/init` guideline synthesis with a frozen safe evidence map, protected existing policy, and the four packaged behavioral sections adapted from `writing-great-guidelines`
-- `question` tool with single-select and opt-in bounded multi-select, height-bounded option windows, configured Pi keybindings, live option/input progress, proposal previews, custom answers, history, cancellation, and compact expandable transcript rendering
-- Mid-prompt slash completion with current Pi `0.84.2` commands, extensions, prompts, and skills; paths, URLs, and invalid commands remain plain text
-- Goal-aware `/clear` that confirms, aborts active work, waits for settlement, and starts a new session, plus `/exit` for graceful shutdown
+- A compact startup card with the extension version, model, provider, `/model`, working directory, Git branch, and a session-stable tip.
+- A dark theme with coral accents and neutral tool-call containers for pending, successful, and failed calls.
+- A 12-frame orange activity glyph with event-based status text and a quiet hidden-thinking label.
+- A multiline editor with a single focus-aware prompt arrow, a session-stable empty-state suggestion, overflow-only scroll indicators, Shift+Enter support, and slash-command completion.
+- A settled transcript line that reports `Done`, `Stopped`, or `Failed` with elapsed time, while preserving older `✻ Worked for ...` entries.
+- A responsive footer that keeps model, context, and goal state visible as the terminal gets narrower.
+- Automatic turn-boundary context compaction in TUI and RPC modes.
+- Optional completion sounds for successful and failed settled requests.
+- `/variants` for selecting a model reasoning level.
+- `/codex-fast` for toggling the `priority` service tier on Codex requests.
+- `/goal` for durable objectives with pause, resume, edit, clear, completion, continuation, and blocker audits.
+- `/init` for generating a root `AGENTS.md` from a bounded, safe set of repository files.
+- A `question` tool with single-select and opt-in multi-select controls.
+- Slash completion based on Pi's registered commands, extensions, prompts, and skills.
+- Goal-aware `/clear` and graceful `/exit` handling.
 
 ## Commands
 
@@ -65,34 +62,61 @@ Add `-l` to either command for a project-only install. Restart Pi after installi
 /goal clear               Stop current goal work and remove the goal
 /variants                 Open the reasoning-level selector
 /variants high            Set a reasoning level directly
+/codex-fast               Toggle process-local Codex fast mode
 /notification             Configure the completion sound
 /clear                    Start a new session after confirmation
 /exit                     Quit Pi gracefully
 ```
 
-`/goal` requires a saved session in TUI or RPC mode. Goal state is stored in versioned session entries on the active branch and restored after reload, resume, fork, or tree navigation. Active goals inject their unchanged objective every turn and continue one settled turn at a time. The model must use KillerOS’s private goal tool to report completion. For an objective that clearly asks to create, write, save, or generate a named file-like deliverable at one quoted absolute path, KillerOS saves that exact path with the goal and verifies that a regular file exists there before accepting completion. Other objectives retain model-reported completion. Blocking requires one stable lowercase blocker key recorded on three consecutive goal turns; a changed key, skipped turn, resume, or edit resets the streak. Final prose alone does not end the loop.
+### Codex fast mode
+
+`/codex-fast` takes no arguments. It toggles a process-local setting. When it is enabled and the active model uses the `openai-codex` provider, KillerOS adds `service_tier: "priority"` to the provider request. The footer shows bold `Fast` between the model and provider.
+
+The setting survives a session reload within the same process, does not change other providers, is not saved to KillerOS configuration, and starts disabled after Pi restarts. A provider failure leaves the setting enabled and follows Pi's normal error handling.
+
+### Goals
+
+`/goal` requires a saved session in TUI or RPC mode. Goal state is stored in versioned session entries on the active branch and restored after reload, resume, fork, and tree navigation.
+
+An active goal injects its unchanged objective on each turn and continues one settled turn at a time. The model must use KillerOS's private goal tool to report completion. If the objective explicitly asks for a named file-like deliverable at one quoted absolute path, KillerOS records that path and checks that a regular file exists before accepting completion. Other objectives use the model's completion report.
+
+KillerOS marks a goal blocked only after a stable lowercase blocker key recorded on three consecutive goal turns. A changed key, skipped turn, resume, or edit resets the streak. Final prose does not end the loop.
+
+Active goals replace the footer path with warning-yellow `/goal is active (...)` and keep the exact elapsed time visible.
+
+`/goal pause` and `/goal clear` save paused or cleared state before aborting current goal work, so settlement cannot restart it. Aborted turns, provider failures, and continuation failures pause safely. Failed edit and replacement writes dispatch no edited objective. Replacing unfinished work requires confirmation, and `/goal edit` works only in TUI mode.
 
-`/goal pause` and `/goal clear` save paused or cleared state before aborting current goal work, so settlement cannot restart it. Aborted turns, provider failures, and continuation failures otherwise pause safely. Failed edit and replacement writes dispatch no edited objective; an active prior objective pauses fail-closed, while inactive durable state remains unchanged. Replacing unfinished work requires confirmation, and `/goal edit` requires TUI mode.
+### Repository initialization
 
-`/init` freezes a safe project-file map and exposes only dedicated read and list operations while it generates root `AGENTS.md`. Git-ignored files, known secret paths, private-key formats, other guidance, dependencies, links, non-regular files, and files outside that map are unavailable. Existing root `AGENTS.md` is separate protected policy: compatible rules are preserved, a real policy conflict leaves it unchanged with a reason, and any concurrent target change aborts installation without replacing the newer file.
+`/init` freezes a safe project-file map and exposes only dedicated read and list operations while it generates the root `AGENTS.md`. Git-ignored files, known secret paths, private-key formats, other guidance files, dependencies, links, non-regular files, and files outside the map are unavailable to the generation step.
 
-The generated file uses the four behavioral sections adapted from `writing-great-guidelines`; no external skill installation is required. `/init` asks no setup questions, starts no second model process, writes no other file, and reloads Pi resources only after a successful write.
+An existing root `AGENTS.md` is protected policy. Compatible rules are preserved. A real policy conflict leaves the file unchanged with a reason, and a concurrent target change aborts installation instead of replacing the newer file.
+
+The generated file uses four behavioral sections adapted from `writing-great-guidelines`. `/init` does not require another skill installation, ask setup questions, start a second model process, or write another file. Pi resources reload only after a successful write.
 
 ### Interactive questions
 
-Single-select remains the default. Explicit `minSelections: 1` and `maxSelections: 1` are equivalent to omitting both bounds; other single-select bounds are rejected. An agent opts into multi-select with `mode: "multiple"` and may set `minSelections` and `maxSelections`; the custom answer counts as one selection.
+Single-select remains the default. Explicit `minSelections: 1` and `maxSelections: 1` are accepted; other single-select bounds are rejected. Use `mode: "multiple"` to opt into multi-select. The custom answer counts as one selection.
 
-In multi-select, use Space or a visible number to toggle an option, `/` to filter, and Enter to submit. The filter accepts spaces; Enter applies it and Escape returns to the choices. Checked options remain selected when the filter changes. Select **Type a custom answer** with Enter to add or edit one custom item alongside checked options.
+In multi-select mode, use Space or a visible number to toggle an option, `/` to filter, and Enter to submit. The filter accepts spaces. Enter applies the filter and Escape returns to the choices. Checked options remain selected when the filter changes. Select `Type a custom answer` to add or edit one custom item alongside the checked options.
 
-Supported reasoning levels are `off`, `minimal`, `low`, `medium`, `high`, `xhigh`, and `max`. KillerOS limits choices to levels supported by the current model.
+Supported reasoning levels are `off`, `minimal`, `low`, `medium`, `high`, `xhigh`, and `max`. KillerOS limits the selector to levels supported by the current model.
 
 ## Configuration
 
-KillerOS activates its packaged `killeros` theme when a TUI session starts. Tool-call backgrounds stay neutral across pending, successful, and failed states; restrained text and icons preserve status visibility.
+KillerOS activates its packaged `killeros` theme when a TUI session starts. Tool-call backgrounds stay neutral in pending, successful, and failed states.
+
+The completion sound is a global user preference in Pi's agent directory and is off by default. Run `/notification` in TUI mode to change it. Enabled TUI tabs append `󰂚`, which requires a Nerd Font. KillerOS uses the terminal's audible bell, so a terminal that disables the bell cannot play the sound.
+
+### Automatic compaction
 
-The completion sound is a global user preference stored in Pi's agent directory and is off by default. Run `/notification` in TUI mode to enable or disable it; enabling does not play a preview. Enabled TUI tabs append `󰂚`, which requires a Nerd Font in the terminal tab UI. An unsupported font may show a box without affecting sound. KillerOS uses the terminal's audible bell and cannot produce sound when the terminal disables it.
+Automatic compaction is enabled by default when Pi's effective `compaction.enabled` setting is true. After each completed assistant turn, including tool execution, KillerOS reads the active model's context usage and calls Pi's public compaction API when:
+
+```text
+remainingTokens <= max(contextWindow * percentRemaining / 100, reserveTokens)
+```
 
-Automatic compaction is enabled by default when Pi's effective `compaction.enabled` setting is true. After each completed assistant turn, including its tool execution, KillerOS reads the active model's current context usage and triggers the public Pi compaction API when `remainingTokens <= max(contextWindow * percentRemaining / 100, reserveTokens)`. The default `percentRemaining` is `15`; `reserveTokens` and `keepRecentTokens` remain Pi-owned. KillerOS reads those effective settings with Pi's public `SettingsManager` using `getAgentDir()` and the current project trust state. The KillerOS-only preference lives in the same global `killeros.json` file:
+The default `percentRemaining` is `15`. Pi owns `reserveTokens` and `keepRecentTokens`. KillerOS reads the effective settings through Pi's public `SettingsManager` with `getAgentDir()` and stores its own preference in the global `killeros.json` file:
 
 ```json
 {
@@ -103,29 +127,33 @@ Automatic compaction is enabled by default when Pi's effective `compaction.enabl
 }
 ```
 
-Missing context readings skip the check. Successful ordinary-prompt compaction queues one hidden continuation; active `/goal` runs use the existing session-compaction and goal-continuation path. A failed compaction does not automatically retry. Manual `/compact` behavior is unchanged.
+Missing context readings skip the check. Successful ordinary-prompt compaction queues one hidden continuation. Active `/goal` runs use the existing session-compaction and goal-continuation path. Failed compaction does not retry automatically, and manual `/compact` behavior is unchanged.
 
-KillerOS displays session costs in USD. The footer uses Pi's human-readable model name when available, keeps the provider visually secondary, and renders context as `percent left (tokens)` without a progress bar. An active goal replaces the right-side path with warning-yellow `/goal is active (...)` and keeps exact seconds in minute and hour formats. Paused and blocked goals retain their existing placement; completed goals remain in transcript history and `/goal` status rather than the footer. At narrow widths, context pressure and actionable goal state take priority.
+Pi writes the summary, applies manual focus instructions, tracks files, retries summarization, and handles overflow recovery. KillerOS only decides when to request proactive compaction.
 
-Pi writes the summary, applies manual focus instructions, tracks files, retries summarization, and handles overflow recovery. KillerOS owns only the proactive turn-boundary trigger and does not replace Pi's compaction implementation. Active `/goal` work continues from the settled compaction boundary, after Pi finishes retries, compaction, and queued work.
+Manual `/compact` pauses the current goal turn before summarization. After Pi saves the summary, KillerOS resumes that goal revision automatically. A failed or cancelled manual compaction stays paused. Run `/goal pause` during the pause to cancel automatic recovery.
 
-Manual `/compact` aborts the current goal turn before summarization, so KillerOS records an honest temporary pause for that exact goal revision. After Pi saves the manual summary, KillerOS resumes that revision automatically. A failed or cancelled manual compaction stays paused; run `/goal pause` during the pause to cancel automatic recovery.
+### Project instructions and hooks
 
 For trusted projects, KillerOS loads `AGENTS.local.md` after Pi's shared repository context. A one-line `@path` or `@~/path` file imports personal guidance from another location.
 
-Lifecycle hooks are loaded from `.pi/killeros-hooks.json` at session start. Supported event keys are `tool_call`, `tool_result`, and `agent_settled`. Optional matchers are JavaScript regular expressions over Pi tool names, so they are valid only for `tool_call` and `tool_result`; KillerOS rejects an `agent_settled` hook that defines a matcher. Hook commands run from the repository root with `KILLEROS_EVENT`, `KILLEROS_TOOL`, and `KILLEROS_PAYLOAD` environment variables. Failed `tool_call` hooks block the tool, while later-event failures notify the user. Aborting the parent request stops the hook process tree with bounded graceful and forced cleanup without reporting cancellation as a hook failure.
+Lifecycle hooks load from `.pi/killeros-hooks.json` at session start. Supported event keys are `tool_call`, `tool_result`, and `agent_settled`. Regular-expression matchers apply only to the first two events. KillerOS rejects a matcher on `agent_settled`.
+
+Hook commands run from the repository root with `KILLEROS_EVENT`, `KILLEROS_TOOL`, and `KILLEROS_PAYLOAD` environment variables. A failed `tool_call` hook blocks the tool. Failures for later events notify the user. If the parent request is aborted, KillerOS stops the hook process tree with bounded graceful and forced cleanup without reporting cancellation as a hook failure.
 
 ## Behavior by mode
 
 | Mode | Behavior |
-|---|---|
-| TUI | All features are available, including proactive compaction, the completion sound, and the tab-title indicator |
-| RPC | Proactive compaction and goal set/view/pause/resume/clear work; TUI components, `/goal edit`, `/init`, completion sounds, and the title indicator are disabled |
-| Print/JSON | Interactive questions, `/goal`, `/init`, and proactive compaction are disabled; completion sounds and the title indicator are disabled |
+| --- | --- |
+| TUI | All features are available, including proactive compaction, completion sounds, and the tab-title indicator. |
+| RPC | Proactive compaction and goal set/view/pause/resume/clear work. TUI components, `/goal edit`, `/init`, completion sounds, and the title indicator are disabled. |
+| Print/JSON | Interactive questions, `/goal`, `/init`, and proactive compaction are disabled. Completion sounds and the title indicator are disabled. |
+
+## Development and validation
 
-## Validation
+Source and tests use strict TypeScript. Tests run with Node's built-in test runner and type stripping.
 
-Before release, run:
+Before a release, run:
 
 ```bash
 npm ci
@@ -135,17 +163,23 @@ npm pack --dry-run
 pi -ne -e . --mode rpc
 ```
 
-The package manifest lists Pi’s built-in modules as peer dependencies, so npm does not bundle a second copy.
+The package manifest lists Pi's built-in modules as peer dependencies, so npm does not bundle another copy.
+
+## Releases
+
+For a normal release:
 
-## Publish
+1. Update the version in `package.json` and both matching version fields in `package-lock.json`.
+2. Add a dated section with the same version to `CHANGELOG.md`.
+3. Push the release commit to `main`.
 
-To release KillerOS, update the version in `package.json` and `package-lock.json`, add the matching `CHANGELOG.md` section, and push the release commit to `main`. After the full CI workflow passes, the release workflow publishes the package to npm through trusted publishing, then creates the matching tag and GitHub release from that verified commit. The [`pi-package`](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/packages.md) keyword makes the npm release visible in Pi’s package catalog.
+After the full CI workflow passes on `main`, the release workflow validates the commit and changelog, publishes the package to npm through trusted publishing, and creates the matching tag and GitHub release. The [`pi-package` keyword](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/packages.md) makes the npm package visible in Pi's package catalog.
 
-Do not manually tag a normal release. If automation must recover a missing GitHub release, push the matching version tag. The workflow validates the tag against the package and changelog, skips npm publication when that version already exists, and creates only the missing release.
+Do not create a tag for the normal path. If a release is missing, use the manual tag recovery path and push the matching version tag. The recovery path checks the tag against the package and changelog, skips npm publication when that version already exists, and creates only the missing GitHub release.
 
 ## Security
 
-Pi extensions run with your user permissions. Review the source before installing KillerOS globally. KillerOS executes lifecycle hook commands only for projects Pi marks as trusted; review `.pi/killeros-hooks.json` before enabling project trust.
+Pi extensions run with your user permissions. Review the source before installing KillerOS globally. KillerOS runs lifecycle hook commands only for projects Pi marks as trusted. Review `.pi/killeros-hooks.json` before enabling project trust.
 
 ## License
 

package/killeros/codex-fast-state.ts

@@ -0,0 +1,38 @@
+type CodexFastStateListener = () => void;
+
+interface CodexFastState {
+  enabled: boolean;
+  listeners: Set<CodexFastStateListener>;
+}
+
+const GLOBAL_STATE_KEY = "__killerosCodexFastState";
+type GlobalWithCodexFastState = typeof globalThis & {
+  [GLOBAL_STATE_KEY]?: CodexFastState;
+};
+
+const globalState = globalThis as GlobalWithCodexFastState;
+const state = globalState[GLOBAL_STATE_KEY] ??= {
+  enabled: false,
+  listeners: new Set<CodexFastStateListener>(),
+};
+
+export function isCodexFastEnabled(): boolean {
+  return state.enabled;
+}
+
+export function toggleCodexFast(): boolean {
+  state.enabled = !state.enabled;
+  for (const listener of [...state.listeners]) listener();
+  return state.enabled;
+}
+
+export function subscribeCodexFast(listener: CodexFastStateListener): () => void {
+  state.listeners.add(listener);
+  return () => state.listeners.delete(listener);
+}
+
+/** Test-only reset for the process-global state between isolated harnesses. */
+export function resetCodexFastState(): void {
+  state.enabled = false;
+  state.listeners.clear();
+}

package/killeros/codex-fast.ts

@@ -0,0 +1,31 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { isCodexFastEnabled, toggleCodexFast } from "./codex-fast-state.ts";
+
+const CODEX_PROVIDER = "openai-codex";
+type RequestPayload = Record<string, unknown>;
+
+function isRequestPayload(value: unknown): value is RequestPayload {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function registerCodexFastMode(pi: ExtensionAPI): void {
+  pi.registerCommand("codex-fast", {
+    description: "Toggle Codex fast mode",
+    handler: async (args, ctx) => {
+      if (args.trim()) {
+        ctx.ui.notify("Usage: /codex-fast", "error");
+        return;
+      }
+
+      const enabled = toggleCodexFast();
+      ctx.ui.notify(`Fast ${enabled ? "enabled" : "disabled"}`, "info");
+    },
+  });
+
+  pi.on("before_provider_request", (event, ctx) => {
+    if (!isCodexFastEnabled() || ctx.model?.provider !== CODEX_PROVIDER || !isRequestPayload(event.payload)) {
+      return event.payload;
+    }
+    return { ...event.payload, service_tier: "priority" };
+  });
+}

package/killeros/footer.ts

@@ -1,11 +1,13 @@
 import { DynamicBorder, type ExtensionAPI, type ExtensionContext, type Theme, type ThemeColor } from "@earendil-works/pi-coding-agent";
 import { Container, Text, truncateToWidth, visibleWidth, type TUI } from "@earendil-works/pi-tui";
+import { isCodexFastEnabled, subscribeCodexFast } from "./codex-fast-state.ts";
 import { formatCwd, formatTime, formatTokens, padRight } from "./display.ts";
 import { goalElapsedMilliseconds } from "./goals.ts";
 import type { GoalRuntime, GoalState } from "./runtime.ts";
 import { LEVEL_COLORS, type ThinkingLevel } from "./variants.ts";
 
 const FOOTER_REFRESH_INTERVAL_MS = 1_000;
+const CODEX_PROVIDER = "openai-codex";
 
 export function formatCost(usd: number): string {
   if (!Number.isFinite(usd)) return "$—";
@@ -88,10 +90,19 @@ function modelDisplayName(model: NonNullable<ExtensionContext["model"]>): string
   return model.name?.trim() || model.id;
 }
 
-export function formatModel(model: ExtensionContext["model"], theme: Theme, includeProvider = true): string {
+export function formatModel(
+  model: ExtensionContext["model"],
+  theme: Theme,
+  includeProvider = true,
+  showCodexFast = false,
+): string {
   if (!model) return theme.fg("dim", "No model");
   const name = theme.fg("text", theme.bold(modelDisplayName(model)));
-  return includeProvider ? `${name} ${theme.fg("dim", formatProviderName(model.provider))}` : name;
+  const fast = showCodexFast && model.provider === CODEX_PROVIDER
+    ? theme.fg("accent", theme.bold("Fast"))
+    : "";
+  const provider = includeProvider ? theme.fg("dim", formatProviderName(model.provider)) : "";
+  return [name, fast, provider].filter(Boolean).join(" ");
 }
 
 function compactDirectory(cwd: string): string {
@@ -158,6 +169,7 @@ export function registerFooter(pi: ExtensionAPI, goalRuntime: GoalRuntime): void
   let activeTui: TUI | undefined;
   let cachedSessionCost = 0;
   let sessionCostDirty = true;
+  let unsubscribeCodexFast: (() => void) | undefined;
   const resetSessionCost = (): void => {
     cachedSessionCost = 0;
     sessionCostDirty = true;
@@ -178,6 +190,8 @@ export function registerFooter(pi: ExtensionAPI, goalRuntime: GoalRuntime): void
   pi.on("session_start", (_event, ctx) => {
     resetSessionCost();
     if (ctx.mode !== "tui") return;
+    unsubscribeCodexFast?.();
+    unsubscribeCodexFast = subscribeCodexFast(() => activeTui?.requestRender());
     const sessionStart = Date.now();
     currentModel = ctx.model;
     thinkingLevel = pi.getThinkingLevel() as ThinkingLevel;
@@ -210,7 +224,7 @@ export function registerFooter(pi: ExtensionAPI, goalRuntime: GoalRuntime): void
           const contextWindow = usage?.contextWindow ?? model?.contextWindow ?? 128_000;
           const context = formatContextProgress(usage?.tokens ?? null, contextWindow, theme);
           const branch = footerData.getGitBranch();
-          const signature = formatModel(model, theme);
+          const signature = formatModel(model, theme, true, isCodexFastEnabled());
           const fullDirectory = theme.fg("dim", cwd);
           const focusedDirectory = theme.fg("dim", compactDirectory(cwd));
           const goal = formatGoalFooter(goalRuntime.state, theme);
@@ -224,7 +238,7 @@ export function registerFooter(pi: ExtensionAPI, goalRuntime: GoalRuntime): void
             theme.fg("dim", formatTime(Date.now() - sessionStart)),
             theme.fg("dim", formatCost(getSessionCost(ctx))),
           ], theme);
-          const essentialModel = formatModel(model, theme, false);
+          const essentialModel = formatModel(model, theme, false, isCodexFastEnabled());
           const primaryRow = footerRowFits(primary, session, width)
             ? renderFooterRow(primary, session, width)
             : footerRowFits(primary, "", width)
@@ -241,7 +255,6 @@ export function registerFooter(pi: ExtensionAPI, goalRuntime: GoalRuntime): void
               : footerRowFits(branchLabel, focusedDirectory, width)
                 ? renderFooterRow(branchLabel, focusedDirectory, width)
                 : renderFooterRow(branchLabel, "", width);
-
           return renderFooter([primaryRow, secondaryRow], width, theme);
         },
       };
@@ -263,6 +276,8 @@ export function registerFooter(pi: ExtensionAPI, goalRuntime: GoalRuntime): void
     activeTui?.requestRender();
   });
   pi.on("session_shutdown", () => {
+    unsubscribeCodexFast?.();
+    unsubscribeCodexFast = undefined;
     resetSessionCost();
     activeTui = undefined;
     goalRuntime.requestRender = undefined;

package/killeros/goals.ts

@@ -468,8 +468,6 @@ function completeAutomaticCompaction(
     runtime.automaticCompaction = undefined;
     return;
   }
-  runtime.automaticCompaction = "completed";
-  if (runtime.goalTurnInFlight || !ctx.isIdle()) return;
   runtime.automaticCompaction = undefined;
   setImmediate(() => scheduleGoalContinuation(pi, runtime, initState, ctx));
 }
@@ -1058,12 +1056,7 @@ export function registerGoalSettlement(
       const reason = runtime.lastError || "the agent turn was aborted";
       runtime.lastStopReason = undefined;
       runtime.lastError = undefined;
-      if (runtime.automaticCompaction !== undefined) {
-        if (runtime.automaticCompaction === "completed") {
-          completeAutomaticCompaction(pi, runtime, initState, ctx);
-        }
-        return;
-      }
+      if (runtime.automaticCompaction !== undefined) return;
       pauseGoalForPossibleManualCompaction(pi, runtime, ctx, reason);
       return;
     }
@@ -1080,10 +1073,7 @@ export function registerGoalSettlement(
   });
 
   pi.on("session_compact", (event, ctx) => {
-    if (runtime.automaticCompaction !== undefined) {
-      completeAutomaticCompaction(pi, runtime, initState, ctx);
-      return;
-    }
+    if (runtime.automaticCompaction !== undefined) return;
     if (event.reason !== "manual") return;
     recoverGoalAfterManualCompaction(pi, runtime, initState, ctx);
   });

package/killeros/runtime.ts

@@ -57,7 +57,7 @@ export interface GoalRuntime {
   continuationHeld: boolean;
   goalTurnInFlight: boolean;
   agentEndObserved: boolean;
-  automaticCompaction?: "pending" | "completed";
+  automaticCompaction?: "pending";
   persistenceRetryNeeded: boolean;
   lastStopReason?: string;
   lastError?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "killeros",
-  "version": "2.0.11",
+  "version": "2.0.13",
   "description": "TUI, goals, and workflow automation for the Pi coding agent",
   "type": "module",
   "keywords": [