killeros 2.0.12 → 2.0.14

package/CHANGELOG.md

@@ -4,6 +4,27 @@ All notable changes to KillerOS are documented here.
 
 ## [Unreleased]
 
+## [2.0.14] - 2026-08-22
+
+### Fixed
+
+- Prevented direct tag pushes from publishing commits that have not passed CI on `main`.
+- Kept oversized hook payloads valid JSON and marked their bounded preview as truncated.
+- Stripped terminal escape sequences and unsafe controls from model-controlled question and goal text.
+- Aligned hook timeout validation and execution on the documented five-minute maximum.
+- Required file-backed goals to create or change their deliverable after the goal starts, including after session restore.
+- Removed a CI test dependency on an intentionally untracked internal document.
+
+## [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

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.14`:
 
 ```bash
-pi install git:github.com/KyrosHendrix/pi-KillerOS@v2.0.12
+pi install git:github.com/KyrosHendrix/pi-KillerOS@v2.0.14
 ```
 
-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 push version tags manually. Tag pushes cannot publish; every published commit must pass the full `main` CI workflow.
 
 ## 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

@@ -9,7 +9,8 @@ import { BoundedText } from "./bounded-text.ts";
 import { formatTime, formatTokens } from "./display.ts";
 import { reportError } from "./errors.ts";
 import { resolvePersonalInstructions } from "./personal-instructions.ts";
-import type { GoalBlockerAudit, GoalFileVerification, GoalRuntime, GoalState, GoalStatus, InitRuntime } from "./runtime.ts";
+import type { GoalBlockerAudit, GoalFileBaseline, GoalFileVerification, GoalRuntime, GoalState, GoalStatus, InitRuntime } from "./runtime.ts";
+import { safeTerminalText } from "./safe-terminal-text.ts";
 
 const GOAL_ENTRY_TYPE = "killeros-goal";
 const GOAL_CONTINUATION_TYPE = "killeros-goal-continuation";
@@ -67,13 +68,21 @@ function finiteNonNegative(value: unknown): value is number {
   return typeof value === "number" && Number.isFinite(value) && value >= 0;
 }
 
+function isGoalFileBaseline(value: unknown): value is GoalFileBaseline {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value as { exists?: unknown; size?: unknown; mtimeMs?: unknown };
+  if (candidate.exists === false) return candidate.size === undefined && candidate.mtimeMs === undefined;
+  return candidate.exists === true && finiteNonNegative(candidate.size) && finiteNonNegative(candidate.mtimeMs);
+}
+
 function isGoalFileVerification(value: unknown): value is GoalFileVerification {
   if (!value || typeof value !== "object") return false;
   const candidate = value as Partial<GoalFileVerification>;
   return candidate.kind === "file"
     && typeof candidate.path === "string"
     && candidate.path === candidate.path.trim()
-    && isAbsoluteFilePath(candidate.path);
+    && isAbsoluteFilePath(candidate.path)
+    && isGoalFileBaseline(candidate.baseline);
 }
 
 function isAbsoluteFilePath(value: string): boolean {
@@ -81,13 +90,23 @@ function isAbsoluteFilePath(value: string): boolean {
   return path.isAbsolute(value) || path.win32.isAbsolute(value);
 }
 
+function captureGoalFileBaseline(filePath: string): GoalFileBaseline {
+  try {
+    const artifact = lstatSync(filePath);
+    return { exists: true, size: artifact.size, mtimeMs: artifact.mtimeMs };
+  } catch {
+    return { exists: false };
+  }
+}
+
 function inferGoalVerification(objective: string): GoalFileVerification | undefined {
   const destination = /\b(?:create|write|save|generate)\b[^\r\n]{0,160}?\b(?:file|document|markdown|report|spreadsheet|presentation|image)\b\s+(?:to|at|as|destination(?:\s+is)?|output(?:\s+(?:to|at))?)\b\s*(?:`([^`\r\n]+)`|"([^"\r\n]+)"|'([^'\r\n]+)'|([A-Za-z]:\\[^\s,;]+|\/[^\s,;]+))/giu;
   const paths = [...objective.matchAll(destination)]
     .map((match) => (match[1] ?? match[2] ?? match[3] ?? match[4] ?? "").trim())
     .filter(isAbsoluteFilePath);
   const unique = [...new Set(paths)];
