feat(core): fail impossible goals (#4230)

* feat(core): fail impossible goals

* fix(core): refine impossible goal judgement

* fix(core): include goal feedback when continuing

* fix(core): clarify impossible goal terminal state

* fix(core): harden impossible goal feedback

* fix(core): log suppressed impossible verdicts

* fix(goal): address review suggestions

* test(goal): cover impossible parsing suggestions

Author: qqqys

packages/cli/src/ui/commands/goalCommand.test.ts

@@ -326,4 +326,27 @@ describe('goalCommand', () => {
       lastReason: 'Goal max iterations reached',
     });
   });
+
+  it('after impossible failure, empty /goal shows the failed summary', async () => {
+    const ctx = createMockCommandContext({
+      services: { config: makeConfig() as unknown as Config },
+    });
+    await goalCommand.action!(ctx, 'do x');
+    clearActiveGoal('sess-1');
+    notifyGoalTerminal('sess-1', {
+      kind: 'failed',
+      condition: 'do x',
+      iterations: 2,
+      durationMs: 12_000,
+      lastReason: 'the required branch does not exist',
+    });
+
+    const result = await goalCommand.action!(ctx, '');
+    const content = (result as { content: string }).content;
+    expect(content).toMatch(/Goal could not be achieved/);
+    expect(content).toMatch(/2 turns/);
+    expect(content).toMatch(/12s/);
+    expect(content).toMatch(/Goal: do x/);
+    expect(content).toMatch(/Last check: the required branch does not exist/);
+  });
 });

packages/cli/src/ui/commands/goalCommand.ts

@@ -52,12 +52,29 @@ const goalInstructionPrompt = (condition: string): string =>
 
 const formatTurns = (n: number) => `${n} ${n === 1 ? 'turn' : 'turns'}`;
 
+function assertNeverGoalKind(kind: never): never {
+  throw new Error(`Unexpected terminal goal kind: ${kind}`);
+}
+
+function terminalGoalTitle(kind: GoalTerminalEvent['kind']): string {
+  switch (kind) {
+    case 'achieved':
+      return 'Goal achieved';
+    case 'failed':
+      return 'Goal could not be achieved';
+    case 'aborted':
+      return 'Goal aborted';
+    default:
+      return assertNeverGoalKind(kind);
+  }
+}
+
 function formatTerminalSummary(event: GoalTerminalEvent): string {
   // Mirrors GoalStatusMessage: empty-`/goal` after completion surfaces the
   // most recent terminal event, including the judge's `lastReason` (when
-  // present) so this view matches the inline `Goal achieved / aborted`
+  // present) so this view matches the inline terminal
   // history card.
-  const title = event.kind === 'achieved' ? 'Goal achieved' : 'Goal aborted';
+  const title = terminalGoalTitle(event.kind);
   const stats: string[] = [];
   if (event.iterations > 0) stats.push(formatTurns(event.iterations));
   if (typeof event.durationMs === 'number')
@@ -110,9 +127,8 @@ export const goalCommand: SlashCommand = {
           `Goal active: ${active.condition} (${turns})${lastReason}`,
         );
       }
