killeros 3.0.3 → 3.0.5

package/CHANGELOG.md

@@ -4,6 +4,34 @@ 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
+
+- Made the explicitly enabled `prepublishOnly` lifecycle the single release-validator invocation at npm publication. The release workflow now publishes the source directory with `npm publish . --ignore-scripts=false`, preserving the existing release checks and trusted publishing.
+- Added current release-metadata validation and isolated publication-lifecycle tests with release-pinned npm to the Node-floor quality check. Extended the existing packed-package Pi test to check all required files and package identity without another pack operation. The package smoke job remains until replacement coverage lands and the required-check migration is approved and verified.
+
+### Fixed
+
+- Allowed later verified ordinary work to complete the same saved blocked goal without resume, clear, or extra automatic turns. Completion retains the original objective, file baseline, and accounting, respects native tool selection, and prevents compaction from restarting completed work.
+- Stopped false CRLF change counts in the footer and task receipts for text files with `eol=lf`. Added a differential Git-oracle matrix covering attributes, `core.autocrlf`, text and binary contents, plus mode and symlink comparisons. Fixes #47.
+- Gave each real Pi decision-tool exposure scenario its own bounded timeout so slower Windows TUI scenarios do not cancel the remaining codemode and RPC coverage. All behavioral assertions remain unchanged.
+
 ## [3.0.3] - 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.3`. 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
 
@@ -73,9 +73,25 @@ Pi 1.0 defaults to fullscreen. Use `--tui-mode regular` for one invocation or se
 
 With Pi 1.0.3's default [keybindings](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/keybindings.md#fullscreen), `Home` and `End` move within the current editor line. In fullscreen mode, `Ctrl+Home` and `Ctrl+End` scroll to the transcript's beginning or end without moving the editor cursor. KillerOS inherits these bindings; user overrides still apply.
 
-`question` and the active `killeros_goal_update` tool use Pi's `model-only` exposure. They stay directly declared to the model when codemode is disabled or enabled in `on` or `only` mode, but scripts and other tools cannot call them through `ctx.executeTool()`. The goal tool remains inactive without an active goal. Questions still require TUI mode; a direct RPC call fails with `The question tool requires interactive TUI mode`. KillerOS does not enable or configure codemode.
+`question` and the active `killeros_goal_update` tool use Pi's `model-only` exposure. They stay directly declared to the model when codemode is disabled or enabled in `on` or `only` mode, but scripts and other tools cannot call them through `ctx.executeTool()`. The goal tool is active for active goals and, during a later ordinary request, for completion only of a saved blocked goal. It is inactive outside those cases. Questions still require TUI mode; a direct RPC call fails with `The question tool requires interactive TUI mode`. KillerOS does not enable or configure codemode.
 
-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 before any model request. See Pi's [tool selection](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/cli.md#tools).
+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
 