-  return unique.length === 1 ? { kind: "file", path: unique[0]! } : undefined;
+  const filePath = unique.length === 1 ? unique[0] : undefined;
+  return filePath ? { kind: "file", path: filePath, baseline: captureGoalFileBaseline(filePath) } : undefined;
 }
 
 function verifyGoalDeliverable(verification: GoalFileVerification): void {
@@ -100,6 +119,11 @@ function verifyGoalDeliverable(verification: GoalFileVerification): void {
   if (!artifact.isFile()) {
     throw new Error(`Goal deliverable is not a regular file at the required path: ${verification.path}`);
   }
+  if (verification.baseline.exists
+    && artifact.size === verification.baseline.size
+    && artifact.mtimeMs === verification.baseline.mtimeMs) {
+    throw new Error(`Goal deliverable has not changed since the goal started: ${verification.path}`);
+  }
 }
 
 function isGoalBlockerAudit(value: unknown, turns: number, status: GoalStatus): value is GoalBlockerAudit {
@@ -555,9 +579,10 @@ export function registerGoal(
     const icon = state.status === "active" ? "✻" : state.status === "paused" ? "Ⅱ" : state.status === "blocked" ? "!" : "✓";
     const color: ThemeColor = state.status === "active" ? "accent" : state.status === "paused" ? "warning" : state.status === "blocked" ? "error" : "success";
     const status = theme.fg(color, `${icon} Goal ${state.status}`);
-    if (!options.expanded) return new BoundedText(`${status}${theme.fg("dim", ` · ${state.objective}`)}`, 3);
-    const lines = [status, theme.fg("dim", state.objective)];
-    if (state.result) lines.push(theme.fg("muted", state.result));
+    const objective = safeTerminalText(state.objective);
+    if (!options.expanded) return new BoundedText(`${status}${theme.fg("dim", ` · ${objective}`)}`, 3);
+    const lines = [status, theme.fg("dim", objective)];
+    if (state.result) lines.push(theme.fg("muted", safeTerminalText(state.result)));
     return new BoundedText(lines.join("\n"));
   });
 
@@ -615,18 +640,18 @@ export function registerGoal(
       };
     },
     renderCall(args, theme) {
-      return new Text(`${theme.fg("toolTitle", theme.bold("goal "))}${theme.fg("muted", args.status)}`, 0, 0);
+      return new Text(`${theme.fg("toolTitle", theme.bold("goal "))}${theme.fg("muted", safeTerminalText(args.status))}`, 0, 0);
     },
     renderResult(result, options, theme, context) {
       if (context?.isError) {
         const first = result.content[0];
-        const message = first?.type === "text" ? first.text : "Goal update failed";
+        const message = first?.type === "text" ? safeTerminalText(first.text) : "Goal update failed";
         return new BoundedText(theme.fg("error", message), options.expanded ? undefined : 3);
       }
       const details = result.details;
       if (!details) return new BoundedText(theme.fg("dim", "Goal updated"));
       const label = details.status === "complete" ? "✓ Complete" : details.status === "blocked" ? "! Blocked" : `! Blocker audit ${details.streak}/3`;
-      const text = `${theme.fg(details.status === "complete" ? "success" : "warning", label)}${theme.fg("dim", ` · ${details.evidence}`)}`;
+      const text = `${theme.fg(details.status === "complete" ? "success" : "warning", label)}${theme.fg("dim", ` · ${safeTerminalText(details.evidence)}`)}`;
       return new BoundedText(text, options.expanded ? undefined : 3);
     },
   });

package/killeros/hooks.ts

@@ -4,7 +4,6 @@ import path from "node:path";
 import { StringDecoder } from "node:string_decoder";
 import { CONFIG_DIR_NAME, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { reportError } from "./errors.ts";
-import { MAX_NODE_TIMER_MS } from "./limits.ts";
 
 type KillerosHookEvent = "tool_call" | "tool_result" | "agent_settled";
 
@@ -29,6 +28,8 @@ interface HookExecutionResult {
 
 const HOOK_EVENTS: readonly KillerosHookEvent[] = ["tool_call", "tool_result", "agent_settled"];
 const HOOK_OUTPUT_LIMIT = 16 * 1024;
+const HOOK_PAYLOAD_LIMIT = 8_000;
+const HOOK_TIMEOUT_MAX_MS = 300_000;
 
 function loadKillerosHooks(ctx: ExtensionContext): KillerosHookConfig {
   const configPath = path.join(ctx.cwd, CONFIG_DIR_NAME, "killeros-hooks.json");
@@ -49,11 +50,14 @@ function loadKillerosHooks(ctx: ExtensionContext): KillerosHookConfig {
           ctx.ui.notify(`Ignored ${event} hook ${index + 1}: matchers are only valid for tool events`, "warning");
           return false;
         }
+        if (hook?.timeoutMs !== undefined && (!Number.isSafeInteger(hook.timeoutMs) || hook.timeoutMs <= 0 || hook.timeoutMs > HOOK_TIMEOUT_MAX_MS)) {
+          ctx.ui.notify(`Ignored ${event} hook ${index + 1}: timeoutMs must be an integer from 1 to ${HOOK_TIMEOUT_MAX_MS}`, "warning");
+          return false;
+        }
         const valid = hook
           && typeof hook.command === "string"
           && hook.command.trim().length > 0
-          && (hook.matcher === undefined || typeof hook.matcher === "string")
-          && (hook.timeoutMs === undefined || Number.isSafeInteger(hook.timeoutMs) && hook.timeoutMs > 0 && hook.timeoutMs <= MAX_NODE_TIMER_MS);
+          && (hook.matcher === undefined || typeof hook.matcher === "string");
         if (!valid) {
           ctx.ui.notify(`Ignored invalid ${event} hook ${index + 1} in ${configPath}`, "warning");
           return false;
@@ -189,15 +193,22 @@ export function executeHook(
       finish(termination ? terminationCode() : 1);
     });
     child.once("close", (code) => finish(termination ? terminationCode() : code ?? 1));
-    timer = setTimeout(() => beginTermination("timeout"), Math.max(1_000, Math.min(timeoutMs, 300_000)));
+    timer = setTimeout(() => beginTermination("timeout"), Math.max(1, Math.min(timeoutMs, HOOK_TIMEOUT_MAX_MS)));
   });
 }
 