-      // No active goal — surface a summary of the most recent terminal goal
-      // for this session. Only achieved / aborted entries flow through
-      // `getLastGoalTerminal`; user-initiated `/goal clear` does not
+      // No active goal — surface a summary of the most recent automatic
+      // terminal goal for this session. User-initiated `/goal clear` does not
       // populate it.
       const last = getLastGoalTerminal(sessionId);
       if (last) {
@@ -128,7 +144,7 @@ export const goalCommand: SlashCommand = {
     // When an active goal exists, drop the Stop hook and emit a `cleared`
     // history sentinel. When no active goal exists, this is a no-op that just
     // returns "No goal set." The cached terminal summary is left intact so a
-    // later empty `/goal` can still show the latest achieved/aborted state.
+    // later empty `/goal` can still show the latest automatic terminal state.
     if (CLEAR_KEYWORDS.has(q.toLowerCase())) {
       const cleared = unregisterGoalHook(config, sessionId);
       if (!cleared) {

packages/cli/src/ui/components/messages/GoalStatusMessage.test.tsx

@@ -9,6 +9,12 @@ import { describe, expect, it } from 'vitest';
 import { GoalStatusMessage } from './GoalStatusMessage.js';
 
 describe('<GoalStatusMessage />', () => {
+  it('is wrapped in React.memo to avoid unnecessary scrollback rerenders', () => {
+    expect(
+      (GoalStatusMessage as unknown as { $$typeof?: symbol }).$$typeof,
+    ).toBe(Symbol.for('react.memo'));
+  });
+
   it('shows the goal and judge reason on checking cards', () => {
     const { lastFrame } = render(
       <GoalStatusMessage
@@ -25,4 +31,23 @@ describe('<GoalStatusMessage />', () => {
     expect(output).toContain('Goal: finish the refactor');
     expect(output).toContain('Judge: tests are still failing');
   });
+
+  it('shows impossible goals as failed terminal cards', () => {
+    const { lastFrame } = render(
+      <GoalStatusMessage
+        kind="failed"
+        condition="merge a nonexistent branch"
+        iterations={2}
+        durationMs={12_000}
+        lastReason="the remote branch does not exist"
+      />,
+    );
+
+    const output = lastFrame();
+    expect(output).toContain('✖');
+    expect(output).toContain('Goal could not be achieved');
+    expect(output).toContain('2 turns');
+    expect(output).toContain('Goal: merge a nonexistent branch');
+    expect(output).toContain('Last check: the remote branch does not exist');
+  });
 });

packages/cli/src/ui/components/messages/GoalStatusMessage.tsx

@@ -4,11 +4,11 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import type React from 'react';
+import React from 'react';
 import { Box, Text } from 'ink';
 import { theme } from '../../semantic-colors.js';
 import { formatDuration } from '../../utils/formatters.js';
-import type { GoalStatusKind } from '../../types.js';
+import { isTerminalGoalStatusKind, type GoalStatusKind } from '../../types.js';
 
 interface GoalStatusMessageProps {
   kind: GoalStatusKind;
@@ -20,7 +20,11 @@ interface GoalStatusMessageProps {
 
 const pluralTurns = (n: number) => (n === 1 ? 'turn' : 'turns');
 
-export const GoalStatusMessage: React.FC<GoalStatusMessageProps> = ({
+function assertNeverGoalStatusKind(kind: never): never {
+  throw new Error(`Unexpected goal status kind: ${kind}`);
+}
+
+const GoalStatusMessageInternal: React.FC<GoalStatusMessageProps> = ({
   kind,
   condition,
   iterations,
@@ -81,13 +85,20 @@ export const GoalStatusMessage: React.FC<GoalStatusMessageProps> = ({
           prefixColor: theme.text.secondary,
           title: 'Goal cleared',
         };
+      case 'failed':
+        return {
+          prefix: '✖',
+          prefixColor: theme.status.error,
+          title: 'Goal could not be achieved',
+        };
       case 'aborted':
-      default:
         return {
           prefix: '!',
           prefixColor: theme.status.warning,
           title: 'Goal aborted',
         };
+      default:
+        return assertNeverGoalStatusKind(kind);
     }
   })();
 
@@ -126,7 +137,8 @@ export const GoalStatusMessage: React.FC<GoalStatusMessageProps> = ({
             <Text wrap="wrap">{condition}</Text>
           </Box>
         </Box>
-        {/* `lastReason` is shown on terminal cards (achieved / aborted) so
+        {/* `lastReason` is shown on terminal cards (achieved / aborted /
+            failed) so
             the final summary records *why* the judge ruled the goal complete
             or why the loop gave up. Skipped for `cleared` because user-driven
             clears don't carry a judge reason.
@@ -136,7 +148,7 @@ export const GoalStatusMessage: React.FC<GoalStatusMessageProps> = ({
             flex-row variant hangs the continuation at the value column's
             left edge (≈12 cols of empty space, easily mistaken for a blank
             line). One Text + natural wrap keeps the continuation flush. */}
-        {(kind === 'achieved' || kind === 'aborted') && lastReason?.trim() ? (
+        {isTerminalGoalStatusKind(kind) && lastReason?.trim() ? (
           <Text color={theme.text.secondary} wrap="wrap">
             Last check: {lastReason.trim()}
           </Text>
@@ -145,3 +157,5 @@ export const GoalStatusMessage: React.FC<GoalStatusMessageProps> = ({
     </Box>
   );
 };
+
+export const GoalStatusMessage = React.memo(GoalStatusMessageInternal);

packages/cli/src/ui/types.ts

@@ -505,9 +505,24 @@ export type GoalStatusKind =
   | 'set'
   | 'achieved'
   | 'cleared'
+  | 'failed'
   | 'aborted'
   | 'checking';
 
+export const TERMINAL_GOAL_STATUS_KINDS = [
+  'achieved',
+  'aborted',
+  'failed',
+] as const satisfies readonly GoalStatusKind[];
+
+export function isTerminalGoalStatusKind(
+  kind: GoalStatusKind,
+): kind is (typeof TERMINAL_GOAL_STATUS_KINDS)[number] {
+  return TERMINAL_GOAL_STATUS_KINDS.includes(
+    kind as (typeof TERMINAL_GOAL_STATUS_KINDS)[number],
+  );
+}
+
 export type HistoryItemGoalStatus = HistoryItemBase & {
   type: 'goal_status';
   kind: GoalStatusKind;

packages/cli/src/ui/utils/restoreGoal.test.ts

@@ -98,6 +98,15 @@ describe('findGoalToRestore', () => {
       ]),
     ).toBeNull();
   });
+
+  it('returns null when last goal_status is failed', () => {
+    expect(
+      findGoalToRestore([
+        goalItem({ kind: 'set', condition: 'do x' }),
+        goalItem({ kind: 'failed', condition: 'do x' }),
+      ]),
+    ).toBeNull();
+  });
 });
 
 describe('restoreGoalFromHistory', () => {
@@ -270,4 +279,21 @@ describe('findLastTerminalGoal', () => {
     expect(result?.kind).toBe('aborted');
     expect(result?.condition).toBe('goal B');
   });
+
+  it('returns failed when it is the most recent terminal', () => {
+    const result = findLastTerminalGoal([
+      goalItem({ kind: 'achieved', condition: 'goal A' }),
+      goalItem({ kind: 'set', condition: 'goal B' }),
+      goalItem({
+        kind: 'failed',
+        condition: 'goal B',
+        lastReason: 'external service unavailable',
+      }),
+    ]);
+    expect(result).toMatchObject({
+      kind: 'failed',
+      condition: 'goal B',
+      lastReason: 'external service unavailable',
+    });
+  });
 });

packages/cli/src/ui/utils/restoreGoal.ts

@@ -13,14 +13,18 @@ import {
   type GoalTerminalEvent,
   type GoalTerminalKind,
 } from '@qwen-code/qwen-code-core';
-import type { HistoryItem, HistoryItemGoalStatus } from '../types.js';
-import { MessageType } from '../types.js';
+import {
+  isTerminalGoalStatusKind,
+  MessageType,
+  type HistoryItem,
+  type HistoryItemGoalStatus,
+} from '../types.js';
 
 /**
  * Finds the most recent `goal_status` history item. Returns the active
  * condition when the latest goal event is non-terminal (`set` or `checking`),
  * or `null` if the last goal_status was terminal/cancelled
- * (achieved / cleared / aborted) or none exists.
+ * (achieved / failed / cleared / aborted) or none exists.
  */
 export function findGoalToRestore(history: HistoryItem[]): string | null {
   for (let i = history.length - 1; i >= 0; i--) {
@@ -35,7 +39,7 @@ export function findGoalToRestore(history: HistoryItem[]): string | null {
 }
 
 /**
- * Finds the most recent terminal (achieved / aborted) goal_status item in
+ * Finds the most recent terminal (achieved / failed / aborted) goal_status item in
  * the transcript. Sentinel-style entries (`set`, `cleared`, `checking`) are
  * SKIPPED — `/goal clear` after an achievement is intentionally a no-op on
  * this scan, matching Claude Code's `yjK` behavior (`if (!K.met || K.sentinel)
@@ -49,7 +53,7 @@ export function findLastTerminalGoal(
     const item = history[i];
     if (item?.type !== MessageType.GOAL_STATUS) continue;
     const goal = item as HistoryItemGoalStatus;
-    if (goal.kind !== 'achieved' && goal.kind !== 'aborted') continue;
+    if (!isTerminalGoalStatusKind(goal.kind)) continue;
     return {
       kind: goal.kind as GoalTerminalKind,
       condition: goal.condition,

packages/core/src/goals/activeGoalStore.ts

@@ -62,15 +62,21 @@ export function __resetActiveGoalStoreForTests(): void {
 // Terminal-state observers
 //
 // The Stop hook callback that drives /goal runs inside core, but the UI cards
-// for "Goal achieved" / "Goal aborted" need to land in CLI history. We bridge
-// the two with a module-scoped observer table that the CLI command populates
-// when it registers the goal and clears when the goal is unregistered.
+// for terminal outcomes need to land in CLI history. We bridge the two with a
+// module-scoped observer table that the CLI command populates when it
+// registers the goal and clears when the goal is unregistered.
 //
 // Observers are fire-and-forget — they MUST NOT throw or block the hook
 // callback; any side effect (e.g. context.ui.addItem) should be guarded.
 // ───────────────────────────────────────────────────────────────────────────
 
-export type GoalTerminalKind = 'achieved' | 'aborted';
+/**
+ * Terminal outcomes for an automatic `/goal` loop:
+ * - `achieved`: the judge found transcript evidence that satisfies the goal.
+ * - `aborted`: the loop stopped at a system safety limit.
+ * - `failed`: the judge found the goal is genuinely impossible this session.
+ */
+export type GoalTerminalKind = 'achieved' | 'aborted' | 'failed';
 
 export interface GoalTerminalEvent {
   kind: GoalTerminalKind;
@@ -119,8 +125,8 @@ export function notifyGoalTerminal(
 // Last-completed-goal cache
 //
 // Empty `/goal` after the active goal is gone should show the most recent
-// actually-finished goal. Only `achieved` and `aborted` qualify (those are
-// the `GoalTerminalKind`s); the user-driven `/goal clear` path emits a
+// actually-finished goal. Automatic terminal states (`achieved`, `aborted`,
+// and `failed`) qualify; the user-driven `/goal clear` path emits a
 // `cleared` history card directly and never flows through this notifier.
 // ───────────────────────────────────────────────────────────────────────────