@@ -109,7 +125,9 @@ A direct quoted path-shaped file target binds silent file proof. For an extensio
 /goal Fix `killeros/footer.ts`, verified by npm test
 ```
 
-Bare quoted prose remains model-reported. KillerOS captures the file baseline at goal start and only completes when the file is created or changed. A normal response never continues a goal by itself: the agent must record `continue`, `complete`, or a blocker decision through `killeros_goal_update`. Repeated continuation reports and unavailable goal tools pause the goal. New goals pause after 20 turns without warning. An explicit `/goal resume` on an exhausted goal grants another 20 turns; compaction recovery never grants turns. Same-turn recovery requires an actual interruption; successful or skipped compaction cannot restart a normally stopped goal without a decision. A request that completes or blocks a goal remains goal-owned through settlement, so automatic compaction cannot restart it as ordinary work. Later ordinary requests still support compaction continuation. Restored goals keep their persisted limit.
+Bare quoted prose remains model-reported. KillerOS captures the file baseline at goal start and only completes when the file is created or changed. File proof verifies that deliverable, not every natural-language acceptance criterion. The assistant must audit the whole objective before reporting completion; KillerOS cannot independently prove arbitrary objectives from prose. A normal response never continues a goal by itself: the agent must record `continue`, `complete`, or a blocker decision through `killeros_goal_update`. Repeated continuation reports and unavailable goal tools pause the goal. New goals pause after 20 turns without warning. An explicit `/goal resume` on an exhausted goal grants another 20 turns; compaction recovery never grants turns. Same-turn recovery requires an actual interruption; successful or skipped compaction cannot restart a normally stopped goal without a decision. A request that completes or blocks a goal remains goal-owned through settlement, so automatic compaction cannot restart it as ordinary work. Later ordinary requests still support compaction continuation. Restored goals keep their persisted limit.
+
+A blocked goal stays stopped. In a later ordinary TUI or RPC request in a saved session, the assistant can complete the same unchanged objective through `killeros_goal_update` after verification and current evidence. Only `complete` is accepted on this path. Completion does not resume automatic work, grant turns, restart the active clock, or require `/goal clear`. It retains the original file baseline and records either `file` proof or `model-reported` completion. Failed proof and ordinary responses without a completion decision leave the goal blocked. Paused goals still require explicit user controls. A completed goal leaves the footer but remains inspectable through `/goal` and session history.
 
 Session replacement, reload, and committed tree navigation discard unfinished task receipts. Late receipt results do not write or notify through the old session context or attach to a different branch. Cancelled navigation preserves the pending receipt.
 
@@ -117,8 +135,12 @@ Pending `/goal` commands discard their mutation if committed navigation changes
 
 Failed Git metadata reads keep the footer's last successful file counts and mark task changes unavailable. They are not treated as an empty repository.
 
+Passive Git scans compare content without running repository filters. CRLF text that normalizes to the indexed LF content stays unchanged, including with `text=auto eol=lf` or bare `eol=lf`. Git's `status` can still report a modification after a size-changing rewrite because of its index stat cache, even when `git diff` is empty.
+
 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:
@@ -163,9 +185,15 @@ npm ci && npm run check && npm test
 
 `main` requires pull requests and the CI workflow's required checks, including for administrators. Force pushes and branch deletion are blocked. Pi compatibility checks use the stable names `Pi compatibility (minimum)` and `Pi compatibility (latest)`, independent of the tested versions.
 
-When adopting these names, first confirm both checks passed on the release PR's exact head commit. Replace only the two old versioned Pi required checks with their corresponding stable names, preserving their GitHub Actions app bindings and every other protection. If other CI job names change, update GitHub's required status checks to match.
+When adopting these names, first confirm both checks passed on the release PR's exact head commit. Replace only the two old versioned Pi required checks with their corresponding stable names, preserving their GitHub Actions app bindings and every other protection.
+
+`Quality (Node 22.19.0)` validates current release metadata before the full test suite. It also tests the publication lifecycle with the release workflow's pinned npm CLI in an isolated installation. The packed-package Pi test checks the installed archive's entry point, README, changelog, theme, package name, and current version before activation and reload. These archive assertions run throughout the Node, Windows, and Pi compatibility matrix.
+
+`Package smoke test` remains during the required-check migration. Before removing it, land the replacement coverage and confirm the Node-floor quality check passed on the replacement PR's exact head commit and that the coverage is present on `main`. Inspect live branch protection and rulesets, obtain approval, and remove only the smoke requirement while preserving the required quality check's GitHub Actions binding and every other protection. Remove the job in a follow-up PR and recheck that PR's final head. Do not remove the job if these prerequisites are unmet.
+
+Releases go through CI on `main`; do not push version tags manually. The release workflow publishes the source directory with `npm publish . --ignore-scripts=false`. The package's `prepublishOnly` lifecycle invokes the existing release validator once at that boundary, even if an inherited npm setting disables scripts. A validator failure stops publication and release creation. The earlier verified-commit, provenance, version, tag, and release-note checks remain.
 
-Releases go through CI on `main`; do not push version tags manually. The package smoke job validates release metadata before packing, and the release workflow checks it again before publication. The prepublish check rejects ordinary direct `npm publish`, but `--ignore-scripts` can bypass it. Configure npm's trusted publisher for `release.yml`, set package publishing access to "Require two-factor authentication and disallow tokens", and revoke unused publish tokens. npm maintainers can still publish interactively with 2FA, so workflow-only publishing also depends on maintainer policy.
+The prepublish guard rejects ordinary direct publication, but it does not prove GitHub authorization. Disabling scripts or publishing a tarball bypasses `prepublishOnly`. Configure npm's trusted publisher for `release.yml`, set package publishing access to "Require two-factor authentication and disallow tokens", and revoke unused publish tokens. npm maintainers can still publish interactively with 2FA, so workflow-only publishing also depends on maintainer policy.
 
 ## Security
 

package/killeros/auto-compaction.ts

@@ -23,6 +23,7 @@ export interface AutoCompactionPreference {
 
 export interface AutoCompactionGoalHandlers {
   isActive(ctx: ExtensionContext): boolean;
+  hasAcceptedTerminalDecision(): boolean;
   onRequested(): void;
   onCompleted(ctx: ExtensionContext): void;
   onFailed(ctx: ExtensionContext, error: unknown): void;
@@ -246,7 +247,20 @@ export function registerAutoCompaction(
     goalRequestOwned = dependencies.goal?.isActive(ctx) === true;
   });
 
+  // Capture later blocked completion before goal settlement discards its permission.
+  // A compaction already pending as ordinary work must also stop after that decision.
+  const observeTerminalDecision = (): void => {
+    if (!dependencies.goal?.hasAcceptedTerminalDecision()) return;
+    goalRequestOwned = true;
+    if (request?.phase === "compacting") {
+      request.goal = true;
+      if (request.compactionCompleted) request = undefined;
+    }
+  };
+  pi.on("agent_end", observeTerminalDecision);
+
   pi.on("turn_end", (_event, ctx) => {
+    observeTerminalDecision();
     if (!supportedMode(ctx) || request) return;
 
     let preference: AutoCompactionPreference;
@@ -305,9 +319,10 @@ export function registerAutoCompaction(
     try {
       ctx.compact({
         onComplete: () => {
+          observeTerminalDecision();
           if (request?.phase !== "compacting" || request.token !== token) return;
           rearmOnNextLogicalRequest = preference.percentRemaining === 100;
-          if (goal) {
+          if (goal || request.goal) {
             request = undefined;
             if (activeGoal && dependencies.goal) {
               try {
@@ -328,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-interface.ts

@@ -13,7 +13,7 @@ import { safeTerminalText } from "./safe-terminal-text.ts";
 
 const GoalUpdateParams = Type.Object({
   status: StringEnum(["complete", "continue", "blocked"] as const, {
-    description: "Record exactly one active-goal decision: complete, continue, or blocked",
+    description: "Record an active-goal decision, or complete a blocked goal during an eligible later ordinary request",
   }),
   evidence: Type.String({
     minLength: 1,
@@ -148,7 +148,7 @@ export function registerGoalInterface(
   pi.registerTool<typeof GoalUpdateParams, GoalUpdateDetails>({
     name: GOAL_UPDATE_TOOL,
     label: "Goal update",
-    description: "Record exactly one active-goal decision: complete after verification, continue with evidence and one next action, or audit the same blocker before blocking it.",
+    description: "Record exactly one active-goal decision: complete after verification, continue with evidence and one next action, or audit the same blocker before blocking it. During an eligible later ordinary request for a blocked goal, only verified completion of the whole unchanged objective is permitted; it does not resume work or grant turns.",
     parameters: GoalUpdateParams,
     exposure: "model-only",
     executionMode: "sequential",
@@ -157,14 +157,27 @@ export function registerGoalInterface(
       if (!isGoalModeSupported(ctx)) throw new Error("KillerOS goals require TUI or RPC mode");
       if (!isSavedSession(ctx)) throw new Error("KillerOS goals require a saved session");
       const state = runtime.state;
-      if (!state || state.status !== "active") throw new Error("There is no active KillerOS goal to update");
-      if (!runtime.goalTurnInFlight
-        || runtime.goalTurn?.turn !== state.turns
-        || runtime.goalTurn.revision !== state.revision) {
-        throw new Error("A goal decision can only be recorded during an active KillerOS goal turn");
-      }
-      if (state.turnDecision !== undefined) {
-        throw new Error("Only one goal decision may be accepted per logical goal turn");
+      if (!state || state.status !== "active" && state.status !== "blocked") throw new Error("There is no active KillerOS goal to update");
+      const generation = runtime.lifecycleGeneration;
+      const permission = runtime.blockedCompletion;
+      const ownsDecision = (): boolean => runtime.state === state
+        && runtime.lifecycleGeneration === generation
+        && (state.status === "blocked"
+          ? permission?.kind === "eligible"
+            && runtime.blockedCompletion === permission
+            && permission.state === state
+            && permission.generation === generation
+          : runtime.goalTurnInFlight
+            && runtime.goalTurn?.turn === state.turns
+            && runtime.goalTurn.revision === state.revision
+            && state.turnDecision === undefined);
+      if (state.status === "blocked") {
+        if (!ownsDecision()) throw new Error("A blocked goal can only be completed during an eligible later ordinary request");
+        if (params.status !== "complete") throw new Error("A blocked goal accepts only complete; automatic continuation remains stopped");
+        if (state.turns === 0) throw new Error("A zero-turn blocked goal cannot record completion; no accounted goal turn exists");
+      } else {
+        if (state.turnDecision !== undefined) throw new Error("Only one goal decision may be accepted per logical goal turn");
+        if (!ownsDecision()) throw new Error("A goal decision can only be recorded during an active KillerOS goal turn");
       }
       if (params.status !== "complete" && params.status !== "continue" && params.status !== "blocked") {
         throw new Error("Goal update status is invalid");
@@ -175,11 +188,7 @@ export function registerGoalInterface(
       if (params.status === "complete") {
         if (state.verification) await verifyGoalDeliverable(state.verification);
         signal?.throwIfAborted();
-        if (runtime.state !== state
-          || runtime.goalTurn?.turn !== state.turns
-          || runtime.goalTurn.revision !== state.revision
-          || state.turnDecision !== undefined
-          || !runtime.goalTurnInFlight) throw new Error("Goal changed while completion was being verified");
+        if (!ownsDecision()) throw new Error("Goal changed while completion was being verified");
         const verification: "file" | "model-reported" = state.verification ? "file" : "model-reported";
         const decision = { kind: "complete" as const, turn: state.turns, evidence, verification };
         try {
@@ -188,6 +197,7 @@ export function registerGoalInterface(
           pauseGoalAfterFailure(pi, runtime, ctx, `goal completion could not be saved: ${error instanceof Error ? error.message : String(error)}`);
           throw error;
         }
+        if (state.status === "blocked") runtime.blockedCompletion = { kind: "accepted", generation };
         const text = state.verification
           ? `Goal verified complete at ${safeTerminalText(state.verification.path)}: ${evidence}`
           : `Goal marked complete (model-reported): ${evidence}`;
@@ -197,6 +207,7 @@ export function registerGoalInterface(
         };
       }
 
+      if (state.status !== "active") throw new Error("A blocked goal accepts only complete");
       if (params.status === "continue") {
         if (typeof params.nextAction !== "string") throw new Error("A continue decision requires a nextAction");
         const nextAction = normalizeGoalText(params.nextAction, GOAL_EVIDENCE_LIMIT, "Goal nextAction");

package/killeros/goal-runtime.ts

@@ -97,7 +97,11 @@ function setGoalUpdateToolActive(pi: ExtensionAPI, active: boolean): void {
 }
 
 export function syncGoalUpdateTool(pi: ExtensionAPI, runtime: GoalRuntime): void {
-  setGoalUpdateToolActive(pi, runtime.state?.status === "active");
+  const permission = runtime.blockedCompletion;
+  setGoalUpdateToolActive(pi, runtime.state?.status === "active"
+    || permission?.kind === "eligible"
+      && permission.state === runtime.state
+      && permission.generation === runtime.lifecycleGeneration);
 }
 
 function goalUpdateToolIsAvailable(pi: ExtensionAPI): boolean {
@@ -119,6 +123,7 @@ export function persistGoalState(
   const data: GoalEntryData = { version: GOAL_VERSION, event, state: state ?? null };
   pi.appendEntry(GOAL_ENTRY_TYPE, data);
   runtime.state = state;
+  runtime.blockedCompletion = undefined;
   if (event === "clear") {
     runtime.lifecycleGeneration += 1;
     runtime.continuationHeld = undefined;
@@ -372,6 +377,21 @@ function goalInstructions(state: GoalState, heading: string): string {
   ].join("\n");
 }
 
+function blockedGoalSystemPrompt(state: Extract<GoalState, { status: "blocked" }>): string {
+  return [
+    "# Blocked KillerOS goal",
+    "Status: blocked",
+    "Objective:",
+    state.objective,
+    "",
+    "Treat the exact saved objective above as authoritative. Automatic goal continuation remains stopped; this ordinary request grants no goal turns.",
+    "If killeros_goal_update is available, you may call it only with status complete and current evidence after auditing and verifying the whole unchanged objective.",
+    "File proof checks only the persisted deliverable against its original baseline, not every acceptance criterion. General-objective completion is model-reported.",
+    "The disappearance of a blocker alone does not prove completion. If useful work remains or this request is unrelated, finish normally without a goal update. No decision is mandatory.",
+    "Never use the goal tool to continue, audit a blocker, pause, resume, edit, replace, or clear this goal. User controls remain unchanged.",
+  ].join("\n");
+}
+
 function goalSystemPrompt(state: GoalState): string {
   return goalInstructions(state, "Active KillerOS goal");
 }
@@ -406,6 +426,7 @@ export function registerGoalRuntime(
     const generation = runtime.lifecycleGeneration;
     const restored = restoreGoalState(ctx);
     runtime.state = isGoalModeSupported(ctx) ? restored.state : undefined;
+    runtime.blockedCompletion = undefined;
     syncGoalUpdateTool(pi, runtime);
     runtime.continuationScheduled = false;
     runtime.continuationHeld = undefined;
@@ -434,6 +455,7 @@ export function registerGoalRuntime(
 
   pi.on("session_shutdown", (_event, ctx) => {
     runtime.lifecycleGeneration += 1;
+    runtime.blockedCompletion = undefined;
     if (runtime.state?.status === "active") {
       const checkpoint = checkpointActiveGoalState(runtime.state, Date.now());
       try {
@@ -453,7 +475,13 @@ export function registerGoalRuntime(
     runtime.continuationScheduled = false;
     if (!runtime.goalTurnInFlight && isGoalModeSupported(ctx) && isSavedSession(ctx) && pauseGoalAtTurnLimit(pi, runtime, ctx)) return;
     const current = runtime.state;
-    if (!isGoalModeSupported(ctx) || !isSavedSession(ctx) || !current || current.status !== "active") return;
+    if (!isGoalModeSupported(ctx) || !isSavedSession(ctx) || !current) return;
+    if (current.status === "blocked") {
+      runtime.blockedCompletion ??= { kind: "eligible", state: current, generation: runtime.lifecycleGeneration };
+      syncGoalUpdateTool(pi, runtime);
+      return { systemPrompt: `${event.systemPrompt}\n\n${blockedGoalSystemPrompt(current)}` };
+    }
+    if (current.status !== "active") return;
     if (runtime.goalTurnInFlight) {
       if (!goalUpdateToolIsAvailable(pi)) {
         pauseGoalBeforeTurn(pi, runtime, ctx);

package/killeros/goal-settlement.ts

@@ -219,7 +219,9 @@ 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;
     const continuationWasScheduled = runtime.continuationScheduled;
     const agentEndObserved = runtime.agentEndObserved;
@@ -228,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 ?? "");
@@ -311,6 +325,8 @@ export function registerGoalSettlement(
   });
 
   return {
+    hasAcceptedTerminalDecision: (): boolean => runtime.blockedCompletion?.kind === "accepted"
+      && runtime.blockedCompletion.generation === runtime.lifecycleGeneration,
     isActive: (ctx: ExtensionContext): boolean => isGoalModeSupported(ctx)
       && isSavedSession(ctx)
       && runtime.state?.status === "active",

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/passive-git-status.ts

@@ -325,7 +325,8 @@ function matchesIndex(content: Buffer, entry: IndexEntry, autoCrlf: string): boo
   if (blobObjectId(content, entry.objectId.length) === entry.objectId) return true;
   if (entry.mode === "120000" || !content.includes(Buffer.from("\r\n"))) return false;
   const attributes = entry.eolAttributes;
-  if (attributes.endsWith("eol=lf") || attributes === "-text") return false;
+  // eol controls checkout bytes; text files still normalize CRLF when compared with the index.
+  if (attributes === "-text") return false;
   const automatic = attributes.startsWith("text=auto") || !attributes;
   if (!attributes && !["true", "input"].includes(autoCrlf)) return false;
   if (automatic) {

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/runtime.ts

@@ -121,6 +121,10 @@ export interface GoalTurnExecution {
   revision: number;
 }
 
+export type BlockedGoalCompletion =
+  | { kind: "eligible"; state: Extract<GoalState, { status: "blocked" }>; generation: number }
+  | { kind: "accepted"; generation: number };
+
 export interface GoalRuntime {
   state?: GoalState;
   continuationScheduled: boolean;
@@ -128,6 +132,7 @@ export interface GoalRuntime {
   goalTurnInFlight: boolean;
   agentEndObserved: boolean;
   goalTurn?: GoalTurnExecution;
+  blockedCompletion?: BlockedGoalCompletion;
   automaticCompaction?: AutomaticGoalCompaction;
   persistenceRetryNeeded: boolean;
   lastStopReason?: string;

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.3",
+  "version": "3.0.5",
   "description": "TUI, goals, and workflow automation for the Pi coding agent",
   "type": "module",
   "keywords": [