- {formatTimestamp(run.scheduled_for, locale)}
-
- {run.error}
+ (taskRunsQuery.data ?? []).map((run) => {
+ const goal = describeGoalOutcome(run);
+ return (
+
+
{runSummary(run)}
+
+ {run.run_id ?? NONE}
- )}
-
- ))
+
+ {formatTimestamp(run.scheduled_for, locale)}
+
+ {goal?.kind === "met" && (
+
+ {goal.reliedOnAssumption
+ ? st.goal.metAssumed
+ : st.goal.met}
+
+ )}
+ {goal?.kind === "unmet"
+ ? goal.code && (
+
+ {goal.reasonKey
+ ? st.goal.reasons[goal.reasonKey]
+ : goal.code}
+
+ )
+ : run.error && (
+
+ {run.error}
+
+ )}
+ {requestedScheduleStop(run) && (
+
+ {st.goal.stopRequested}
+
+ )}
+
+ );
+ })
) : !taskRunsQuery.isPending && !taskRunsQuery.isError ? (
{st.detail.noRuns}
diff --git a/frontend/src/core/i18n/locales/en-US.ts b/frontend/src/core/i18n/locales/en-US.ts
index b45870d850..03ea225d2e 100644
--- a/frontend/src/core/i18n/locales/en-US.ts
+++ b/frontend/src/core/i18n/locales/en-US.ts
@@ -944,6 +944,32 @@ export const enUS: Translations = {
skipped: "Skipped",
interrupted: "Interrupted",
},
+ goal: {
+ objective: "Goal per run",
+ maxRuns: "Automatic runs: up to {count}",
+ endAt: "Ends at",
+ met: "Goal met",
+ metAssumed: "Goal met, relying on stated assumptions",
+ stopRequested: "This run asked to stop the schedule",
+ lastPause: "Last pause reason",
+ agentStopped: "The agent stopped its own schedule",
+ autoPaused: "3 scheduled runs in a row did not meet the goal",
+ lastUnmet: "Last unmet reason",
+ reasons: {
+ missingEvidence: "Goal check: evidence missing",
+ needsUserInput: "Needs your input",
+ externalWait: "Goal check: waiting on something external",
+ runFailed: "Goal check: the run did not finish the work",
+ goalNotMetYet: "Goal check: not met yet",
+ maxContinuations: "Continuation limit reached",
+ noProgress: "No progress between turns",
+ tokenCapped: "Token budget reached",
+ evaluatorFailed: "Goal check could not run",
+ noDurableEndOfTurn: "No final reply was saved",
+ threadChanged: "Conversation changed during the goal check",
+ noVerdict: "No goal verdict",
+ },
+ },
recipes: {
label: "Quick create",
trending: {
diff --git a/frontend/src/core/i18n/locales/types.ts b/frontend/src/core/i18n/locales/types.ts
index c9261aa6ce..425ab8b0a2 100644
--- a/frontend/src/core/i18n/locales/types.ts
+++ b/frontend/src/core/i18n/locales/types.ts
@@ -780,6 +780,32 @@ export interface Translations {
skipped: string;
interrupted: string;
};
+ goal: {
+ objective: string;
+ maxRuns: string;
+ endAt: string;
+ met: string;
+ metAssumed: string;
+ stopRequested: string;
+ lastPause: string;
+ agentStopped: string;
+ autoPaused: string;
+ lastUnmet: string;
+ reasons: {
+ missingEvidence: string;
+ needsUserInput: string;
+ externalWait: string;
+ runFailed: string;
+ goalNotMetYet: string;
+ maxContinuations: string;
+ noProgress: string;
+ tokenCapped: string;
+ evaluatorFailed: string;
+ noDurableEndOfTurn: string;
+ threadChanged: string;
+ noVerdict: string;
+ };
+ };
recipes: {
label: string;
trending: { title: string; desc: string };
diff --git a/frontend/src/core/i18n/locales/zh-CN.ts b/frontend/src/core/i18n/locales/zh-CN.ts
index 4eba00ae76..c954cd5411 100644
--- a/frontend/src/core/i18n/locales/zh-CN.ts
+++ b/frontend/src/core/i18n/locales/zh-CN.ts
@@ -885,6 +885,32 @@ export const zhCN: Translations = {
skipped: "跳过",
interrupted: "已中断",
},
+ goal: {
+ objective: "每次执行的目标",
+ maxRuns: "自动执行上限：{count} 次",
+ endAt: "截止时间",
+ met: "目标已达成",
+ metAssumed: "目标已达成（基于已声明的假设）",
+ stopRequested: "本次执行请求停止该定时任务",
+ lastPause: "上次暂停原因",
+ agentStopped: "Agent 主动停止了该定时任务",
+ autoPaused: "连续 3 次定时执行未达成目标",
+ lastUnmet: "上次未达成原因",
+ reasons: {
+ missingEvidence: "目标检查：缺少证据",
+ needsUserInput: "需要你补充信息",
+ externalWait: "目标检查：正在等待外部条件",
+ runFailed: "目标检查：本次执行未完成任务",
+ goalNotMetYet: "目标检查：尚未达成",
+ maxContinuations: "已达到续跑次数上限",
+ noProgress: "连续多轮没有进展",
+ tokenCapped: "已达到 token 预算",
+ evaluatorFailed: "目标检查未能完成",
+ noDurableEndOfTurn: "没有保存最终回复",
+ threadChanged: "目标检查期间对话发生了变化",
+ noVerdict: "未得到目标判定",
+ },
+ },
recipes: {
label: "快速创建",
trending: {
diff --git a/frontend/src/core/scheduled-tasks/goal-outcome.ts b/frontend/src/core/scheduled-tasks/goal-outcome.ts
new file mode 100644
index 0000000000..5c90407c2d
--- /dev/null
+++ b/frontend/src/core/scheduled-tasks/goal-outcome.ts
@@ -0,0 +1,100 @@
+import type { ScheduledTaskRun } from "./types";
+
+export type GoalReasonKey =
+ | "missingEvidence"
+ | "needsUserInput"
+ | "externalWait"
+ | "runFailed"
+ | "goalNotMetYet"
+ | "maxContinuations"
+ | "noProgress"
+ | "tokenCapped"
+ | "evaluatorFailed"
+ | "noDurableEndOfTurn"
+ | "threadChanged"
+ | "noVerdict";
+
+// Host-defined codes an `unmet` occurrence stores in `error`, keyed without
+// the `blocked:` prefix like the IM notice map (`_GOAL_REASON_TEXT`).
+// contracts/scheduled_goal_notes_contract.json pins the codes the backend
+// writes; unknown codes stay visible verbatim.
+const REASON_KEYS: Record
= {
+ missing_evidence: "missingEvidence",
+ needs_user_input: "needsUserInput",
+ external_wait: "externalWait",
+ run_failed: "runFailed",
+ goal_not_met_yet: "goalNotMetYet",
+ max_continuations_reached: "maxContinuations",
+ no_progress_detected: "noProgress",
+ token_capped: "tokenCapped",
+ evaluator_failed: "evaluatorFailed",
+ no_durable_end_of_turn: "noDurableEndOfTurn",
+ thread_changed_after_evaluation: "threadChanged",
+ thread_changed_before_continuation: "threadChanged",
+ no_verdict: "noVerdict",
+};
+
+// Host-written task `last_error` values, pinned by the same contract.
+const AGENT_STOP_LAST_ERROR_PREFIX = "stopped by the agent in run ";
+const AUTO_PAUSE_LAST_ERROR = "paused after 3 unmet scheduled goal runs";
+
+function reasonKeyOf(code: string): GoalReasonKey | null {
+ return REASON_KEYS[code.replace(/^blocked:/, "")] ?? null;
+}
+
+export type GoalOutcome =
+ | { kind: "met"; reliedOnAssumption: boolean }
+ | { kind: "unmet"; code: string | null; reasonKey: GoalReasonKey | null };
+
+/** Goal result of a finished occurrence; null when the run had no goal outcome. */
+export function describeGoalOutcome(
+ run: Pick,
+): GoalOutcome | null {
+ if (run.status === "unmet") {
+ const code = run.error ?? null;
+ return { kind: "unmet", code, reasonKey: code ? reasonKeyOf(code) : null };
+ }
+ if (run.status === "success" && run.goal_verdict?.satisfied === true) {
+ return {
+ kind: "met",
+ reliedOnAssumption: run.goal_verdict.relied_on_assumption === true,
+ };
+ }
+ return null;
+}
+
+/** True for the occurrence whose agent asked to stop its own schedule. */
+export function requestedScheduleStop(
+ run: Pick,
+): boolean {
+ return Boolean(run.run_id) && run.stop_requested_run_id === run.run_id;
+}
+
+export type TaskLastNote =
+ | { kind: "agentStop" }
+ | { kind: "autoPause" }
+ | { kind: "goalUnmet"; reasonKey: GoalReasonKey };
+
+/**
+ * Recognize the host-written `last_error` values from goal and stop
+ * finalization (backend `scheduled_task_runs/finalization.py`). Anything else
+ * is a real error message and returns null.
+ */
+export function describeTaskLastError(
+ lastError: string | null,
+): TaskLastNote | null {
+ if (!lastError) {
+ return null;
+ }
+ if (
+ lastError.startsWith(AGENT_STOP_LAST_ERROR_PREFIX) &&
+ /^\S+$/.test(lastError.slice(AGENT_STOP_LAST_ERROR_PREFIX.length))
+ ) {
+ return { kind: "agentStop" };
+ }
+ if (lastError === AUTO_PAUSE_LAST_ERROR) {
+ return { kind: "autoPause" };
+ }
+ const reasonKey = reasonKeyOf(lastError);
+ return reasonKey ? { kind: "goalUnmet", reasonKey } : null;
+}
diff --git a/frontend/src/core/scheduled-tasks/types.ts b/frontend/src/core/scheduled-tasks/types.ts
index 052339be78..3ec2b853d9 100644
--- a/frontend/src/core/scheduled-tasks/types.ts
+++ b/frontend/src/core/scheduled-tasks/types.ts
@@ -21,10 +21,23 @@ export type ScheduledTask = {
last_thread_id: string | null;
last_error: string | null;
run_count: number;
+ // Only conversation-created tasks set these; other tasks omit them or send null.
+ goal_objective?: string | null;
+ max_runs?: number | null;
+ end_at?: string | null;
created_at: string;
updated_at: string;
};
+// The verdict an occurrence finished with: from the goal evaluator, or from
+// the host when it stood the goal down (see `stand_down_reason`).
+export type ScheduledGoalVerdict = {
+ satisfied?: boolean;
+ blocker?: string;
+ relied_on_assumption?: boolean;
+ stand_down_reason?: string;
+};
+
export type ScheduledTaskRun = {
id: string;
task_id: string;
@@ -42,6 +55,9 @@ export type ScheduledTaskRun = {
| "skipped"
| "interrupted";
error: string | null;
+ goal_objective?: string | null;
+ goal_verdict?: ScheduledGoalVerdict | null;
+ stop_requested_run_id?: string | null;
attempt_count: number;
started_at: string | null;
finished_at: string | null;
diff --git a/frontend/tests/e2e/scheduled-goal-history.spec.ts b/frontend/tests/e2e/scheduled-goal-history.spec.ts
new file mode 100644
index 0000000000..3097862290
--- /dev/null
+++ b/frontend/tests/e2e/scheduled-goal-history.spec.ts
@@ -0,0 +1,173 @@
+import { expect, test, type Page } from "@playwright/test";
+
+import { mockLangGraphAPI } from "./utils/mock-api";
+
+const baseTask = {
+ thread_id: null,
+ context_mode: "fresh_thread_per_run" as const,
+ prompt: "Check the release checklist",
+ schedule_type: "interval" as const,
+ schedule_spec: { every_seconds: 3600 },
+ timezone: "UTC",
+ status: "paused" as const,
+ next_run_at: null,
+ last_run_at: null,
+ last_run_id: null,
+ last_error: null,
+ run_count: 5,
+ created_at: "2026-10-01T00:00:00Z",
+ updated_at: "2026-10-01T00:00:00Z",
+};
+const goalTask = {
+ ...baseTask,
+ id: "goal-task",
+ title: "Goal task",
+ goal_objective: "status.md lists every unchecked item",
+ max_runs: 5,
+ end_at: null,
+ last_error: "stopped by the agent in run execution-stop",
+};
+const plainTask = {
+ ...baseTask,
+ id: "plain-task",
+ title: "Plain task",
+ last_error: "boom",
+};
+
+const run = (
+ id: string,
+ overrides: Record,
+): Record => ({
+ id,
+ task_id: "goal-task",
+ thread_id: `thread-${id}`,
+ run_id: `execution-${id}`,
+ scheduled_for: "2026-10-01T00:00:00Z",
+ trigger: "scheduled",
+ status: "success",
+ error: null,
+ attempt_count: 1,
+ started_at: null,
+ finished_at: null,
+ created_at: "2026-10-01T00:00:00Z",
+ ...overrides,
+});
+const goal = { goal_objective: goalTask.goal_objective };
+const goalRuns = [
+ run("met", { ...goal, goal_verdict: { satisfied: true } }),
+ run("assumed", {
+ ...goal,
+ goal_verdict: { satisfied: true, relied_on_assumption: true },
+ }),
+ run("unmet", {
+ ...goal,
+ status: "unmet",
+ error: "blocked:missing_evidence",
+ goal_verdict: {
+ satisfied: false,
+ blocker: "missing_evidence",
+ stand_down_reason: "blocked:missing_evidence",
+ },
+ }),
+ run("stop", {
+ ...goal,
+ goal_verdict: { satisfied: true },
+ stop_requested_run_id: "execution-stop",
+ }),
+ run("unknown", { ...goal, status: "unmet", error: "future_reason" }),
+ run("failed", { ...goal, status: "failed", error: "boom" }),
+];
+const plainRuns = [
+ run("plain-ok", { task_id: "plain-task" }),
+ run("plain-failed", {
+ task_id: "plain-task",
+ status: "failed",
+ error: "boom",
+ }),
+];
+
+async function openTask(
+ page: Page,
+ task: typeof goalTask | typeof plainTask,
+ runs: Record[],
+ locale?: "zh-CN",
+) {
+ mockLangGraphAPI(page, { threads: [], scheduledTasks: [task] });
+ await page.route(/\/api\/scheduled-tasks\/[^/]+\/runs(?:\?|$)/, (route) =>
+ route.fulfill({ json: runs }),
+ );
+ await page.goto("/workspace/scheduled-tasks");
+ if (locale) {
+ await page.evaluate((value) => {
+ document.cookie = `locale=${value}; path=/; SameSite=Lax`;
+ }, locale);
+ await page.reload();
+ }
+ return page.getByTestId("scheduled-task-run-list");
+}
+
+const rowOf = (list: ReturnType, runId: string) =>
+ list.locator("div.rounded-md").filter({ hasText: runId });
+
+test("goal runs show their outcome and the unmet reason is not styled as an error", async ({
+ page,
+}) => {
+ const list = await openTask(page, goalTask, goalRuns);
+ const detail = page.getByTestId("scheduled-task-detail");
+ await expect(page.getByTestId("scheduled-task-goal")).toHaveText(
+ "Goal per run: status.md lists every unchecked item",
+ );
+ await expect(detail.getByText("Automatic runs: up to 5")).toBeVisible();
+ await expect(page.getByTestId("scheduled-task-last-error")).toHaveText(
+ "Last pause reason: The agent stopped its own schedule",
+ );
+
+ await expect(rowOf(list, "execution-met")).toContainText("Goal met");
+ await expect(rowOf(list, "execution-assumed")).toContainText(
+ "Goal met, relying on stated assumptions",
+ );
+ const unmet = rowOf(list, "execution-unmet").getByTestId(
+ "scheduled-run-goal",
+ );
+ await expect(unmet).toHaveText("Goal check: evidence missing");
+ await expect(unmet).toHaveAttribute("title", "blocked:missing_evidence");
+ await expect(unmet).not.toHaveClass(/text-destructive/);
+ await expect(
+ rowOf(list, "execution-unknown").getByTestId("scheduled-run-goal"),
+ ).toHaveText("future_reason");
+ await expect(
+ rowOf(list, "execution-stop").getByTestId("scheduled-run-stop-requested"),
+ ).toHaveText("This run asked to stop the schedule");
+ await expect(list.getByTestId("scheduled-run-stop-requested")).toHaveCount(1);
+ await expect(
+ rowOf(list, "execution-failed").locator(".text-destructive"),
+ ).toHaveText("boom");
+});
+
+test("tasks without a goal render their runs as before", async ({ page }) => {
+ const list = await openTask(page, plainTask, plainRuns);
+ await expect(list.getByText("execution-plain-ok")).toBeVisible();
+ await expect(page.getByTestId("scheduled-task-goal")).toHaveCount(0);
+ await expect(page.getByTestId("scheduled-task-last-error")).toHaveText(
+ "Last error: boom",
+ );
+ await expect(list.getByTestId("scheduled-run-goal")).toHaveCount(0);
+ await expect(list.getByTestId("scheduled-run-stop-requested")).toHaveCount(0);
+ await expect(
+ rowOf(list, "execution-plain-failed").locator(".text-destructive"),
+ ).toHaveText("boom");
+});
+
+test("goal outcomes use the Chinese copy", async ({ page }) => {
+ const list = await openTask(page, goalTask, goalRuns, "zh-CN");
+ await expect(page.getByTestId("scheduled-task-goal")).toHaveText(
+ "每次执行的目标: status.md lists every unchecked item",
+ );
+ await expect(rowOf(list, "execution-met")).toContainText("目标已达成");
+ await expect(page.getByTestId("scheduled-task-last-error")).toHaveText(
+ "上次暂停原因: Agent 主动停止了该定时任务",
+ );
+ await expect(
+ rowOf(list, "execution-unmet").getByTestId("scheduled-run-goal"),
+ ).toHaveText("目标检查：缺少证据");
+});
diff --git a/frontend/tests/unit/core/scheduled-tasks/goal-outcome.test.ts b/frontend/tests/unit/core/scheduled-tasks/goal-outcome.test.ts
new file mode 100644
index 0000000000..7055ac9429
--- /dev/null
+++ b/frontend/tests/unit/core/scheduled-tasks/goal-outcome.test.ts
@@ -0,0 +1,158 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+import { expect, test } from "@rstest/core";
+
+import {
+ describeGoalOutcome,
+ describeTaskLastError,
+ requestedScheduleStop,
+} from "@/core/scheduled-tasks/goal-outcome";
+import type { ScheduledTaskRun } from "@/core/scheduled-tasks/types";
+
+type OutcomeInput = Pick;
+
+type ContractFile = {
+ agent_stop_last_error_prefix: string;
+ auto_pause_last_error: string;
+ unmet_reason_codes: string[];
+};
+
+const CONTRACT = JSON.parse(
+ readFileSync(
+ resolve(
+ __dirname,
+ "../../../../../contracts/scheduled_goal_notes_contract.json",
+ ),
+ "utf-8",
+ ),
+) as ContractFile;
+
+const run = (overrides: Partial): OutcomeInput => ({
+ status: "success",
+ error: null,
+ ...overrides,
+});
+
+test("a run without a goal verdict has no goal outcome", () => {
+ expect(describeGoalOutcome(run({}))).toBeNull();
+ expect(describeGoalOutcome(run({ goal_verdict: null }))).toBeNull();
+ expect(
+ describeGoalOutcome(run({ status: "failed", error: "boom" })),
+ ).toBeNull();
+});
+
+test("a satisfied verdict is met, with the assumption flag kept", () => {
+ expect(
+ describeGoalOutcome(run({ goal_verdict: { satisfied: true } })),
+ ).toEqual({ kind: "met", reliedOnAssumption: false });
+ expect(
+ describeGoalOutcome(
+ run({
+ goal_verdict: { satisfied: true, relied_on_assumption: true },
+ }),
+ ),
+ ).toEqual({ kind: "met", reliedOnAssumption: true });
+});
+
+test("a success with an unsatisfied verdict is not reported as met", () => {
+ expect(
+ describeGoalOutcome(run({ goal_verdict: { satisfied: false } })),
+ ).toBeNull();
+});
+
+test.each([
+ ["blocked:missing_evidence", "missingEvidence"],
+ ["blocked:needs_user_input", "needsUserInput"],
+ ["blocked:external_wait", "externalWait"],
+ ["blocked:run_failed", "runFailed"],
+ ["blocked:goal_not_met_yet", "goalNotMetYet"],
+ ["max_continuations_reached", "maxContinuations"],
+ ["no_progress_detected", "noProgress"],
+ ["token_capped", "tokenCapped"],
+ ["evaluator_failed", "evaluatorFailed"],
+ ["no_durable_end_of_turn", "noDurableEndOfTurn"],
+ ["thread_changed_after_evaluation", "threadChanged"],
+ ["thread_changed_before_continuation", "threadChanged"],
+ ["no_verdict", "noVerdict"],
+])("unmet reason %s maps to %s", (code, reasonKey) => {
+ expect(describeGoalOutcome(run({ status: "unmet", error: code }))).toEqual({
+ kind: "unmet",
+ code,
+ reasonKey,
+ });
+});
+
+test("an unknown unmet code stays visible without a label", () => {
+ expect(
+ describeGoalOutcome(run({ status: "unmet", error: "future_reason" })),
+ ).toEqual({ kind: "unmet", code: "future_reason", reasonKey: null });
+ expect(describeGoalOutcome(run({ status: "unmet", error: null }))).toEqual({
+ kind: "unmet",
+ code: null,
+ reasonKey: null,
+ });
+});
+
+test.each([
+ ["run-2", "run-2", true],
+ ["run-2", "run-1", false],
+ ["run-2", null, false],
+ [null, null, false],
+])(
+ "run %s with stop request %s reports a stop request: %s",
+ (runId, stopRequestedRunId, expected) => {
+ expect(
+ requestedScheduleStop({
+ run_id: runId,
+ stop_requested_run_id: stopRequestedRunId,
+ }),
+ ).toBe(expected);
+ },
+);
+
+test.each([
+ [
+ "stopped by the agent in run 3f2a9c1e-8b47-4d2a-9e61-5c0b7a1d4e93",
+ { kind: "agentStop" },
+ ],
+ ["paused after 3 unmet scheduled goal runs", { kind: "autoPause" }],
+ [
+ "blocked:missing_evidence",
+ { kind: "goalUnmet", reasonKey: "missingEvidence" },
+ ],
+ ["no_verdict", { kind: "goalUnmet", reasonKey: "noVerdict" }],
+])("host-written last_error %s is recognized", (lastError, expected) => {
+ expect(describeTaskLastError(lastError)).toEqual(expected);
+});
+
+test.each([
+ [null],
+ [""],
+ ["Connection reset by peer"],
+ ["stopped by the agent in run "],
+ ["Paused after 3 unmet scheduled goal runs"],
+ ["stopped by the agent in run abc; then failed"],
+])("other last_error %s stays a plain error message", (lastError) => {
+ expect(describeTaskLastError(lastError)).toBeNull();
+});
+
+test("every contract reason code has a label in run history and task detail", () => {
+ for (const code of CONTRACT.unmet_reason_codes) {
+ const outcome = describeGoalOutcome(run({ status: "unmet", error: code }));
+ expect(outcome?.kind).toBe("unmet");
+ expect(outcome?.kind === "unmet" ? outcome.reasonKey : null).not.toBeNull();
+ expect(describeTaskLastError(code)?.kind).toBe("goalUnmet");
+ }
+});
+
+test("contract last_error strings are recognized", () => {
+ expect(
+ describeTaskLastError(
+ `${CONTRACT.agent_stop_last_error_prefix}3f2a9c1e-8b47-4d2a-9e61-5c0b7a1d4e93`,
+ ),
+ ).toEqual({ kind: "agentStop" });
+ expect(describeTaskLastError(CONTRACT.auto_pause_last_error)).toEqual({
+ kind: "autoPause",
+ });
+});