killeros 2.0.2 → 2.0.3

package/CHANGELOG.md

@@ -4,6 +4,23 @@ All notable changes to KillerOS are documented here.
 
 ## [Unreleased]
 
+## [2.0.3] - 2026-08-09
+
+### Added
+
+- Added an opt-in global completion sound with `/notification` and an enabled-state Nerd Font bell in the terminal tab title.
+- Moved active goal status to the footer's right side in warning yellow, replacing the path with `/goal is active (...)` and exact seconds.
+
+### Changed
+
+- Returned compaction timing, summary generation, manual instructions, retries, file tracking, and overflow recovery to Pi's public lifecycle.
+- Continued active goals only after Pi reaches its settled boundary and preserved `/goal` as the sole durable objective and status owner.
+
+### Fixed
+
+- Added fail-closed, revision-bound recovery after successful manual compaction, including reload and branch navigation recovery without reviving stale or explicitly paused goals.
+- Rendered question help from the effective selector keybindings across supported Pi versions.
+
 ## [2.0.2] - 2026-08-08
 
 ### Changed

package/Killeros.ts

@@ -1,27 +1,32 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { registerAliases, registerSlashAutocomplete } from "./killeros/commands.ts";
 import { registerConcisePrompt } from "./killeros/concise.ts";
-import { registerContextCompaction } from "./killeros/context-compaction.ts";
 import { registerFooter } from "./killeros/footer.ts";
 import { registerGoal, registerGoalSettlement } from "./killeros/goals.ts";
 import { registerLifecycleHooks } from "./killeros/hooks.ts";
 import { registerInitCommand, registerInitSettlement } from "./killeros/init.ts";
+import {
+  registerCompletionNotifications,
+  type CompletionNotificationDependencies,
+} from "./killeros/notifications.ts";
 import { registerPersonalInstructions } from "./killeros/personal-instructions.ts";
 import { registerQuestionTool } from "./killeros/question.ts";
-import { createCompactionRuntime, createGoalRuntime, createInitRuntime } from "./killeros/runtime.ts";
+import { createGoalRuntime, createInitRuntime } from "./killeros/runtime.ts";
 import { registerShellUi } from "./killeros/shell-ui.ts";
 import { registerVariants } from "./killeros/variants.ts";
 
 export { CONCISE_SYSTEM_PROMPT, isConcisedEnabled } from "./killeros/concise.ts";
-export { contextPercentRemaining } from "./killeros/context-compaction.ts";
-export { formatCost, formatContextProgress } from "./killeros/footer.ts";
+export { contextPercentRemaining, formatCost, formatContextProgress } from "./killeros/footer.ts";
 export { executeHook } from "./killeros/hooks.ts";
 export { INIT_WORKFLOW_PROMPT, writeInitAgentsFile } from "./killeros/init.ts";
 
