killeros 2.1.27 → 2.1.28

package/CHANGELOG.md

@@ -4,6 +4,24 @@ All notable changes to KillerOS are documented here.
 
 ## [Unreleased]
 
+## [2.1.28] - 2026-09-15
+
+### Changed
+
+- Simplified goal presentation without changing goal behavior: transcript history shows one iconless event row per lifecycle change (`Goal started`, `Goal replaced`, `Goal paused`, `Goal resumed`, `Goal cleared`), progress and blocker outcomes render once through the goal tool result, the footer shows compact `/goal active · 1/20 · 10s` status, the `/goal` panel leads with status then objective then `Pause goal` / `Resume goal` / `Clear goal` actions, and duplicate TUI success notifications are suppressed while RPC confirmations remain. Active-goal labels use muted teal `#6FAEB2` through the packaged theme's extension-label role.
+- Removed the legacy `✻` marker from version-1 `Worked for …` transcript rows; stored entries are unchanged and remain readable.
+
+### Added
+
+- Appended the selected model ID as a gray `· <model-id>` suffix to every TUI activity working message, retained for the full request cycle and falling back to `unknown model` when no usable ID exists.
+
+### Fixed
+
+- Kept resumed blocked goals and goals paused by truncated provider errors readable after reload.
+- Made goal continuation explicit: each settled turn now needs one accepted `continue`, `complete`, or blocker decision. Missing decisions, repeated continuation reports, unavailable goal tools, and runtime failures pause without scheduling another turn; compaction recovery resumes the same logical turn.
+- Preserved accepted goal decisions across automatic compaction: a `continue` or blocker audit recorded before compaction now authorizes exactly one next turn instead of being discarded and re-decided. Duplicate compaction and settlement callbacks cannot start a second turn.
+- Scoped goal pause reasons to the current paused state: resume and manual pause no longer surface an earlier automatic reason, terminal states keep no pause reason, and contradictory persisted states fail closed instead of starting automatic work.
+
 ## [2.1.27] - 2026-09-12
 
 ### Added

package/README.md

@@ -5,7 +5,7 @@ A TypeScript extension for the [Pi coding agent](https://github.com/earendil-wor
 ## What you get
 
 - A custom TUI: startup masthead with versions, model, working directory, and Git branch; a dark theme with coral accents; a multiline editor with slash-command completion; a footer that tracks model, context, and goal state; settled task receipts with duration and token usage.
-- `/goal`: set an objective and Pi keeps working toward it across turns, compaction, reloads, and branch navigation. New goals pause after 20 turns; `/goal resume` grants another 20.
+- `/goal`: set an objective and Pi keeps working toward it across turns, compaction, reloads, and branch navigation. Each turn must record `continue` with evidence and one next action, `complete`, or the existing blocker decision; otherwise the goal pauses. New goals pause after 20 turns; `/goal resume` grants another 20.
 - `/codex-fast`: toggles the `priority` service tier on Codex requests or reports its status.
 - `/handoff`: starts a fresh linked session carrying visible continuation context.
 - Automatic context compaction when remaining tokens drop below 15% of the window (configurable).
@@ -32,7 +32,7 @@ Or from GitHub:
 pi install git:github.com/KyrosHendrix/pi-KillerOS
 ```
 
-Pin a release by appending its tag, for example `@v2.1.27`. Add `-l` to install only for the current project. Restart Pi after installing.
+Pin a release by appending its tag, for example `@v2.1.28`. Add `-l` to install only for the current project. Restart Pi after installing.
 
 ## Commands
 
@@ -85,7 +85,7 @@ A direct quoted file target binds silent file proof:
 /goal Fix `killeros/footer.ts`, verified by npm test
 ```
 
-KillerOS captures the file baseline at goal start and only completes when the file is created or changed. 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. Restored goals keep their persisted limit.
+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. Restored goals keep their persisted limit.
 
 Completion sounds are off by default; change with `/notification` in TUI mode. The tab-title indicator requires a Nerd Font.
 

package/killeros/activity.ts

@@ -1,5 +1,6 @@
 import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth } from "@earendil-works/pi-tui";
