killeros 2.1.27 → 2.1.29

package/killeros/footer.ts

@@ -1,10 +1,11 @@
 import { execFile } from "node:child_process";
 import { watch } from "node:fs";
+import path from "node:path";
 import { type ExtensionAPI, type ExtensionContext, type Theme, type ThemeColor } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth, visibleWidth, type TUI } from "@earendil-works/pi-tui";
 import { isCodexFastEnabled, subscribeCodexFast } from "./codex-fast-state.ts";
 import { formatCwd, formatTime, modelDisplayName, padRight } from "./display.ts";
-import { PASSIVE_GIT_CONFIG_ARGS, passiveGitCommand, passiveGitEnv, passiveStatusSafetyArgs, samePassiveFilters } from "./passive-git-status.ts";
+import { inspectWorktreeWithoutFilters, passiveGitCommand, passiveGitEnv, type PassiveGitRunner } from "./passive-git-status.ts";
 import { goalElapsedMilliseconds } from "./goal-state.ts";
 import type { GoalRuntime, GoalState } from "./runtime.ts";
 import { safeTerminalText } from "./safe-terminal-text.ts";
@@ -36,26 +37,16 @@ type GitStatusExecutor = (
   callback: (error: Error | null, stdout: string) => void,
 ) => unknown;
 
-/** Resolves changed-file counts with a bounded asynchronous Git status process in a trusted project. */
-export function resolveGitFileChanges(
+/** Resolves changed-file counts without asking Git to inspect worktree content. */
+export async function resolveGitFileChanges(
   cwd: string,
   execute: GitStatusExecutor = execFile,
   trusted = true,
 ): Promise<GitFileChanges | undefined> {
-  if (!trusted) return Promise.resolve(undefined);
-  return new Promise((resolve) => {
-    let gitCommand: string;
-    try {
-      const found = passiveGitCommand(cwd);
-      if (!found) {
-        resolve(undefined);
-        return;
-      }
-      gitCommand = found;
-    } catch {
-      resolve(undefined);
-      return;
-    }
+  if (!trusted) return undefined;
+  try {
+    const gitCommand = passiveGitCommand(cwd);
+    if (!gitCommand) return undefined;
     const options = {
       encoding: "utf8" as const,
       env: passiveGitEnv(),
@@ -63,64 +54,42 @@ export function resolveGitFileChanges(
       timeout: GIT_STATUS_TIMEOUT_MS,
       windowsHide: true as const,
     };
-    const verifyFiltersUnchanged = (before: string, done: (unchanged: boolean) => void): void => {
-      try {
-        execute(gitCommand, ["-C", cwd, ...PASSIVE_GIT_CONFIG_ARGS], options, (error, after) => {
-          done(!error && samePassiveFilters(before, after));
-        });
-      } catch {
-        done(false);
-      }
-    };
-    const runStatus = (config: string, args: string[]): void => {
-      try {
-        execute(gitCommand, args, options, (error, stdout) => {
-          if (error) {
-            resolve(undefined);
-            return;
-          }
-          verifyFiltersUnchanged(config, (unchanged) => {
-            if (!unchanged) {
-              resolve(undefined);
-              return;
-            }
-
-          const changes: GitFileChanges = { modified: 0, added: 0, deleted: 0 };
-          const entries = stdout.split("\0");
-          for (let index = 0; index < entries.length; index += 1) {
-            const entry = entries[index];
-            if (!entry) continue;
-            const status = entry.slice(0, 2);
-            if (status.includes("D")) changes.deleted += 1;
-            else if (status === "??" || status.includes("A")) changes.added += 1;
-            else changes.modified += 1;
-            if (status.includes("R") || status.includes("C")) index += 1;
-          }
-          resolve(changes);
-          });
-        });
-      } catch {
-        resolve(undefined);
-      }
-    };
-
-    try {
-      execute(gitCommand, ["-C", cwd, ...PASSIVE_GIT_CONFIG_ARGS], options, (error, config) => {
-        if (error) {
-          resolve(undefined);
-          return;
-        }
-        const safetyArgs = passiveStatusSafetyArgs(config);
-        if (!safetyArgs) {
-          resolve(undefined);
-          return;
-        }
-        runStatus(config, ["-C", cwd, ...safetyArgs, "status", "--porcelain=v1", "-z", "--untracked-files=all"]);
+    const runAt = (directory: string): PassiveGitRunner => (args) => new Promise((resolve, reject) => {
+      execute(gitCommand, ["-C", directory, ...args], options, (error, stdout) => {
+        if (error) reject(error);
+        else resolve(Buffer.from(stdout));
       });
-    } catch {
-      resolve(undefined);
+    });
+    const initialRunner = runAt(cwd);
+    const root = new TextDecoder("utf-8", { fatal: true }).decode(
+      await initialRunner(["rev-parse", "--path-format=absolute", "--show-toplevel"]),
+    ).trim();
+    if (!path.isAbsolute(root)) return undefined;
+    const snapshot = await inspectWorktreeWithoutFilters(root, runAt(root));
+    const changes: GitFileChanges = { modified: 0, added: 0, deleted: 0 };
+    const deletedObjectIds: string[] = [];
+    const addedObjectIds: string[] = [];
+    for (const file of snapshot.files.values()) {
+      if (!file.mode) {
+        changes.deleted += 1;
+        if (!file.indexMode && file.headObjectId) deletedObjectIds.push(file.headObjectId);
+      } else if (!file.headMode) {
+        changes.added += 1;
+        if (file.indexObjectId) addedObjectIds.push(file.indexObjectId);
+      } else changes.modified += 1;
     }
-  });
+    for (const objectId of deletedObjectIds) {
+      const match = addedObjectIds.indexOf(objectId);
+      if (match < 0) continue;
+      addedObjectIds.splice(match, 1);
+      changes.deleted -= 1;
+      changes.added -= 1;
+      changes.modified += 1;
+    }
+    return changes;
+  } catch {
+    return undefined;
+  }
 }
 
 async function resolveUncommittedFileCount(cwd: string): Promise<number | undefined> {
@@ -383,11 +352,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) {