killeros 2.0.4 → 2.0.5

package/CHANGELOG.md

@@ -4,6 +4,26 @@ All notable changes to KillerOS are documented here.
 
 ## [Unreleased]
 
+## [2.0.5] - 2026-08-11
+
+### Added
+
+- Added shuffled session-stable suggestions to the empty three-line prompt editor.
+
+### Fixed
+
+- Preserved complete UTF-8 characters in truncated `/init` evidence and chunked lifecycle-hook output, and kept filesystem-root paths visible in notification titles.
+- Kept the startup-tip shuffle deck across session rebinds so every tip appears before the bank repeats.
+- Rejected matchers on `agent_settled` lifecycle hooks instead of silently bypassing their tool-name guard.
+- Made the goal update status schema compatible with Google models while preserving strict completion and blocking values.
+- Kept multiline custom-answer drafts within tiny terminal row limits by rendering a clipped single-line preview.
+- Preserved existing spaces and tabs after the cursor when applying slash-command autocomplete.
+- Made `/init` abort safely when Git ignore inspection fails or returns untrusted output, preventing ignored files from entering model evidence.
+- Wrapped long interactive questions to the current terminal width while keeping the question UI within the terminal height.
+- Made `/goal pause` and `/goal clear` save terminal state before immediately stopping active goal work.
+- Kept failed goal edits and replacements visible and fail-closed without restarting a stale objective.
+- Required one durable blocker key on three consecutive goal turns before a goal can be marked blocked.
+
 ## [2.0.4] - 2026-08-10
 
 ### Changed

package/README.md

@@ -31,7 +31,7 @@ pi install git:github.com/KyrosHendrix/pi-KillerOS
 Pin an install to a release:
 
 ```bash
-pi install git:github.com/KyrosHendrix/pi-KillerOS@v2.0.4
+pi install git:github.com/KyrosHendrix/pi-KillerOS@v2.0.5
 ```
 
 Add `-l` to either command for a project-only install. Restart Pi after installing.
@@ -41,12 +41,12 @@ Add `-l` to either command for a project-only install. Restart Pi after installi
 - 52-column Compact startup card with inline version, polished model/provider identity, adjacent `/model`, directory, conditional Git branch, and a shuffled session-stable tip
 - Cohesive dark theme with coral accents and neutral tool-call containers across pending, success, and error states
 - Animated orange 12-frame activity glyph loop at 120 ms per frame, with orange shuffled Claude-adjacent verbs changing every 2.5 seconds, a gray `(esc to interrupt · thinking)` status with bold `esc`, and a quiet hidden-thinking label
-- Framed multiline editor with Shift+Enter support and slash-command autocomplete; KillerOS preserves an editor factory configured by another extension
+- Full-width framed multiline editor with a shuffled session-stable empty-state suggestion, Shift+Enter support, and slash-command autocomplete; KillerOS preserves an editor factory configured by another extension
 - Responsive footer with polished model/provider identity, plain-language context, and active goal state remaining; reasoning, Git branch, elapsed time, cost, and path cut down by available width
 - Pi-owned context compaction with active goals continuing from Pi's settled boundary after manual, threshold, and overflow compaction
 - Optional completion sounds after successful or failed settled requests, excluding manual aborts
 - `/variants` selector and direct reasoning-level arguments
-- Codex-style `/goal` with an interactive status/action panel, durable objectives, pause, resume, edit, confirmed panel clearing, automatic continuation, and explicit completion
+- Codex-style `/goal` with an interactive status/action panel, durable objectives, immediate pause and clear cancellation, automatic continuation, explicit completion, and durable blocker audits
 - Automatic `/init` guideline synthesis with a frozen safe evidence map, protected existing policy, and the four packaged behavioral sections adapted from `writing-great-guidelines`
 - `question` tool with height-bounded option windows, configured Pi keybindings, live option/input progress, proposal previews, custom answers, history, cancellation, and compact expandable transcript rendering
 - Mid-prompt slash completion with current Pi `0.82.1` commands, extensions, prompts, and skills; paths, URLs, and invalid commands remain plain text
@@ -60,9 +60,9 @@ Add `-l` to either command for a project-only install. Restart Pi after installi
 /goal                     Open current goal status and valid actions
 /goal <objective>         Set an objective and start working
 /goal edit                Edit and reactivate the current goal
-/goal pause               Stop automatic continuation
+/goal pause               Stop the current goal turn and automatic continuation
 /goal resume              Resume automatic continuation
-/goal clear               Remove the current goal
+/goal clear               Stop current goal work and remove the goal
 /variants                 Open the reasoning-level selector
 /variants high            Set a reasoning level directly
 /notification             Configure the completion sound