-export default function Killeros(pi: ExtensionAPI): void {
+export interface KillerosOptions {
+  completionNotifications?: CompletionNotificationDependencies;
+}
+
+export default function Killeros(pi: ExtensionAPI, options: KillerosOptions = {}): void {
   const initRuntime = createInitRuntime();
   const goalRuntime = createGoalRuntime();
-  const compactionRuntime = createCompactionRuntime();
   registerShellUi(pi);
   registerConcisePrompt(pi);
   registerGoal(pi, goalRuntime, initRuntime);
@@ -33,7 +38,7 @@ export default function Killeros(pi: ExtensionAPI): void {
   registerVariants(pi);
   registerInitCommand(pi, initRuntime, goalRuntime);
   registerLifecycleHooks(pi);
-  registerContextCompaction(pi, compactionRuntime, goalRuntime);
-  registerGoalSettlement(pi, goalRuntime, initRuntime, compactionRuntime);
+  registerGoalSettlement(pi, goalRuntime, initRuntime);
   registerInitSettlement(pi, initRuntime);
+  registerCompletionNotifications(pi, options.completionNotifications);
 }

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.2
+pi install git:github.com/KyrosHendrix/pi-KillerOS@v2.0.3
 ```
 
 Add `-l` to either command for a project-only install. Restart Pi after installing.
@@ -43,7 +43,8 @@ Add `-l` to either command for a project-only install. Restart Pi after installi
 - 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 live command-blue highlighting for recognized slash command prefixes
 - 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
-- Automatic model-backed context compaction at 40% remaining; active goals continue after the saved summary
+- 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
 - Claude Code-style `/init` that scans the repository and generates a concise root `AGENTS.md` without setup questions
@@ -64,6 +65,7 @@ Add `-l` to either command for a project-only install. Restart Pi after installi
 /goal clear               Remove the current goal
 /variants                 Open the reasoning-level selector
 /variants high            Set a reasoning level directly
+/notification             Configure the completion sound
 /clear                    Start a new session after confirmation
 /exit                     Quit Pi gracefully
 ```
@@ -78,9 +80,13 @@ Supported reasoning levels are `off`, `minimal`, `low`, `medium`, `high`, `xhigh
 
 KillerOS activates its packaged `killeros` theme when a TUI session starts. Tool-call backgrounds stay neutral across pending, successful, and failed states; restrained text and icons preserve status visibility.
 
-KillerOS displays session costs in USD. The footer uses Pi's human-readable model name when available, keeps the provider visually secondary, and renders context as `percent left (tokens)` without a progress bar. Active, paused, and blocked goals remain visible; completed goals remain in transcript history and `/goal` status rather than the footer. At narrow widths, context pressure and actionable goal state take priority.
+The completion sound is a global user preference stored in Pi's agent directory and is off by default. Run `/notification` in TUI mode to enable or disable it; enabling does not play a preview. Enabled TUI tabs append `󰂚`, which requires a Nerd Font in the terminal tab UI. An unsupported font may show a box without affecting sound. KillerOS uses the terminal's audible bell and cannot produce sound when the terminal disables it.
 
-KillerOS checks context after each agent turn. At 40% remaining, it starts Pi's model-backed compaction after the current run settles, so the active turn is not aborted. Manual `/compact` uses the same model path and keeps custom focus instructions. If model compaction is unavailable or exhausts its retries, KillerOS uses the disclosed deterministic fallback and warns that repeated compaction can reduce accuracy.
+KillerOS displays session costs in USD. The footer uses Pi's human-readable model name when available, keeps the provider visually secondary, and renders context as `percent left (tokens)` without a progress bar. An active goal replaces the right-side path with warning-yellow `/goal is active (...)` and keeps exact seconds in minute and hour formats. Paused and blocked goals retain their existing placement; completed goals remain in transcript history and `/goal` status rather than the footer. At narrow widths, context pressure and actionable goal state take priority.
+
+Pi decides when compaction runs and Pi writes the summary, applies manual focus instructions, tracks files, retries summarization, and handles overflow recovery. KillerOS does not add a second threshold or replace Pi's summary. Active `/goal` work continues from Pi's settled boundary, after Pi finishes retries, compaction, and queued work.
+
+Manual `/compact` aborts the current goal turn before summarization, so KillerOS records an honest temporary pause for that exact goal revision. After Pi saves the manual summary, KillerOS resumes that revision automatically. A failed or cancelled manual compaction stays paused; run `/goal pause` during the pause to cancel automatic recovery.
 
 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.
 
@@ -90,9 +96,9 @@ Lifecycle hooks are loaded from `.pi/killeros-hooks.json` at session start. Supp
 
 | Mode | Behavior |
 |---|---|
-| TUI | All features are available |
-| RPC | Goal set/view/pause/resume/clear and concise prompt guidance work; TUI components, `/goal edit`, and `/init` are disabled |
-| Print/JSON | Concise prompt guidance works; interactive questions, `/goal`, and `/init` fail explicitly |
+| TUI | All features are available, including the completion sound and tab-title indicator |
+| RPC | Goal set/view/pause/resume/clear and concise prompt guidance work; TUI components, `/goal edit`, `/init`, completion sounds, and the title indicator are disabled |
+| Print/JSON | Concise prompt guidance works; interactive questions, `/goal`, and `/init` fail explicitly; completion sounds and the title indicator are disabled |
 
 ## Validation
 

package/killeros/footer.ts

@@ -12,6 +12,20 @@ export function formatCost(usd: number): string {
   return `$${usd.toFixed(2)}`;
 }
 
+export function contextPercentRemaining(ctx: ExtensionContext): number | null {
+  let usage: ReturnType<ExtensionContext["getContextUsage"]>;
+  try {
+    usage = ctx.getContextUsage();
+  } catch {
+    return null;
+  }
+  if (!usage || !Number.isFinite(usage.contextWindow) || usage.contextWindow <= 0) return null;
+  if (usage.tokens === null || !Number.isFinite(usage.tokens)) return null;
+
+  const percentRemaining = ((usage.contextWindow - Math.max(0, usage.tokens)) / usage.contextWindow) * 100;
+  return Math.round(Math.max(0, Math.min(100, percentRemaining)));
+}
+
 export function formatContextProgress(tokensUsed: number | null, contextWindow: number, theme: Theme): string {
   if (tokensUsed === null || !Number.isFinite(tokensUsed)) return theme.fg("dim", "—% left (—)");
   const windowSize = Number.isFinite(contextWindow) && contextWindow > 0 ? contextWindow : 128_000;
@@ -111,9 +125,26 @@ function renderFooterRow(left: string, right: string, width: number): string {
   return ` ${clippedLeft}${gap}${clippedRight} `;
 }
 
+function formatGoalElapsed(milliseconds: number): string {
+  const totalSeconds = Number.isFinite(milliseconds) ? Math.max(0, Math.floor(milliseconds / 1_000)) : 0;
+  if (totalSeconds < 60) return `${totalSeconds}s`;
+
+  const seconds = totalSeconds % 60;
+  const totalMinutes = Math.floor(totalSeconds / 60);
+  if (totalMinutes < 60) return `${totalMinutes}m ${seconds.toString().padStart(2, "0")}s`;
+
+  const hours = Math.floor(totalMinutes / 60);
+  const minutes = totalMinutes % 60;
+  return `${hours}h ${minutes.toString().padStart(2, "0")}m ${seconds.toString().padStart(2, "0")}s`;
+}
+
+function formatActiveGoalFooter(state: GoalState | undefined, theme: Theme): string {
+  if (state?.status !== "active") return "";
+  return theme.fg("warning", `/goal is active (${formatGoalElapsed(goalElapsedMilliseconds(state))})`);
+}
+
 function formatGoalFooter(state: GoalState | undefined, theme: Theme): string {
   if (!state) return "";
-  if (state.status === "active") return theme.fg("accent", `✻ goal · ${formatTime(goalElapsedMilliseconds(state))}`);
   if (state.status === "paused") return theme.fg("warning", "Ⅱ goal paused");
   if (state.status === "blocked") return theme.fg("error", "! goal blocked");
   return "";
@@ -180,6 +211,7 @@ export function registerFooter(pi: ExtensionAPI, goalRuntime: GoalRuntime): void
           const signature = formatModel(model, theme);
           const fullDirectory = theme.fg("dim", cwd);
           const focusedDirectory = theme.fg("dim", compactDirectory(cwd));
+          const activeGoal = formatActiveGoalFooter(goalRuntime.state, theme);
           const goal = formatGoalFooter(goalRuntime.state, theme);
           const rich = joinFooterParts([
             signature,
@@ -192,6 +224,19 @@ export function registerFooter(pi: ExtensionAPI, goalRuntime: GoalRuntime): void
           ], theme);
           const focused = joinFooterParts([signature, context, goal], theme);
 
+          if (activeGoal) {
+            if (footerRowFits(rich, activeGoal, width)) {
+              return [renderFooterRow(rich, activeGoal, width)];
+            }
+            if (footerRowFits(focused, activeGoal, width)) {
+              return [renderFooterRow(focused, activeGoal, width)];
+            }
+            if (footerRowFits(context, activeGoal, width)) {
+              return [renderFooterRow(context, activeGoal, width)];
+            }
+            return [renderFooterRow("", activeGoal, width)];
+          }
+
           if (footerRowFits(rich, fullDirectory, width)) {
             return [renderFooterRow(rich, fullDirectory, width)];
           }

package/killeros/goals.ts

@@ -7,7 +7,7 @@ import { CONCISE_SYSTEM_PROMPT } from "./concise.ts";
 import { formatTime, formatTokens } from "./display.ts";
 import { reportError } from "./errors.ts";
 import { resolvePersonalInstructions } from "./personal-instructions.ts";
-import type { CompactionRuntime, GoalRuntime, GoalState, GoalStatus, InitRuntime } from "./runtime.ts";
+import type { GoalRuntime, GoalState, GoalStatus, InitRuntime } from "./runtime.ts";
 
 const GOAL_ENTRY_TYPE = "killeros-goal";
 const GOAL_CONTINUATION_TYPE = "killeros-goal-continuation";
@@ -21,6 +21,16 @@ interface GoalEntryData {
   state: GoalState | null;
 }
 
+interface GoalTransitionOptions {
+  resetBlockedAudit?: boolean;
+  resumeAfterManualCompaction?: true;
+}
+
+interface RestoredGoalState {
+  state?: GoalState;
+  recoveryProven: boolean;
+}
+
 const GoalUpdateParams = Type.Object({
   status: Type.Union([Type.Literal("complete"), Type.Literal("blocked")], {
     description: "Mark the active goal complete or blocked",
@@ -61,7 +71,9 @@ function parseGoalState(value: unknown): GoalState | undefined {
       && (!Number.isInteger(candidate.blockedAuditStartTurn) || candidate.blockedAuditStartTurn < 0 || candidate.blockedAuditStartTurn > candidate.turns!)
     || !finiteNonNegative(candidate.baselineTokens)
     || candidate.activeStartedAt !== undefined && !finiteNonNegative(candidate.activeStartedAt)
-    || candidate.result !== undefined && typeof candidate.result !== "string") {
+    || candidate.result !== undefined && typeof candidate.result !== "string"
+    || candidate.resumeAfterManualCompaction !== undefined && candidate.resumeAfterManualCompaction !== true
+    || candidate.resumeAfterManualCompaction === true && candidate.status !== "paused") {
     return undefined;
   }
   return {
@@ -77,6 +89,7 @@ function parseGoalState(value: unknown): GoalState | undefined {
     blockedAuditStartTurn: candidate.blockedAuditStartTurn ?? 0,
     baselineTokens: candidate.baselineTokens,
     result: candidate.result,
+    resumeAfterManualCompaction: candidate.resumeAfterManualCompaction,
   };
 }
 
@@ -88,21 +101,26 @@ function goalBranchEntries(ctx: ExtensionContext): ReturnType<ExtensionContext["
   }
 }
 
-function restoreGoalState(ctx: ExtensionContext): GoalState | undefined {
+function restoreGoalState(ctx: ExtensionContext): RestoredGoalState {
   const entries = goalBranchEntries(ctx);
   for (let index = entries.length - 1; index >= 0; index -= 1) {
     const entry = entries[index];
     if (entry?.type !== "custom" || entry.customType !== GOAL_ENTRY_TYPE) continue;
     const data = entry.data as Partial<GoalEntryData> | undefined;
-    if (!data || data.version !== GOAL_VERSION) return undefined;
-    if (data.state === null) return undefined;
+    if (!data || data.version !== GOAL_VERSION || data.state === null) {
+      return { state: undefined, recoveryProven: false };
+    }
     const restored = parseGoalState(data.state);
-    if (!restored) return undefined;
-    return restored.status === "active"
+    if (!restored) return { state: undefined, recoveryProven: false };
+    const state = restored.status === "active"
       ? { ...restored, activeStartedAt: Date.now() }
       : { ...restored, activeStartedAt: undefined };
+    const recoveryProven = state.status === "paused"
+      && state.resumeAfterManualCompaction === true
+      && entries.slice(index + 1).some((candidate) => candidate.type === "compaction");
+    return { state, recoveryProven };
   }
-  return undefined;
+  return { state: undefined, recoveryProven: false };
 }
 
 export function goalElapsedMilliseconds(state: GoalState, now = Date.now()): number {
@@ -152,7 +170,7 @@ function transitionGoal(
   event: GoalEntryEvent,
   status: GoalStatus,
   result?: string,
-  resetBlockedAudit = false,
+  options: GoalTransitionOptions = {},
 ): GoalState {
   const current = runtime.state;
   if (!current) throw new Error("No goal is set");
@@ -164,8 +182,9 @@ function transitionGoal(
     status,
     updatedAt: now,
     activeStartedAt: status === "active" ? now : undefined,
-    blockedAuditStartTurn: resetBlockedAudit ? stopped.turns : stopped.blockedAuditStartTurn,
+    blockedAuditStartTurn: options.resetBlockedAudit ? stopped.turns : stopped.blockedAuditStartTurn,
     result,
+    resumeAfterManualCompaction: options.resumeAfterManualCompaction,
   };
   persistGoalState(pi, runtime, event, next);
   if (status !== "active") runtime.continuationScheduled = false;
@@ -209,7 +228,12 @@ export function pauseGoalAfterFailure(
   try {
     transitionGoal(pi, runtime, "error", "paused", reason);
   } catch {
-    runtime.state = runtime.state ? { ...stopGoalClock(runtime.state, Date.now()), status: "paused", result: reason } : undefined;
+    runtime.state = runtime.state ? {
+      ...stopGoalClock(runtime.state, Date.now()),
+      status: "paused",
+      result: reason,
+      resumeAfterManualCompaction: undefined,
+    } : undefined;
     runtime.persistenceRetryNeeded = true;
     runtime.continuationScheduled = false;
     runtime.requestRender?.();
@@ -217,6 +241,56 @@ export function pauseGoalAfterFailure(
   ctx.ui.notify(`Goal paused: ${reason}\n${recoveryInstruction}`, "error");
 }
 
+function pauseGoalForPossibleManualCompaction(
+  pi: ExtensionAPI,
+  runtime: GoalRuntime,
+  ctx: ExtensionContext,
+  reason: string,
+): void {
+  if (runtime.state?.status !== "active") return;
+  try {
+    transitionGoal(pi, runtime, "error", "paused", reason, {
+      resumeAfterManualCompaction: true,
+    });
+  } catch {
+    runtime.state = runtime.state ? {
+      ...stopGoalClock(runtime.state, Date.now()),
+      status: "paused",
+      result: reason,
+      resumeAfterManualCompaction: true,
+    } : undefined;
+    runtime.persistenceRetryNeeded = true;
+    runtime.continuationScheduled = false;
+    runtime.requestRender?.();
+  }
+  ctx.ui.notify(
+    "Goal paused because the turn was aborted. If /compact is running, KillerOS will resume after Pi saves the summary. Run /goal pause to keep it paused.",
+    "warning",
+  );
+}
+
+function recoverGoalAfterManualCompaction(
+  pi: ExtensionAPI,
+  runtime: GoalRuntime,
+  initState: InitRuntime,
+  ctx: ExtensionContext,
+): boolean {
+  if (runtime.state?.status !== "paused"
+    || runtime.state.resumeAfterManualCompaction !== true
+    || initState.active) return false;
+  try {
+    transitionGoal(pi, runtime, "resume", "active", undefined, { resetBlockedAudit: true });
+  } catch (error) {
+    runtime.persistenceRetryNeeded = true;
+    reportError(ctx, "Manual compaction succeeded, but the goal could not be resumed", error);
+    return false;
+  }
+  runtime.continuationScheduled = false;
+  ctx.ui.notify("Manual compaction complete. Goal resumed.", "info");
+  setImmediate(() => scheduleGoalContinuation(pi, runtime, initState, ctx));
+  return true;
+}
+
 function scheduleGoalContinuation(
   pi: ExtensionAPI,
   runtime: GoalRuntime,
@@ -259,6 +333,8 @@ function goalInstructions(state: GoalState, heading: string): string {
     "Objective:",
     state.objective,
     "",
+    "Treat the exact objective above from /goal as authoritative; a compaction summary may describe it but does not replace it.",
+    "If the current context contains a compaction summary, take its first concrete next step after checking the current repository state.",
     "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.",
@@ -354,37 +430,26 @@ export function registerGoal(
     },
   });
 
-  pi.on("session_start", (_event, ctx) => {
-    runtime.state = restoreGoalState(ctx);
+  const restoreGoal = (ctx: ExtensionContext): void => {
+    const restored = restoreGoalState(ctx);
+    runtime.state = restored.state;
     runtime.continuationScheduled = false;
     runtime.continuationHeld = false;
-    runtime.continuationHeldForCompaction = false;
     runtime.goalTurnInFlight = false;
     runtime.agentEndObserved = false;
     runtime.persistenceRetryNeeded = false;
     runtime.lastStopReason = undefined;
     runtime.lastError = undefined;
     runtime.requestRender?.();
-    if (runtime.state?.status === "active") {
+    if (restored.recoveryProven) {
+      recoverGoalAfterManualCompaction(pi, runtime, initState, ctx);
+    } else if (runtime.state?.status === "active") {
       setImmediate(() => scheduleGoalContinuation(pi, runtime, initState, ctx));
     }
-  });
+  };
 
-  pi.on("session_tree", (_event, ctx) => {
-    runtime.state = restoreGoalState(ctx);
-    runtime.continuationScheduled = false;
-    runtime.continuationHeld = false;
-    runtime.continuationHeldForCompaction = false;
-    runtime.goalTurnInFlight = false;
-    runtime.agentEndObserved = false;
-    runtime.persistenceRetryNeeded = false;
-    runtime.lastStopReason = undefined;
-    runtime.lastError = undefined;
-    runtime.requestRender?.();
-    if (runtime.state?.status === "active") {
-      setImmediate(() => scheduleGoalContinuation(pi, runtime, initState, ctx));
-    }
-  });
+  pi.on("session_start", (_event, ctx) => restoreGoal(ctx));
+  pi.on("session_tree", (_event, ctx) => restoreGoal(ctx));
 
   pi.on("session_shutdown", (_event, ctx) => {
     if (runtime.state?.status === "active") {
@@ -403,7 +468,6 @@ export function registerGoal(
     runtime.state = undefined;
     runtime.continuationScheduled = false;
     runtime.continuationHeld = false;
-    runtime.continuationHeldForCompaction = false;
     runtime.goalTurnInFlight = false;
     runtime.agentEndObserved = false;
     runtime.persistenceRetryNeeded = false;
@@ -423,6 +487,7 @@ export function registerGoal(
       turns: current.turns + 1,
       updatedAt: now,
       activeStartedAt: current.activeStartedAt ?? now,
+      resumeAfterManualCompaction: undefined,
     };
     try {
       persistGoalState(pi, runtime, "turn", next);
@@ -507,7 +572,7 @@ export function registerGoal(
           return;
         }
         if (runtime.state.status === "paused") {
-          if (!runtime.persistenceRetryNeeded) {
+          if (!runtime.persistenceRetryNeeded && runtime.state.resumeAfterManualCompaction !== true) {
             ctx.ui.notify("Goal is already paused", "info");
             return;
           }
@@ -516,11 +581,16 @@ export function registerGoal(
             ...runtime.state,
             revision: runtime.state.revision + 1,
             updatedAt: now,
+            resumeAfterManualCompaction: undefined,
           };
           try {
             persistGoalState(pi, runtime, "pause", checkpoint);
-            ctx.ui.notify("Goal pause saved", "info");
+            ctx.ui.notify("Goal pause saved. Goal remains paused. Automatic compaction recovery is off.", "info");
           } catch (error) {
+            runtime.state = checkpoint;
+            runtime.persistenceRetryNeeded = true;
+            runtime.continuationScheduled = false;
+            runtime.requestRender?.();
             reportError(ctx, "Goal pause still could not be saved", error);
           }
           return;
@@ -562,7 +632,7 @@ export function registerGoal(
           return;
         }
         try {
-          transitionGoal(pi, runtime, "resume", "active", undefined, true);
+          transitionGoal(pi, runtime, "resume", "active", undefined, { resetBlockedAudit: true });
           runtime.continuationScheduled = false;
           if (scheduleGoalContinuation(pi, runtime, initState, ctx)) ctx.ui.notify("Goal resumed", "info");
         } catch (error) {
@@ -620,6 +690,7 @@ export function registerGoal(
           activeStartedAt: now,
           blockedAuditStartTurn: current.turns,
           result: undefined,
+          resumeAfterManualCompaction: undefined,
         };
         try {
           persistGoalState(pi, runtime, "edit", next);
@@ -720,7 +791,6 @@ export function registerGoalSettlement(
   pi: ExtensionAPI,
   runtime: GoalRuntime,
   initState: InitRuntime,
-  compactionRuntime?: CompactionRuntime,
 ): void {
   pi.on("agent_settled", (_event, ctx) => {
     const wasGoalTurn = runtime.goalTurnInFlight;
@@ -739,17 +809,18 @@ export function registerGoalSettlement(
       pauseGoalAfterFailure(pi, runtime, ctx, "the goal turn ended without an agent result");
       return;
     }
-    if (runtime.lastStopReason === "error" || runtime.lastStopReason === "aborted") {
-      const reason = runtime.lastError || (runtime.lastStopReason === "aborted" ? "the agent turn was aborted" : "the agent turn failed");
+    if (runtime.lastStopReason === "aborted") {
+      const reason = runtime.lastError || "the agent turn was aborted";
       runtime.lastStopReason = undefined;
       runtime.lastError = undefined;
-      pauseGoalAfterFailure(pi, runtime, ctx, reason);
+      pauseGoalForPossibleManualCompaction(pi, runtime, ctx, reason);
       return;
     }
-    if (compactionRuntime?.compactionInFlight) {
-      runtime.continuationHeld = true;
-      runtime.continuationHeldForCompaction = true;
-      runtime.requestRender?.();
+    if (runtime.lastStopReason === "error") {
+      const reason = runtime.lastError || "the agent turn failed";
+      runtime.lastStopReason = undefined;
+      runtime.lastError = undefined;
+      pauseGoalAfterFailure(pi, runtime, ctx, reason);
       return;
     }
     runtime.lastStopReason = undefined;
@@ -757,16 +828,8 @@ export function registerGoalSettlement(
     scheduleGoalContinuation(pi, runtime, initState, ctx);
   });
 
-  if (compactionRuntime) {
-    pi.on("session_compact", (_event, ctx) => {
-      if (!runtime.continuationHeldForCompaction) return;
-      runtime.continuationHeldForCompaction = false;
-      if (!runtime.continuationHeld || runtime.state?.status !== "active" || initState.active) {
-        runtime.continuationHeld = false;
-        return;
-      }
-      runtime.continuationHeld = false;
-      setImmediate(() => scheduleGoalContinuation(pi, runtime, initState, ctx));
-    });
-  }
+  pi.on("session_compact", (event, ctx) => {
+    if (event.reason !== "manual") return;
+    recoverGoalAfterManualCompaction(pi, runtime, initState, ctx);
+  });
 }