killeros 2.0.6 → 2.0.7

package/CHANGELOG.md

@@ -4,6 +4,29 @@ All notable changes to KillerOS are documented here.
 
 ## [Unreleased]
 
+## [2.0.7] - 2026-08-13
+
+### Changed
+
+- Raised the supported and locked Pi baseline from 0.82.1 to the current matched 0.84.1 AI, coding-agent, and TUI packages.
+- Added a compact two-deck footer beneath the prompt and removed the work-trail widget.
+- Replaced the framed prompt and shuffled activity verbs with a focus-aware single-arrow editor and event-derived working copy.
+- Made settled timing entries report `Done`, `Stopped`, or `Failed` while keeping existing `Worked for` history readable.
+
+### Fixed
+
+- Separated response output from the prompt editor while keeping footer telemetry close beneath a quiet muted divider.
+- Kept `/variants` within the active terminal height, preserved the focused reasoning level across resizes, and initially focused the current level.
+- Rendered `/variants` controls from the same Pi keybinding manager that handles input, including installations with separate package module instances.
+- Rendered active, paused, and blocked `/goal` status text consistently in the footer's far-right slot.
+- Kept the private goal-update tool inactive outside active `/goal` runs and rendered its real execution errors instead of malformed blocker-audit fields.
+- Verified exact persisted paths for clearly declared file-deliverable goals before completion, while preserving model-reported completion for general objectives.
+- Accepted explicit `1`/`1` bounds for single-select questions and applied the same bounds validation before rendering and execution.
+- Prevented reload and branch navigation from preserving or reconstructing stale manual-compaction recovery eligibility; only Pi's live event in the current session can resume the interrupted goal safely.
+- Restricted goal deliverable verification to explicit destination phrases so source and reference paths cannot be reported as completed output.
+- Kept saved goals fully inactive in print and JSON modes, including the private update tool and shutdown checkpoints.
+- Rejected concurrent `/init` starts during preflight, cancelled pending preflight work on shutdown, and settled active `/init` command handlers when their session closes.
+
 ## [2.0.6] - 2026-08-11
 
 ### Added

package/Killeros.ts

@@ -1,4 +1,5 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { registerRequestActivity } from "./killeros/activity.ts";
 import { registerAliases, registerSlashAutocomplete } from "./killeros/commands.ts";
 import { registerConcisePrompt } from "./killeros/concise.ts";
 import { registerFooter } from "./killeros/footer.ts";
@@ -43,6 +44,7 @@ export default function Killeros(pi: ExtensionAPI, options: KillerosOptions = {}
   registerLifecycleHooks(pi);
   registerGoalSettlement(pi, goalRuntime, initRuntime);
   registerInitSettlement(pi, initRuntime);
+  registerRequestActivity(pi);
   registerCompletionNotifications(pi, options.completionNotifications);
   registerWorkedFor(pi);
 }

package/README.md

@@ -5,7 +5,7 @@ A production-hardened Pi extension that combines a custom TUI, repository initia
 ## Requirements
 
 - Node.js `22.19.0` or later
-- Pi `0.82.1` or later
+- Pi `0.84.1` or later
 - Interactive TUI mode for the custom header, editor, footer, `question` tool, and `/init`
 
 The extension is strict TypeScript. Pi provides the runtime modules.
@@ -31,7 +31,7 @@ pi install git:github.com/KyrosHendrix/pi-KillerOS
 Pin an install to a release:
 
 ```bash
-pi install git:github.com/KyrosHendrix/pi-KillerOS@v2.0.6
+pi install git:github.com/KyrosHendrix/pi-KillerOS@v2.0.7
 ```
 
 Add `-l` to either command for a project-only install. Restart Pi after installing.
@@ -40,16 +40,17 @@ Add `-l` to either command for a project-only install. Restart Pi after installi
 
 - 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 orange shuffled Claude-adjacent verbs changing every 2.5 seconds, a gray `(esc to interrupt · thinking)` status with bold `esc`, and a quiet hidden-thinking label
-- Full-width framed multiline editor with a shuffled session-stable empty-state suggestion, Shift+Enter support, and slash-command autocomplete; KillerOS preserves an editor factory configured by another extension
-- Responsive footer with polished model/provider identity, plain-language context, and active goal state remaining; reasoning, Git branch, elapsed time, cost, and path cut down by available width
+- 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
 - Pi-owned context compaction with active goals continuing from Pi's settled boundary after manual, threshold, and overflow compaction
 - 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.82.1` commands, extensions, prompts, and skills; paths, URLs, and invalid commands remain plain text
+- Mid-prompt slash completion with current Pi `0.84.1` 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
 - Concise system-prompt guidance and supported native concise defaults that preserve explicit provider settings
 
@@ -70,7 +71,7 @@ Add `-l` to either command for a project-only install. Restart Pi after installi
 /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 mark verified 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.
+`/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.
 
 `/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.
 
@@ -80,7 +81,7 @@ The generated file uses the four behavioral sections adapted from `writing-great
 
 ### Interactive questions
 
-Single-select remains the default. 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 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.
 
 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.
 

package/killeros/activity.ts

@@ -0,0 +1,97 @@
+import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth } from "@earendil-works/pi-tui";
+
+export type ActivityMessage =
+  | { kind: "prompt" }
+  | { kind: "tool"; toolName: string }
+  | { kind: "tool-result"; failed: boolean }
+  | { kind: "responding" };
+
+function safeToolName(toolName: string): string {
+  const normalized = toolName.replace(/[\u0000-\u001F\u007F]+/gu, " ").replace(/\s+/gu, " ").trim();
+  return truncateToWidth(normalized || "tool", 32, "…");
+}
+
+export function formatActivityMessage(message: ActivityMessage, theme: Theme): string {
+  let verb: string;
+  let detail: string;
+
+  switch (message.kind) {
+    case "prompt":
+      verb = "Mapping…";
+      detail = "understanding request";
+      break;
+    case "tool-result":
+      verb = message.failed ? "Recovering…" : "Reviewing…";
+      detail = message.failed ? "tool failed" : "reading the result";
+      break;
+    case "responding":
+      verb = "Responding…";
+      detail = "assembling the answer";
+      break;
+    case "tool":
+      switch (message.toolName.trim().toLocaleLowerCase()) {
+        case "read":
+        case "grep":
+        case "find":
+        case "ls":
+          verb = "Inspecting…";
+          detail = "reading relevant code";
+          break;
+        case "edit":
+        case "write":
+          verb = "Changing…";
+          detail = "editing";
+          break;
+        case "bash":
+          verb = "Running…";
+          detail = "command";
+          break;
+        default:
+          verb = "Working…";
+          detail = `using ${safeToolName(message.toolName)}`;
+      }
+      break;
+  }
+
+  return `${theme.fg("accent", verb)} ${theme.fg("dim", `(${theme.bold("esc")} to interrupt · ${detail})`)}`;
+}
+
+export function registerRequestActivity(pi: ExtensionAPI): void {
+  let active = false;
+
+  const clear = (ctx?: ExtensionContext): void => {
+    if (ctx?.mode === "tui") {
+      ctx.ui.setWorkingMessage();
+    }
+    active = false;
+  };
+
+  pi.on("agent_start", (_event, ctx) => {
+    if (ctx.mode !== "tui") return;
+    active = true;
+    ctx.ui.setWorkingMessage(formatActivityMessage({ kind: "prompt" }, ctx.ui.theme));
+  });
+
+  pi.on("tool_execution_start", (event, ctx) => {
+    if (ctx.mode !== "tui" || !active) return;
+    ctx.ui.setWorkingMessage(formatActivityMessage({ kind: "tool", toolName: event.toolName }, ctx.ui.theme));
+  });
+
+  pi.on("tool_execution_end", (event, ctx) => {
+    if (ctx.mode !== "tui" || !active) return;
+    ctx.ui.setWorkingMessage(formatActivityMessage({ kind: "tool-result", failed: event.isError }, ctx.ui.theme));
+  });
+
+  pi.on("message_update", (event, ctx) => {
+    if (ctx.mode !== "tui" || !active || event.assistantMessageEvent.type !== "text_start") return;
+    ctx.ui.setWorkingMessage(formatActivityMessage({ kind: "responding" }, ctx.ui.theme));
+  });
+
+  pi.on("agent_settled", (_event, ctx) => {
+    if (ctx.mode !== "tui" || !active || !ctx.isIdle?.() || ctx.hasPendingMessages?.()) return;
+    clear(ctx);
+  });
+
+  pi.on("session_shutdown", (_event, ctx) => clear(ctx));
+}