@@ -70,7 +70,9 @@ Add `-l` to either command for a project-only install. Restart Pi after installi
 /exit                     Quit Pi gracefully
 ```
 
-`/goal` requires a saved session in TUI or RPC mode. Goal state is stored in versioned session entries on the active branch and restored after reload, resume, fork, or tree navigation. Active goals inject their unchanged objective every turn and continue one settled turn at a time. The model must use KillerOS’s private goal tool to mark verified completion or a blocker repeated across at least three goal turns; final prose alone does not end the loop. Aborted turns, provider failures, and continuation failures pause safely. Replacing unfinished work requires confirmation, and `/goal edit` requires TUI mode.
+`/goal` requires a saved session in TUI or RPC mode. Goal state is stored in versioned session entries on the active branch and restored after reload, resume, fork, or tree navigation. Active goals inject their unchanged objective every turn and continue one settled turn at a time. The model must use KillerOS’s private goal tool to mark verified completion. Blocking requires one stable lowercase blocker key recorded on three consecutive goal turns; a changed key, skipped turn, resume, or edit resets the streak. Final prose alone does not end the loop.
+
+`/goal pause` and `/goal clear` save paused or cleared state before aborting current goal work, so settlement cannot restart it. Aborted turns, provider failures, and continuation failures otherwise pause safely. Failed edit and replacement writes dispatch no edited objective; an active prior objective pauses fail-closed, while inactive durable state remains unchanged. Replacing unfinished work requires confirmation, and `/goal edit` requires TUI mode.
 
 `/init` freezes a safe project-file map and exposes only dedicated read and list operations while it generates root `AGENTS.md`. Git-ignored files, known secret paths, private-key formats, other guidance, dependencies, links, non-regular files, and files outside that map are unavailable. Existing root `AGENTS.md` is separate protected policy: compatible rules are preserved, a real policy conflict leaves it unchanged with a reason, and any concurrent target change aborts installation without replacing the newer file.
 
@@ -92,7 +94,7 @@ Manual `/compact` aborts the current goal turn before summarization, so KillerOS
 
 For trusted projects, KillerOS loads `AGENTS.local.md` after Pi's shared repository context. A one-line `@path` or `@~/path` file imports personal guidance from another location.
 
-Lifecycle hooks are loaded from `.pi/killeros-hooks.json` at session start. Supported event keys are `tool_call`, `tool_result`, and `agent_settled`; matchers are JavaScript regular expressions over Pi tool names. Hook commands run from the repository root with `KILLEROS_EVENT`, `KILLEROS_TOOL`, and `KILLEROS_PAYLOAD` environment variables. Failed `tool_call` hooks block the tool, while later-event failures notify the user. Aborting the parent request stops the hook process tree with bounded graceful and forced cleanup without reporting cancellation as a hook failure.
+Lifecycle hooks are loaded from `.pi/killeros-hooks.json` at session start. Supported event keys are `tool_call`, `tool_result`, and `agent_settled`. Optional matchers are JavaScript regular expressions over Pi tool names, so they are valid only for `tool_call` and `tool_result`; KillerOS rejects an `agent_settled` hook that defines a matcher. Hook commands run from the repository root with `KILLEROS_EVENT`, `KILLEROS_TOOL`, and `KILLEROS_PAYLOAD` environment variables. Failed `tool_call` hooks block the tool, while later-event failures notify the user. Aborting the parent request stops the hook process tree with bounded graceful and forced cleanup without reporting cancellation as a hook failure.
 
 ## Behavior by mode
 

package/killeros/commands.ts

@@ -150,12 +150,11 @@ export function registerSlashAutocomplete(pi: ExtensionAPI): void {
         usage.set(tagged.killerosCommand, (usage.get(tagged.killerosCommand) ?? 0) + 1);
         const line = lines[cursorLine] ?? "";
         const beforeCursor = line.slice(0, cursorCol);
-        let afterCursor = line.slice(cursorCol);
+        const afterCursor = line.slice(cursorCol);
         const match = beforeCursor.match(/(?:^|[ \t])\/([^\s/]*)$/);
         if (!match || match.index === undefined) return current.applyCompletion(lines, cursorLine, cursorCol, item, prefix);
         const slashIndex = match.index + (match[0].startsWith("/") ? 0 : 1);
         const newBefore = beforeCursor.slice(0, slashIndex) + item.value;
-        if (item.value.endsWith(" ") && afterCursor.startsWith(" ")) afterCursor = afterCursor.trimStart();
         const nextLines = [...lines];
         nextLines[cursorLine] = newBefore + afterCursor;
         return { lines: nextLines, cursorLine, cursorCol: newBefore.length };

package/killeros/goals.ts

@@ -1,3 +1,4 @@
+import { StringEnum } from "@earendil-works/pi-ai";
 import { type ExtensionAPI, type ExtensionCommandContext, type ExtensionContext, type ThemeColor } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
@@ -6,14 +7,14 @@ import { BoundedText } from "./bounded-text.ts";
 import { formatTime, formatTokens } from "./display.ts";
 import { reportError } from "./errors.ts";
 import { resolvePersonalInstructions } from "./personal-instructions.ts";
-import type { GoalRuntime, GoalState, GoalStatus, InitRuntime } from "./runtime.ts";
+import type { GoalBlockerAudit, GoalRuntime, GoalState, GoalStatus, InitRuntime } from "./runtime.ts";
 
 const GOAL_ENTRY_TYPE = "killeros-goal";
 const GOAL_CONTINUATION_TYPE = "killeros-goal-continuation";
 const GOAL_OBJECTIVE_LIMIT = 4_000;
 const GOAL_VERSION = 1;
 
-type GoalEntryEvent = "set" | "replace" | "edit" | "turn" | "pause" | "resume" | "blocked" | "complete" | "error" | "clear" | "checkpoint";
+type GoalEntryEvent = "set" | "replace" | "edit" | "turn" | "pause" | "resume" | "blocked" | "complete" | "error" | "clear" | "checkpoint" | "blocker-audit";
 interface GoalEntryData {
   version: 1;
   event: GoalEntryEvent;
@@ -23,6 +24,7 @@ interface GoalEntryData {
 interface GoalTransitionOptions {
   resetBlockedAudit?: boolean;
   resumeAfterManualCompaction?: true;
+  blockerAudit?: GoalBlockerAudit;
 }
 
 interface RestoredGoalState {
@@ -31,7 +33,7 @@ interface RestoredGoalState {
 }
 
 const GoalUpdateParams = Type.Object({
-  status: Type.Union([Type.Literal("complete"), Type.Literal("blocked")], {
+  status: StringEnum(["complete", "blocked"] as const, {
     description: "Mark the active goal complete or blocked",
   }),
   evidence: Type.String({
@@ -39,11 +41,19 @@ const GoalUpdateParams = Type.Object({
     maxLength: 2_000,
     description: "Concise evidence that the objective is complete, or the repeated blocker and attempted workarounds",
   }),
+  blockerKey: Type.Optional(Type.String({
+    minLength: 1,
+    maxLength: 120,
+    pattern: "^[a-z0-9][a-z0-9._-]{0,119}$",
+    description: "Stable lowercase key identifying the repeated blocker",
+  })),
 });
 
 interface GoalUpdateDetails {
-  status: "complete" | "blocked";
+  status: "complete" | "blocked" | "blocker-audit";
   evidence: string;
+  blockerKey?: string;
+  streak?: number;
 }
 
 function isGoalStatus(value: unknown): value is GoalStatus {
@@ -54,6 +64,17 @@ function finiteNonNegative(value: unknown): value is number {
   return typeof value === "number" && Number.isFinite(value) && value >= 0;
 }
 
+function isGoalBlockerAudit(value: unknown, turns: number, status: GoalStatus): value is GoalBlockerAudit {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value as Partial<GoalBlockerAudit>;
+  if (typeof candidate.key !== "string"
+    || !/^[a-z0-9][a-z0-9._-]{0,119}$/u.test(candidate.key)
+    || !Number.isInteger(candidate.streak) || (candidate.streak ?? 0) < 1 || (candidate.streak ?? 0) > 3
+    || !Number.isInteger(candidate.lastTurn) || (candidate.lastTurn ?? 0) < 1 || (candidate.lastTurn ?? 0) > turns) return false;
+  if (status === "complete") return false;
+  return status === "blocked" ? candidate.streak === 3 : candidate.streak! < 3;
+}
+
 function parseGoalState(value: unknown): GoalState | undefined {
   if (!value || typeof value !== "object") return undefined;
   const candidate = value as Partial<GoalState>;
@@ -71,6 +92,7 @@ function parseGoalState(value: unknown): GoalState | undefined {
     || !finiteNonNegative(candidate.baselineTokens)
     || candidate.activeStartedAt !== undefined && !finiteNonNegative(candidate.activeStartedAt)
     || candidate.result !== undefined && typeof candidate.result !== "string"
+    || candidate.blockerAudit !== undefined && !isGoalBlockerAudit(candidate.blockerAudit, candidate.turns!, candidate.status)
     || candidate.resumeAfterManualCompaction !== undefined && candidate.resumeAfterManualCompaction !== true
     || candidate.resumeAfterManualCompaction === true && candidate.status !== "paused") {
     return undefined;
@@ -89,6 +111,7 @@ function parseGoalState(value: unknown): GoalState | undefined {
     baselineTokens: candidate.baselineTokens,
     result: candidate.result,
     resumeAfterManualCompaction: candidate.resumeAfterManualCompaction,
+    blockerAudit: candidate.blockerAudit,
   };
 }
 
@@ -182,6 +205,7 @@ function transitionGoal(
     updatedAt: now,
     activeStartedAt: status === "active" ? now : undefined,
     blockedAuditStartTurn: options.resetBlockedAudit ? stopped.turns : stopped.blockedAuditStartTurn,
+    blockerAudit: options.resetBlockedAudit ? undefined : options.blockerAudit ?? stopped.blockerAudit,
     result,
     resumeAfterManualCompaction: options.resumeAfterManualCompaction,
   };
@@ -190,6 +214,24 @@ function transitionGoal(
   return next;
 }
 
+function clearGoalExecutionFlags(runtime: GoalRuntime): void {
+  runtime.continuationScheduled = false;
+  runtime.goalTurnInFlight = false;
+  runtime.agentEndObserved = false;
+  runtime.lastStopReason = undefined;
+  runtime.lastError = undefined;
+}
+
+async function stopGoalRun(runtime: GoalRuntime, ctx: ExtensionCommandContext, shouldStop: boolean): Promise<void> {
+  if (!shouldStop) return;
+  try {
+    ctx.abort();
+    await ctx.waitForIdle();
+  } finally {
+    clearGoalExecutionFlags(runtime);
+  }
+}
+
 function goalStatusLabel(status: GoalStatus): string {
   return `${status.charAt(0).toLocaleUpperCase()}${status.slice(1)}`;
 }
@@ -222,6 +264,7 @@ export function pauseGoalAfterFailure(
   ctx: ExtensionContext,
   reason: string,
   recoveryInstruction = "Run /goal resume after resolving the problem.",
+  notify = true,
 ): void {
   if (runtime.state?.status !== "active") return;
   try {
@@ -237,7 +280,7 @@ export function pauseGoalAfterFailure(
     runtime.continuationScheduled = false;
     runtime.requestRender?.();
   }
-  ctx.ui.notify(`Goal paused: ${reason}\n${recoveryInstruction}`, "error");
+  if (notify) ctx.ui.notify(`Goal paused: ${reason}\n${recoveryInstruction}`, "error");
 }
 
 function pauseGoalForPossibleManualCompaction(
@@ -303,6 +346,7 @@ function scheduleGoalContinuation(
     || runtime.continuationHeld
     || runtime.goalTurnInFlight
     || initState.active
+    || !ctx.isIdle()
     || ctx.hasPendingMessages()) return false;
   const current = runtime.state;
   runtime.continuationScheduled = true;
@@ -337,7 +381,7 @@ function goalInstructions(state: GoalState, heading: string): string {
     "Continue making concrete progress toward this unchanged objective. Re-check repository state and prior results instead of repeating work.",
     "Do not stop merely because one response is complete: KillerOS will start another goal turn while the goal remains active.",
     "Before declaring completion, audit every part of the objective and verify the relevant results. Then call killeros_goal_update with status complete and concise evidence.",
-    "Call killeros_goal_update with status blocked only when the same external impasse has prevented progress for three consecutive goal turns; name the blocker and attempted workarounds.",
+    "Call killeros_goal_update with status blocked and the same lowercase blockerKey on each turn where one external impasse persists; attempts one and two record the audit, and attempt three marks the goal blocked.",
     "Never use the goal tool to pause, resume, edit, replace, or clear the objective. Those transitions belong to the user.",
   ].join("\n");
 }
@@ -398,7 +442,7 @@ export function registerGoal(
   pi.registerTool<typeof GoalUpdateParams, GoalUpdateDetails>({
     name: "killeros_goal_update",
     label: "Goal update",
-    description: "Mark the active KillerOS long-running goal complete after verification, or blocked after the same impasse persists for three consecutive goal turns.",
+    description: "Mark the active KillerOS long-running goal complete after verification, or record the same blocker key on three consecutive goal turns before blocking it.",
     parameters: GoalUpdateParams,
     executionMode: "sequential",
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
@@ -408,13 +452,40 @@ export function registerGoal(
       if (!state || state.status !== "active") throw new Error("There is no active KillerOS goal to update");
       const evidence = params.evidence.trim();
       if (!evidence) throw new Error("Goal evidence must not be empty");
-      if (params.status === "blocked" && state.turns - state.blockedAuditStartTurn < 3) {
-        throw new Error("A goal cannot be marked blocked before three goal turns in the current audit; keep working and audit the same blocker again");
+      if (params.status === "complete") {
+        transitionGoal(pi, runtime, "complete", "complete", evidence, { resetBlockedAudit: true });
+        return {
+          content: [{ type: "text", text: `Goal marked complete: ${evidence}` }],
+          details: { status: "complete", evidence },
+        };
       }
-      transitionGoal(pi, runtime, params.status, params.status, evidence);
+      if (!runtime.goalTurnInFlight) throw new Error("A blocker audit can only be recorded during an active KillerOS goal turn");
+      const blockerKey = params.blockerKey;
+      if (!blockerKey || !/^[a-z0-9][a-z0-9._-]{0,119}$/u.test(blockerKey)) {
+        throw new Error("A blocked goal update requires a stable lowercase blockerKey");
+      }
+      const previous = state.blockerAudit;
+      const sameTurn = previous?.key === blockerKey && previous.lastTurn === state.turns;
+      const consecutive = previous?.key === blockerKey && previous.lastTurn === state.turns - 1;
+      const streak = sameTurn ? previous.streak : consecutive ? previous.streak + 1 : 1;
+      const blockerAudit = { key: blockerKey, streak, lastTurn: state.turns };
+      if (streak < 3) {
+        const next: GoalState = {
+          ...state,
+          revision: state.revision + 1,
+          updatedAt: Date.now(),
+          blockerAudit,
+        };
+        persistGoalState(pi, runtime, "blocker-audit", next);
+        return {
+          content: [{ type: "text", text: `Blocker audit ${streak}/3 recorded; the goal remains active: ${evidence}` }],
+          details: { status: "blocker-audit", evidence, blockerKey, streak },
+        };
+      }
+      transitionGoal(pi, runtime, "blocked", "blocked", evidence, { blockerAudit });
       return {
-        content: [{ type: "text", text: `Goal marked ${params.status}: ${evidence}` }],
-        details: { status: params.status, evidence },
+        content: [{ type: "text", text: `Goal marked blocked: ${evidence}` }],
+        details: { status: "blocked", evidence, blockerKey, streak },
       };
     },
     renderCall(args, theme) {
@@ -423,7 +494,8 @@ export function registerGoal(
     renderResult(result, options, theme) {
       const details = result.details;
       if (!details) return new BoundedText(theme.fg("dim", "Goal updated"));
-      const text = `${theme.fg(details.status === "complete" ? "success" : "warning", details.status === "complete" ? "✓ Complete" : "! Blocked")}${theme.fg("dim", ` · ${details.evidence}`)}`;
+      const label = details.status === "complete" ? "✓ Complete" : details.status === "blocked" ? "! Blocked" : `! Blocker audit ${details.streak}/3`;
+      const text = `${theme.fg(details.status === "complete" ? "success" : "warning", label)}${theme.fg("dim", ` · ${details.evidence}`)}`;
       return new BoundedText(text, options.expanded ? undefined : 3);
     },
   });
@@ -544,10 +616,11 @@ export function registerGoal(
           ctx.ui.notify("No goal is set", "info");
           return;
         }
+        const shouldStopGoalRun = runtime.goalTurnInFlight || runtime.continuationScheduled;
+        let saved = false;
         try {
           persistGoalState(pi, runtime, "clear", undefined);
-          runtime.continuationScheduled = false;
-          ctx.ui.notify("Goal cleared", "info");
+          saved = true;
         } catch (error) {
           if (runtime.state?.status === "active") {
             pauseGoalAfterFailure(
@@ -556,11 +629,24 @@ export function registerGoal(
               ctx,
               `the requested clear could not be saved: ${error instanceof Error ? error.message : String(error)}`,
               "Automatic continuation is stopped. Retry /goal clear to remove the goal.",
+              false,
             );
           } else {
             reportError(ctx, "Goal could not be cleared", error);
+            return;
           }
         }
+        try {
+          await stopGoalRun(runtime, ctx, shouldStopGoalRun);
+        } catch (error) {
+          reportError(ctx, saved ? "Goal cleared, but the active goal turn could not be confirmed stopped" : "Goal paused, but the active goal turn could not be confirmed stopped", error);
+          return;
+        }
+        if (saved) {
+          ctx.ui.notify("Goal cleared", "info");
+        } else {
+          ctx.ui.notify("Goal paused: the requested clear could not be saved\nAutomatic continuation is stopped. Retry /goal clear to remove the goal.", "error");
+        }
         return;
       }
 
@@ -597,18 +683,34 @@ export function registerGoal(
           ctx.ui.notify(`Goal is ${runtime.state.status}; only an active goal can be paused`, "warning");
           return;
         }
+        const shouldStopGoalRun = runtime.goalTurnInFlight || runtime.continuationScheduled;
+        let saved = false;
+        let failureReason: string | undefined;
         try {
           transitionGoal(pi, runtime, "pause", "paused");
-          ctx.ui.notify("Goal paused. Run /goal resume to continue.", "info");
+          saved = true;
         } catch (error) {
+          failureReason = `the requested pause could not be saved: ${error instanceof Error ? error.message : String(error)}`;
           pauseGoalAfterFailure(
             pi,
             runtime,
             ctx,
-            `the requested pause could not be saved: ${error instanceof Error ? error.message : String(error)}`,
+            failureReason,
             "Automatic continuation is stopped. If session storage is still unavailable, retry /goal pause after it recovers.",
+            false,
           );
         }
+        try {
+          await stopGoalRun(runtime, ctx, shouldStopGoalRun);
+        } catch (error) {
+          reportError(ctx, "Goal paused, but the active goal turn could not be confirmed stopped", error);
+          return;
+        }
+        if (saved) {
+          ctx.ui.notify("Goal paused. Run /goal resume to continue.", "info");
+        } else {
+          ctx.ui.notify(`Goal paused: ${failureReason}\nAutomatic continuation is stopped. If session storage is still unavailable, retry /goal pause after it recovers.`, "error");
+        }
         return;
       }
 
@@ -687,6 +789,7 @@ export function registerGoal(
           updatedAt: now,
           activeStartedAt: now,
           blockedAuditStartTurn: current.turns,
+          blockerAudit: undefined,
           result: undefined,
           resumeAfterManualCompaction: undefined,
         };
@@ -695,13 +798,17 @@ export function registerGoal(
           runtime.continuationScheduled = false;
           if (scheduleGoalContinuation(pi, runtime, initState, ctx)) ctx.ui.notify("Goal updated and active", "info");
         } catch (error) {
-          pauseGoalAfterFailure(
-            pi,
-            runtime,
-            ctx,
-            `Goal could not be edited: ${error instanceof Error ? error.message : String(error)}`,
-            "Automatic continuation is stopped. Retry /goal edit after session storage recovers.",
-          );
+          if (runtime.state?.status === "active") {
+            pauseGoalAfterFailure(
+              pi,
+              runtime,
+              ctx,
+              `Goal could not be edited: ${error instanceof Error ? error.message : String(error)}`,
+              "Automatic continuation is stopped. Retry /goal edit after session storage recovers.",
+            );
+          } else {
+            reportError(ctx, "Goal could not be edited", error);
+          }
         }
         return;
       }
@@ -761,8 +868,19 @@ export function registerGoal(
           ctx.ui.notify("Goal active. KillerOS will continue until completion, a repeated blocker, or pause.", "info");
         }
       } catch (error) {
-        reportError(ctx, "Goal could not be started", error);
-        scheduleGoalContinuation(pi, runtime, initState, ctx);
+        if (!unfinished) {
+          reportError(ctx, "Goal could not be started", error);
+        } else if (runtime.state?.status === "active") {
+          pauseGoalAfterFailure(
+            pi,
+            runtime,
+            ctx,
+            `Goal could not be replaced: ${error instanceof Error ? error.message : String(error)}`,
+            "Automatic continuation is stopped. Retry replacement after session storage recovers.",
+          );
+        } else {
+          reportError(ctx, "Goal could not be replaced", error);
+        }
       }
   };
 
@@ -800,6 +918,8 @@ export function registerGoalSettlement(
     if (!wasGoalTurn || runtime.state?.status !== "active" || initState.active) {
       if (continuationWasScheduled && runtime.state?.status === "active" && !initState.active) {
         pauseGoalAfterFailure(pi, runtime, ctx, "the goal continuation ended before an agent turn started");
+      } else if (runtime.state?.status === "active" && !initState.active) {
+        scheduleGoalContinuation(pi, runtime, initState, ctx);
       }
       return;
     }

package/killeros/hooks.ts

@@ -1,6 +1,7 @@
 import { spawn } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
+import { StringDecoder } from "node:string_decoder";
 import { CONFIG_DIR_NAME, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { reportError } from "./errors.ts";
 import { MAX_NODE_TIMER_MS } from "./limits.ts";
@@ -44,6 +45,10 @@ function loadKillerosHooks(ctx: ExtensionContext): KillerosHookConfig {
       const candidates = parsed.hooks?.[event];
       if (!Array.isArray(candidates)) continue;
       hooks[event] = candidates.filter((hook, index) => {
+        if (event === "agent_settled" && hook?.matcher !== undefined) {
+          ctx.ui.notify(`Ignored ${event} hook ${index + 1}: matchers are only valid for tool events`, "warning");
+          return false;
+        }
         const valid = hook
           && typeof hook.command === "string"
           && hook.command.trim().length > 0
@@ -80,9 +85,19 @@ function matchesHook(hook: KillerosHook, value: string): boolean {
   }
 }
 
-function appendBounded(current: string, chunk: Buffer | string): string {
-  if (current.length >= HOOK_OUTPUT_LIMIT) return current;
-  return (current + chunk.toString()).slice(0, HOOK_OUTPUT_LIMIT);
+interface HookOutputBuffer {
+  bytes: number;
+  decoder: StringDecoder;
+  text: string;
+}
+
+function appendBounded(output: HookOutputBuffer, chunk: Buffer | string): void {
+  const remaining = HOOK_OUTPUT_LIMIT - output.bytes;
+  if (remaining <= 0) return;
+  const bytes = typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk;
+  const captured = bytes.subarray(0, remaining);
+  output.bytes += captured.length;
+  output.text += output.decoder.write(captured);
 }
 
 function terminateHookProcess(child: ReturnType<typeof spawn>, force: boolean): void {
@@ -130,8 +145,8 @@ export function executeHook(
       stdio: ["ignore", "pipe", "pipe"],
       windowsHide: true,
     });
-    let stdout = "";
-    let stderr = "";
+    const stdout: HookOutputBuffer = { bytes: 0, decoder: new StringDecoder("utf8"), text: "" };
+    const stderr: HookOutputBuffer = { bytes: 0, decoder: new StringDecoder("utf8"), text: "" };
     let completed = false;
     let termination: "timeout" | "cancelled" | undefined;
     let timer: NodeJS.Timeout | undefined;
@@ -146,8 +161,8 @@ export function executeHook(
       signal?.removeEventListener("abort", abort);
       resolve({
         code,
-        stdout,
-        stderr,
+        stdout: stdout.text,
+        stderr: stderr.text,
         timedOut: termination === "timeout",
         cancelled: termination === "cancelled",
         exitUnconfirmed,
@@ -167,10 +182,10 @@ export function executeHook(
     const abort = (): void => beginTermination("cancelled");
     signal?.addEventListener("abort", abort, { once: true });
     if (signal?.aborted) beginTermination("cancelled");
-    child.stdout.on("data", (chunk) => { stdout = appendBounded(stdout, chunk); });
-    child.stderr.on("data", (chunk) => { stderr = appendBounded(stderr, chunk); });
+    child.stdout.on("data", (chunk) => appendBounded(stdout, chunk));
+    child.stderr.on("data", (chunk) => appendBounded(stderr, chunk));
     child.on("error", (error) => {
-      stderr = appendBounded(stderr, error.message);
+      appendBounded(stderr, error.message);
       finish(termination ? terminationCode() : 1);
     });
     child.once("close", (code) => finish(termination ? terminationCode() : code ?? 1));

package/killeros/init-evidence.ts

@@ -1,6 +1,7 @@
 import { spawn } from "node:child_process";
 import { promises as fs } from "node:fs";
 import path from "node:path";
+import { StringDecoder } from "node:string_decoder";
 
 export const INIT_READ_TOOL = "killeros_init_read";
 export const INIT_LIST_TOOL = "killeros_init_list";
@@ -91,7 +92,7 @@ async function collectCandidates(projectRoot: string): Promise<string[]> {
 
 async function gitIgnoredPaths(projectRoot: string, candidates: readonly string[]): Promise<ReadonlySet<string>> {
   if (!candidates.length) return new Set();
-  return new Promise((resolve) => {
+  return new Promise((resolve, reject) => {
     let settled = false;
     let stdout = Buffer.alloc(0);
     const child = spawn("git", ["-C", projectRoot, "check-ignore", "--stdin", "-z"], {
@@ -99,7 +100,13 @@ async function gitIgnoredPaths(projectRoot: string, candidates: readonly string[
       stdio: ["pipe", "pipe", "ignore"],
       windowsHide: true,
     });
-    const finish = (value: ReadonlySet<string>): void => {
+    const fail = (): void => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(new Error("Git ignore inspection failed; /init did not build repository evidence"));
+    };
+    const succeed = (value: ReadonlySet<string>): void => {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
@@ -107,30 +114,59 @@ async function gitIgnoredPaths(projectRoot: string, candidates: readonly string[
     };
     const timer = setTimeout(() => {
       child.kill("SIGKILL");
-      finish(new Set());
+      fail();
     }, 2_000);
     child.stdout.on("data", (chunk: Buffer) => {
-      if (stdout.length <= 256 * 1024) stdout = Buffer.concat([stdout, chunk]);
+      if (stdout.length + chunk.length > 256 * 1024) {
+        child.kill("SIGKILL");
+        fail();
+        return;
+      }
+      stdout = Buffer.concat([stdout, chunk]);
+    });
+    child.once("error", fail);
+    child.stdin.once("error", () => {
+      child.kill("SIGKILL");
+      fail();
     });
-    child.once("error", () => finish(new Set()));
     child.once("close", (code) => {
-      if (code === 1) return finish(new Set());
-      if (code !== 0 || stdout.length > 256 * 1024 || stdout.at(-1) !== 0) return finish(new Set());
+      if (code === 1) {
+        if (stdout.length) fail();
+        else succeed(new Set());
+        return;
+      }
+      if (code !== 0 || !stdout.length || stdout.at(-1) !== 0) {
+        fail();
+        return;
+      }
+      let values: string[];
+      try {
+        values = new TextDecoder("utf-8", { fatal: true }).decode(stdout.subarray(0, -1)).split("\0");
+      } catch {
+        fail();
+        return;
+      }
       const candidateSet = new Set(candidates.map(evidenceKey));
-      const values = stdout.subarray(0, -1).toString("utf8").split("\0");
-      if (values.some((value) => !value || !candidateSet.has(evidenceKey(value)))) return finish(new Set());
-      finish(new Set(values.map(evidenceKey)));
+      const ignored = new Set(values.map(evidenceKey));
+      if (values.some((value) => !value || !candidateSet.has(evidenceKey(value))) || ignored.size !== values.length) {
+        fail();
+        return;
+      }
+      succeed(ignored);
     });
-    child.stdin.on("error", () => {});
     child.stdin.end(`${candidates.join("\0")}\0`);
   });
 }
 
+function decodeCompleteUtf8(bytes: Buffer): string {
+  return new StringDecoder("utf8").write(bytes);
+}
+
 function appendWithinLimit(current: string, section: string, limit: number): string {
   const remaining = limit - Buffer.byteLength(current, "utf8");
   if (remaining <= 0) return current;
   const bytes = Buffer.from(section, "utf8");
-  return current + bytes.subarray(0, remaining).toString("utf8");
+  return current + decodeCompleteUtf8(bytes.subarray(0, remaining));
 }
 
 async function validateAndRead(projectRoot: string, absolutePath: string, limit: number): Promise<{ content: string; truncated: boolean }> {
@@ -157,7 +193,7 @@ async function validateAndRead(projectRoot: string, absolutePath: string, limit:
     const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
     const data = buffer.subarray(0, Math.min(bytesRead, limit));
     if (data.includes(0)) throw new Error("/init rejects binary files");
-    return { content: data.toString("utf8"), truncated: bytesRead > limit };
+    return { content: decodeCompleteUtf8(data), truncated: bytesRead > limit };
   } finally {
     await handle.close();
   }

package/killeros/notifications.ts

@@ -65,7 +65,7 @@ export function formatNotificationTitle(
   sessionName: string | undefined,
   enabled: boolean,
 ): string {
-  const directory = basename(cwd);
+  const directory = basename(cwd) || cwd;
   const base = sessionName ? `π - ${sessionName} - ${directory}` : `π - ${directory}`;
   return enabled ? `${base} ${COMPLETION_BELL_GLYPH}` : base;
 }

package/killeros/question.ts

@@ -89,12 +89,24 @@ 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);
+  visible[rowLimit - 1] = truncateToWidth(visible[rowLimit - 1]!, width, "…");
+  return visible;
+}
+
 export function registerQuestionTool(pi: ExtensionAPI): void {
   const customInputHistory: string[] = [];
   let customInputHistoryBytes = 0;
@@ -349,27 +361,29 @@ export function registerQuestionTool(pi: ExtensionAPI): void {
           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 answerCount = inputCharacterCount(editor.getExpandedText()).toLocaleString();
+          const expandedAnswer = editor.getExpandedText();
+          const answerCount = inputCharacterCount(expandedAnswer).toLocaleString();
           const filterCount = inputCharacterCount(filterQuery).toLocaleString();
+          const compactDraft = expandedAnswer.replace(/\r\n|\r|\n/gu, " ↵ ") || "Type an answer";
 
           if (rowBudget <= 2) {
             const compact = editMode
-              ? [`Answer ${answerCount}/${CUSTOM_INPUT_MAX_CHARACTERS.toLocaleString()}`, editor.getExpandedText() || "Type an answer"]
+              ? [`Answer ${answerCount}/${CUSTOM_INPUT_MAX_CHARACTERS.toLocaleString()}`, compactDraft]
               : [`${selected ? `> ${selected.label}` : "No matching options"} · ${position}`];
             cachedWidth = renderWidth;
             cachedRows = rowBudget;
-            cachedLines = compact.slice(0, rowBudget).map((line) => truncateToWidth(line, renderWidth, "…"));
+            cachedLines = compact.slice(0, rowBudget).map((line) => boundedRenderLine(line, renderWidth, "…"));
             return cachedLines;
           }
 
           if (rowBudget <= 5) {
             const compact = [
-              truncateToWidth(params.question.replace(/\s+/gu, " "), renderWidth, "…"),
+              ...boundedQuestionLines(params.question, renderWidth, Math.max(1, rowBudget - 3)),
               editMode
                 ? `Answer ${answerCount}/${CUSTOM_INPUT_MAX_CHARACTERS.toLocaleString()}`
                 : `${selected ? `> ${selected.label}` : "No matching options"} · ${position}`,
               editMode
-                ? editor.getExpandedText() || "Type an answer"
+                ? compactDraft
                 : filterQuery
                   ? `Filter ${filterCount}/${FILTER_QUERY_MAX_CHARACTERS.toLocaleString()}`
                   : position,
@@ -379,11 +393,12 @@ export function registerQuestionTool(pi: ExtensionAPI): void {
             ];
             cachedWidth = renderWidth;
             cachedRows = rowBudget;
-            cachedLines = compact.slice(0, rowBudget).map((line) => truncateToWidth(line, renderWidth, "…"));
+            cachedLines = compact.slice(0, rowBudget).map((line) => boundedRenderLine(line, renderWidth, "…"));
             return cachedLines;
           }
 
-          const contentRows = rowBudget - 5;
+          const questionLines = boundedQuestionLines(params.question, renderWidth, 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);
@@ -401,7 +416,7 @@ export function registerQuestionTool(pi: ExtensionAPI): void {
             : `${keyHint("tui.select.up", "up")} • ${keyHint("tui.select.down", "down")} • ${keyHint("tui.select.confirm", "select")} • ${keyHint("tui.select.cancel", filterQuery ? "clear filter" : "cancel")}`;
           const lines: string[] = [
             theme.fg("accent", "─".repeat(renderWidth)),
-            theme.fg("text", truncateToWidth(` ${params.question.replace(/\s+/gu, " ")}`, renderWidth, "…")),
+            ...questionLines.map((line) => theme.fg("text", line)),
             theme.fg("muted", truncateToWidth(` ${progress}`, renderWidth, "…")),
           ];
 
@@ -459,7 +474,7 @@ export function registerQuestionTool(pi: ExtensionAPI): void {
           lines.push(theme.fg("accent", "─".repeat(renderWidth)));
           cachedWidth = renderWidth;
           cachedRows = rowBudget;
-          cachedLines = lines.slice(0, rowBudget).map((line) => truncateToWidth(line, renderWidth, ""));
+          cachedLines = lines.slice(0, rowBudget).map((line) => boundedRenderLine(line, renderWidth, ""));
           return cachedLines;
         };
 

package/killeros/runtime.ts

@@ -20,6 +20,12 @@ export interface InitRuntime {
 
 export type GoalStatus = "active" | "paused" | "blocked" | "complete";
 
+export interface GoalBlockerAudit {
+  key: string;
+  streak: number;
+  lastTurn: number;
+}
+
 export interface GoalState {
   version: 1;
   revision: number;
@@ -34,6 +40,7 @@ export interface GoalState {
   baselineTokens: number;
   result?: string;
   resumeAfterManualCompaction?: true;
+  blockerAudit?: GoalBlockerAudit;
 }
 
 export interface GoalRuntime {

package/killeros/shell-ui.ts

@@ -11,6 +11,7 @@ import {
 } from "@earendil-works/pi-coding-agent";
 import {
   Container,
+  CURSOR_MARKER,
   Text,
   truncateToWidth,
   visibleWidth,
@@ -43,6 +44,13 @@ const STARTUP_TIPS = [
   "Run /notification to enable a terminal bell when work settles.",
 ] as const;
 
+const EDITOR_SUGGESTIONS = [
+  'Try "how does <filepath> work?"',
+  'Try "find edge cases in <filepath>"',
+  'Try "simplify <filepath> without changing behavior"',
+  'Try "write tests for <filepath>"',
+] as const;
+
 export function resolveGitBranch(cwd: string): Promise<string | undefined> {
   return new Promise((resolve) => {
     execFile(
@@ -66,13 +74,26 @@ export function resolveGitBranch(cwd: string): Promise<string | undefined> {
   });
 }
 
-function shuffledTips(): string[] {
-  const tips = [...STARTUP_TIPS];
-  for (let index = tips.length - 1; index > 0; index -= 1) {
+function shuffledDeck(values: readonly string[]): string[] {
+  const deck = [...values];
+  for (let index = deck.length - 1; index > 0; index -= 1) {
     const swapIndex = Math.floor(Math.random() * (index + 1));
-    [tips[index], tips[swapIndex]] = [tips[swapIndex]!, tips[index]!];
+    [deck[index], deck[swapIndex]] = [deck[swapIndex]!, deck[index]!];
   }
-  return tips;
+  return deck;
+}
+
+let tipDeck: string[] = [];
+let editorSuggestionDeck: string[] = [];
+
+function nextStartupTip(): string {
+  if (tipDeck.length === 0) tipDeck = shuffledDeck(STARTUP_TIPS);
+  return tipDeck.pop() ?? STARTUP_TIPS[0];
+}
+
+function nextEditorSuggestion(): string {
+  if (editorSuggestionDeck.length === 0) editorSuggestionDeck = shuffledDeck(EDITOR_SUGGESTIONS);
+  return editorSuggestionDeck.pop() ?? EDITOR_SUGGESTIONS[0];
 }
 
 function compactBoxLine(content: string, width: number, theme: Theme): string {
@@ -167,16 +188,19 @@ function isScrolledTopBorder(line: string): boolean {
 class PiCodeEditor extends CustomEditor {
   private readonly appKeybindings: KeybindingsManager;
   private readonly runtimeTheme: Theme;
+  private readonly suggestion: string;
 
   constructor(
     tui: TUI,
     theme: EditorTheme,
     appKeybindings: KeybindingsManager,
     runtimeTheme: Theme,
+    suggestion: string,
   ) {
     super(tui, theme, appKeybindings);
     this.appKeybindings = appKeybindings;
     this.runtimeTheme = runtimeTheme;
+    this.suggestion = suggestion;
   }
 
   override handleInput(data: string): void {
@@ -220,8 +244,16 @@ class PiCodeEditor extends CustomEditor {
     }
 
     for (let index = 1; index < bottomBorderIndex; index += 1) {
-      const prefix = index === 1 && !isScrolledHeader ? gray("❯ ") : "  ";
-      framed.push(`${prefix}${padRight(lines[index] ?? "", innerWidth)}`);
+      const isPromptLine = index === 1 && !isScrolledHeader;
+      const prefix = isPromptLine ? gray("❯\u00A0") : "  ";
+      let content = lines[index] ?? "";
+      if (isPromptLine && this.getText() === "") {
+        const first = this.suggestion.slice(0, 1);
+        const rest = this.suggestion.slice(1);
+        const cursorMarker = this.focused ? CURSOR_MARKER : "";
+        content = `${cursorMarker}\x1B[7m${gray(first)}\x1B[27m${gray(rest)}`;
+      }
+      framed.push(`${prefix}${padRight(content, innerWidth)}`);
     }
 
     const bottom = stripAnsi(lines[bottomBorderIndex] ?? "");
@@ -258,11 +290,6 @@ export function registerShellUi(pi: ExtensionAPI): void {
   let activityDeck: string[] = [];
   let lastActivityWord: string | undefined;
   let activityTimer: ReturnType<typeof setInterval> | undefined;
-  let tipDeck: string[] = [];
-  const nextStartupTip = (): string => {
-    if (tipDeck.length === 0) tipDeck = shuffledTips();
-    return tipDeck.pop() ?? STARTUP_TIPS[0];
-  };
   const refillActivityDeck = (): void => {
     activityDeck = [...ACTIVITY_WORDS];
     for (let index = activityDeck.length - 1; index > 0; index -= 1) {
@@ -302,8 +329,9 @@ export function registerShellUi(pi: ExtensionAPI): void {
       ctx.ui.setHiddenThinkingLabel("└ Thinking…");
       const existingEditorFactory = ctx.ui.getEditorComponent?.();
       if (!existingEditorFactory || existingEditorFactory === killerosEditorFactory) {
+        const editorSuggestion = nextEditorSuggestion();
         killerosEditorFactory = (tui, editorTheme, keybindings) =>
-          new PiCodeEditor(tui, editorTheme, keybindings, ctx.ui.theme);
+          new PiCodeEditor(tui, editorTheme, keybindings, ctx.ui.theme, editorSuggestion);
         ctx.ui.setEditorComponent(killerosEditorFactory);
       }
     } catch (error) {

package/package.json

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