fix(core): make the native Agent goal mechanism robust (tools, waiting, budget, judge-failure) (#18016)

Co-authored-by: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>
Co-authored-by: Abhi Aiyer <abhi@mastra.ai>
Co-authored-by: Tyler Barnes <tylerdbarnes@gmail.com>
Co-authored-by: Mastra Code (openai/gpt-5.5) <noreply@mastra.ai>

Author: 5 people

.changeset/goal-judge-robustness.md

@@ -0,0 +1,17 @@
+---
+'@mastra/core': minor
+'mastracode': patch
+---
+
+Made the native Agent goal mechanism robust, restoring behavior that regressed when goal handling moved into core.
+
+- **Tool-capable judges.** Scorer judge configs accept optional `tools`, and the default goal scorer can use them to verify the agent's work against reality instead of grading prose alone. MastraCode wires its read-only workspace tools (`view`, `search_content`, `find_files`, `file_stat`, `lsp_inspect`) into `goal.tools`.
+- **Judge memory restored.** Scorer judge configs accept optional `memory`; goal scoring uses the original MastraCode per-goal judge thread shape and prompt format so repeated evaluations retain prior facts, feedback, and user checkpoints through judge memory.
+- **Tri-state waiting.** The default goal scorer emits `done`/`continue`/`waiting`; a `waiting` decision (only when the goal text explicitly asks to stop for the user) stops the auto-loop but keeps the objective `active` so the next agent turn is still judged — no `/goal resume` needed.
+- **Budget-exhaustion pause.** Reaching `maxRuns` without completing now parks the objective as `paused` with a clear reason, resumable by raising `maxRuns` and reactivating, instead of silently leaving it `active`.
+- **Judge-failure pause (no infinite loop).** Any failure while evaluating the goal — including judge-model/tools resolution, not just the scorer run — pauses the objective and stops the loop, surfacing the cause, rather than re-running the model against a broken judge every turn.
+- **Structured-output retry.** `tryGenerateWithJsonFallback` now retries with `jsonPromptInjection` when the judge resolves without a parseable object (not only on a thrown error), matching the streaming path.
+- **Signal-based feedback.** Goal judge feedback is now injected as a `goal-judge` system-reminder signal instead of an assistant-authored "Completion Check Results" transcript message, so reloads and subsequent model context match the original MastraCode goal loop. Continuation, waiting, paused, and done decisions all persist structured evaluation metadata for replay.
+- **TUI activity/replay fixes.** Goal evaluation chunks close the current assistant message before rendering the judge UI, stream judge activity with useful tool targets, stream partial judge reason text while scoring, replay persisted judge results as judge display components instead of raw Goal reminder text, and correctly persist Esc/Ctrl+C pauses while the judge is running.
+
+The goal evaluation chunk now carries `pausedReason`, `judgeFailed`, `waitingForUser`, `pending` (emitted before scoring starts so consumers can show a loading indicator), and judge `activity` entries including streamed `reason` updates.

mastracode/src/__tests__/index.test.ts

@@ -187,6 +187,7 @@ vi.mock('../agents/tools.js', () => ({
 
 vi.mock('../agents/workspace.js', () => ({
   getDynamicWorkspace: getDynamicWorkspaceMock,
+  getGoalJudgeTools: vi.fn(),
 }));
 
 vi.mock('../auth/storage.js', () => ({

mastracode/src/agents/__tests__/goal-judge-tools.test.ts

@@ -0,0 +1,64 @@
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { RequestContext } from '@mastra/core/request-context';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+vi.mock('../onboarding/settings.js', () => ({
+  loadSettings: () => ({}),
+}));
+vi.mock('../../onboarding/settings.js', () => ({
+  loadSettings: () => ({}),
+}));
+
+afterEach(() => {
+  vi.resetModules();
+});
+
+function createRequestContext(projectPath: string) {
+  const requestContext = new RequestContext();
+  requestContext.set('harness', {
+    modeId: 'build',
+    getState: () => ({
+      projectPath,
+      sandboxAllowedPaths: [],
+    }),
+  });
+  return requestContext;
+}
+
+const READONLY = ['view', 'search_content', 'find_files', 'file_stat', 'lsp_inspect'];
+const MUTATING = ['write_file', 'string_replace_lsp', 'delete_file', 'mkdir', 'ast_smart_edit', 'execute_command'];
+
+describe('getGoalJudgeTools', () => {
+  it('returns only the read-only verification subset of workspace tools', async () => {
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mastracode-goal-judge-tools-'));
+    try {
+      const { getGoalJudgeTools } = await import('../workspace.js');
+      const tools = await getGoalJudgeTools({ requestContext: createRequestContext(tempDir) as any });
+
+      expect(tools).toBeDefined();
+      const names = Object.keys(tools!);
+
+      // Every read-only tool is present.
+      for (const name of READONLY) {
+        expect(names).toContain(name);
+      }
+      // No mutating / command-execution tool leaks into the judge toolset.
+      for (const name of MUTATING) {
+        expect(names).not.toContain(name);
+      }
+    } finally {
+      await fs.rm(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  it('returns undefined when no project path can be resolved (keeps judge text-only)', async () => {
+    const { getGoalJudgeTools } = await import('../workspace.js');
+    // Empty harness state → getDynamicWorkspace throws → resolver returns undefined.
+    const requestContext = new RequestContext();
+    requestContext.set('harness', { modeId: 'build', getState: () => ({}) });
+    const tools = await getGoalJudgeTools({ requestContext: requestContext as any });
+    expect(tools).toBeUndefined();
+  });
+});

mastracode/src/agents/workspace.ts

@@ -2,15 +2,16 @@ import fs, { existsSync } from 'node:fs';
 import os from 'node:os';
 import path, { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import type { ToolsInput } from '@mastra/core/agent';
 import type { HarnessRequestContext } from '@mastra/core/harness';
 import type { Mastra } from '@mastra/core/mastra';
 import type { RequestContext } from '@mastra/core/request-context';
-import { Workspace, LocalFilesystem, LocalSandbox } from '@mastra/core/workspace';
+import { Workspace, LocalFilesystem, LocalSandbox, createWorkspaceTools } from '@mastra/core/workspace';
 import type { LSPConfig, WorkspaceToolsConfig } from '@mastra/core/workspace';
 import { DEFAULT_CONFIG_DIR } from '../constants.js';
 import { loadSettings } from '../onboarding/settings.js';
 import type { MastraCodeState } from '../schema';
-import { TOOL_NAME_OVERRIDES } from '../tool-names.js';
+import { MC_TOOLS, TOOL_NAME_OVERRIDES } from '../tool-names.js';
 
 // =============================================================================
 // Sandbox Environment
@@ -194,3 +195,48 @@ export function getDynamicWorkspace({ requestContext, mastra }: { requestContext
     lsp: lspConfig,
   });
 }
+
+/**
+ * Read-only workspace tools the goal judge is allowed to call to verify the
+ * agent's work. Mirrors the original (pre-native-goal) MastraCode judge, which
+ * could inspect the workspace before deciding `done`/`continue`/`waiting`
+ * instead of grading the assistant's prose alone. Strictly read-only: no write,
+ * edit, delete, mkdir, or command-execution tools.
+ */
+const GOAL_JUDGE_READONLY_TOOLS: readonly string[] = [
+  MC_TOOLS.VIEW,
+  MC_TOOLS.SEARCH_CONTENT,
+  MC_TOOLS.FIND_FILES,
+  MC_TOOLS.FILE_STAT,
+  MC_TOOLS.LSP_INSPECT,
+];
+
+/**
+ * Resolver for the agent's `goal.tools` config. Builds the request's workspace
+ * (same per-request resolution as the agent's own tools) and returns only the
+ * read-only verification subset, remapped to mastracode's tool names (`view`,
+ * `search_content`, etc.). Returns `undefined` when no workspace can be resolved
+ * (e.g. no project path), keeping the default judge text-only rather than
+ * throwing inside the goal step.
+ */
+export async function getGoalJudgeTools({
+  requestContext,
+  mastra,
+}: {
+  requestContext: RequestContext;
+  mastra?: Mastra;
+}): Promise<ToolsInput | undefined> {
+  let workspace: Workspace<LocalFilesystem, LocalSandbox>;
+  try {
+    workspace = getDynamicWorkspace({ requestContext, mastra });
+  } catch {
+    return undefined;
+  }
+
+  const allTools = await createWorkspaceTools(workspace, { requestContext, workspace });
+  const readonly: ToolsInput = {};
+  for (const name of GOAL_JUDGE_READONLY_TOOLS) {
+    if (allTools[name]) readonly[name] = allTools[name];
+  }
+  return Object.keys(readonly).length > 0 ? readonly : undefined;
+}

mastracode/src/index.test.ts

@@ -56,7 +56,7 @@ vi.mock('./agents/subagents/execute.js', () => ({ executeSubagent: {} }));
 vi.mock('./agents/subagents/explore.js', () => ({ exploreSubagent: {} }));
 vi.mock('./agents/subagents/plan.js', () => ({ planSubagent: {} }));
 vi.mock('./agents/tools.js', () => ({ createDynamicTools: vi.fn(), createToolHooks: vi.fn() }));
-vi.mock('./agents/workspace.js', () => ({ getDynamicWorkspace: vi.fn() }));
+vi.mock('./agents/workspace.js', () => ({ getDynamicWorkspace: vi.fn(), getGoalJudgeTools: vi.fn() }));
 
 vi.mock('./auth/storage.js', () => ({
   AuthStorage: class {

mastracode/src/index.ts

@@ -53,7 +53,7 @@ import { getStaticallyLoadedInstructionPaths } from './agents/prompts/agent-inst
 import { attachOMThreadStatePersistence, restoreOMThreadStateForCurrentThread } from './agents/thread-caveman-state.js';
 import { createDynamicTools, createToolHooks } from './agents/tools.js';
 
-import { getDynamicWorkspace } from './agents/workspace.js';
+import { getDynamicWorkspace, getGoalJudgeTools } from './agents/workspace.js';
 import { AuthStorage } from './auth/storage.js';
 import { DEFAULT_CONFIG_DIR, validateConfigDirName } from './constants.js';
 import { createOutcomeScorer, createEfficiencyScorer } from './evals/scorers/index.js';
@@ -465,6 +465,12 @@ export async function createMastraCode(config?: MastraCodeConfig) {
       judge: ctx => getGoalJudgeModel(ctx, config?.settingsPath),
       maxRuns: globalSettings.models.goalMaxTurns ?? 50,
       prompt: DEFAULT_GOAL_JUDGE_PROMPT,
+      // Read-only workspace tools the default goal judge may call to verify the
+      // agent's work against the actual filesystem (view, search_content,
+      // find_files, file_stat, lsp_inspect) rather than grading prose alone —
+      // restoring the original MastraCode judge's verification ability. Resolved
+      // per-request from the active workspace (mirrors `judge`).
+      tools: getGoalJudgeTools,
     },
     inputProcessors: [
       new AgentsMDInjector({

mastracode/src/tui/__tests__/goal-manager.test.ts

@@ -220,12 +220,16 @@ describe('GoalManager adapter', () => {
     const state = createState(agent);
     const manager = new GoalManager();
     await manager.setGoal(state, 'finish the task', '__GATEWAY_OPENAI_MODEL__');
-    manager.pause();
+    manager.pause('Judge evaluation was interrupted.');
 
     await manager.saveToThread(state);
 
     expect(agent.updateObjectiveOptions).toHaveBeenCalledWith(
-      expect.objectContaining({ threadId: 'parent-thread', status: 'paused' }),
+      expect.objectContaining({
+        threadId: 'parent-thread',
+        status: 'paused',
+        pausedReason: 'Judge evaluation was interrupted.',
+      }),
     );
     expect(state.harness.setThreadSetting).toHaveBeenCalledWith({ key: 'goal', value: undefined });
   });

mastracode/src/tui/__tests__/mastra-tui-queueing.test.ts

@@ -556,6 +556,59 @@ describe('MastraTUI queueing', () => {
     expect(ctx.updateStatusLine).toHaveBeenCalledTimes(6);
   });
 
+  it('adds goal activity to the active judge display while pending', () => {
+    const state = createQueueState({
+      goalManager: {
+        applyEvaluation: vi.fn(),
+        getGoal: vi.fn(() => ({
+          id: 'goal-activity',
+          status: 'active',
+          judgeModelId: '__GATEWAY_OPENAI_MODEL__',
+          turnsUsed: 1,
+          maxTurns: 20,
+        })),
+      } as any,
+    });
+    const ctx = createQueueContext(state);
+
+    handleGoalEvaluation(ctx, createGoalPayload({ pending: true }));
+    handleGoalEvaluation(
+      ctx,
+      createGoalPayload({
+        pending: true,
+        activity: [{ type: 'tool-call', name: 'read', message: 'read' }],
+      } as any),
+    );
+
+    expect((state.activeGoalJudge?.component as any).activity).toEqual(['read']);
+    expect(state.goalManager.applyEvaluation).not.toHaveBeenCalled();
+    expect(state.ui.requestRender).toHaveBeenCalled();
+  });
+
+  it('ignores late goal chunks after the user has aborted and paused the goal', () => {
+    const applyEvaluation = vi.fn();
+    const state = createQueueState({
+      userInitiatedAbort: true,
+      goalManager: {
+        applyEvaluation,
+        getGoal: vi.fn(() => ({
+          id: 'paused-goal',
+          status: 'paused',
+          judgeModelId: '__GATEWAY_OPENAI_MODEL__',
+          turnsUsed: 5,
+          maxTurns: 500,
+        })),
+      } as any,
+    });
+    const ctx = createQueueContext(state);
+
+    handleGoalEvaluation(ctx, createGoalPayload({ iteration: 5, status: 'active' }));
+
+    expect(applyEvaluation).not.toHaveBeenCalled();
+    expect(state.activeGoalJudge).toBeUndefined();
+    expect(state.ui.requestRender).not.toHaveBeenCalled();
+  });
+
   it('switches to plan mode when a plan-started goal completes with status=done', () => {
     const switchMode = vi.fn().mockResolvedValue({ accepted: true });
     const applyEvaluation = vi.fn();
@@ -637,6 +690,7 @@ describe('MastraTUI queueing', () => {
 
     expect(switchMode).not.toHaveBeenCalled();
     expect(state.planStartedGoalId).toBe('plan-goal-123');
+    expect(state.activeGoalJudge).toBeUndefined();
   });
 
   it('does not switch to plan mode when goal evaluation reports status=paused', () => {

mastracode/src/tui/__tests__/render-messages.test.ts

@@ -4,6 +4,7 @@ import { describe, expect, it, vi } from 'vitest';
 
 import { AssistantMessageComponent } from '../components/assistant-message.js';
 import { isChatBoundarySpacer } from '../components/chat-boundary-spacer.js';
+import { JudgeDisplayComponent } from '../components/judge-display.js';
 import { NotificationSummaryComponent } from '../components/notification-summary.js';
 import { NotificationComponent } from '../components/notification.js';
 import { ReactiveSignalComponent } from '../components/reactive-signal.js';
@@ -374,6 +375,47 @@ describe('addUserMessage', () => {
     expect(rendered).toContain('Continue & handle <tags>');
   });
 
+  it('renders persisted goal-judge evaluations as judge display components', () => {
+    const state = createState();
+
+    addUserMessage(
+      state,
+      createReminderMessage(
+        {
+          type: 'system_reminder',
+          reminderType: 'goal-judge',
+          message: '[Goal attempt 2/20] The goal is not yet complete. Judge feedback: Need another fact.',
+          goalEvaluation: {
+            objective: 'List whale facts',
+            iteration: 2,
+            maxRuns: 20,
+            passed: false,
+            status: 'active',
+            results: [],
+            reason: 'Need another fact.',
+            duration: 0,
+            timedOut: false,
+            maxRunsReached: false,
+            suppressFeedback: false,
+          },
+        } as Extract<HarnessMessage['content'][number], { type: 'system_reminder' }>,
+        'goal-judge-1',
+      ),
+    );
+
+    expect(state.chatContainer.children).toHaveLength(1);
+    expect(state.chatContainer.children[0]).toBeInstanceOf(JudgeDisplayComponent);
+    expect(state.allSystemReminderComponents).toHaveLength(0);
+    expect(state.messageComponentsById.get('goal-judge-1')).toBe(state.chatContainer.children[0]);
+    const rendered = (state.chatContainer.children[0] as JudgeDisplayComponent)
+      .render(80)
+      .join('\n')
+      .replace(/\x1b\[[0-9;]*m/g, '');
+    expect(rendered).toContain('continue');
+    expect(rendered).toContain('(2/20)');
+    expect(rendered).toContain('Need another fact.');
+  });
+
   it('renders canonical initial goal reminders as system reminders', () => {
     const state = createState();
 

mastracode/src/tui/__tests__/setup-keyboard-shortcuts.test.ts

@@ -393,7 +393,7 @@ describe('setupKeyboardShortcuts', () => {
     expect(abortController.signal.aborted).toBe(true);
     expect(component.setInterrupted).toHaveBeenCalledTimes(1);
     expect(state.userInitiatedAbort).toBe(true);
-    expect(state.harness.abort).not.toHaveBeenCalled();
+    expect(state.harness.abort).toHaveBeenCalledTimes(1);
     expect(editor.setText).not.toHaveBeenCalled();
     expect(state.ui.requestRender).toHaveBeenCalled();
   });
@@ -435,6 +435,29 @@ describe('setupKeyboardShortcuts', () => {
     expect(editor.setText).not.toHaveBeenCalled();
   });
 
+  it('aborts the harness and persists a paused goal when clearing during goal judge evaluation', () => {
+    const { state, actions } = createState(true);
+    const abortController = { abort: vi.fn() };
+    const component = { setInterrupted: vi.fn() };
+    state.activeGoalJudge = { modelId: 'openai/gpt-5.5', abortController, component };
+
+    setupKeyboardShortcuts(state, {
+      stop: vi.fn(),
+      doubleCtrlCMs: 500,
+      queueFollowUpMessage: vi.fn(),
+    });
+
+    actions.get('clear')?.();
+
+    expect(abortController.abort).toHaveBeenCalledTimes(1);
+    expect(component.setInterrupted).toHaveBeenCalledTimes(1);
+    expect(state.harness.abort).toHaveBeenCalledTimes(1);
+    expect(state.goalManager.pause).toHaveBeenCalledWith('Judge evaluation was interrupted.');
+    expect(state.goalManager.saveToThread).toHaveBeenCalledWith(state);
+    expect(state.activeGoalJudge).toBeUndefined();
+    expect(state.userInitiatedAbort).toBe(true);
+  });
+
   it('aborts and clears an active plan approval parked in a tool suspension', () => {
     // Regression: Ctrl+C while a submit_plan approval box is up must abort the
     // parked suspension (not hang). The editor-level handleInput override lets