package/killeros/footer.ts

@@ -125,6 +125,10 @@ function renderFooterRow(left: string, right: string, width: number): string {
   return ` ${clippedLeft}${gap}${clippedRight} `;
 }
 
+function renderFooter(rows: string[], width: number, theme: Theme): string[] {
+  return [theme.fg("borderMuted", "─".repeat(width)), ...rows];
+}
+
 function formatGoalElapsed(milliseconds: number): string {
   const totalSeconds = Number.isFinite(milliseconds) ? Math.max(0, Math.floor(milliseconds / 1_000)) : 0;
   if (totalSeconds < 60) return `${totalSeconds}s`;
@@ -138,15 +142,13 @@ function formatGoalElapsed(milliseconds: number): string {
   return `${hours}h ${minutes.toString().padStart(2, "0")}m ${seconds.toString().padStart(2, "0")}s`;
 }
 
-function formatActiveGoalFooter(state: GoalState | undefined, theme: Theme): string {
-  if (state?.status !== "active") return "";
-  return theme.fg("warning", `/goal is active (${formatGoalElapsed(goalElapsedMilliseconds(state))})`);
-}
-
 function formatGoalFooter(state: GoalState | undefined, theme: Theme): string {
   if (!state) return "";
-  if (state.status === "paused") return theme.fg("warning", "Ⅱ goal paused");
-  if (state.status === "blocked") return theme.fg("error", "! goal blocked");
+  if (state.status === "active") {
+    return theme.fg("warning", `/goal is active (${formatGoalElapsed(goalElapsedMilliseconds(state))})`);
+  }
+  if (state.status === "paused") return theme.fg("warning", "/goal is paused");
+  if (state.status === "blocked") return theme.fg("error", "/goal is blocked");
   return "";
 }
 
@@ -211,52 +213,36 @@ export function registerFooter(pi: ExtensionAPI, goalRuntime: GoalRuntime): void
           const signature = formatModel(model, theme);
           const fullDirectory = theme.fg("dim", cwd);
           const focusedDirectory = theme.fg("dim", compactDirectory(cwd));
-          const activeGoal = formatActiveGoalFooter(goalRuntime.state, theme);
           const goal = formatGoalFooter(goalRuntime.state, theme);
-          const rich = joinFooterParts([
+          const primary = joinFooterParts([
             signature,
             level,
             context,
-            goal,
-            branch ? theme.fg("dim", branch) : "",
+          ], theme);
+          const primaryFocused = joinFooterParts([signature, context], theme);
+          const session = joinFooterParts([
             theme.fg("dim", formatTime(Date.now() - sessionStart)),
             theme.fg("dim", formatCost(getSessionCost(ctx))),
           ], theme);
-          const focused = joinFooterParts([signature, context, goal], theme);
-
-          if (activeGoal) {
-            if (footerRowFits(rich, activeGoal, width)) {
-              return [renderFooterRow(rich, activeGoal, width)];
-            }
-            if (footerRowFits(focused, activeGoal, width)) {
-              return [renderFooterRow(focused, activeGoal, width)];
-            }
-            if (footerRowFits(context, activeGoal, width)) {
-              return [renderFooterRow(context, activeGoal, width)];
-            }
-            return [renderFooterRow("", activeGoal, width)];
-          }
-
-          if (footerRowFits(rich, fullDirectory, width)) {
-            return [renderFooterRow(rich, fullDirectory, width)];
-          }
-          if (footerRowFits(rich, focusedDirectory, width)) {
-            return [renderFooterRow(rich, focusedDirectory, width)];
-          }
-          if (footerRowFits(focused, focusedDirectory, width)) {
-            return [renderFooterRow(focused, focusedDirectory, width)];
-          }
-          if (footerRowFits(focused, "", width)) {
-            return [renderFooterRow(focused, "", width)];
-          }
-          if (goal) {
-            const essentialGoal = joinFooterParts([context, goal], theme);
-            if (footerRowFits(essentialGoal, "", width)) return [renderFooterRow(essentialGoal, "", width)];
-            return [renderFooterRow(goal, context, width)];
-          }
-
           const essentialModel = formatModel(model, theme, false);
-          return [renderFooterRow(essentialModel, context, width)];
+          const primaryRow = footerRowFits(primary, session, width)
+            ? renderFooterRow(primary, session, width)
+            : footerRowFits(primary, "", width)
+              ? renderFooterRow(primary, "", width)
+              : footerRowFits(primaryFocused, "", width)
+                ? renderFooterRow(primaryFocused, "", width)
+                : renderFooterRow(essentialModel, context, width);
+          const branchLabel = branch ? theme.fg("dim", branch) : "";
+          const workspaceRight = goal || fullDirectory;
+          const secondaryRow = footerRowFits(branchLabel, workspaceRight, width)
+            ? renderFooterRow(branchLabel, workspaceRight, width)
+            : goal
+              ? renderFooterRow("", goal, width)
+              : footerRowFits(branchLabel, focusedDirectory, width)
+                ? renderFooterRow(branchLabel, focusedDirectory, width)
+                : renderFooterRow(branchLabel, "", width);
+
+          return renderFooter([primaryRow, secondaryRow], width, theme);
         },
       };
     });

package/killeros/goals.ts

@@ -1,4 +1,6 @@
 import { StringEnum } from "@earendil-works/pi-ai";
+import { lstatSync } from "node:fs";
+import path from "node:path";
 import { type ExtensionAPI, type ExtensionCommandContext, type ExtensionContext, type ThemeColor } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