+function serializeHookPayload(payload: unknown): string {
+  const serialized = JSON.stringify(payload) ?? "null";
+  if (serialized.length <= HOOK_PAYLOAD_LIMIT) return serialized;
+  const previewLength = Math.floor((HOOK_PAYLOAD_LIMIT - 64) / 2);
+  return JSON.stringify({ truncated: true, preview: serialized.slice(0, previewLength) });
+}
+
 function hookEnvironment(event: KillerosHookEvent, toolName = "", payload: unknown = {}): Record<string, string> {
   return {
     KILLEROS_EVENT: event,
     KILLEROS_TOOL: toolName,
-    KILLEROS_PAYLOAD: JSON.stringify(payload).slice(0, 8_000),
+    KILLEROS_PAYLOAD: serializeHookPayload(payload),
   };
 }
 

package/killeros/question.ts

@@ -16,6 +16,7 @@ import {
 } from "@earendil-works/pi-tui";
 import { Type, type Static } from "typebox";
 import { BoundedText } from "./bounded-text.ts";
+import { safeTerminalText } from "./safe-terminal-text.ts";
 
 const OptionSchema = Type.Object({
   label: Type.String({ minLength: 1, maxLength: 200, description: "Display label for the option" }),
@@ -264,11 +265,12 @@ export function registerQuestionTool(pi: ExtensionAPI): void {
       if (ctx.mode !== "tui") throw new Error("The question tool requires interactive TUI mode");
       if (signal?.aborted) throw new Error("Question cancelled before it opened");
 
+      const question = safeTerminalText(params.question);
       const options: DisplayOption[] = [
         ...params.options.map((option, index) => ({
-          label: option.label,
-          description: option.description,
-          preview: option.preview,
+          label: safeTerminalText(option.label),
+          description: option.description === undefined ? undefined : safeTerminalText(option.description),
+          preview: option.preview === undefined ? undefined : safeTerminalText(option.preview),
           originalIndex: index + 1,
           isOther: false,
         })),
@@ -599,7 +601,7 @@ export function registerQuestionTool(pi: ExtensionAPI): void {
             } else lines = [`${selected ? `> ${selected.label}` : "No matching options"} · ${position}`];
           } else if (rowBudget <= 5) {
             lines = [
-              ...boundedQuestionLines(params.question, width, Math.max(1, rowBudget - 3)),
+              ...boundedQuestionLines(question, width, Math.max(1, rowBudget - 3)),
               editMode !== "none"
                 ? `${editMode === "filter" ? "Filter" : "Answer"} ${editMode === "filter" ? filterCount : editorCount}/${CUSTOM_INPUT_MAX_CHARACTERS.toLocaleString()}`
                 : selected ? optionLabel(selected, optionIndex) : "No matching options",
@@ -607,7 +609,7 @@ export function registerQuestionTool(pi: ExtensionAPI): void {
               editMode !== "none" ? editHint : browseHint,
             ];
           } else {
-            const questionLines = boundedQuestionLines(params.question, width, Math.max(1, rowBudget - 5));
+            const questionLines = boundedQuestionLines(question, width, Math.max(1, rowBudget - 5));
             const contentRows = rowBudget - questionLines.length - 4;
             const optionCapacity = Math.max(1, Math.min(5, Math.ceil(contentRows / 2)));
             const detailCapacity = Math.max(0, contentRows - optionCapacity);
@@ -723,20 +725,26 @@ export function registerQuestionTool(pi: ExtensionAPI): void {
     renderCall(args, theme, context) {
       const { mode, minSelections: minimum, maxSelections: maximum } = normalizeQuestionSelection(args);
       const multiple = mode === "multiple";
+      const question = safeTerminalText(args.question);
+      const options = args.options.map((option) => ({
+        label: safeTerminalText(option.label),
+        description: option.description === undefined ? undefined : safeTerminalText(option.description),
+        preview: option.preview === undefined ? undefined : safeTerminalText(option.preview),
+      }));
       if (!context.expanded) {
         const title = multiple ? "question (multi-select) " : "question ";
-        const detail = multiple ? `${args.options.length} options · choose ${minimum}–${maximum}` : `${args.options.length} option${args.options.length === 1 ? "" : "s"}`;
-        return new BoundedText(`${theme.fg("toolTitle", theme.bold(title))}${theme.fg("muted", oneLine(args.question))}\n${theme.fg("dim", `  ${detail}`)}`, 3);
+        const detail = multiple ? `${options.length} options · choose ${minimum}–${maximum}` : `${options.length} option${options.length === 1 ? "" : "s"}`;
+        return new BoundedText(`${theme.fg("toolTitle", theme.bold(title))}${theme.fg("muted", oneLine(question))}\n${theme.fg("dim", `  ${detail}`)}`, 3);
       }
       const title = multiple ? "question (multi-select) " : "question ";
-      const lines = [`${theme.fg("toolTitle", theme.bold(title))}${theme.fg("muted", args.question)}`];
-      if (multiple) lines.push(theme.fg("dim", `${args.options.length} options · choose ${minimum}–${maximum}`));
-      args.options.forEach((option, index) => {
+      const lines = [`${theme.fg("toolTitle", theme.bold(title))}${theme.fg("muted", question)}`];
+      if (multiple) lines.push(theme.fg("dim", `${options.length} options · choose ${minimum}–${maximum}`));
+      options.forEach((option, index) => {
         lines.push(theme.fg("text", `${multiple ? "[ ] " : ""}${index + 1}. ${option.label}`));
         if (option.description) lines.push(theme.fg("muted", `   ${option.description}`));
         if (option.preview) lines.push(theme.fg("dim", option.preview));
       });
-      lines.push(theme.fg("text", `${multiple ? "[ ] " : ""}${args.options.length + 1}. Type a custom answer`));
+      lines.push(theme.fg("text", `${multiple ? "[ ] " : ""}${options.length + 1}. Type a custom answer`));
       return new BoundedText(lines.join("\n"));
     },
 
@@ -744,14 +752,16 @@ export function registerQuestionTool(pi: ExtensionAPI): void {
       const details = result.details;
       if (!details) {
         const first = result.content[0];
-        return new BoundedText(first?.type === "text" ? first.text : "", options.expanded ? undefined : 3);
+        return new BoundedText(first?.type === "text" ? safeTerminalText(first.text) : "", options.expanded ? undefined : 3);
       }
       if (details.cancelled || ("answer" in details && details.answer === null)) return new BoundedText(theme.fg("warning", "Cancelled"));
       if ("mode" in details && details.mode === "multiple") {
-        return new MultipleResultText(details.answers, options.expanded, details.customAnswer, theme.fg.bind(theme));
+        const answers = details.answers.map(safeTerminalText);
+        const customAnswer = details.customAnswer === undefined ? undefined : safeTerminalText(details.customAnswer);
+        return new MultipleResultText(answers, options.expanded, customAnswer, theme.fg.bind(theme));
       }
       if (!("answer" in details) || details.answer === null) return new BoundedText("");
-      const answer = details.answer;
+      const answer = safeTerminalText(details.answer);
       if (details.wasCustom) {
         return new BoundedText(`${theme.fg("success", "✓ ")}${theme.fg("muted", "(wrote) ")}${theme.fg("accent", answer)}`, options.expanded ? undefined : 3);
       }

package/killeros/runtime.ts

@@ -28,9 +28,14 @@ export interface GoalBlockerAudit {
   lastTurn: number;
 }
 
+export type GoalFileBaseline =
+  | { exists: false }
+  | { exists: true; size: number; mtimeMs: number };
+
 export interface GoalFileVerification {
   kind: "file";
   path: string;
+  baseline: GoalFileBaseline;
 }
 
 export interface GoalState {

package/killeros/safe-terminal-text.ts

@@ -0,0 +1,6 @@
+import { stripTerminalSequences } from "@earendil-works/pi-tui";
+
+/** Remove terminal commands and unsafe controls while preserving line feeds. */
+export function safeTerminalText(value: string): string {
+  return stripTerminalSequences(value).replace(/[\u0000-\u0009\u000B-\u001F\u007F-\u009F]/gu, "");
+}

package/package.json

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