killeros 3.0.4 → 3.0.5

package/CHANGELOG.md

@@ -4,6 +4,21 @@ All notable changes to KillerOS are documented here. Releases use New Features f
 
 ## [Unreleased]
 
+## [3.0.5] - 2026-10-08
+
+### Fixed
+
+- Used Pi 1.1.0's final cancellation signal for `Stopped` task receipts and silent completion notifications, including cancellation after a normal assistant response or without an assistant result. Kept observed changes and checks and the Pi 1.0.4 fallback.
+- Stopped accepted goal continuation after final request cancellation while preserving compaction recovery through its completion and cancellation callbacks.
+
+### Added
+
+- Added real Pi 1.1.0 cancellation, busy-error retry, native Mistral transport retry, and additive tool-selection checks. Documented native tool modifiers and reliable extension-tool exclusion through `--exclude-tools`, including Pi 1.1.0's modifier limitation. Kept the Pi and Node support floors and locked development packages unchanged.
+
+### Changed
+
+- Moved question input to Pi's native dialogs, with KillerOS coordinating bounded multi-select, filtering, custom answers, recent-answer history, and paged text previews. Each step uses native dialog controls and Pi 1.1.0's blocked-status reporting. Preserved the question tool's inputs and results, TUI restriction, and sequential model-only exposure; cancellation and session changes prevent stale steps or partial success.
+
 ## [3.0.4] - 2026-10-07
 
 ### Changed

package/README.md