@@ -7,10 +9,11 @@ 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, GoalRuntime, GoalState, GoalStatus, InitRuntime } from "./runtime.ts";
+import type { GoalBlockerAudit, GoalFileVerification, GoalRuntime, GoalState, GoalStatus, InitRuntime } from "./runtime.ts";
 
 const GOAL_ENTRY_TYPE = "killeros-goal";
 const GOAL_CONTINUATION_TYPE = "killeros-goal-continuation";
+const GOAL_UPDATE_TOOL = "killeros_goal_update";
 const GOAL_OBJECTIVE_LIMIT = 4_000;
 const GOAL_VERSION = 1;
 
@@ -29,7 +32,6 @@ interface GoalTransitionOptions {
 
 interface RestoredGoalState {
   state?: GoalState;
-  recoveryProven: boolean;
 }
 
 const GoalUpdateParams = Type.Object({
@@ -52,6 +54,7 @@ const GoalUpdateParams = Type.Object({
 interface GoalUpdateDetails {
   status: "complete" | "blocked" | "blocker-audit";
   evidence: string;
+  verification?: "file" | "model-reported";
   blockerKey?: string;
   streak?: number;
 }
@@ -64,6 +67,41 @@ function finiteNonNegative(value: unknown): value is number {
   return typeof value === "number" && Number.isFinite(value) && value >= 0;
 }
 
+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);
+}
+
+function isAbsoluteFilePath(value: string): boolean {
+  if (!value || /^(?:https?|file):\/\//iu.test(value) || /[\\\/]$/u.test(value)) return false;
+  return path.isAbsolute(value) || path.win32.isAbsolute(value);
+}
+
+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;
+}
+
+function verifyGoalDeliverable(verification: GoalFileVerification): void {
+  let artifact: ReturnType<typeof lstatSync>;
+  try {
+    artifact = lstatSync(verification.path);
+  } catch {
+    throw new Error(`Goal deliverable is not a regular file at the required path: ${verification.path}`);
+  }
+  if (!artifact.isFile()) {
+    throw new Error(`Goal deliverable is not a regular file at the required path: ${verification.path}`);
+  }
+}
+
 function isGoalBlockerAudit(value: unknown, turns: number, status: GoalStatus): value is GoalBlockerAudit {
   if (!value || typeof value !== "object") return false;
   const candidate = value as Partial<GoalBlockerAudit>;
@@ -92,6 +130,7 @@ function parseGoalState(value: unknown): GoalState | undefined {
     || !finiteNonNegative(candidate.baselineTokens)
     || candidate.activeStartedAt !== undefined && !finiteNonNegative(candidate.activeStartedAt)
     || candidate.result !== undefined && typeof candidate.result !== "string"
+    || candidate.verification !== undefined && !isGoalFileVerification(candidate.verification)
     || candidate.blockerAudit !== undefined && !isGoalBlockerAudit(candidate.blockerAudit, candidate.turns!, candidate.status)
     || candidate.resumeAfterManualCompaction !== undefined && candidate.resumeAfterManualCompaction !== true
     || candidate.resumeAfterManualCompaction === true && candidate.status !== "paused") {
@@ -112,6 +151,7 @@ function parseGoalState(value: unknown): GoalState | undefined {
     result: candidate.result,
     resumeAfterManualCompaction: candidate.resumeAfterManualCompaction,
     blockerAudit: candidate.blockerAudit,
+    verification: candidate.verification,
   };
 }
 
@@ -130,19 +170,17 @@ function restoreGoalState(ctx: ExtensionContext): RestoredGoalState {
     if (entry?.type !== "custom" || entry.customType !== GOAL_ENTRY_TYPE) continue;
     const data = entry.data as Partial<GoalEntryData> | undefined;
     if (!data || data.version !== GOAL_VERSION || data.state === null) {
-      return { state: undefined, recoveryProven: false };
+      return { state: undefined };
     }
     const restored = parseGoalState(data.state);
-    if (!restored) return { state: undefined, recoveryProven: false };
+    if (!restored) return { state: undefined };
     const state = restored.status === "active"
       ? { ...restored, activeStartedAt: Date.now() }
       : { ...restored, activeStartedAt: undefined };
-    const recoveryProven = state.status === "paused"
-      && state.resumeAfterManualCompaction === true
-      && entries.slice(index + 1).some((candidate) => candidate.type === "compaction");
-    return { state, recoveryProven };
+    if (state.status === "paused") state.resumeAfterManualCompaction = undefined;
+    return { state };
   }
-  return { state: undefined, recoveryProven: false };
+  return { state: undefined };
 }
 
 export function goalElapsedMilliseconds(state: GoalState, now = Date.now()): number {
@@ -173,6 +211,21 @@ function sumGoalTokens(ctx: ExtensionContext): number {
   return total;
 }
 
+function setGoalUpdateToolActive(pi: ExtensionAPI, active: boolean): void {
+  const api = pi as ExtensionAPI & { getActiveTools?: () => string[]; setActiveTools?: (names: string[]) => void };
+  if (!api.getActiveTools || !api.setActiveTools) return;
+  const activeTools = api.getActiveTools();
+  const isActive = activeTools.includes(GOAL_UPDATE_TOOL);
+  if (active === isActive) return;
+  api.setActiveTools(active
+    ? [...activeTools, GOAL_UPDATE_TOOL]
+    : activeTools.filter((name) => name !== GOAL_UPDATE_TOOL));
+}
+
+function syncGoalUpdateTool(pi: ExtensionAPI, runtime: GoalRuntime): void {
+  setGoalUpdateToolActive(pi, runtime.state?.status === "active");
+}
+
 function persistGoalState(
   pi: ExtensionAPI,
   runtime: GoalRuntime,
@@ -182,6 +235,7 @@ function persistGoalState(
   const data: GoalEntryData = { version: GOAL_VERSION, event, state: state ?? null };
   pi.appendEntry(GOAL_ENTRY_TYPE, data);
   runtime.state = state;
+  syncGoalUpdateTool(pi, runtime);
   runtime.persistenceRetryNeeded = false;
   runtime.requestRender?.();
 }
@@ -276,6 +330,7 @@ export function pauseGoalAfterFailure(
       result: reason,
       resumeAfterManualCompaction: undefined,
     } : undefined;
+    syncGoalUpdateTool(pi, runtime);
     runtime.persistenceRetryNeeded = true;
     runtime.continuationScheduled = false;
     runtime.requestRender?.();
@@ -301,6 +356,7 @@ function pauseGoalForPossibleManualCompaction(
       result: reason,
       resumeAfterManualCompaction: true,
     } : undefined;
+    syncGoalUpdateTool(pi, runtime);
     runtime.persistenceRetryNeeded = true;
     runtime.continuationScheduled = false;
     runtime.requestRender?.();
@@ -465,7 +521,7 @@ export function registerGoal(
   });
 
   pi.registerTool<typeof GoalUpdateParams, GoalUpdateDetails>({
-    name: "killeros_goal_update",
+    name: GOAL_UPDATE_TOOL,
     label: "Goal update",
     description: "Mark the active KillerOS long-running goal complete after verification, or record the same blocker key on three consecutive goal turns before blocking it.",
     parameters: GoalUpdateParams,
@@ -478,10 +534,14 @@ export function registerGoal(
       const evidence = params.evidence.trim();
       if (!evidence) throw new Error("Goal evidence must not be empty");
       if (params.status === "complete") {
+        if (state.verification) verifyGoalDeliverable(state.verification);
+        const verification = state.verification ? "file" : "model-reported";
         transitionGoal(pi, runtime, "complete", "complete", evidence, { resetBlockedAudit: true });
         return {
-          content: [{ type: "text", text: `Goal marked complete: ${evidence}` }],
-          details: { status: "complete", evidence },
+          content: [{ type: "text", text: state.verification
+            ? `Goal verified complete at ${state.verification.path}: ${evidence}`
+            : `Goal marked complete (model-reported): ${evidence}` }],
+          details: { status: "complete", evidence, verification },
         };
       }
       if (!runtime.goalTurnInFlight) throw new Error("A blocker audit can only be recorded during an active KillerOS goal turn");
@@ -516,7 +576,12 @@ export function registerGoal(
     renderCall(args, theme) {
       return new Text(`${theme.fg("toolTitle", theme.bold("goal "))}${theme.fg("muted", args.status)}`, 0, 0);
     },
-    renderResult(result, options, theme) {
+    renderResult(result, options, theme, context) {
+      if (context?.isError) {
+        const first = result.content[0];
+        const message = first?.type === "text" ? 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`;
@@ -527,7 +592,8 @@ export function registerGoal(
 
   const restoreGoal = (ctx: ExtensionContext): void => {
     const restored = restoreGoalState(ctx);
-    runtime.state = restored.state;
+    runtime.state = isGoalModeSupported(ctx) ? restored.state : undefined;
+    syncGoalUpdateTool(pi, runtime);
     runtime.continuationScheduled = false;
     runtime.continuationHeld = false;
     runtime.goalTurnInFlight = false;
@@ -536,9 +602,7 @@ export function registerGoal(
     runtime.lastStopReason = undefined;
     runtime.lastError = undefined;
     runtime.requestRender?.();
-    if (restored.recoveryProven) {
-      recoverGoalAfterManualCompaction(pi, runtime, initState, ctx);
-    } else if (runtime.state?.status === "active") {
+    if (runtime.state?.status === "active") {
       setImmediate(() => scheduleGoalContinuation(pi, runtime, initState, ctx));
     }
   };
@@ -561,6 +625,7 @@ export function registerGoal(
       }
     }
     runtime.state = undefined;
+    syncGoalUpdateTool(pi, runtime);
     runtime.continuationScheduled = false;
     runtime.continuationHeld = false;
     runtime.goalTurnInFlight = false;
@@ -680,6 +745,7 @@ export function registerGoal(
             ctx.ui.notify("Goal pause saved. Goal remains paused. Automatic compaction recovery is off.", "info");
           } catch (error) {
             runtime.state = checkpoint;
+            syncGoalUpdateTool(pi, runtime);
             runtime.persistenceRetryNeeded = true;
             runtime.continuationScheduled = false;
             runtime.requestRender?.();
@@ -798,6 +864,7 @@ export function registerGoal(
           activeStartedAt: now,
           blockedAuditStartTurn: current.turns,
           blockerAudit: undefined,
+          verification: inferGoalVerification(objective),
           result: undefined,
           resumeAfterManualCompaction: undefined,
         };
@@ -869,6 +936,7 @@ export function registerGoal(
         turns: 0,
         blockedAuditStartTurn: 0,
         baselineTokens: sumGoalTokens(ctx),
+        verification: inferGoalVerification(objective),
       };
       try {
         persistGoalState(pi, runtime, unfinished ? "replace" : "set", state);

package/killeros/init.ts

@@ -133,8 +133,10 @@ export function registerInitCommand(pi: ExtensionAPI, initState: InitRuntime, go
 
   pi.on("session_start", () => setInitTools(pi, initState, false));
   pi.on("session_shutdown", () => {
+    const settle = initState.settle;
     setInitTools(pi, initState, false);
     resetInitRuntime(initState);
+    settle?.({ kind: "cancelled" });
   });
   pi.on("before_agent_start", () => {
     if (initState.active) setInitTools(pi, initState, true);
@@ -160,7 +162,7 @@ export function registerInitCommand(pi: ExtensionAPI, initState: InitRuntime, go
         ctx.ui.notify("/init requires interactive TUI mode", "error");
         return;
       }
-      if (initState.active) {
+      if (initState.active || initState.starting) {
         ctx.ui.notify("/init is already running", "warning");
         return;
       }
@@ -172,28 +174,45 @@ export function registerInitCommand(pi: ExtensionAPI, initState: InitRuntime, go
         ctx.ui.notify("Trust this project before running /init", "error");
         return;
       }
-      await ctx.waitForIdle();
+      const starting = Symbol();
+      initState.starting = starting;
+      try {
+        await ctx.waitForIdle();
+      } catch (error) {
+        if (initState.starting !== starting) return;
+        initState.starting = undefined;
+        reportError(ctx, "/init could not wait for active work", error);
+        return;
+      }
+      if (initState.starting !== starting) return;
 
       let projectRoot: string;
       try {
         projectRoot = await fs.realpath(ctx.cwd);
       } catch (error) {
+        if (initState.starting !== starting) return;
+        initState.starting = undefined;
         reportError(ctx, "/init could not resolve the project root", error);
         return;
       }
+      if (initState.starting !== starting) return;
       const targetPath = path.join(projectRoot, "AGENTS.md");
       try {
         const [{ index: evidence }, baseline] = await Promise.all([
           buildInitEvidence(projectRoot),
           captureInitTargetBaseline(targetPath),
         ]);
+        if (initState.starting !== starting) return;
         initState.active = true;
         initState.projectRoot = projectRoot;
         initState.targetPath = targetPath;
         initState.evidence = evidence;
         initState.baseline = baseline;
         initState.outcome = { kind: "pending" };
+        initState.starting = undefined;
       } catch (error) {
+        if (initState.starting !== starting) return;
+        initState.starting = undefined;
         reportError(ctx, "/init could not capture safe repository evidence", error);
         return;
       }
@@ -234,6 +253,8 @@ export function registerInitCommand(pi: ExtensionAPI, initState: InitRuntime, go
         case "policy-conflict":
           ctx.ui.notify(`/init left AGENTS.md unchanged: ${outcome.reason}`, "warning");
           break;
+        case "cancelled":
+          break;
         default:
           reportError(ctx, "/init did not generate AGENTS.md", "the model completed without a write or policy-conflict outcome");
       }

package/killeros/question.ts

@@ -9,7 +9,7 @@ import {
   wrapTextWithAnsi,
   type EditorTheme,
 } from "@earendil-works/pi-tui";
-import { Type } from "typebox";
+import { Type, type Static } from "typebox";
 import { BoundedText } from "./bounded-text.ts";
 
 const OptionSchema = Type.Object({
@@ -31,16 +31,42 @@ const QuestionParams = Type.Object({
   minSelections: Type.Optional(Type.Integer({
     minimum: 1,
     maximum: 10,
-    description: "Minimum answers required in multiple mode; defaults to 1",
+    description: "Minimum answers required in multiple mode; defaults to 1. Single mode accepts only an explicit 1/1 bounds pair",
   })),
   maxSelections: Type.Optional(Type.Integer({
     minimum: 1,
     maximum: 10,
-    description: "Maximum answers allowed in multiple mode; defaults to all options plus one custom answer",
+    description: "Maximum answers allowed in multiple mode; defaults to all options plus one custom answer. Single mode accepts only an explicit 1/1 bounds pair",
   })),
 });
 
-type QuestionMode = "single" | "multiple";
+type QuestionParamsValue = Static<typeof QuestionParams>;
+
+type NormalizedQuestionSelection =
+  | { mode: "single"; minSelections: 1; maxSelections: 1 }
+  | { mode: "multiple"; minSelections: number; maxSelections: number };
+
+function normalizeQuestionSelection(params: QuestionParamsValue): NormalizedQuestionSelection {
+  const mode = params.mode ?? "single";
+  if (mode === "single") {
+    const hasSelectionBounds = params.minSelections !== undefined || params.maxSelections !== undefined;
+    if (hasSelectionBounds && (params.minSelections !== 1 || params.maxSelections !== 1)) {
+      throw new Error("Single-select question bounds must be omitted or both be 1");
+    }
+    return { mode, minSelections: 1, maxSelections: 1 };
+  }
+
+  const maximumAvailable = params.options.length + 1;
+  const minSelections = params.minSelections ?? 1;
+  const maxSelections = params.maxSelections ?? maximumAvailable;
+  if (minSelections > maxSelections) {
+    throw new Error("Question minimum selections cannot exceed maximum selections");
+  }
+  if (maxSelections > maximumAvailable) {
+    throw new Error(`Question allows at most ${maximumAvailable} selections including one custom answer`);
+  }
+  return { mode, minSelections, maxSelections };
+}
 
 interface DisplayOption {
   label: string;
@@ -229,20 +255,7 @@ export function registerQuestionTool(pi: ExtensionAPI): void {
     executionMode: "sequential",
 
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
-      const mode: QuestionMode = params.mode ?? "single";
-      const hasSelectionBounds = params.minSelections !== undefined || params.maxSelections !== undefined;
-      if (mode === "single" && hasSelectionBounds) {
-        throw new Error("Question selection bounds require mode \"multiple\"");
-      }
-      const maximumAvailable = params.options.length + 1;
-      const minSelections = params.minSelections ?? 1;
-      const maxSelections = params.maxSelections ?? maximumAvailable;
-      if (minSelections > maxSelections) {
-        throw new Error("Question minimum selections cannot exceed maximum selections");
-      }
-      if (maxSelections > maximumAvailable) {
-        throw new Error(`Question allows at most ${maximumAvailable} selections including one custom answer`);
-      }
+      const { mode, minSelections, maxSelections } = normalizeQuestionSelection(params);
       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");
 
@@ -703,9 +716,8 @@ export function registerQuestionTool(pi: ExtensionAPI): void {
     },
 
     renderCall(args, theme, context) {
-      const multiple = args.mode === "multiple";
-      const minimum = args.minSelections ?? 1;
-      const maximum = args.maxSelections ?? args.options.length + 1;
+      const { mode, minSelections: minimum, maxSelections: maximum } = normalizeQuestionSelection(args);
+      const multiple = mode === "multiple";
       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"}`;

package/killeros/runtime.ts

@@ -5,10 +5,12 @@ export type InitOutcome =
   | { kind: "pending" }
   | { kind: "written" }
   | { kind: "policy-conflict"; reason: string }
+  | { kind: "cancelled" }
   | { kind: "no-outcome" };
 
 export interface InitRuntime {
   active: boolean;
+  starting?: symbol;
   targetPath?: string;
   projectRoot?: string;
   activeTools?: string[];
@@ -26,6 +28,11 @@ export interface GoalBlockerAudit {
   lastTurn: number;
 }
 
+export interface GoalFileVerification {
+  kind: "file";
+  path: string;
+}
+
 export interface GoalState {
   version: 1;
   revision: number;
@@ -41,6 +48,7 @@ export interface GoalState {
   result?: string;
   resumeAfterManualCompaction?: true;
   blockerAudit?: GoalBlockerAudit;
+  verification?: GoalFileVerification;
 }
 
 export interface GoalRuntime {
@@ -71,6 +79,7 @@ export function createGoalRuntime(): GoalRuntime {
 
 export function resetInitRuntime(state: InitRuntime): void {
   state.active = false;
+  state.starting = undefined;
   state.targetPath = undefined;
   state.projectRoot = undefined;
   state.activeTools = undefined;

package/killeros/shell-ui.ts

@@ -2,7 +2,6 @@ import { execFile } from "node:child_process";
 import { readFileSync } from "node:fs";
 import {
   CustomEditor,
-  DynamicBorder,
   VERSION,
   type ExtensionAPI,
   type ExtensionContext,
@@ -10,9 +9,7 @@ import {
   type Theme,
 } from "@earendil-works/pi-coding-agent";
 import {
-  Container,
   CURSOR_MARKER,
-  Text,
   truncateToWidth,
   visibleWidth,
   wrapTextWithAnsi,
@@ -182,7 +179,7 @@ function isBorderLine(line: string): boolean {
 
 function isScrolledTopBorder(line: string): boolean {
   const unstyled = stripAnsi(line);
-  return unstyled.includes("↑") || unstyled.includes(".");
+  return unstyled.includes("↑");
 }
 
 class PiCodeEditor extends CustomEditor {
@@ -219,10 +216,9 @@ class PiCodeEditor extends CustomEditor {
 
   override render(width: number): string[] {
     if (width <= 0) return [];
-    if (width < 4) return super.render(width).map((line) => truncateToWidth(line, width, ""));
-    const innerWidth = width - 2;
+    const innerWidth = Math.max(1, width - 2);
     const lines = super.render(innerWidth);
-    if (lines.length < 2) return lines.map((line) => truncateToWidth(line, width, ""));
+    if (lines.length < 2) return ["", ...lines.map((line) => truncateToWidth(line, width, ""))];
     let bottomBorderIndex = lines.length - 1;
     for (let index = lines.length - 1; index >= 1; index -= 1) {
       if (isBorderLine(lines[index] ?? "")) {
@@ -231,44 +227,40 @@ class PiCodeEditor extends CustomEditor {
       }
     }
 
-    const gray = (text: string): string => this.runtimeTheme.fg("dim", text);
-    const framed: string[] = [];
+    const dim = (text: string): string => this.runtimeTheme.fg("dim", text);
+    const rendered: string[] = [];
     const top = stripAnsi(lines[0] ?? "");
     const isScrolledHeader = isScrolledTopBorder(lines[0] ?? "");
     if (isScrolledHeader) {
       const count = top.match(/↑\s*(\d+)/)?.[1] ?? "";
-      const indicator = `${gray("─── ↑ ")}${count}${gray(" more ")}${gray("─".repeat(Math.max(0, width - 12 - count.length)))}`;
-      framed.push(truncateToWidth(indicator, width, ""));
-    } else {
-      framed.push(gray("─".repeat(width)));
+      rendered.push(truncateToWidth(dim(`  ↑ ${count} more`), width, ""));
     }
 
     for (let index = 1; index < bottomBorderIndex; index += 1) {
       const isPromptLine = index === 1 && !isScrolledHeader;
-      const prefix = isPromptLine ? gray("❯\u00A0") : "  ";
+      const prefix = isPromptLine
+        ? this.runtimeTheme.fg(this.focused ? "accent" : "dim", "❯\u00A0")
+        : "  ";
       let content = lines[index] ?? "";
       if (isPromptLine && this.getText() === "") {
         const first = this.suggestion.slice(0, 1);
         const rest = this.suggestion.slice(1);
         const cursorMarker = this.focused ? CURSOR_MARKER : "";
-        content = `${cursorMarker}\x1B[7m${gray(first)}\x1B[27m${gray(rest)}`;
+        content = `${cursorMarker}\x1B[7m${dim(first)}\x1B[27m${dim(rest)}`;
       }
-      framed.push(`${prefix}${padRight(content, innerWidth)}`);
+      rendered.push(`${prefix}${padRight(content, innerWidth)}`);
     }
 
     const bottom = stripAnsi(lines[bottomBorderIndex] ?? "");
     if (bottom.includes("↓")) {
       const count = bottom.match(/↓\s*(\d+)/)?.[1] ?? "";
-      const indicator = `${gray("─── ↓ ")}${count}${gray(" more ")}${gray("─".repeat(Math.max(0, width - 12 - count.length)))}`;
-      framed.push(truncateToWidth(indicator, width, ""));
-    } else {
-      framed.push(gray("─".repeat(width)));
+      rendered.push(truncateToWidth(dim(`  ↓ ${count} more`), width, ""));
     }
 
     for (let index = bottomBorderIndex + 1; index < lines.length; index += 1) {
-      framed.push(`  ${padRight(lines[index] ?? "", innerWidth)}`);
+      rendered.push(`  ${padRight(lines[index] ?? "", innerWidth)}`);
     }
-    return framed.map((line) => truncateToWidth(line, width, ""));
+    return ["", ...rendered.map((line) => truncateToWidth(line, width, ""))];
   }
 }
 
@@ -277,39 +269,11 @@ const ACTIVITY_FRAMES = [
   "✽", "✻", "✶", "✱", "✢", "·",
 ] as const;
 const ACTIVITY_FRAME_INTERVAL_MS = 120;
-const ACTIVITY_WORDS = ["Brewing", "Pondering", "Tinkering", "Wrangling", "Noodling", "Cooking"] as const;
-
-function formatActivityMessage(word: string, theme: Theme): string {
-  return `${theme.fg("accent", `${word}…`)} ${theme.fg("dim", `(${theme.bold("esc")} to interrupt · thinking)`)}`;
-}
 
 let killerosEditorFactory: ReturnType<ExtensionContext["ui"]["getEditorComponent"]>;
 
 export function registerShellUi(pi: ExtensionAPI): void {
   let activeHeader: PiStartupHeader | undefined;
-  let activityDeck: string[] = [];
-  let lastActivityWord: string | undefined;
-  let activityTimer: ReturnType<typeof setInterval> | undefined;
-  const refillActivityDeck = (): void => {
-    activityDeck = [...ACTIVITY_WORDS];
-    for (let index = activityDeck.length - 1; index > 0; index -= 1) {
-      const swapIndex = Math.floor(Math.random() * (index + 1));
-      [activityDeck[index], activityDeck[swapIndex]] = [activityDeck[swapIndex]!, activityDeck[index]!];
-    }
-    if (activityDeck.length > 1 && activityDeck.at(-1) === lastActivityWord) {
-      [activityDeck[0], activityDeck[activityDeck.length - 1]] = [activityDeck.at(-1)!, activityDeck[0]!];
-    }
-  };
-  const nextActivityWord = (): string => {
-    if (activityDeck.length === 0) refillActivityDeck();
-    const word = activityDeck.pop() ?? ACTIVITY_WORDS[0];
-    lastActivityWord = word;
-    return word;
-  };
-  const clearActivityTimer = (): void => {
-    if (activityTimer) clearInterval(activityTimer);
-    activityTimer = undefined;
-  };
 
   pi.on("session_start", (_event, ctx) => {
     if (ctx.mode !== "tui") return;
@@ -321,7 +285,6 @@ export function registerShellUi(pi: ExtensionAPI): void {
         activeHeader = new PiStartupHeader(pi, ctx, startupTip, tui);
         return activeHeader;
       });
-      clearActivityTimer();
       ctx.ui.setWorkingIndicator({
         frames: ACTIVITY_FRAMES.map((frame) => ctx.ui.theme.fg("accent", frame)),
         intervalMs: ACTIVITY_FRAME_INTERVAL_MS,
@@ -339,25 +302,8 @@ export function registerShellUi(pi: ExtensionAPI): void {
     }
   });
 
-  pi.on("agent_start", (_event, ctx) => {
-    if (ctx.mode !== "tui") return;
-    clearActivityTimer();
-    const updateWorkingWord = (): void => ctx.ui.setWorkingMessage(formatActivityMessage(nextActivityWord(), ctx.ui.theme));
-    updateWorkingWord();
-    activityTimer = setInterval(updateWorkingWord, 2_500);
-    activityTimer.unref?.();
-  });
-
-  pi.on("agent_end", (_event, ctx) => {
-    clearActivityTimer();
-    if (ctx.mode === "tui") ctx.ui.setWorkingMessage();
-  });
-
   pi.on("session_shutdown", () => {
-    clearActivityTimer();
     activeHeader?.dispose();
     activeHeader = undefined;
-    activityDeck = [];
-    lastActivityWord = undefined;
   });
 }

package/killeros/variants.ts

@@ -1,9 +1,9 @@
-import { DynamicBorder, keyHint, type ExtensionAPI, type ExtensionContext, type ThemeColor } from "@earendil-works/pi-coding-agent";
-import { Container, SelectList, Text, truncateToWidth } from "@earendil-works/pi-tui";
+import { DynamicBorder, type ExtensionAPI, type ExtensionContext, type ThemeColor } from "@earendil-works/pi-coding-agent";
+import { SelectList, truncateToWidth } from "@earendil-works/pi-tui";
 
-export type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+export type ThinkingLevel = ReturnType<ExtensionAPI["getThinkingLevel"]>;
 
-const ALL_LEVELS: readonly ThinkingLevel[] = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+const ALL_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const satisfies readonly ThinkingLevel[];
 const LEVEL_LABELS: Readonly<Record<ThinkingLevel, string>> = {
   off: "Off",
   minimal: "Minimal",
@@ -42,7 +42,7 @@ const LEVEL_ALIASES: Readonly<Record<string, ThinkingLevel>> = {
 };
 
 function isThinkingLevel(value: string): value is ThinkingLevel {
-  return (ALL_LEVELS as readonly string[]).includes(value);
+  return ALL_LEVELS.some((level) => level === value);
 }
 
 function resolveThinkingLevel(input: string): ThinkingLevel | undefined {
@@ -96,40 +96,82 @@ export function registerVariants(pi: ExtensionAPI): void {
         ctx.ui.notify(`${modelLabel(ctx.model)} does not support extended reasoning`, "info");
         return;
       }
-      const current = pi.getThinkingLevel() as ThinkingLevel;
+      const current = pi.getThinkingLevel();
       const items = supported.map((level) => ({
         value: level,
         label: level === current ? `${LEVEL_LABELS[level]} ← current` : LEVEL_LABELS[level],
         description: LEVEL_DESCRIPTIONS[level],
       }));
-      const selected = await ctx.ui.custom<ThinkingLevel | null>((tui, theme, _keybindings, done) => {
-        const container = new Container();
-        container.addChild(new DynamicBorder((text: string) => theme.fg("accent", text)));
-        container.addChild(new Text(theme.fg("accent", theme.bold("Thinking variants")), 1, 0));
-        container.addChild(new Text(theme.fg("dim", `Model: ${modelLabel(ctx.model)}`), 1, 0));
-        container.addChild(new Text("", 0, 0));
-        const selectList = new SelectList(items, Math.min(items.length, 10), {
-          selectedPrefix: (text) => theme.fg("accent", text),
-          selectedText: (text) => theme.fg("accent", text),
-          description: (text) => theme.fg("muted", text),
-          scrollInfo: (text) => theme.fg("dim", text),
-          noMatch: (text) => theme.fg("warning", text),
-        });
-        selectList.onSelect = (item) => done(isThinkingLevel(item.value) ? item.value : null);
-        selectList.onCancel = () => done(null);
-        container.addChild(selectList);
-        container.addChild(new Text("", 0, 0));
-        container.addChild(new Text(
-          theme.fg("dim", `${keyHint("tui.select.up", "up")} • ${keyHint("tui.select.down", "down")} • ${keyHint("tui.select.confirm", "select")} • ${keyHint("tui.select.cancel", "cancel")}`),
-          1,
-          0,
-        ));
-        container.addChild(new DynamicBorder((text: string) => theme.fg("accent", text)));
+      const selected = await ctx.ui.custom<ThinkingLevel | null>((tui, theme, keybindings, done) => {
+        const listTheme = {
+          selectedPrefix: (text: string) => theme.fg("accent", text),
+          selectedText: (text: string) => theme.fg("accent", text),
+          description: (text: string) => theme.fg("muted", text),
+          scrollInfo: (text: string) => theme.fg("dim", text),
+          noMatch: (text: string) => theme.fg("warning", text),
+        };
+        let selectList: SelectList | undefined;
+        let visibleOptionRows = 0;
+
+        const chromeFor = (rowBudget: number): "full" | "compact" | "none" => (
+          rowBudget >= 8 ? "full" : rowBudget >= 4 ? "compact" : "none"
+        );
+        const visibleRowsFor = (rowBudget: number): number => {
+          const chrome = chromeFor(rowBudget);
+          const chromeRows = chrome === "full" ? 5 : chrome === "compact" ? 2 : 0;
+          const availableListRows = Math.max(1, rowBudget - chromeRows);
+          return availableListRows >= items.length
+            ? items.length
+            : Math.max(1, availableListRows - 1);
+        };
+        const ensureSelectList = (nextVisibleOptionRows: number): SelectList => {
+          if (selectList && visibleOptionRows === nextVisibleOptionRows) return selectList;
+          const selectedValue = selectList?.getSelectedItem()?.value ?? current;
+          const nextSelectList = new SelectList(items, nextVisibleOptionRows, listTheme);
+          const selectedIndex = items.findIndex((item) => item.value === selectedValue);
+          nextSelectList.setSelectedIndex(Math.max(0, selectedIndex));
+          nextSelectList.onSelect = (item) => done(isThinkingLevel(item.value) ? item.value : null);
+          nextSelectList.onCancel = () => done(null);
+          selectList = nextSelectList;
+          visibleOptionRows = nextVisibleOptionRows;
+          return nextSelectList;
+        };
+
+        const border = new DynamicBorder((text: string) => theme.fg("accent", text));
+        const title = ` ${theme.fg("accent", theme.bold("Thinking variants"))}`;
+        const model = ` ${theme.fg("dim", `Model: ${modelLabel(ctx.model)}`)}`;
+        const keyHint = (keybinding: Parameters<typeof keybindings.getKeys>[0], description: string): string => {
+          const keyText = keybindings.getKeys(keybinding)
+            .join("/")
+            .split("/")
+            .map((key) => key.split("+").map((part) => process.platform === "darwin" && part.toLocaleLowerCase() === "alt" ? "option" : part).join("+"))
+            .join("/");
+          return theme.fg("dim", keyText) + theme.fg("muted", ` ${description}`);
+        };
+        const controls = ` ${theme.fg("dim", `${keyHint("tui.select.up", "up")} • ${keyHint("tui.select.down", "down")} • ${keyHint("tui.select.confirm", "select")} • ${keyHint("tui.select.cancel", "cancel")}`)}`;
+
+        const render = (width: number): string[] => {
+          const rowBudget = Math.max(0, tui.terminal.rows);
+          if (width <= 0 || rowBudget === 0) return [];
+          const chrome = chromeFor(rowBudget);
+          const list = ensureSelectList(visibleRowsFor(rowBudget));
+          const lines: string[] = [];
+
+          if (chrome === "full") lines.push(...border.render(width));
+          if (chrome !== "none") lines.push(title);
+          if (chrome === "full") lines.push(model);
+          lines.push(...list.render(width));
+          if (chrome !== "none") lines.push(controls);
+          if (chrome === "full") lines.push(...border.render(width));
+
+          return lines.slice(0, rowBudget).map((line) => truncateToWidth(line, width, ""));
+        };
+
         return {
-          render: (width) => container.render(width).map((line) => truncateToWidth(line, width, "")),
-          invalidate: () => container.invalidate(),
+          render,
+          invalidate: () => selectList?.invalidate(),
           handleInput: (data) => {
-            selectList.handleInput(data);
+            ensureSelectList(visibleRowsFor(Math.max(1, tui.terminal.rows))).handleInput(data);
             tui.requestRender();
           },
         };

package/killeros/worked-for.ts

@@ -1,14 +1,34 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { StopReason } from "@earendil-works/pi-ai";
 import { Text } from "@earendil-works/pi-tui";
 
 const WORKED_FOR_ENTRY_TYPE = "killeros-worked-for";
-const WORKED_FOR_ENTRY_VERSION = 1;
 
-interface WorkedForEntryData {
-  version: typeof WORKED_FOR_ENTRY_VERSION;
+interface WorkedForEntryDataV1 {
+  version: 1;
   milliseconds: number;
 }
 
+export type WorkedForOutcome = "done" | "stopped" | "failed";
+
+interface WorkedForEntryDataV2 {
+  version: 2;
+  milliseconds: number;
+  outcome: WorkedForOutcome;
+}
+
+type WorkedForEntryData = WorkedForEntryDataV1 | WorkedForEntryDataV2;
+
+const OUTCOMES = {
+  done: { marker: "✓", label: "Done", color: "success" },
+  stopped: { marker: "■", label: "Stopped", color: "warning" },
+  failed: { marker: "×", label: "Failed", color: "error" },
+} as const satisfies Record<WorkedForOutcome, { marker: string; label: string; color: string }>;
+
+function isWorkedForOutcome(value: unknown): value is WorkedForOutcome {
+  return value === "done" || value === "stopped" || value === "failed";
+}
+
 export function formatWorkedForDuration(milliseconds: number): string {
   const boundedMilliseconds = Number.isFinite(milliseconds) ? Math.max(0, milliseconds) : 0;
   const totalSeconds = Math.max(1, Math.floor(boundedMilliseconds / 1_000));
@@ -22,13 +42,23 @@ export function formatWorkedForDuration(milliseconds: number): string {
   return `${Math.floor(totalMinutes / 60)}h ${(totalMinutes % 60).toString().padStart(2, "0")}m`;
 }
 
-function isWorkedForEntryData(data: unknown): data is WorkedForEntryData {
-  if (!data || typeof data !== "object") return false;
-  const candidate = data as Partial<WorkedForEntryData>;
-  return candidate.version === WORKED_FOR_ENTRY_VERSION
-    && typeof candidate.milliseconds === "number"
-    && Number.isFinite(candidate.milliseconds)
-    && candidate.milliseconds >= 0;
+function parseWorkedForEntryData(data: unknown): WorkedForEntryData | undefined {
+  if (!data || typeof data !== "object" || Array.isArray(data)) return undefined;
+  if (!("version" in data) || !("milliseconds" in data)) return undefined;
+  if (typeof data.milliseconds !== "number" || !Number.isFinite(data.milliseconds) || data.milliseconds < 0) {
+    return undefined;
+  }
+  if (data.version === 1) return { version: 1, milliseconds: data.milliseconds };
+  if (data.version !== 2 || !("outcome" in data) || !isWorkedForOutcome(data.outcome)) {
+    return undefined;
+  }
+  return { version: 2, milliseconds: data.milliseconds, outcome: data.outcome };
+}
+
+export function workedForOutcome(stopReason: StopReason | undefined): WorkedForOutcome {
+  if (stopReason === "stop") return "done";
+  if (stopReason === "aborted") return "stopped";
+  return "failed";
 }
 
 function errorMessage(error: unknown): string {
@@ -40,11 +70,21 @@ export function registerWorkedFor(
   now: () => number = Date.now,
 ): void {
   let startedAt: number | undefined;
+  let stopReason: StopReason | undefined;
 
   pi.registerEntryRenderer<WorkedForEntryData>(WORKED_FOR_ENTRY_TYPE, (entry, _options, theme) => {
-    if (!isWorkedForEntryData(entry.data)) return undefined;
+    const data = parseWorkedForEntryData(entry.data);
+    if (!data) return undefined;
+    if (data.version === 1) {
+      return new Text(
+        theme.fg("dim", `✻ Worked for ${formatWorkedForDuration(data.milliseconds)}`),
+        0,
+        0,
+      );
+    }
+    const outcome = OUTCOMES[data.outcome];
     return new Text(
-      theme.fg("dim", `✻ Worked for ${formatWorkedForDuration(entry.data.milliseconds)}`),
+      `${theme.fg(outcome.color, `${outcome.marker} ${outcome.label}`)}${theme.fg("dim", ` · ${formatWorkedForDuration(data.milliseconds)}`)}`,
       0,
       0,
     );
@@ -52,6 +92,7 @@ export function registerWorkedFor(
 
   pi.on("session_start", () => {
     startedAt = undefined;
+    stopReason = undefined;
   });
 
   pi.on("agent_start", (_event, ctx) => {
@@ -59,15 +100,28 @@ export function registerWorkedFor(
     startedAt = now();
   });
 
+  pi.on("agent_end", (event, ctx) => {
+    if (ctx.mode !== "tui" || startedAt === undefined) return;
+    for (let index = event.messages.length - 1; index >= 0; index -= 1) {
+      const message = event.messages[index];
+      if (message?.role !== "assistant") continue;
+      stopReason = message.stopReason;
+      break;
+    }
+  });
+
   pi.on("agent_settled", (_event, ctx) => {
     if (ctx.mode !== "tui" || startedAt === undefined) return;
     if (!ctx.isIdle() || ctx.hasPendingMessages()) return;
     const milliseconds = Math.max(0, now() - startedAt);
+    const outcome = workedForOutcome(stopReason);
     startedAt = undefined;
+    stopReason = undefined;
     try {
-      pi.appendEntry<WorkedForEntryData>(WORKED_FOR_ENTRY_TYPE, {
-        version: WORKED_FOR_ENTRY_VERSION,
+      pi.appendEntry<WorkedForEntryDataV2>(WORKED_FOR_ENTRY_TYPE, {
+        version: 2,
         milliseconds,
+        outcome,
       });
     } catch (error) {
       ctx.ui.notify(`Worked-for timing could not be saved: ${errorMessage(error)}`, "error");
@@ -76,5 +130,6 @@ export function registerWorkedFor(
 
   pi.on("session_shutdown", () => {
     startedAt = undefined;
+    stopReason = undefined;
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "killeros",
-  "version": "2.0.6",
+  "version": "2.0.7",
   "description": "TUI, goals, and workflow automation for the Pi coding agent",
   "type": "module",
   "keywords": [
@@ -42,14 +42,15 @@
     ]
   },
   "peerDependencies": {
-    "@earendil-works/pi-ai": ">=0.82.1",
-    "@earendil-works/pi-coding-agent": ">=0.82.1",
-    "@earendil-works/pi-tui": ">=0.82.1",
+    "@earendil-works/pi-ai": ">=0.84.1",
+    "@earendil-works/pi-coding-agent": ">=0.84.1",
+    "@earendil-works/pi-tui": ">=0.84.1",
     "typebox": ">=1.1.38 <2"
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "0.82.1",
-    "@earendil-works/pi-tui": "0.82.1",
+    "@earendil-works/pi-ai": "0.84.1",
+    "@earendil-works/pi-coding-agent": "0.84.1",
+    "@earendil-works/pi-tui": "0.84.1",
     "@types/node": "24.12.4",
     "typebox": "1.1.38",
     "typescript": "5.9.3"