+import { modelDisplayName } from "./display.ts";
 
 export type ActivityMessage =
   | { kind: "prompt" }
@@ -12,7 +13,7 @@ function safeToolName(toolName: string): string {
   return truncateToWidth(normalized || "tool", 32, "…");
 }
 
-export function formatActivityMessage(message: ActivityMessage, theme: Theme): string {
+export function formatActivityMessage(message: ActivityMessage, theme: Theme, modelId?: string): string {
   let verb: string;
   let detail: string;
 
@@ -58,38 +59,46 @@ export function formatActivityMessage(message: ActivityMessage, theme: Theme): s
     }
   }
 
-  return `${theme.fg("accent", verb)} ${theme.fg("dim", `(${theme.bold("esc")} to interrupt · ${detail})`)}`;
+  const suffix = modelDisplayName({ id: modelId }) || "unknown model";
+  return `${theme.fg("accent", verb)} ${theme.fg("dim", `(${theme.bold("esc")} to interrupt · ${detail})`)}${theme.fg("dim", ` · ${suffix}`)}`;
 }
 
 export function registerRequestActivity(pi: ExtensionAPI): void {
   let active = false;
+  let activeModel: string | undefined;
+
+  const render = (message: ActivityMessage, ctx: ExtensionContext): void => {
+    ctx.ui.setWorkingMessage(formatActivityMessage(message, ctx.ui.theme, activeModel));
+  };
 
   const clear = (ctx?: ExtensionContext): void => {
+    active = false;
+    activeModel = undefined;
     if (ctx?.mode === "tui") {
       ctx.ui.setWorkingMessage();
     }
-    active = false;
   };
 
   pi.on("agent_start", (_event, ctx) => {
     if (ctx.mode !== "tui") return;
+    if (!active) activeModel = ctx.model?.id;
     active = true;
-    ctx.ui.setWorkingMessage(formatActivityMessage({ kind: "prompt" }, ctx.ui.theme));
+    render({ kind: "prompt" }, ctx);
   });
 
   pi.on("tool_execution_start", (event, ctx) => {
     if (ctx.mode !== "tui" || !active) return;
-    ctx.ui.setWorkingMessage(formatActivityMessage({ kind: "tool", toolName: event.toolName }, ctx.ui.theme));
+    render({ kind: "tool", toolName: event.toolName }, ctx);
   });
 
   pi.on("tool_execution_end", (event, ctx) => {
     if (ctx.mode !== "tui" || !active) return;
-    ctx.ui.setWorkingMessage(formatActivityMessage({ kind: "tool-result", failed: event.isError }, ctx.ui.theme));
+    render({ kind: "tool-result", failed: event.isError }, ctx);
   });
 
   pi.on("message_update", (event, ctx) => {
     if (ctx.mode !== "tui" || !active || event.assistantMessageEvent.type !== "text_start") return;
-    ctx.ui.setWorkingMessage(formatActivityMessage({ kind: "responding" }, ctx.ui.theme));
+    render({ kind: "responding" }, ctx);
   });
 
   pi.on("agent_settled", (_event, ctx) => {

package/killeros/footer.ts

@@ -383,11 +383,13 @@ function renderFooter(rows: string[], width: number, theme: Theme): string[] {
 function formatGoalFooter(state: GoalState | undefined, theme: Theme): string {
   if (!state) return "";
   if (state.status === "active") {
-    const turns = state.maxTurns === undefined ? "" : ` ${state.turns}/${state.maxTurns}`;
-    return theme.fg("warning", `/goal is active${turns} (${formatTime(goalElapsedMilliseconds(state, Date.now()))})`);
+    const detail = state.maxTurns === undefined
+      ? `${state.turns} turn${state.turns === 1 ? "" : "s"} · ${formatTime(goalElapsedMilliseconds(state, Date.now()))}`
+      : `${state.turns}/${state.maxTurns} · ${formatTime(goalElapsedMilliseconds(state, Date.now()))}`;
+    return `${theme.fg("customMessageLabel", "/goal active")}${theme.fg("dim", ` · ${detail}`)}`;
   }
-  if (state.status === "paused") return theme.fg("warning", "/goal is paused");
-  if (state.status === "blocked") return theme.fg("error", "/goal is blocked");
+  if (state.status === "paused") return theme.fg("warning", "/goal paused");
+  if (state.status === "blocked") return theme.fg("error", "/goal blocked");
   return "";
 }
 

package/killeros/goal-interface.ts

@@ -7,19 +7,24 @@ import { formatTime, formatTokens } from "./display.ts";
 import { reportError } from "./errors.ts";
 import { parseGoalCommand } from "./goal-command.ts";
 import { GOAL_ENTRY_TYPE, GOAL_UPDATE_TOOL, isGoalModeSupported, isSavedSession, pauseGoalAfterFailure, persistGoalState, scheduleGoalContinuation, stopGoalRun, sumGoalTokens, syncGoalUpdateTool, transitionGoal, type GoalEntryData } from "./goal-runtime.ts";
-import { checkpointPausedGoalState, createNewGoalState, DEFAULT_GOAL_MAX_TURNS, GOAL_MAX_TURNS, goalElapsedMilliseconds, GOAL_VERSION, inferGoalVerification, parseGoalState, recordGoalBlockerAudit, transitionGoalState, verifyGoalDeliverable } from "./goal-state.ts";
+import { checkpointPausedGoalState, createNewGoalState, DEFAULT_GOAL_MAX_TURNS, GOAL_EVIDENCE_LIMIT, GOAL_MAX_TURNS, goalElapsedMilliseconds, GOAL_VERSION, inferGoalVerification, normalizeGoalText, parseGoalState, recordGoalDecision, transitionGoalState, verifyGoalDeliverable } from "./goal-state.ts";
 import type { GoalRuntime, GoalState, GoalStatus } from "./runtime.ts";
 import { safeTerminalText } from "./safe-terminal-text.ts";
 
 const GoalUpdateParams = Type.Object({
-  status: StringEnum(["complete", "blocked"] as const, {
-    description: "Mark the active goal complete or blocked",
+  status: StringEnum(["complete", "continue", "blocked"] as const, {
+    description: "Record exactly one active-goal decision: complete, continue, or blocked",
   }),
   evidence: Type.String({
     minLength: 1,
-    maxLength: 2_000,
-    description: "Concise evidence that the objective is complete, or the repeated blocker and attempted workarounds",
+    maxLength: GOAL_EVIDENCE_LIMIT,
+    description: "Concrete current-turn evidence for completion, progress, or the repeated blocker",
   }),
+  nextAction: Type.Optional(Type.String({
+    minLength: 1,
+    maxLength: GOAL_EVIDENCE_LIMIT,
+    description: "One concrete action toward the unchanged objective when status is continue",
+  })),
   blockerKey: Type.Optional(Type.String({
     minLength: 1,
     maxLength: 120,
@@ -29,21 +34,18 @@ const GoalUpdateParams = Type.Object({
 });
 
 interface GoalUpdateDetails {
-  status: "complete" | "blocked" | "blocker-audit";
+  status: "complete" | "continue" | "blocked" | "blocker-audit";
   evidence: string;
+  nextAction?: string;
   verification?: "file" | "model-reported";
   blockerKey?: string;
   streak?: number;
 }
 
-function goalStatusLabel(status: GoalStatus): string {
-  return `${status.charAt(0).toUpperCase()}${status.slice(1)}`;
-}
-
 function goalPanelActions(status: GoalStatus): Array<{ label: string; control: "pause" | "resume" | "clear" }> {
-  if (status === "active") return [{ label: "Pause automatic continuation", control: "pause" }, { label: "Clear goal", control: "clear" }];
+  if (status === "active") return [{ label: "Pause goal", control: "pause" }, { label: "Clear goal", control: "clear" }];
   if (status === "paused" || status === "blocked") {
-    return [{ label: "Resume automatic continuation", control: "resume" }, { label: "Clear goal", control: "clear" }];
+    return [{ label: "Resume goal", control: "resume" }, { label: "Clear goal", control: "clear" }];
   }
   return [{ label: "Clear goal", control: "clear" }];
 }
@@ -54,11 +56,33 @@ function goalStatusSummary(state: GoalState, ctx: ExtensionContext): string {
     ? `${state.turns} turn${state.turns === 1 ? "" : "s"}`
     : `${state.turns}/${state.maxTurns} turns`;
   const lines = [
-    `Goal ${goalStatusLabel(state.status).toLowerCase()} · ${turns} · ${formatTime(goalElapsedMilliseconds(state, Date.now()))} · ${formatTokens(usedTokens)} tokens`,
-    ...(state.verification === undefined ? [] : [`Deliverable: ${state.verification.path}`]),
+    `Goal ${state.status} · ${turns} · ${formatTime(goalElapsedMilliseconds(state, Date.now()))} · ${formatTokens(usedTokens)} tokens`,
     state.objective,
+    ...(state.verification === undefined ? [] : [`Deliverable · ${state.verification.path}`]),
   ];
-  if (state.result) lines.push(state.result);
+  const decision = state.turnDecision ?? state.lastDecision;
+  if (decision?.kind === "continue") {
+    lines.push(`Progress · model-reported on turn ${decision.turn}`);
+    lines.push(`Next · ${decision.nextAction}`);
+  } else if (decision?.kind === "blocker-audit") {
+    lines.push(`Blocker audit · ${decision.streak}/3 on turn ${decision.turn}`);
+    lines.push(`Evidence · ${decision.evidence}`);
+  } else if (decision?.kind === "blocked") {
+    lines.push(`Evidence · ${decision.evidence}`);
+  } else if (decision?.kind === "complete") {
+    lines.push(`Completion · ${decision.verification === "file" ? `verified file ${state.verification?.path ?? "deliverable"}` : "model-reported"}`);
+    lines.push(`Evidence · ${decision.evidence}`);
+  }
+  if (state.status === "paused") {
+    lines.push(state.turns === 0 ? "Paused at · before turn 1" : `Paused at · turn ${state.turns}`);
+    const reason = state.stopReason ?? state.result;
+    if (reason) lines.push(`Reason · ${reason}`);
+    if (state.stopReason === "repeated continue report" && state.lastContinueReport) {
+      lines.push(`Repeated turns · ${state.lastContinueReport.turn} and ${state.turns}`);
+    }
+  } else if (state.result && decision?.kind !== "complete" && decision?.kind !== "blocked") {
+    lines.push(`Result · ${state.result}`);
+  }
   return safeTerminalText(lines.join("\n"));
 }
 
@@ -68,24 +92,63 @@ export function registerGoalInterface(
 ): void {
   pi.registerEntryRenderer<GoalEntryData>(GOAL_ENTRY_TYPE, (entry, options, theme) => {
     const data = entry.data;
-    if (!data || data.version !== GOAL_VERSION || data.event === "turn" || data.event === "checkpoint") return undefined;
+    if (!data || data.version !== GOAL_VERSION) return undefined;
     if (data.event === "clear" || data.state === null) return new Text(theme.fg("dim", "Goal cleared"), 0, 0);
+    const event = data.event;
+    if (event !== "set" && event !== "replace" && event !== "pause" && event !== "resume" && event !== "limit" && event !== "error") return undefined;
     const state = parseGoalState(data.state);
     if (!state) return undefined;
-    const icon = state.status === "active" ? "✻" : state.status === "paused" ? "Ⅱ" : state.status === "blocked" ? "!" : "✓";
-    const color: ThemeColor = state.status === "active" ? "accent" : state.status === "paused" ? "warning" : state.status === "blocked" ? "error" : "success";
-    const status = theme.fg(color, `${icon} Goal ${state.status}`);
+    const reason = state.stopReason ?? state.result;
     const objective = safeTerminalText(state.objective);
-    if (!options.expanded) return new BoundedText(`${status}${theme.fg("dim", ` · ${objective}`)}`, 3);
-    const lines = [status, theme.fg("dim", objective)];
-    if (state.result) lines.push(theme.fg("muted", safeTerminalText(state.result)));
+    let label: string;
+    let detail: string;
+    let color: ThemeColor;
+    switch (event) {
+      case "set":
+        label = "Goal started";
+        detail = objective;
+        color = "customMessageLabel";
+        break;
+      case "replace":
+        label = "Goal replaced";
+        detail = objective;
+        color = "customMessageLabel";
+        break;
+      case "resume":
+        label = "Goal resumed";
+        detail = objective;
+        color = "customMessageLabel";
+        break;
+      case "pause":
+        label = "Goal paused";
+        detail = reason ?? objective;
+        color = "warning";
+        break;
+      case "limit":
+        label = "Goal paused";
+        detail = reason ?? "";
+        color = "warning";
+        break;
+      case "error":
+        label = "Goal paused";
+        detail = reason ?? "";
+        color = "error";
+        break;
+    }
+    const safeDetail = safeTerminalText(detail);
+    const status = theme.fg(color, label);
+    if (!options.expanded) {
+      return new BoundedText(safeDetail ? `${status}${theme.fg("dim", " · ")}${safeDetail}` : status, 1);
+    }
+    const lines = [status, objective];
+    if (reason && reason !== objective) lines.push(theme.fg("muted", safeTerminalText(reason)));
     return new BoundedText(lines.join("\n"));
   });
 
   pi.registerTool<typeof GoalUpdateParams, GoalUpdateDetails>({
     name: GOAL_UPDATE_TOOL,
     label: "Goal update",
-    description: "Mark the active KillerOS long-running goal complete after verification, or record the same blocker key on three consecutive goal turns before blocking it.",
+    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.",
     parameters: GoalUpdateParams,
     executionMode: "sequential",
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
@@ -94,42 +157,110 @@ export function registerGoalInterface(
       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");
-      const evidence = params.evidence.trim();
-      if (!evidence) throw new Error("Goal evidence must not be empty");
+      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 (params.status !== "complete" && params.status !== "continue" && params.status !== "blocked") {
+        throw new Error("Goal update status is invalid");
+      }
+      if (typeof params.evidence !== "string") throw new Error("Goal evidence must be text");
+      const evidence = normalizeGoalText(params.evidence, GOAL_EVIDENCE_LIMIT, "Goal evidence");
+
       if (params.status === "complete") {
         if (state.verification) await verifyGoalDeliverable(state.verification);
         signal?.throwIfAborted();
-        if (runtime.state !== state) throw new Error("Goal changed while completion was being verified");
-        const verification = state.verification ? "file" : "model-reported";
-        transitionGoal(pi, runtime, "complete", "complete", evidence, { resetBlockedAudit: true });
-        const safeEvidence = safeTerminalText(evidence);
+        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");
+        const verification: "file" | "model-reported" = state.verification ? "file" : "model-reported";
+        const decision = { kind: "complete" as const, turn: state.turns, evidence, verification };
+        try {
+          transitionGoal(pi, runtime, "complete", "complete", evidence, { resetBlockedAudit: true, decision });
+        } catch (error) {
+          pauseGoalAfterFailure(pi, runtime, ctx, `goal completion could not be saved: ${error instanceof Error ? error.message : String(error)}`);
+          throw error;
+        }
         const text = state.verification
-          ? `Goal verified complete at ${safeTerminalText(state.verification.path)}: ${safeEvidence}`
-          : `Goal marked complete (model-reported): ${safeEvidence}`;
+          ? `Goal verified complete at ${safeTerminalText(state.verification.path)}: ${evidence}`
+          : `Goal marked complete (model-reported): ${evidence}`;
         return {
           content: [{ type: "text", text }],
           details: { status: "complete", evidence, verification },
         };
       }
-      if (!runtime.goalTurnInFlight) throw new Error("A blocker audit can only be recorded during an active KillerOS goal turn");
+
+      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");
+        const previous = state.lastContinueReport;
+        if (previous?.turn === state.turns - 1
+          && previous.evidence === evidence
+          && previous.nextAction === nextAction) {
+          pauseGoalAfterFailure(pi, runtime, ctx, "repeated continue report", "Run /goal resume only after choosing a different next action.", false);
+          ctx.ui.notify(
+            `Goal paused: repeated continue report on turns ${previous.turn} and ${state.turns}\nRun /goal resume only after choosing a different next action.`,
+            "error",
+          );
+          throw new Error("repeated continue report");
+        }
+        const decision = { kind: "continue" as const, turn: state.turns, evidence, nextAction };
+        try {
+          const next = recordGoalDecision(state, decision, Date.now());
+          persistGoalState(pi, runtime, "continue", next);
+          runtime.goalTurn = { turn: next.turns, revision: next.revision };
+        } catch (error) {
+          pauseGoalAfterFailure(pi, runtime, ctx, `goal decision could not be saved: ${error instanceof Error ? error.message : String(error)}`);
+          throw error;
+        }
+        return {
+          content: [{ type: "text", text: `Model-reported progress recorded; the goal remains active: ${evidence}` }],
+          details: { status: "continue", evidence, nextAction },
+        };
+      }
+
       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;
+      if (previous?.lastTurn === state.turns) {
+        throw new Error("Only one goal decision may be accepted per logical goal turn");
+      }
       const consecutive = previous?.key === blockerKey && previous.lastTurn === state.turns - 1;
-      const streak = sameTurn ? previous.streak : consecutive ? previous.streak + 1 : 1;
+      const streak = consecutive ? previous.streak + 1 : 1;
       const blockerAudit = { key: blockerKey, streak, lastTurn: state.turns, evidence };
       if (streak < 3) {
-        const next = recordGoalBlockerAudit(state, blockerAudit, Date.now());
-        persistGoalState(pi, runtime, "blocker-audit", next);
+        const decision = { kind: "blocker-audit" as const, turn: state.turns, blockerKey, streak, evidence };
+        try {
+          const next = {
+            ...recordGoalDecision(state, decision, Date.now()),
+            blockerAudit,
+          };
+          persistGoalState(pi, runtime, "blocker-audit", next);
+          runtime.goalTurn = { turn: next.turns, revision: next.revision };
+        } catch (error) {
+          pauseGoalAfterFailure(pi, runtime, ctx, `blocker decision could not be saved: ${error instanceof Error ? error.message : String(error)}`);
+          throw error;
+        }
         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 });
+      const decision = { kind: "blocked" as const, turn: state.turns, blockerKey, streak: 3 as const, evidence };
+      try {
+        transitionGoal(pi, runtime, "blocked", "blocked", evidence, { blockerAudit, decision });
+      } catch (error) {
+        pauseGoalAfterFailure(pi, runtime, ctx, `blocked decision could not be saved: ${error instanceof Error ? error.message : String(error)}`);
+        throw error;
+      }
       return {
         content: [{ type: "text", text: `Goal marked blocked: ${evidence}` }],
         details: { status: "blocked", evidence, blockerKey, streak },
@@ -142,15 +273,29 @@ export function registerGoalInterface(
       if (context?.isError) {
         const first = result.content[0];
         const message = first?.type === "text" ? safeTerminalText(first.text) : "Goal update failed";
-        return new BoundedText(theme.fg("error", message), options.expanded ? undefined : 3);
+        return new BoundedText(theme.fg("error", message), options.expanded ? undefined : 1);
       }
       const details = result.details;
-      if (!details) return new BoundedText(theme.fg("dim", "Goal updated"));
-      const label = details.status === "complete" ? "✓ Complete" : details.status === "blocked" ? "! Blocked" : `! Blocker audit ${details.streak}/3`;
-      const text = `${theme.fg(details.status === "complete" ? "success" : "warning", label)}${theme.fg("dim", ` · ${safeTerminalText(details.evidence)}`)}`;
-      return new BoundedText(text, options.expanded ? undefined : 3);
+      if (!details || typeof details.evidence !== "string") return new BoundedText(theme.fg("dim", "Goal updated"), options.expanded ? undefined : 1);
+      const label = details.status === "complete"
+        ? "Goal completed"
+        : details.status === "blocked"
+          ? "Goal blocked"
+          : details.status === "continue"
+            ? "Progress recorded"
+            : `Blocker audit ${details.streak}/3`;
+      const color: ThemeColor = details.status === "complete"
+        ? "success"
+        : details.status === "blocked"
+          ? "error"
+          : details.status === "continue"
+            ? "customMessageLabel"
+            : "warning";
+      const text = `${theme.fg(color, label)}${theme.fg("dim", " · ")}${safeTerminalText(details.evidence)}`;
+      return new BoundedText(text, options.expanded ? undefined : 1);
     },
   });
+  syncGoalUpdateTool(pi, runtime);
   const handleGoalCommand = async (args: string, ctx: ExtensionCommandContext): Promise<void> => {
       const command = parseGoalCommand(args);
       if (ctx.mode === "print" || ctx.mode === "json") {
@@ -216,7 +361,7 @@ export function registerGoalInterface(
           return;
         }
         if (saved) {
-          ctx.ui.notify("Goal cleared", "info");
+          if (ctx.mode !== "tui") 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");
         }
@@ -277,7 +422,7 @@ export function registerGoalInterface(
           return;
         }
         if (saved) {
-          ctx.ui.notify("Goal paused. Run /goal resume to continue.", "info");
+          if (ctx.mode !== "tui") 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");
         }
@@ -308,7 +453,7 @@ export function registerGoalInterface(
             const base = transitionGoalState(runtime.state, "active", undefined, { resetBlockedAudit: true }, Date.now());
             persistGoalState(pi, runtime, "resume", { ...base, maxTurns: renewed });
             runtime.continuationScheduled = false;
-            if (scheduleGoalContinuation(pi, runtime, ctx)) ctx.ui.notify("Goal resumed", "info");
+            if (scheduleGoalContinuation(pi, runtime, ctx) && ctx.mode !== "tui") ctx.ui.notify("Goal resumed", "info");
           } catch (error) {
             reportError(ctx, "Goal could not be resumed", error);
           }
@@ -317,7 +462,7 @@ export function registerGoalInterface(
         try {
           transitionGoal(pi, runtime, "resume", "active", undefined, { resetBlockedAudit: true });
           runtime.continuationScheduled = false;
-          if (scheduleGoalContinuation(pi, runtime, ctx)) ctx.ui.notify("Goal resumed", "info");
+          if (scheduleGoalContinuation(pi, runtime, ctx) && ctx.mode !== "tui") ctx.ui.notify("Goal resumed", "info");
         } catch (error) {
           reportError(ctx, "Goal could not be resumed", error);
         }
@@ -375,8 +520,10 @@ export function registerGoalInterface(
           maxTurns: DEFAULT_GOAL_MAX_TURNS,
         });
         persistGoalState(pi, runtime, unfinished ? "replace" : "set", state);
-        if (scheduleGoalContinuation(pi, runtime, ctx)) {
-          ctx.ui.notify("Goal active. KillerOS will continue until completion, a repeated blocker, or pause.", "info");
+        // The replacement supersedes any recovery still parked after waitForIdle().
+        if (unfinished) runtime.automaticCompaction = undefined;
+        if (scheduleGoalContinuation(pi, runtime, ctx) && ctx.mode !== "tui") {
+          ctx.ui.notify(`${unfinished ? "Goal replaced" : "Goal started"}. Each turn must record continue, complete, or a blocker decision before another turn starts.`, "info");
         }
       } catch (error) {
         if (!unfinished) {