@@ -36,7 +36,7 @@ Or from GitHub:
 pi install git:github.com/KyrosHendrix/pi-KillerOS
 ```
 
-Pin a release by appending its tag, for example `@v3.0.4`. Add `-l` to install only for the current project. Restart Pi after installing.
+Pin a release by appending its tag, for example `@v3.0.5`. Add `-l` to install only for the current project. Restart Pi after installing.
 
 ## Commands
 
@@ -77,6 +77,22 @@ With Pi 1.0.3's default [keybindings](https://github.com/earendil-works/pi/blob/
 
 Pi 1.0.4's native `--tools` and `--exclude-tools` support `*` patterns. Quote patterns such as `"killeros_*"` so the shell does not expand them. An explicit allowlist must include `question` for interactive questions and permit `killeros_goal_update` for goals. Selection does not make questions usable outside TUI mode. Excluding the goal tool pauses goals that are active before any model request. A later ordinary request with a blocked goal still runs, but cannot record its completion when the tool is excluded. See Pi's [tool selection](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/cli.md#tools).
 
+Pi 1.1.0 also accepts a list containing only exact `+name` and `-name` entries to change its default selection. For example, `pi --tools +codemode` adds codemode while retaining the default tools, and `pi --tools +codemode,-write` also removes `write` from that selection. Plain allowlists still replace the selection. Pi rejects mixed lists such as `read,+codemode` and modifier patterns such as `-killeros_*`. Use `--exclude-tools "killeros_*"` for wildcard exclusions.
+
+In Pi 1.1.0, removing an extension tool with a `-name` modifier does not prevent Pi from activating it on registration or reload. To exclude the goal tool reliably, use `pi --exclude-tools killeros_goal_update`. KillerOS delegates selection to Pi; it does not parse or repair native CLI filters.
+
+Pi 1.1.0 reports program status through OSC 7501 when the terminal supports it. KillerOS questions use Pi's native selectors and text inputs. Each open question step reports `blocked` and restores the previous status after an answer, cancellation, or abort. Existing native confirmation dialogs do the same. `PI_PROGRAM_STATUS=1` forces native reporting and `PI_PROGRAM_STATUS=0` disables it. KillerOS preserves this preference and lets Pi handle all status reporting. See Pi's [program status](https://github.com/earendil-works/pi/blob/v1.1.0/packages/coding-agent/docs/terminal-setup.md#program-status).
+
+### Questions
+
+The `question` tool asks one question per invocation. Single-select is the default; choosing a numbered option submits that answer. In multi-select mode, choosing an option toggles its selection and opens the selector again. Choose **Submit answers** when finished. KillerOS checks the requested minimum and maximum and returns the selected predefined answers in their original order, followed by an optional custom answer. Dialog steps stay within the same tool execution and do not start model requests or grant goal turns.
+
+Choose **Custom answer** to open Pi's text input. Multi-select allows one custom answer, which you can edit or remove. Blank answers do not submit; custom answers accept up to 4,000 Unicode characters. Cancelling custom input returns to the selector with existing selections intact. **More actions** includes filtering, clearing a filter, reviewing the full question and option details, and selecting a recent custom answer. Filtering matches labels and descriptions without losing hidden selections. Filter queries accept up to 4,000 Unicode characters and 16,000 UTF-8 bytes.
+
+Descriptions appear in bounded option summaries. Review shows full descriptions and proposal previews as paged plain text, including any markdown source. **Next page**, **Previous page**, and **Back** navigate the review. Long option lists and recent-answer history also use pages. Recent answers stay within the current session, with at most 100 distinct entries and 64 KiB of text; session changes clear them.
+
+The flow uses Pi's native dialog keybindings and editing behavior. Multi-select takes successive selection steps; the former space-toggle and slash-filter shortcuts are replaced by explicit actions. Resizing selectors rebuilds their pages while preserving selections, and Pi resizes text input without discarding its draft. Cancelling the main selector discards unsubmitted answers. Cancelling a filter, history, or review step returns to the selector. Agent cancellation or session invalidation closes the question and prevents another step from opening.
+
 ## Configuration
 
 The packaged `killeros` theme activates on TUI start. Compaction triggers by default at 15% tokens remaining, stored in global `killeros.json`:
@@ -123,6 +139,8 @@ Passive Git scans compare content without running repository filters. CRLF text
 
 Completion sounds are off by default; change with `/notification` in TUI mode. The tab-title indicator requires a Nerd Font.
 
+On Pi 1.1.0, final request cancellation records `Stopped` and suppresses the completion sound even when the last assistant response ended normally. Recorded changes and checks remain in the receipt. Cancellation stops goal continuation and provider retry work; cancelling a pending compaction prevents its recovery. Pi 1.0.4 retains the assistant stop-reason fallback. Receipts and sounds still wait for final `agent_settled`, including across provider retries.
+
 ### Pi model and MCP settings
 
 Use Pi's native `/thinking` selector for reasoning levels. Pi 1.0.2 can also apply different sampling parameters for each level through `samplingParamsByThinkingLevel` in `models.json`. For example, a model entry can contain:

package/killeros/auto-compaction.ts

@@ -343,8 +343,14 @@ export function registerAutoCompaction(
     }
   });
 
-  pi.on("agent_settled", (_event, ctx) => {
+  pi.on("agent_settled", (event, ctx) => {
     goalRequestOwned = false;
+    // Pi aborts the agent when our pending compaction starts. Its callback owns
+    // recovery, including cancellation; the settlement flag alone is ambiguous.
+    if ("aborted" in event && event.aborted === true && request?.phase !== "compacting") {
+      request = undefined;
+      return;
+    }
     if (request?.phase === "continuation-dispatched") {
       request = undefined;
       notifyFailure(ctx, new Error("continuation was not accepted"));

package/killeros/goal-settlement.ts

@@ -219,7 +219,7 @@ export function registerGoalSettlement(
   pi: ExtensionAPI,
   runtime: GoalRuntime,
 ): AutoCompactionGoalHandlers {
-  pi.on("agent_settled", (_event, ctx) => {
+  pi.on("agent_settled", (event, ctx) => {
     runtime.blockedCompletion = undefined;
     syncGoalUpdateTool(pi, runtime);
     const wasGoalTurn = runtime.goalTurnInFlight;
@@ -230,6 +230,18 @@ export function registerGoalSettlement(
     runtime.agentEndObserved = false;
     runtime.continuationScheduled = false;
 
+    // ctx.compact() also aborts the request. An owned compaction must settle through
+    // its success/error callback; its cancellation cannot authorize recovery.
+    if ("aborted" in event && event.aborted === true && !runtime.automaticCompaction
+      && runtime.lastStopReason !== "aborted") {
+      runtime.lastStopReason = undefined;
+      runtime.lastError = undefined;
+      if (runtime.state?.status === "active") {
+        pauseGoalAfterFailure(pi, runtime, ctx, "the agent request was cancelled");
+      }
+      return;
+    }
+
     if (runtime.automaticCompaction) {
       const stopReason = runtime.lastStopReason;
       const error = safeTerminalText(runtime.lastError ?? "");

package/killeros/notifications.ts

@@ -116,11 +116,11 @@ export function registerCompletionNotifications(
     }
   });
 
-  pi.on("agent_settled", (_event, ctx) => {
+  pi.on("agent_settled", (event, ctx) => {
     if (!requestPending || ctx.mode !== "tui") return;
     if (!ctx.isIdle() || ctx.hasPendingMessages()) return;
     requestPending = false;
-    if (!enabled || lastStopReason === "aborted") return;
+    if (!enabled || "aborted" in event && event.aborted === true || lastStopReason === "aborted") return;
     try {
       runtime.ring();
     } catch (error) {

package/killeros/question-ui.ts

@@ -1,21 +1,13 @@
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import {
-  decodeKittyPrintable,
-  Editor,
-  Markdown,
-  truncateToWidth,
-  visibleWidth,
-  wrapTextWithAnsi,
-  type EditorTheme,
-} from "@earendil-works/pi-tui";
-import type { ThemeColor } from "@earendil-works/pi-coding-agent";
+import type { ExtensionContext, ThemeColor } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { safeTerminalText } from "./safe-terminal-text.ts";
 
 export interface DisplayOption {
   label: string;
+  answer: string;
   description?: string;
   preview?: string;
   originalIndex: number;
-  isOther: boolean;
 }
 
 export type QuestionSelection =
@@ -31,65 +23,12 @@ export const CUSTOM_INPUT_HISTORY_BYTES = 64 * 1024;
 export const FILTER_QUERY_MAX_CHARACTERS = 4_000;
 export const FILTER_QUERY_MAX_BYTES = 16_000;
 
-function isPrintableInput(data: string): boolean {
-  return data.length > 0 && !/[\u0000-\u001F\u007F-\u009F]/u.test(data);
-}
-
-const graphemeSegmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
-
-function decodeQuestionFilterInput(data: string): string | undefined {
-  const kittyPrintable = decodeKittyPrintable(data);
-  if (kittyPrintable !== undefined) return isPrintableInput(kittyPrintable) ? kittyPrintable : undefined;
-
-  const pasteStart = "\x1B[200~";
-  const pasteEnd = "\x1B[201~";
-  const startIndex = data.indexOf(pasteStart);
-  const endIndex = data.indexOf(pasteEnd, startIndex + pasteStart.length);
-  if (startIndex >= 0 && endIndex >= 0) {
-    return data
-      .slice(startIndex + pasteStart.length, endIndex)
-      .replace(/\r\n|\r|\n/gu, "")
-      .replace(/\t/gu, "    ")
-      .replace(/[\u0000-\u001F\u007F-\u009F]/gu, "");
-  }
-
-  return isPrintableInput(data) ? data : undefined;
-}
-
-function removeLastGrapheme(value: string): string {
-  const segments = [...graphemeSegmenter.segment(value)];
-  const last = segments.at(-1);
-  return last ? value.slice(0, last.index) : "";
-}
-
-function inputCharacterCount(value: string): number {
-  let count = 0;
-  for (const _character of value) count += 1;
-  return count;
-}
-
 export function oneLine(value: string): string {
   return value.replace(/\s+/gu, " ").trim();
 }
 
-function boundedRenderLine(value: string, width: number, suffix: string): string {
-  return truncateToWidth(value.replace(/\r\n|\r|\n/gu, " "), width, suffix);
-}
-
-function visibleOptionRange(total: number, selected: number, capacity: number): { start: number; end: number } {
-  const size = Math.max(1, Math.min(total, capacity));
-  const start = Math.max(0, Math.min(selected - Math.floor(size / 2), total - size));
-  return { start, end: Math.min(total, start + size) };
-}
-
-function boundedQuestionLines(question: string, width: number, rowLimit: number): string[] {
-  const wrapped = wrapTextWithAnsi(question.replace(/\s+/gu, " ").trim(), width);
-  if (wrapped.length <= rowLimit) return wrapped;
-  const visible = wrapped.slice(0, rowLimit);
-  const finalIndex = rowLimit - 1;
-  const finalLine = visible[finalIndex];
-  if (finalLine !== undefined) visible[finalIndex] = truncateToWidth(finalLine, width, "…");
-  return visible;
+function inputCharacterCount(value: string): number {
+  return [...value].length;
 }
 
 function compactMultipleAnswers(answers: readonly string[], width: number): string {
@@ -139,452 +78,192 @@ export class MultipleResultText {
   invalidate(): void {}
 }
 
+type Choice<T> = { label: string; value: T };
+type DialogSize = { width: number; rows: number };
+type MainAction =
+  | { kind: "option"; option: DisplayOption }
+  | { kind: "custom" }
+  | { kind: "submit" }
+  | { kind: "actions" };
+type MoreAction = "filter" | "clear" | "history" | "remove" | "review" | "question";
+class QuestionAborted extends Error {}
+
+function dialogSize(): DialogSize {
+  return { width: Math.max(1, (process.stdout.columns || 80) - 6), rows: process.stdout.rows || 24 };
+}
+
 export async function openQuestionUi(config: {
   ctx: ExtensionContext;
-  signal?: AbortSignal;
+  signal: AbortSignal;
   question: string;
   options: DisplayOption[];
-  originalOptions: readonly { label: string }[];
   mode: "single" | "multiple";
   minSelections: number;
   maxSelections: number;
   customInputHistory: readonly string[];
   rememberCustomInput: (value: string) => boolean;
 }): Promise<QuestionSelection> {
-  const {
-    ctx,
-    signal,
-    question,
-    options: displayOptions,
-    originalOptions,
-    mode,
-    minSelections,
-    maxSelections,
-    customInputHistory,
-    rememberCustomInput,
-  } = config;
-  const options = displayOptions;
-      let finishFromAbort: (() => void) | undefined;
-      const resultPromise = ctx.ui.custom<QuestionSelection>((tui, theme, keybindings, done) => {
-        let optionIndex = 0;
-        type EditMode = "none" | "filter" | "custom";
-        let editMode: EditMode = "none";
-        let filterQuery = "";
-        const selectedOriginalIndices = new Set<number>();
-        let customAnswer: string | undefined;
-        let cachedWidth: number | undefined;
-        let cachedRows: number | undefined;
-        let cachedLines: string[] | undefined;
-        let completed = false;
-
-        const finish = (selection: QuestionSelection): void => {
-          if (completed) return;
-          completed = true;
-          done(selection);
-        };
-        finishFromAbort = () => finish({ kind: "aborted" });
-
-        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.toLowerCase() === "alt" ? "option" : part).join("+"))
-            .join("/");
-          return theme.fg("dim", keyText) + theme.fg("muted", ` ${description}`);
-        };
-
-        const editorTheme: EditorTheme = {
-          borderColor: (text) => theme.fg("accent", text),
-          selectList: {
-            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),
-          },
-        };
-        const editor = new Editor(tui, editorTheme);
-        customInputHistory.forEach((value) => editor.addToHistory(value));
-
-        const filteredOptions = (): DisplayOption[] => {
-          const query = filterQuery.trim().toLowerCase();
-          return options.filter((option) => option.isOther
-            || query.length === 0
-            || option.label.toLowerCase().includes(query)
-            || option.description?.toLowerCase().includes(query));
-        };
-        const selectedCount = (): number => selectedOriginalIndices.size + (customAnswer === undefined ? 0 : 1);
-        const orderedMultipleSelection = () => {
-          const selectedIndices = [...selectedOriginalIndices].sort((left, right) => left - right);
-          const predefined = selectedIndices.map((index) => {
-            const option = originalOptions[index - 1];
-            if (!option) throw new Error("Question selection no longer matches an available option");
-            return option.label;
-          });
-          return {
-            answers: customAnswer === undefined ? predefined : [...predefined, customAnswer],
-            selectedIndices,
-            ...(customAnswer === undefined ? {} : { customAnswer }),
-          };
-        };
-
-        const invalidate = (): void => {
-          cachedWidth = undefined;
-          cachedRows = undefined;
-          cachedLines = undefined;
-          editor.invalidate();
-        };
-        const refresh = (): void => {
-          invalidate();
-          tui.requestRender();
-        };
-        const notifyFilterLimit = (): void => ctx.ui.notify(
-          `Question filters are limited to ${FILTER_QUERY_MAX_CHARACTERS.toLocaleString()} characters and ${FILTER_QUERY_MAX_BYTES.toLocaleString()} bytes`,
-          "error",
-        );
-        const appendFilterInput = (value: string): void => {
-          const next = filterQuery + value;
-          if (inputCharacterCount(next) > FILTER_QUERY_MAX_CHARACTERS || Buffer.byteLength(next, "utf8") > FILTER_QUERY_MAX_BYTES) {
-            notifyFilterLimit();
-            return;
-          }
-          filterQuery = next;
-          optionIndex = 0;
-          refresh();
-        };
-        const togglePredefined = (option: DisplayOption): void => {
-          if (selectedOriginalIndices.has(option.originalIndex)) {
-            selectedOriginalIndices.delete(option.originalIndex);
-            refresh();
-            return;
-          }
-          if (selectedCount() >= maxSelections) {
-            ctx.ui.notify(`Select at most ${maxSelections} answer${maxSelections === 1 ? "" : "s"}`, "error");
-            return;
-          }
-          selectedOriginalIndices.add(option.originalIndex);
-          refresh();
-        };
-        const enterCustomMode = (): void => {
-          editMode = "custom";
-          editor.setText(mode === "multiple" ? customAnswer ?? "" : "");
-          refresh();
-        };
-        const enterFilterMode = (): void => {
-          editMode = "filter";
-          editor.setText(filterQuery);
-          refresh();
-        };
+  const { ctx, signal, question, options, mode, minSelections, maxSelections, customInputHistory, rememberCustomInput } = config;
+  const selected = new Set<number>();
+  let customAnswer: string | undefined;
+  let filter = "";
+  const checkAbort = (): void => { if (signal.aborted) throw new QuestionAborted(); };
+  const count = (): number => selected.size + (customAnswer === undefined ? 0 : 1);
+  const notifyMaximum = (): void => ctx.ui.notify(`Select at most ${maxSelections} answer${maxSelections === 1 ? "" : "s"}`, "error");
+
+  // Resize dismisses only this native step. Rebuild its pages without losing question state.
+  async function nativeRequest(request: (stepSignal: AbortSignal) => Promise<string | undefined>) {
+    checkAbort();
+    const resize = new AbortController();
+    const onResize = (): void => resize.abort();
+    process.stdout.on("resize", onResize);
+    try {
+      const value = await request(AbortSignal.any([signal, resize.signal]));
+      checkAbort();
+      return resize.signal.aborted ? { kind: "resize" as const } : { kind: "result" as const, value };
+    } finally {
+      process.stdout.off("resize", onResize);
+    }
+  }
 
-        editor.onSubmit = (value) => {
-          if (editMode === "filter") {
-            filterQuery = value;
-            optionIndex = 0;
-            editMode = "none";
-            editor.setText("");
-            refresh();
-            return;
-          }
-          const answer = value.trim();
-          if (answer) {
-            if (inputCharacterCount(answer) > CUSTOM_INPUT_MAX_CHARACTERS) {
-              ctx.ui.notify(`Custom answers are limited to ${CUSTOM_INPUT_MAX_CHARACTERS} characters`, "error");
-              return;
-            }
-            if (mode === "multiple") {
-              const addsSelection = customAnswer === undefined;
-              if (addsSelection && selectedCount() >= maxSelections) {
-                editor.setText(value);
-                ctx.ui.notify(`Select at most ${maxSelections} answer${maxSelections === 1 ? "" : "s"}`, "error");
-                refresh();
-                return;
-              }
-              if (!rememberCustomInput(answer)) {
-                editor.setText(value);
-                ctx.ui.notify(`Custom answer history is limited to ${CUSTOM_INPUT_HISTORY_BYTES} bytes`, "error");
-                refresh();
-                return;
-              }
-              customAnswer = answer;
-              editMode = "none";
-              editor.setText("");
-              refresh();
-              return;
-            }
-            if (!rememberCustomInput(answer)) {
-              ctx.ui.notify(`Custom answer history is limited to ${CUSTOM_INPUT_HISTORY_BYTES} bytes`, "error");
-              return;
-            }
-            finish({ kind: "custom", answer });
-            return;
-          }
-          editMode = "none";
-          editor.setText("");
-          refresh();
-        };
+  async function choose<T>(title: string | ((size: DialogSize) => string), entries: Choice<T>[]): Promise<T | undefined> {
+    let start = 0;
+    while (true) {
+      const size = dialogSize();
+      const text = typeof title === "string" ? title.split("\n").slice(0, 2).map((line) => truncateToWidth(oneLine(line), size.width, "…")).join("\n") : title(size);
+      // Reserve native borders, hints, header/footer, and both page controls.
+      const capacity = Math.max(1, size.rows - 13 - text.split("\n").length);
+      start = Math.min(start, Math.max(0, entries.length - 1));
+      const page = entries.slice(start, start + capacity);
+      const labels = page.map((entry, index) => truncateToWidth(`${start + index + 1}. ${oneLine(entry.label)}`, size.width, "…"));
+      const next = "Next choices";
+      const previous = "Previous choices";
+      const offered = [...labels, ...(start + capacity < entries.length ? [next] : []), ...(start > 0 ? [previous] : [])];
+      const response = await nativeRequest((stepSignal) => ctx.ui.select(text, offered, { signal: stepSignal }));
+      checkAbort();
+      if (response.kind === "resize") continue;
+      if (response.value === undefined) return undefined;
+      if (response.value === next && offered.includes(next)) { start += capacity; continue; }
+      if (response.value === previous && offered.includes(previous)) { start = Math.max(0, start - capacity); continue; }
+      const index = labels.indexOf(response.value);
+      const entry = page[index];
+      if (!entry) throw new Error("Native question selection does not match an offered choice");
+      return entry.value;
+    }
+  }
 
-        const handleEditorInput = (data: string): void => {
-          if (keybindings.matches(data, "tui.select.cancel")) {
-            editMode = "none";
-            editor.setText("");
-            refresh();
-            return;
-          }
-          const before = editor.getExpandedText();
-          editor.handleInput(data);
-          const after = editor.getExpandedText();
-          const overLimit = editMode === "filter"
-            ? inputCharacterCount(after) > FILTER_QUERY_MAX_CHARACTERS || Buffer.byteLength(after, "utf8") > FILTER_QUERY_MAX_BYTES
-            : inputCharacterCount(after) > CUSTOM_INPUT_MAX_CHARACTERS;
-          if (overLimit) {
-            editor.setText(before);
-            if (editMode === "filter") notifyFilterLimit();
-            else ctx.ui.notify(`Custom answers are limited to ${CUSTOM_INPUT_MAX_CHARACTERS} characters`, "error");
-          }
-          refresh();
-        };
+  async function input(title: string, placeholder = ""): Promise<string | undefined> {
+    checkAbort();
+    const size = dialogSize();
+    // Pi reflows native input on resize. Keep its component and in-progress draft.
+    const value = await ctx.ui.input(truncateToWidth(title, size.width, "…"), truncateToWidth(oneLine(placeholder), size.width, "…"), { signal });
+    checkAbort();
+    return value;
+  }
 
-        const handleInput = (data: string): void => {
-          if (editMode !== "none") {
-            handleEditorInput(data);
-            return;
-          }
+  async function review(content: string): Promise<void> {
+    let page = 0;
+    let pages = 1;
+    while (true) {
+      const action = await choose<"next" | "previous" | "back">((size) => {
+        const lines = wrapTextWithAnsi(content, size.width);
+        const capacity = Math.max(1, size.rows - 18);
+        pages = Math.max(1, Math.ceil(lines.length / capacity));
+        page = Math.min(page, pages - 1);
+        return [`Review ${page + 1}/${pages}`, ...lines.slice(page * capacity, (page + 1) * capacity)].join("\n");
+      }, [ { label: "Next page", value: "next" }, { label: "Previous page", value: "previous" }, { label: "Back", value: "back" } ]);
+      if (action === undefined || action === "back") return;
+      if (action === "next") page = Math.min(page + 1, pages - 1);
+      else page = Math.max(0, page - 1);
+    }
+  }
 
-          const visibleOptions = filteredOptions();
-          if (optionIndex >= visibleOptions.length) optionIndex = Math.max(0, visibleOptions.length - 1);
-          const pageSize = Math.max(1, Math.min(5, Math.ceil(Math.max(1, tui.terminal.rows - 5) / 2)));
-          if (keybindings.matches(data, "tui.select.up")) {
-            optionIndex = Math.max(0, optionIndex - 1);
-            refresh();
-            return;
-          }
-          if (keybindings.matches(data, "tui.select.down")) {
-            optionIndex = Math.min(visibleOptions.length - 1, optionIndex + 1);
-            refresh();
-            return;
-          }
-          if (keybindings.matches(data, "tui.select.pageUp")) {
-            optionIndex = Math.max(0, optionIndex - pageSize);
-            refresh();
-            return;
-          }
-          if (keybindings.matches(data, "tui.select.pageDown")) {
-            optionIndex = Math.min(visibleOptions.length - 1, optionIndex + pageSize);
-            refresh();
-            return;
-          }
+  function acceptCustom(raw: string): QuestionSelection | undefined {
+    checkAbort();
+    const answer = safeTerminalText(raw).trim();
+    if (!answer) { ctx.ui.notify("Enter a nonempty custom answer", "error"); return; }
+    if (inputCharacterCount(raw.trim()) > CUSTOM_INPUT_MAX_CHARACTERS) {
+      ctx.ui.notify(`Custom answers are limited to ${CUSTOM_INPUT_MAX_CHARACTERS.toLocaleString()} characters`, "error");
+      return;
+    }
+    if (mode === "multiple" && customAnswer === undefined && count() >= maxSelections) { notifyMaximum(); return; }
+    if (!rememberCustomInput(answer)) { ctx.ui.notify(`Custom answer history is limited to ${CUSTOM_INPUT_HISTORY_BYTES} bytes`, "error"); return; }
+    if (mode === "single") return { kind: "custom", answer };
+    customAnswer = answer;
+  }
 
-          const printableInput = decodeQuestionFilterInput(data);
-          const isPasteInput = data.includes("\x1B[200~");
-          if (mode === "multiple") {
-            const selected = visibleOptions[optionIndex];
-            if (!isPasteInput && printableInput === " ") {
-              if (!selected) return;
-              if (selected.isOther) {
-                if (customAnswer !== undefined) {
-                  customAnswer = undefined;
-                  refresh();
-                }
-              } else togglePredefined(selected);
-              return;
-            }
-            if (!isPasteInput && printableInput === "/") {
-              enterFilterMode();
-              return;
-            }
-            if (!isPasteInput && printableInput && /^[1-9]$/u.test(printableInput)) {
-              const numbered = visibleOptions[Number(printableInput) - 1];
-              if (!numbered) return;
-              if (numbered.isOther) enterCustomMode();
-              else togglePredefined(numbered);
-              return;
+  try {
+    while (true) {
+      checkAbort();
+      const query = filter.trim().toLowerCase();
+      const visible = options.filter((option) => !query || option.label.toLowerCase().includes(query) || option.description?.toLowerCase().includes(query));
+      const entries: Choice<MainAction>[] = visible.map((option) => ({
+        label: `${mode === "multiple" ? selected.has(option.originalIndex) ? "[x] " : "[ ] " : ""}${option.label}${option.description ? ` · ${oneLine(option.description)}` : ""}`,
+        value: { kind: "option", option },
+      }));
+      if (mode === "multiple") entries.push({ label: "Submit answers", value: { kind: "submit" } });
+      entries.push({ label: customAnswer === undefined ? "Custom answer" : "Edit custom answer", value: { kind: "custom" } }, { label: "More actions", value: { kind: "actions" } });
+      const summary = mode === "multiple" ? `Selected ${count()} · choose ${minSelections}–${maxSelections}` : "Choose one answer";
+      const action = await choose(`${summary}${filter ? " · filtered" : ""}\n${question}`, entries);
+      checkAbort();
+      if (action === undefined) return { kind: "cancelled" };
+      switch (action.kind) {
+        case "option":
+          if (mode === "single") return { kind: "selected", answer: action.option.answer, originalIndex: action.option.originalIndex };
+          if (selected.has(action.option.originalIndex)) selected.delete(action.option.originalIndex);
+          else if (count() >= maxSelections) notifyMaximum();
+          else selected.add(action.option.originalIndex);
+          break;
+        case "submit": {
+          if (count() < minSelections) { ctx.ui.notify(`Select at least ${minSelections} answer${minSelections === 1 ? "" : "s"}`, "error"); break; }
+          const ordered = options.filter((option) => selected.has(option.originalIndex));
+          return { kind: "multiple", answers: [...ordered.map((option) => option.answer), ...(customAnswer === undefined ? [] : [customAnswer])], selectedIndices: ordered.map((option) => option.originalIndex), ...(customAnswer === undefined ? {} : { customAnswer }) };
+        }
+        case "custom": {
+          const raw = await input("Custom answer", customAnswer);
+          if (raw !== undefined) { const result = acceptCustom(raw); if (result) return result; }
+          break;
+        }
+        case "actions": {
+          const more: Choice<MoreAction>[] = [ { label: "Filter options", value: "filter" }, { label: "Review question", value: "question" }, { label: "Review option details", value: "review" } ];
+          if (filter) more.push({ label: "Clear filter", value: "clear" });
+          if (customInputHistory.length > 0) more.push({ label: "Recent answers", value: "history" });
+          if (customAnswer !== undefined) more.push({ label: "Remove custom answer", value: "remove" });
+          const extra = await choose("More actions", more);
+          checkAbort();
+          switch (extra) {
+            case undefined: break;
+            case "clear": filter = ""; break;
+            case "remove": customAnswer = undefined; break;
+            case "question": await review(question); break;
+            case "review": {
+              const option = await choose("Review option details", options.map((option) => ({ label: option.label, value: option })));
+              if (option) await review([option.label, option.description, option.preview].filter((value) => value !== undefined).join("\n\n"));
+              break;
             }
-            if (keybindings.matches(data, "tui.select.confirm")) {
-              if (selected?.isOther) {
-                enterCustomMode();
-              } else if (selectedCount() < minSelections) {
-                ctx.ui.notify(`Select at least ${minSelections} answer${minSelections === 1 ? "" : "s"}`, "error");
-              } else {
-                finish({ kind: "multiple", ...orderedMultipleSelection() });
+            case "filter": {
+              const raw = await input("Filter options", filter);
+              checkAbort();
+              if (raw !== undefined) {
+                if (inputCharacterCount(raw) > FILTER_QUERY_MAX_CHARACTERS || Buffer.byteLength(raw, "utf8") > FILTER_QUERY_MAX_BYTES) ctx.ui.notify(`Question filters are limited to ${FILTER_QUERY_MAX_CHARACTERS.toLocaleString()} characters and ${FILTER_QUERY_MAX_BYTES.toLocaleString()} bytes`, "error");
+                else filter = safeTerminalText(raw);
               }
-              return;
+              break;
             }
-            if (keybindings.matches(data, "tui.select.cancel")) {
-              if (filterQuery) {
-                filterQuery = "";
-                optionIndex = 0;
-                refresh();
-              } else finish({ kind: "cancelled" });
-              return;
+            case "history": {
+              const answer = await choose("Recent answers", [...customInputHistory].reverse().map((answer) => ({ label: answer, value: answer })));
+              if (answer !== undefined) { const result = acceptCustom(answer); if (result) return result; }
+              break;
             }
-            return;
+            default: { const exhaustive: never = extra; return exhaustive; }
           }
-
-          if (keybindings.matches(data, "tui.select.confirm")) {
-            const selected = visibleOptions[optionIndex];
-            if (!selected) return;
-            if (selected.isOther) enterCustomMode();
-            else finish({ kind: "selected", answer: selected.label, originalIndex: selected.originalIndex });
-            return;
-          }
-          if (keybindings.matches(data, "tui.select.cancel")) {
-            if (filterQuery) {
-              filterQuery = "";
-              optionIndex = 0;
-              refresh();
-            } else finish({ kind: "cancelled" });
-            return;
-          }
-          if (keybindings.matches(data, "tui.editor.deleteCharBackward")) {
-            if (filterQuery) {
-              filterQuery = removeLastGrapheme(filterQuery);
-              optionIndex = 0;
-              refresh();
-            }
-            return;
-          }
-          if (!isPasteInput && printableInput && /^[1-9]$/u.test(printableInput)) {
-            const selected = visibleOptions[Number(printableInput) - 1];
-            if (!selected) return;
-            if (selected.isOther) enterCustomMode();
-            else finish({ kind: "selected", answer: selected.label, originalIndex: selected.originalIndex });
-            return;
-          }
-          if (printableInput) appendFilterInput(printableInput);
-        };
-
-        const render = (width: number): string[] => {
-          if (width <= 0) return [];
-          const rowBudget = tui.terminal.rows;
-          if (rowBudget <= 0) return [];
-          if (cachedLines && cachedWidth === width && cachedRows === rowBudget) return cachedLines;
-          const visibleOptions = filteredOptions();
-          if (optionIndex >= visibleOptions.length) optionIndex = Math.max(0, visibleOptions.length - 1);
-          const selected = visibleOptions[optionIndex];
-          const position = `Option ${Math.min(optionIndex + 1, visibleOptions.length)}/${visibleOptions.length}`;
-          const editorText = editor.getExpandedText();
-          const editorCount = inputCharacterCount(editorText).toLocaleString();
-          const filterCount = inputCharacterCount(editMode === "filter" ? editorText : filterQuery).toLocaleString();
-          const compactDraft = editorText.replace(/\r\n|\r|\n/gu, " ↵ ") || (editMode === "filter" ? "Type a filter" : "Type an answer");
-          const selectionRange = minSelections === maxSelections ? `${minSelections}` : `${minSelections}–${maxSelections}`;
-          const selectionStatus = `Selected ${selectedCount()} · required ${selectionRange}`;
-          const optionLabel = (option: DisplayOption, index: number): string => {
-            if (mode === "single") return `${index === optionIndex ? ">" : " "} ${index + 1}. ${option.label}`;
-            const checked = option.isOther ? customAnswer !== undefined : selectedOriginalIndices.has(option.originalIndex);
-            const label = option.isOther && customAnswer !== undefined ? `Custom: ${oneLine(customAnswer)}` : option.label;
-            return `${index === optionIndex ? ">" : " "} ${checked ? "[x]" : "[ ]"} ${index + 1}. ${label}`;
-          };
-          const browseHint = mode === "multiple"
-            ? `space toggle • / filter • ${keyHint("tui.select.confirm", selected?.isOther ? (customAnswer ? "edit custom" : "add custom") : "submit")} • ${keyHint("tui.select.cancel", filterQuery ? "clear filter" : "cancel")}`
-            : `${keyHint("tui.select.confirm", "select")} • ${keyHint("tui.select.cancel", "cancel")}`;
-          const editHint = `${keyHint("tui.input.submit", editMode === "filter" ? "apply" : "submit")} • ${keyHint("tui.select.cancel", "options")}`;
-
-          let lines: string[];
-          if (rowBudget <= 2) {
-            if (editMode !== "none") lines = [`${editMode === "filter" ? "Filter" : "Answer"} ${editMode === "filter" ? filterCount : editorCount}/${CUSTOM_INPUT_MAX_CHARACTERS.toLocaleString()}`, compactDraft];
-            else if (mode === "multiple") {
-              const focusedRow = selected ? optionLabel(selected, optionIndex) : "";
-              const compactSelectionStatus = visibleWidth(selectionStatus) <= width
-                ? selectionStatus
-                : `Selected ${selectedCount()}`;
-              lines = focusedRow && visibleWidth(focusedRow) <= width
-                ? [focusedRow, compactSelectionStatus]
-                : [compactSelectionStatus, focusedRow];
-            } else lines = [`${selected ? `> ${selected.label}` : "No matching options"} · ${position}`];
-          } else if (rowBudget <= 5) {
-            lines = [
-              ...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",
-              editMode !== "none" ? compactDraft : mode === "multiple" ? selectionStatus : filterQuery ? `Filter ${filterCount}/${FILTER_QUERY_MAX_CHARACTERS.toLocaleString()}` : position,
-              editMode !== "none" ? editHint : browseHint,
-            ];
-          } else {
-            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);
-            const { start, end } = visibleOptionRange(visibleOptions.length, optionIndex, optionCapacity);
-            const hiddenAbove = start > 0 ? `↑ ${start}` : "";
-            const hiddenBelowCount = visibleOptions.length - end;
-            const hiddenBelow = hiddenBelowCount > 0 ? `↓ ${hiddenBelowCount}` : "";
-            const hiddenStatus = [hiddenAbove, hiddenBelow].filter(Boolean).join(" · ");
-            const progress = editMode === "filter"
-              ? `Filter ${filterCount}/${FILTER_QUERY_MAX_CHARACTERS.toLocaleString()}`
-              : editMode === "custom"
-                ? `Answer ${editorCount}/${CUSTOM_INPUT_MAX_CHARACTERS.toLocaleString()}`
-                : mode === "multiple"
-                  ? `${selectionStatus}${hiddenStatus ? ` · ${hiddenStatus}` : ""}`
-                  : filterQuery ? `Filter ${filterCount}/${FILTER_QUERY_MAX_CHARACTERS.toLocaleString()} · ${position}` : `${position}${hiddenStatus ? ` · ${hiddenStatus}` : ""}`;
-            const navigationHint = editMode !== "none" ? editHint : mode === "multiple"
-              ? `${keyHint("tui.select.up", "up")} • ${keyHint("tui.select.down", "down")} • ${browseHint}`
-              : `${keyHint("tui.select.up", "up")} • ${keyHint("tui.select.down", "down")} • ${keyHint("tui.select.confirm", "select")} • ${keyHint("tui.select.cancel", filterQuery ? "clear filter" : "cancel")}`;
-            lines = [
-              theme.fg("accent", "─".repeat(width)),
-              ...questionLines.map((line) => theme.fg("text", line)),
-              theme.fg("muted", truncateToWidth(` ${progress}`, width, "…")),
-            ];
-            if (editMode !== "none") {
-              const editorLines = editor.render(width);
-              const draftLines = editorLines.length > 2 ? editorLines.slice(1, -1) : editorLines;
-              lines.push(...(draftLines.length > 0 ? draftLines : [editMode === "filter" ? "Type a filter" : "Type an answer"]).slice(-contentRows));
-            } else {
-              for (let index = start; index < end; index += 1) {
-                const option = visibleOptions[index];
-                if (!option) continue;
-                const color: ThemeColor = index === optionIndex ? "accent" : "text";
-                lines.push(theme.fg(color, truncateToWidth(optionLabel(option, index), width, "…")));
-              }
-              const detailLines: string[] = [];
-              if (selected?.description) detailLines.push(...wrapTextWithAnsi(theme.fg("muted", selected.description), width));
-              if (selected?.preview) {
-                detailLines.push(theme.fg("accent", theme.bold("Proposal preview")));
-                detailLines.push(...new Markdown(selected.preview, 0, 0, {
-                  heading: (text) => theme.fg("accent", theme.bold(text)), link: (text) => theme.fg("accent", text),
-                  linkUrl: (text) => theme.fg("dim", text), code: (text) => theme.fg("mdCode", text),
-                  codeBlock: (text) => theme.fg("mdCodeBlock", text), codeBlockBorder: (text) => theme.fg("mdCodeBlockBorder", text),
-                  quote: (text) => theme.fg("mdQuote", text), quoteBorder: (text) => theme.fg("mdQuoteBorder", text),
-                  hr: (text) => theme.fg("mdHr", text), listBullet: (text) => theme.fg("mdListBullet", text),
-                  bold: (text) => theme.bold(text), italic: (text) => theme.italic(text), strikethrough: (text) => theme.strikethrough(text),
-                  underline: (text) => theme.underline(text),
-                }, { color: (text) => theme.fg("muted", text) }).render(width));
-              }
-              if (detailCapacity > 0 && detailLines.length > detailCapacity) {
-                const visibleDetailRows = Math.max(0, detailCapacity - 1);
-                lines.push(...detailLines.slice(0, visibleDetailRows));
-                const hiddenRows = detailLines.length - visibleDetailRows;
-                lines.push(theme.fg("dim", `… ${hiddenRows} more line${hiddenRows === 1 ? "" : "s"}`));
-              } else lines.push(...detailLines.slice(0, detailCapacity));
-            }
-            lines.push(theme.fg("dim", truncateToWidth(` ${navigationHint}`, width, "…")));
-            lines.push(theme.fg("accent", "─".repeat(width)));
-          }
-          cachedWidth = width;
-          cachedRows = rowBudget;
-          cachedLines = lines.slice(0, rowBudget).map((line) => boundedRenderLine(line, width, rowBudget <= 5 ? "…" : ""));
-          return cachedLines;
-        };
-
-        let focused = false;
-        return {
-          get focused(): boolean { return focused; },
-          set focused(value: boolean) { focused = value; editor.focused = value; },
-          render,
-          handleInput,
-          invalidate,
-        };
-      });
-
-      const abortHandler = (): void => finishFromAbort?.();
-      signal?.addEventListener("abort", abortHandler, { once: true });
-      if (signal?.aborted) abortHandler();
-      let result: QuestionSelection;
-      try {
-        result = await resultPromise;
-      } finally {
-        signal?.removeEventListener("abort", abortHandler);
+          break;
+        }
+        default: { const exhaustive: never = action; return exhaustive; }
       }
-
-  return result;
+    }
+  } catch (error) {
+    if (error instanceof QuestionAborted) return { kind: "aborted" };
+    throw error;
+  }
 }

package/killeros/question.ts

@@ -87,8 +87,10 @@ type QuestionDetails = SingleQuestionDetails | MultipleQuestionDetails;
 
 export function registerQuestionTool(pi: ExtensionAPI): void {
   const customInputHistory: string[] = [];
+  const pendingQuestions = new Set<AbortController>();
   let customInputHistoryBytes = 0;
   const clearCustomInputHistory = (): void => {
+    for (const pending of pendingQuestions) pending.abort();
     customInputHistory.length = 0;
     customInputHistoryBytes = 0;
   };
@@ -132,32 +134,37 @@ export function registerQuestionTool(pi: ExtensionAPI): void {
       if (signal?.aborted) throw new Error("Question cancelled before it opened");
 
       const question = safeTerminalText(params.question);
-      const options: DisplayOption[] = [
-        ...params.options.map((option, index) => ({
+      const options: DisplayOption[] = params.options.map((option, index) => ({
           label: safeTerminalText(option.label),
+          answer: option.label,
           description: option.description === undefined ? undefined : safeTerminalText(option.description),
           preview: option.preview === undefined ? undefined : safeTerminalText(option.preview),
           originalIndex: index + 1,
-          isOther: false,
-        })),
-        { label: "Type a custom answer", originalIndex: params.options.length + 1, isOther: true },
-      ];
-
-      const result = await openQuestionUi({
-        ctx,
-        signal,
-        question,
-        options,
-        originalOptions: params.options,
-        mode,
-        minSelections,
-        maxSelections,
-        customInputHistory,
-        rememberCustomInput,
-      });
+      }));
+
+      const pending = new AbortController();
+      pendingQuestions.add(pending);
+      let result;
+      try {
+        result = await openQuestionUi({
+          ctx,
+          signal: signal ? AbortSignal.any([signal, pending.signal]) : pending.signal,
+          question,
+          options,
+          mode,
+          minSelections,
+          maxSelections,
+          customInputHistory,
+          rememberCustomInput,
+        });
+      } finally {
+        pendingQuestions.delete(pending);
+      }
 
       const simpleOptions = params.options.map((option) => option.label);
-      if (result.kind === "aborted") throw new Error("Question cancelled because the agent operation was aborted");
+      if (result.kind === "aborted" || pending.signal.aborted || signal?.aborted) {
+        throw new Error("Question cancelled because the agent operation was aborted");
+      }
       if (result.kind === "cancelled" && mode === "multiple") {
         return {
           content: [{ type: "text", text: "User cancelled the question" }],

package/killeros/worked-for.ts

@@ -454,7 +454,7 @@ export function registerWorkedFor(
     }
   });
 
-  pi.on("agent_settled", async (_event, ctx) => {
+  pi.on("agent_settled", async (event, ctx) => {
     if (!active || ctx.mode !== "tui") return;
     const settled = active;
     const generation = lifecycleGeneration;
@@ -469,7 +469,7 @@ export function registerWorkedFor(
       ctx.ui.notify(`Change receipt unavailable: ${changes.reason}`, "warning");
     }
     const settledTokens = sessionTokenTotal(ctx);
-    const outcome = workedForOutcome(settled.stopReason);
+    const outcome = "aborted" in event && event.aborted === true ? "stopped" : workedForOutcome(settled.stopReason);
     const throughput = outcome === "done" && !settled.throughputInvalid && settled.responseStartedAt === undefined
       && positiveInteger(settled.outputTokens) && positiveDuration(settled.responseMilliseconds)
       ? { outputTokens: settled.outputTokens, responseMilliseconds: settled.responseMilliseconds }

package/package.json

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