taskchef 7.4.0 → 7.5.0

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "taskchef",
-  "version": "7.4.0",
+  "version": "7.5.0",
   "description": "Dispatch work from a data-only workspace to visible Codex project tasks.",
   "author": {
     "name": "Favo Yang",

package/README.md

@@ -3,11 +3,11 @@
 TaskChef is a local dispatch desk for Codex. Give one dispatcher a request and
 it records each independently useful outcome, creates a normal Codex task in
 the right project, and returns immediately. The executor task is where live
-work, approvals, and follow-ups happen; TaskChef keeps the latest compact
-snapshot for navigation and reporting.
+work, approvals, and follow-ups happen; TaskChef keeps every semantic result
+while projecting the latest one for compact navigation and reporting.
 
 ```text
-request -> recorded TaskChef task -> Codex executor -> current state + last result
+request -> recorded TaskChef task -> Codex executor -> current state + result history
 ```
 
 ## Which document should I read?
@@ -49,7 +49,7 @@ The canonical workspace is `~/.agents/taskchef`. TaskChef owns only:
 ```text
 AGENTS.md       managed dispatcher instructions plus user additions
 taskchef.json   schema-2 configured projects and routing metadata
-tasks.jsonl     one schema-4/5 snapshot per task (new writes use schema 5)
+tasks.jsonl     one task snapshot per line (schema 6; schema 4/5 migration supported)
 ```
 
 List or change routing targets conversationally:
@@ -119,10 +119,12 @@ when a turn starts and one semantic outcome before that same turn ends:
 - `failed`: the executor or creation attempt ended unsuccessfully.
 
 A native approval prompt is live Codex state, not `needs_input`.
-TaskChef stores the current reported execution state and separately preserves
-the last concise semantic result. A follow-up therefore appears as `working`
-immediately without erasing the previous outcome. TaskChef does not store the
-transcript or a lifecycle event log.
+TaskChef stores the current reported execution state and appends every concise
+semantic result to `results`. A follow-up therefore appears as `working`
+immediately without erasing any prior outcome. The final entry is exposed as a
+derived `lastResult` compatibility alias; it is not persisted independently and
+is planned for removal in the next major version after callers move to
+`results.at(-1)`. TaskChef does not store transcripts or non-semantic events.
 
 Delegated tasks created by earlier TaskChef versions remain compatible: their
 inline executor protocol still parses, self-links, and may use the deprecated
@@ -172,7 +174,9 @@ taskchef dashboard --port 3211
 ```
 
 The loopback dashboard watches `tasks.jsonl`, groups current states, and opens
-linked Codex tasks. It does not mutate TaskChef data and prints its local URL.
+linked Codex tasks. List snapshots and SSE events carry only the latest-result
+projection; opening task details fetches the full newest-first result history.
+It does not mutate TaskChef data and prints its local URL.
 When a compatible foreground dashboard already owns port 3210,
 `ensure_dashboard` reuses it but does not take ownership. If an unknown,
 different-workspace, or stale-version process owns the port, TaskChef reports a
@@ -183,6 +187,8 @@ The health endpoint contains only a fixed service marker, health schema,
 TaskChef version, dashboard-server version, and canonical workspace. It exposes
 no task data, credentials, environment variables, process control, or secrets.
 
+![Task detail result history](docs/images/result-history-dashboard.jpg)
+
 ## Common recovery
 
 Check the managed workspace:
@@ -190,20 +196,27 @@ Check the managed workspace:
 ```sh
 taskchef doctor
 taskchef workspace init
+taskchef workspace migrate
 taskchef doctor
 ```
 
-`doctor` is read-only. `workspace init` creates missing current-schema files
-and refreshes managed instructions; it does not migrate unsupported
-configuration or task records.
+`doctor` is read-only. `workspace init` creates missing files and refreshes
+managed instructions. `workspace migrate` explicitly upgrades supported schema
+4/5 task lines to schema 6 under the workspace lock. It validates the complete
+source and converted log before writing, creates an exclusive `tasks.jsonl.pre-v6-*.bak`
+backup, atomically replaces the log, validates the result, and becomes an
+idempotent no-op after migration. If replacement fails, the original remains
+or the reported backup can be restored; unsupported or invalid input is rejected
+before a backup or rewrite.
 
 If a new record has no thread ID, the executor is link-pending. Reopen that
 executor so its first action can retry `link_task`. Do not guess an identity
 or edit `tasks.jsonl`. If native task creation failed, the record is retained
 as `failed` with null thread and turn IDs.
 
-If an unsupported workspace must be retained, keep it as a backup and create a
-new current workspace. TaskChef provides no conversion or merge command.
+Schemas other than 4, 5, and 6 remain unsupported. Retain such a workspace
+unchanged and create a current workspace; the migration command deliberately
+does not guess how to convert unknown formats.
 
 ## Boundaries
 

package/docs/spec.md

@@ -23,7 +23,8 @@ is dated research, not contract.
 | **Self-linking** | The executor's one-way registration of its own canonical Codex UUIDv7 from `CODEX_THREAD_ID`. |
 | **Link-pending** | A working task whose `threadId` is null and `updatedBy` is `dispatcher`. |
 | **Current execution state** | The latest reported executor turn and its `working`, `needs_input`, `completed`, or `failed` status. |
-| **Last semantic result** | The most recent `completed`, `needs_input`, or `failed` outcome, preserved separately while a newer turn is working. |
+| **Result history** | The ordered collection of every accepted `completed`, `needs_input`, or `failed` per-turn outcome. |
+| **Last semantic result** | The final result-history entry, exposed through the derived `lastResult` compatibility alias. |
 | **Current turn ID** | The canonical Codex UUIDv7 returned by an exact native read of the linked executor for the turn being reported. |
 | **Dashboard** | The loopback, read-only UI derived from validated workspace snapshots and bounded native actions. |
 | **Skill** | One packaged agent procedure: `taskchef-bootstrap`, `taskchef-delegate`, `taskchef-executor`, or `taskchef-report`. |
@@ -67,10 +68,10 @@ Names and paths MUST be unique. Git projects MUST be exact Git roots.
 Repository URLs MUST canonicalize to `https://github.com/<owner>/<repository>`
 and be case-insensitively deduplicated.
 
-`tasks.jsonl` MUST contain zero or more newline-terminated schema-4 or schema-5
-records, one per line. Schema 4 is read compatibility for the previously
-released format; every new record and state mutation MUST write schema 5.
-Other schemas or unsupported fields MUST be rejected without conversion.
+`tasks.jsonl` MUST contain zero or more newline-terminated schema-4, schema-5,
+or schema-6 records, one per line. Schemas 4 and 5 are supported migration/read
+formats; every new record and state mutation MUST write schema 6. Other schemas
+or unsupported fields MUST be rejected without conversion.
 Reads and writes MUST reject symlinked managed files. Mutations
 MUST hold the shared workspace lock and replace state atomically; read-only
 operations MUST NOT require write permission.
@@ -81,7 +82,7 @@ Every record MUST contain exactly these fields:
 
 | Field | Contract |
 | --- | --- |
-| `schemaVersion` | Integer `5`; schema-4 records remain readable until their next mutation. |
+| `schemaVersion` | Integer `6`; schema-4/5 records remain readable until explicit migration or their next mutation. |
 | `id` | Unique safe TaskChef ID; delegation uses a lowercase full UUID. |
 | `project` | Immutable configured-project snapshot. |
 | `title` | Non-empty display title. |
@@ -93,7 +94,13 @@ Every record MUST contain exactly these fields:
 | `turnId` | Null before turn reporting; otherwise the current reported turn. Linked MCP journeys use a canonical Codex UUIDv7. |
 | `updatedAt` | ISO 8601 timestamp not earlier than `createdAt` or the prior `updatedAt`; clock rollback cannot backdate a transition. |
 | `updatedBy` | `dispatcher` or `mcp`. |
-| `lastResult` | Null before a semantic result; otherwise `{status, summary, turnId, updatedAt}` preserving the latest semantic result. |
+| `results` | Ordered oldest-first array of `{status, summary, turnId, updatedAt}` semantic results, with unique turn IDs and nondecreasing timestamps. |
+
+Returned Task objects MUST additionally expose `lastResult` as null for an empty
+history or the final `results` entry. `lastResult` MUST be derived and MUST NOT
+be persisted in schema 6. It is a compatibility alias for schema-4/5, CLI,
+MCP, reporting-skill, and dashboard-list callers, with removal planned for the
+next major version after callers migrate to `results.at(-1)`.
 
 Task IDs and non-null thread identities MUST be unique. The immutable intent
 fields MUST NOT change after recording.
@@ -231,7 +238,8 @@ new preparation values, though it writes no state.
 
 **Structured output:** `{ task: Task }`.
 
-The returned task has schema 5, `working`, null summary/turn/thread/lastResult,
+The returned task has schema 6, `working`, null summary/turn/thread/lastResult,
+an empty `results` array,
 `updatedBy: dispatcher`, and equal creation/update timestamps. Duplicate IDs,
 unknown projects, malformed markers, and invalid input fail. Repeating a
 successful call is not idempotent; it fails as a duplicate.
@@ -260,7 +268,7 @@ marker, or ineligible state fails.
 ### `report_state`
 
 **Caller:** executor, or dispatcher only for native creation failure.
-**Mutation:** replaces the current state atomically and preserves `lastResult`.
+**Mutation:** replaces the current state atomically and preserves `results`.
 
 **Input:**
 
@@ -279,8 +287,10 @@ the current turn and last semantic result. A semantic state MUST match the
 current working turn. Repeating an identical state is idempotent; conflicting
 or older state fails. A null-identity record accepts only a fresh executor
 creation `failed` state with both IDs null. Success sets the current state and
-preserves the semantic state in `lastResult`; starting newer work does not erase
-that result.
+appends a semantic result to `results`; starting newer work preserves the entire
+collection. An identical retry for any settled turn returns success without an
+append. A different result for a settled turn, a stale turn, or a semantic
+result that does not match the active working turn MUST fail.
 
 **Annotations:** `readOnlyHint: false`, `destructiveHint: true`,
 `openWorldHint: false`.
@@ -289,10 +299,10 @@ that result.
 
 `report_result` retains the prior semantic-only input shape and statuses as a
 temporary compatibility alias. It implicitly accepts a fresh supplied turn and
-stores its semantic result, including for supported schema-4 records and
+stores its semantic result, including for supported schema-4/5 records and
 low-level opaque direct records. It does not accept `working`. New executor
-instructions MUST use `report_state`. Successful mutation upgrades schema 4 to
-schema 5; unsupported schemas remain rejected.
+instructions MUST use `report_state`. Successful mutation upgrades schema 4/5
+to schema 6; unsupported schemas remain rejected.
 
 ## Reporting and dashboard
 
@@ -302,6 +312,7 @@ state overrides cache. An inactive task does not prove completion. Focused
 reports MAY read a selected task once when metadata is newer or evidence is
 uncertain. Reports MUST NOT poll or classify assistant prose.
 
+Task lists, summaries, and broad reports MUST use the final result by default.
 The dashboard MUST bind only to loopback, validate the current workspace
 snapshot, and avoid sessions or shared client state. `GET /api/health` MUST
 return only the bounded service identity, health schema, exact TaskChef and
@@ -313,6 +324,21 @@ startup safely. Direct thread navigation
 MUST require a canonical Codex UUIDv7. Otherwise it MAY open the revalidated
 configured project. Project paths from task history MUST be matched against
 current configuration before use.
+Snapshot and SSE list payloads MUST omit full `results` history and include the
+derived latest-result projection. The bounded per-task detail endpoint MAY
+return the full validated task so the dialog can render history newest first.
+
+## Task-log migration
+
+`workspace migrate` MUST explicitly convert every supported schema-4/5 record
+under the shared lock. A legacy `lastResult`, or a schema-4 current semantic
+state, becomes zero or one initial `results` entry. Migration MUST validate the
+complete source and complete schema-6 candidate before changing the task log,
+create and read back an exclusive recovery backup, atomically replace the log,
+and validate the installed result. A fully schema-6 log MUST be an idempotent
+no-op without another backup. Invalid/unsupported input MUST remain untouched;
+failures after backup creation MUST report the backup path and MUST never
+partially rewrite individual lines.
 
 ## Concurrency and trust
 

package/docs/workflows.md

@@ -18,7 +18,7 @@ research.
 | `src/delegation.js` | UUID marker, concise executor-skill invocation shape, and creation-failure handling. |
 | `src/workspace.js` | Current schemas, validation, locking, atomic JSONL writes, linking, and result freshness. |
 | `src/cli.js` | Administration, inspection, diagnostics, and dashboard startup. |
-| `src/dashboard.js` | Versioned health identity, validated snapshots, SSE fan-out, and bounded open actions. |
+| `src/dashboard.js` | Versioned health identity, validated compact snapshots, SSE fan-out, on-demand details, and bounded open actions. |
 | `src/dashboard-manager.js` | Concurrent singleton ensure, exact listener reuse, conflicts, and owned shutdown. |
 
 The MCP process resolves `TASKCHEF_WORKSPACE` once and never accepts a model
@@ -89,7 +89,7 @@ sequenceDiagram
   D->>D: Choose one configured and native project
   D->>M: record_task(id, project, title, instruction, null)
   M->>W: recordTask()
-  W->>W: Lock, validate, append schema-5 snapshot
+  W->>W: Lock, validate, append schema-6 snapshot
   W-->>M: working link-pending task
   M-->>D: task
   D->>C: Create executor with marked instruction
@@ -116,8 +116,8 @@ semantic callbacks.
 ## State reporting
 
 The executor obtains the turn identity from an exact native read of its own
-linked task. `report_state` records live turn state while preserving the last
-semantic result separately.
+linked task. `report_state` records live turn state while preserving the ordered
+semantic result history.
 
 ```mermaid
 sequenceDiagram
@@ -130,13 +130,13 @@ sequenceDiagram
   C-->>E: Current turn ID
   E->>M: report_state(..., working, null)
   M->>W: reportTaskState()
-  W->>W: Store current turn and preserve lastResult
+  W->>W: Store current turn and preserve results
   E->>E: Work, finish, or reach semantic decision
   E->>M: report_state(..., semantic status, summary)
   M->>W: reportTaskState()
   W->>W: Lock and validate identity and freshness
   alt Same current working turn
-    W->>W: Store semantic state and lastResult
+    W->>W: Append semantic result and derive lastResult
     W-->>M: Updated task
     M-->>E: Recorded result
   else Same turn and same result
@@ -173,9 +173,9 @@ sequenceDiagram
   C-->>E: turnB
   E->>M: report_state(..., turnB, working, null)
   M->>W: reportTaskState()
-  W->>W: Require turnB greater and preserve result A
-  W-->>M: working snapshot plus lastResult A
-  M-->>E: working snapshot plus lastResult A
+  W->>W: Require turnB greater and preserve results
+  W-->>M: working snapshot plus history A
+  M-->>E: working snapshot plus history A
   E->>M: report_state(..., turnB, completed, summaryB)
   M->>W: reportTaskState()
   W-->>M: completed snapshot plus result B
@@ -263,7 +263,9 @@ sequenceDiagram
   F-->>D: Filesystem change
   D->>F: Bounded read from one descriptor
   D->>D: Validate current schema and sort
-  D-->>B: SSE snapshot
+  D-->>B: Compact SSE snapshot without results
+  B->>D: GET task detail on demand
+  D-->>B: Full validated history
   B->>D: Open task action
   alt Canonical Codex UUIDv7
     D->>C: Direct thread navigation
@@ -273,10 +275,25 @@ sequenceDiagram
   end
 ```
 
-The dashboard binds to `127.0.0.1`, has no shared session state, limits
-request bodies, and checks origin/authority for stateful local actions. Its
-bounded identity endpoint contains no task data or secrets. Historical project
-paths are untrusted until matched against current configuration.
+The dashboard binds to `127.0.0.1`, has no shared session state, limits task
+count, file size, result count, and display fields, and checks origin/authority
+for stateful local actions. Its bounded identity endpoint contains no task data
+or secrets. The monitor already validates the complete log, but
+snapshot/SSE list projections omit `results` so repeated updates do not resend
+unnecessary history. A read-only per-task endpoint returns full history only
+when the dialog opens. Historical project paths are untrusted until matched
+against current configuration.
+
+## Schema 4/5 migration
+
+`taskchef workspace migrate` acquires the same workspace lock as lifecycle
+writers, validates the complete legacy log, converts each schema-4/5 latest
+result into zero or one initial schema-6 `results` entry, then validates the
+complete candidate. Before replacement it writes and reads back an exclusive
+`tasks.jsonl.pre-v6-*.bak` file. The task log is replaced atomically and
+validated again. A second run sees only schema 6 and returns unchanged without
+another backup. Unsupported or malformed input fails before backup/rewrite;
+after a later filesystem failure, the reported backup is the recovery source.
 
 ## Concurrency and trust boundaries
 
@@ -291,6 +308,7 @@ summary is cryptographically authenticated; this is a local single-user trust
 model. Managed files, instructions, project snapshots, MCP inputs, and dashboard
 requests are validated at every action boundary.
 
-Configuration schema 2 and task schemas 4 and 5 are accepted. Schema 4 is
-read-only compatibility until a lifecycle mutation upgrades that record to
-schema 5. Other schemas are rejected without rewrite.
+Configuration schema 2 and task schemas 4, 5, and 6 are accepted. Schemas 4/5
+are read/migration compatibility until an explicit migration or lifecycle
+mutation upgrades each record to schema 6. Schema 6 persists `results` only and
+derives `lastResult` for compatibility. Other schemas are rejected without rewrite.

package/index.js

@@ -10,6 +10,7 @@ export {
   initializeWorkspace,
   linkTask,
   listProjects,
+  migrateTaskLog,
   prepareDispatch,
   readConfig,
   listTasks,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taskchef",
-  "version": "7.4.0",
+  "version": "7.5.0",
   "description": "A non-blocking interactive dispatcher for visible Codex tasks.",
   "license": "MIT",
   "author": "Favo Yang",
@@ -26,6 +26,7 @@
     "docs/spec.md",
     "docs/workflows.md",
     "docs/firstmate-taskchef-comparison.md",
+    "docs/images/result-history-dashboard.jpg",
     "index.js",
     "mcp",
     "scripts/benchmark-dispatch-prepare.js",

package/skills/taskchef-report/SKILL.md

@@ -44,14 +44,16 @@ all deterministic task-log operations.
    detailed read. Native approval is live Codex state, not a `needs_input`
    callback. An inactive status never proves semantic completion; it only
    permits a trustworthy cached MCP result to stand.
-4. In schema 5, treat `status`, `turnId`, and `updatedAt` as the latest reported
-   execution state and treat `lastResult` as the separately preserved semantic
-   result. A `working` state with a non-null `lastResult` means a newer executor
+4. In schema 6, treat `status`, `turnId`, and `updatedAt` as the latest reported
+   execution state and treat `results` as the ordered semantic history.
+   `lastResult` is the derived compatibility alias for `results.at(-1)`; prefer
+   the collection when full history matters and the alias for compact latest-state
+   reporting. A `working` state with a non-null `lastResult` means a newer executor
    turn started after that result; show the prior result as history, not as the
    current outcome. Treat a failed `lastResult` with null thread and turn IDs as
-   a fresh executor-creation failure. No live read is possible or needed.
-   Schema 4 snapshots normalize a structurally complete result into
-   `lastResult` without rewriting their log line. When identity is certain and
+   a fresh executor-creation failure. Schema 4/5 snapshots normalize zero or one
+   semantic result into `results` and `lastResult` without rewriting their log line.
+   No live read is possible or needed for that creation failure. When identity is certain and
    metadata says the thread is inactive, trust the latest semantic result by
    default in a broad overview unless a newer working state makes it historical.
    Do not read every idle terminal task in an overview merely because native

package/src/cli.js

@@ -14,6 +14,7 @@ import {
   initializeWorkspace,
   listProjects,
   listTasks,
+  migrateTaskLog,
   prepareDispatch,
   recordTask,
   removeProject,
@@ -182,11 +183,28 @@ function taskDetails(task) {
     `Updated by: ${singleLineDetail(task.updatedBy ?? "-")}`,
     `Task ID: ${singleLineDetail(task.id)}`,
     `Thread ID: ${singleLineDetail(task.threadId ?? "-")}`,
+    `Result count: ${task.results.length}`,
+    "Result history (newest first):",
+    ...[...task.results].reverse().map((result) => (
+      `- ${singleLineDetail(result.updatedAt)} | ${singleLineDetail(result.status)} | turn ${singleLineDetail(result.turnId ?? "-")} | ${singleLineDetail(result.summary)}`
+    )),
     "Instruction:",
     task.instruction,
   ].join("\n");
 }
 
+async function migrate(args) {
+  validateCommandArgs(args, 2, { values: ["--workspace"], switches: ["--json"] });
+  const result = await migrateTaskLog(workspaceRoot(args));
+  print(result, args, (value) => [
+    `Task log: ${value.action}`,
+    `Tasks: ${value.taskCount}`,
+    `Migrated: ${value.migratedCount}`,
+    `Backup: ${value.backupPath ?? "not needed"}`,
+  ].join("\n"));
+  return 0;
+}
+
 async function readTaskForShow(workspace, taskId) {
   const id = requireSafeId(taskId, "taskId");
   const tasks = await listTasks(workspace);
@@ -456,6 +474,7 @@ Usage:
   taskchef doctor [--json] [--workspace <path>]
   taskchef workspace path [--json] [--workspace <path>]
   taskchef workspace init [--register-codex] [--codex-cli <path>] [--json] [--workspace <path>]
+  taskchef workspace migrate [--json] [--workspace <path>]
   taskchef project add <path> [--name <name>] [--description <text>] [--github-repo <url> ... | --no-github] [--json] [--workspace <path>]
   taskchef project import [<file> | -] [--replace] [--json] [--workspace <path>]
   taskchef project list [--json] [--workspace <path>]
@@ -489,6 +508,7 @@ export async function runCli(args) {
   if (args[0] === "doctor") return doctor(args);
   if (args[0] === "workspace" && args[1] === "path") return workspacePath(args);
   if (args[0] === "workspace" && args[1] === "init") return initialize(args);
+  if (args[0] === "workspace" && args[1] === "migrate") return migrate(args);
   if (args[0] === "project" && args[1] === "add") return projectAdd(args);
   if (args[0] === "project" && args[1] === "import") return projectImport(args);
   if (args[0] === "project" && args[1] === "list") return projectList(args);

package/src/dashboard/app.js

@@ -17,6 +17,7 @@ const state = {
   selectedTask: null,
 };
 let dateRefreshTimer = null;
+let detailRequestGeneration = 0;
 
 const elements = {
   clearNotifications: document.querySelector("#clear-notifications"),
@@ -31,7 +32,7 @@ const elements = {
   dialogInstruction: document.querySelector("#dialog-instruction"),
   dialogMetadata: document.querySelector("#dialog-metadata"),
   dialogProject: document.querySelector("#dialog-project"),
-  dialogSummary: document.querySelector("#dialog-summary"),
+  dialogResults: document.querySelector("#dialog-results"),
   dialogTitle: document.querySelector("#dialog-title"),
   dismissDashboardMessage: document.querySelector("#dismiss-dashboard-message"),
   emptyState: document.querySelector("#empty-state"),
@@ -119,12 +120,48 @@ function detailRow(term, value) {
   return [dt, dd];
 }
 
-function openDialog(task) {
-  state.selectedTask = task;
+function resultHistory(results) {
+  if (results.length === 0) {
+    const empty = document.createElement("p");
+    empty.className = "result-history-empty";
+    empty.textContent = "No semantic result has been reported yet.";
+    return [empty];
+  }
+  return [...results].reverse().map((result, index) => {
+    const item = document.createElement("article");
+    item.className = `result-history-item${index === 0 ? " result-history-latest" : ""}`;
+    const header = document.createElement("div");
+    header.className = "result-history-header";
+    const status = document.createElement("span");
+    status.className = `status status-${result.status}`;
+    status.textContent = result.status.replaceAll("_", " ");
+    const timestamp = document.createElement("time");
+    timestamp.dateTime = result.updatedAt;
+    timestamp.textContent = formatTime(result.updatedAt);
+    header.append(status, timestamp);
+    const summary = document.createElement("p");
+    summary.className = "preserve-lines";
+    summary.textContent = result.summary;
+    const turn = document.createElement("p");
+    turn.className = "result-history-turn";
+    turn.textContent = result.turnId ? `Turn ${result.turnId}` : "No turn ID (creation failure)";
+    item.append(header, summary, turn);
+    return item;
+  });
+}
+
+function renderDialog(task) {
+  const preservedResults = state.selectedTask?.id === task.id
+    ? state.selectedTask.results
+    : null;
+  const detailedTask = {
+    ...task,
+    results: task.results ?? preservedResults ?? [],
+  };
+  state.selectedTask = detailedTask;
   elements.dialogProject.textContent = task.project.name;
   elements.dialogTitle.textContent = task.title;
-  elements.dialogSummary.textContent = task.lastResult?.summary
-    ?? "No semantic result has been reported yet.";
+  elements.dialogResults.replaceChildren(...resultHistory(detailedTask.results));
   elements.dialogInstruction.textContent = task.instruction;
   elements.copyThreadId.disabled = !task.threadId;
   elements.dialogMetadata.replaceChildren(
@@ -142,7 +179,28 @@ function openDialog(task) {
     )),
     ...detailRow("Updated by", task.updatedBy),
   );
+}
+
+async function openDialog(task) {
+  const requestGeneration = ++detailRequestGeneration;
+  renderDialog(task);
   if (!elements.dialog.open) elements.dialog.showModal();
+  try {
+    const response = await fetch(`/api/tasks/${encodeURIComponent(task.id)}`);
+    if (!response.ok) throw new Error("Task details are unavailable.");
+    const detail = await response.json();
+    if (
+      requestGeneration === detailRequestGeneration
+      && state.selectedTask?.id === task.id
+      && elements.dialog.open
+    ) {
+      renderDialog(detail.task);
+    }
+  } catch {
+    if (state.selectedTask?.id === task.id) {
+      showMessage("Task result history is temporarily unavailable.");
+    }
+  }
 }
 
 function taskCard(task) {

package/src/dashboard/index.html

@@ -87,8 +87,8 @@
         <button id="copy-thread-id" class="secondary-button" type="button">Copy thread ID</button>
       </div>
       <section>
-        <h3>Result</h3>
-        <p id="dialog-summary" class="preserve-lines"></p>
+        <h3>Result history</h3>
+        <div id="dialog-results" class="result-history"></div>
       </section>
       <section>
         <h3>Original instruction</h3>

package/src/dashboard/styles.css

@@ -117,6 +117,14 @@ dialog::backdrop { background: rgb(18 23 21 / 50%); backdrop-filter: blur(2px);
 .primary-button:disabled, .secondary-button:disabled { opacity: 0.5; cursor: not-allowed; }
 dialog section + section { margin-top: 24px; }
 .preserve-lines { white-space: pre-wrap; }
+.result-history { display: grid; gap: 10px; }
+.result-history-item { padding: 13px 14px; border: 1px solid var(--border); border-radius: 8px; background: var(--surface-muted); }
+.result-history-latest { border-color: var(--accent); background: var(--accent-soft); box-shadow: inset 3px 0 var(--accent); }
+.result-history-header { display: flex; align-items: center; justify-content: space-between; gap: 12px; margin-bottom: 9px; }
+.result-history-item p { margin-bottom: 7px; }
+.result-history-item p:last-child { margin-bottom: 0; }
+.result-history-turn, .result-history-empty { color: var(--muted); font-size: 0.78rem; overflow-wrap: anywhere; }
+.result-history-empty { margin: 0; }
 pre { max-height: 280px; margin: 0; padding: 14px; overflow: auto; border-radius: 7px; background: var(--surface-muted); white-space: pre-wrap; overflow-wrap: anywhere; font: 0.86rem/1.55 ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; }
 .metadata { display: grid; grid-template-columns: minmax(100px, 150px) 1fr; margin: 0; font-size: 0.88rem; }
 .metadata dt, .metadata dd { padding: 7px 0; border-bottom: 1px solid var(--border); overflow-wrap: anywhere; }

package/src/dashboard.js

@@ -136,6 +136,14 @@ function assertDashboardTaskBounds(tasks, maximumTasks) {
     boundedText(task.turnId, 512, `${name} turn ID`);
     boundedText(task.lastResult?.summary, 2_000, `${name} last result summary`);
     boundedText(task.lastResult?.turnId, 512, `${name} last result turn ID`);
+    const results = task.results ?? [];
+    if (results.length > 10_000) {
+      throw new Error(`${name} has too many results for the dashboard`);
+    }
+    for (const [resultIndex, result] of results.entries()) {
+      boundedText(result.summary, 2_000, `${name} result ${resultIndex + 1} summary`);
+      boundedText(result.turnId, 512, `${name} result ${resultIndex + 1} turn ID`);
+    }
     boundedText(task.project.name, 1_000, `${name} project name`);
     boundedText(task.project.path, 8_192, `${name} project path`);
     boundedText(task.project.description, 4_000, `${name} project description`);
@@ -148,6 +156,11 @@ function assertDashboardTaskBounds(tasks, maximumTasks) {
   }
 }
 
+function taskListProjection(task) {
+  const { results: _results, ...projection } = task;
+  return projection;
+}
+
 export class DashboardMonitor extends EventEmitter {
   constructor(workspace, {
     debounceMs = 75,
@@ -197,7 +210,7 @@ export class DashboardMonitor extends EventEmitter {
       generatedAt: new Date().toISOString(),
       healthy: !this.unhealthy,
       tasks: this.tasks.map((task) => ({
-        ...task,
+        ...taskListProjection(task),
         meaningfulUpdatedAt: new Date(
           meaningfulUpdateTime(task, this.observedUpdateTimes),
         ).toISOString(),
@@ -510,6 +523,22 @@ export async function createDashboardServer({
       return;
     }
 
+    const detailMatch = url.pathname.match(/^\/api\/tasks\/([a-zA-Z0-9._-]+)$/);
+    if (detailMatch && (method === "GET" || method === "HEAD")) {
+      const task = monitor.tasks.find((candidate) => candidate.id === detailMatch[1]);
+      if (!task) {
+        sendJson(response, 404, { message: "Task not found." });
+        return;
+      }
+      if (method === "HEAD") {
+        response.writeHead(200, securityHeaders("application/json; charset=utf-8"));
+        response.end();
+      } else {
+        sendJson(response, 200, { schemaVersion: 1, task });
+      }
+      return;
+    }
+
     const taskMatch = url.pathname.match(/^\/api\/tasks\/([a-zA-Z0-9._-]+)\/open-codex$/);
     if (taskMatch && method === "POST") {
       if (request.headers.origin !== allowedOrigin) {

package/src/mcp.js

@@ -21,7 +21,7 @@ const projectSchema = z.object({
 });
 
 const taskSchema = z.object({
-  schemaVersion: z.union([z.literal(4), z.literal(5)]),
+  schemaVersion: z.union([z.literal(4), z.literal(5), z.literal(6)]),
   id: z.string(),
   project: projectSchema,
   title: z.string(),
@@ -33,6 +33,12 @@ const taskSchema = z.object({
   turnId: z.string().nullable(),
   updatedAt: z.string(),
   updatedBy: z.enum(["dispatcher", "mcp"]),
+  results: z.array(z.object({
+    status: z.enum(["needs_input", "completed", "failed"]),
+    summary: z.string(),
+    turnId: z.string().nullable(),
+    updatedAt: z.string(),
+  })),
   lastResult: z.object({
     status: z.enum(["needs_input", "completed", "failed"]),
     summary: z.string(),

package/src/workspace.js

@@ -38,8 +38,9 @@ const DISPATCH_FILE_NAME = "tasks.jsonl";
 const WORKSPACE_LOCK_NAME = ".taskchef-workspace.lock";
 const SAFE_ID = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
 const CURRENT_CONFIG_SCHEMA_VERSION = 2;
-const CURRENT_TASK_SCHEMA_VERSION = 5;
-const PREVIOUS_SELF_LINKING_TASK_SCHEMA_VERSION = 4;
+const CURRENT_TASK_SCHEMA_VERSION = 6;
+const PREVIOUS_TASK_SCHEMA_VERSION = 5;
+const FIRST_SELF_LINKING_TASK_SCHEMA_VERSION = 4;
 const CONFIG_FIELDS = new Set(["schemaVersion", "projects"]);
 const PROJECT_FIELDS = new Set([
   "name",
@@ -63,7 +64,8 @@ const STATEFUL_DISPATCH_FIELDS = new Set([
   "updatedAt",
   "updatedBy",
 ]);
-const DISPATCH_FIELDS = new Set([...STATEFUL_DISPATCH_FIELDS, "lastResult"]);
+const SCHEMA_5_DISPATCH_FIELDS = new Set([...STATEFUL_DISPATCH_FIELDS, "lastResult"]);
+const DISPATCH_FIELDS = new Set([...STATEFUL_DISPATCH_FIELDS, "results"]);
 const RECORD_DISPATCH_FIELDS = new Set([
   "id",
   "project",
@@ -75,7 +77,7 @@ const RESULT_STATUSES = new Set(["needs_input", "completed", "failed"]);
 const TASK_STATUSES = new Set(["working", ...RESULT_STATUSES]);
 const TASK_UPDATE_SOURCES = new Set(["dispatcher", "mcp"]);
 const MAX_RESULT_SUMMARY_LENGTH = 2_000;
-const LAST_RESULT_FIELDS = new Set(["status", "summary", "turnId", "updatedAt"]);
+const RESULT_FIELDS = new Set(["status", "summary", "turnId", "updatedAt"]);
 
 function requireExactFields(value, fields, name) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -221,7 +223,9 @@ async function appendDispatchesAtomic(workspaceRoot, dispatches) {
   if (dispatches.length === 0) return;
   const dispatchPath = path.join(workspaceRoot, DISPATCH_FILE_NAME);
   const content = await readFile(dispatchPath, "utf8");
-  const appended = dispatches.map((dispatch) => `${JSON.stringify(dispatch)}\n`).join("");
+  const appended = dispatches
+    .map((dispatch) => `${JSON.stringify(schema6Task(dispatch))}\n`)
+    .join("");
   await writeTextAtomic(dispatchPath, `${content}${appended}`);
 }
 
@@ -679,7 +683,8 @@ export async function removeProject(workspaceRoot, name) {
 
 async function validateDispatchShape(dispatch, name = "task") {
   const supportedVersions = [
-    PREVIOUS_SELF_LINKING_TASK_SCHEMA_VERSION,
+    FIRST_SELF_LINKING_TASK_SCHEMA_VERSION,
+    PREVIOUS_TASK_SCHEMA_VERSION,
     CURRENT_TASK_SCHEMA_VERSION,
   ];
   if (!supportedVersions.includes(dispatch?.schemaVersion)) {
@@ -687,9 +692,11 @@ async function validateDispatchShape(dispatch, name = "task") {
   }
   requireExactFields(
     dispatch,
-    dispatch.schemaVersion >= CURRENT_TASK_SCHEMA_VERSION
+    dispatch.schemaVersion === CURRENT_TASK_SCHEMA_VERSION
       ? DISPATCH_FIELDS
-      : STATEFUL_DISPATCH_FIELDS,
+      : dispatch.schemaVersion === PREVIOUS_TASK_SCHEMA_VERSION
+        ? SCHEMA_5_DISPATCH_FIELDS
+        : STATEFUL_DISPATCH_FIELDS,
     name,
   );
   const id = requireSafeId(dispatch.id, `${name}.id`);
@@ -700,38 +707,48 @@ async function validateDispatchShape(dispatch, name = "task") {
   });
   const turnId = optionalString(dispatch.turnId, `${name}.turnId`, { maxLength: 256 });
   const updatedAt = requireTimestamp(dispatch.updatedAt, `${name}.updatedAt`);
-  let lastResult = null;
-  if (dispatch.schemaVersion >= CURRENT_TASK_SCHEMA_VERSION) {
-    if (dispatch.lastResult !== null) {
-      requireExactFields(dispatch.lastResult, LAST_RESULT_FIELDS, `${name}.lastResult`);
-      lastResult = {
+  const normalizeResult = (result, resultName) => {
+    requireExactFields(result, RESULT_FIELDS, resultName);
+    const normalizedResult = {
         status: requireEnum(
-          dispatch.lastResult.status,
+          result.status,
           RESULT_STATUSES,
-          `${name}.lastResult.status`,
+          `${resultName}.status`,
         ),
         summary: optionalString(
-          dispatch.lastResult.summary,
-          `${name}.lastResult.summary`,
+          result.summary,
+          `${resultName}.summary`,
           { maxLength: MAX_RESULT_SUMMARY_LENGTH },
         ),
         turnId: optionalString(
-          dispatch.lastResult.turnId,
-          `${name}.lastResult.turnId`,
+          result.turnId,
+          `${resultName}.turnId`,
           { maxLength: 256 },
         ),
         updatedAt: requireTimestamp(
-          dispatch.lastResult.updatedAt,
-          `${name}.lastResult.updatedAt`,
+          result.updatedAt,
+          `${resultName}.updatedAt`,
         ),
-      };
-      if (lastResult.summary === null) {
-        throw new Error(`${name}.lastResult.summary must be a non-empty string`);
-      }
+    };
+    if (normalizedResult.summary === null) {
+      throw new Error(`${resultName}.summary must be a non-empty string`);
+    }
+    return normalizedResult;
+  };
+  let results = [];
+  if (dispatch.schemaVersion === CURRENT_TASK_SCHEMA_VERSION) {
+    if (!Array.isArray(dispatch.results)) throw new Error(`${name}.results must be an array`);
+    results = dispatch.results.map((result, index) => (
+      normalizeResult(result, `${name}.results[${index}]`)
+    ));
+  } else if (dispatch.schemaVersion === PREVIOUS_TASK_SCHEMA_VERSION) {
+    if (dispatch.lastResult !== null) {
+      results = [normalizeResult(dispatch.lastResult, `${name}.lastResult`)];
     }
   } else if (RESULT_STATUSES.has(status)) {
-    lastResult = { status, summary, turnId, updatedAt };
+    results = [{ status, summary, turnId, updatedAt }];
   }
+  const lastResult = results.at(-1) ?? null;
   const normalized = {
     schemaVersion: dispatch.schemaVersion,
     id,
@@ -747,22 +764,25 @@ async function validateDispatchShape(dispatch, name = "task") {
     turnId,
     updatedAt,
     updatedBy: requireEnum(dispatch.updatedBy, TASK_UPDATE_SOURCES, `${name}.updatedBy`),
+    results,
     lastResult,
   };
   const isSelfLinkingRecord = normalized.threadId !== null
     && parseTaskChefMarker(normalized.instruction) === normalized.id;
   if (isSelfLinkingRecord) {
     if (normalized.turnId !== null) {
-      normalizeCodexThreadId(normalized.turnId, `${name}.turnId`);
+      normalized.turnId = normalizeCodexThreadId(normalized.turnId, `${name}.turnId`);
     }
-    if (normalized.lastResult?.turnId != null) {
-      normalizeCodexThreadId(
-        normalized.lastResult.turnId,
-        `${name}.lastResult.turnId`,
-      );
+    for (const [index, result] of normalized.results.entries()) {
+      if (result.turnId != null) {
+        result.turnId = normalizeCodexThreadId(
+          result.turnId,
+          `${name}.results[${index}].turnId`,
+        );
+      }
     }
   }
-  if (normalized.schemaVersion >= PREVIOUS_SELF_LINKING_TASK_SCHEMA_VERSION) {
+  if (normalized.schemaVersion >= FIRST_SELF_LINKING_TASK_SCHEMA_VERSION) {
     if (normalized.threadId === null) {
       const isLinkPending = normalized.status === "working"
         && normalized.summary === null
@@ -782,8 +802,9 @@ async function validateDispatchShape(dispatch, name = "task") {
       if (RESULT_STATUSES.has(normalized.status) && normalized.turnId === null) {
         throw new Error(`${name}.turnId is required for a linked semantic state`);
       }
-      if (normalized.lastResult !== null && normalized.lastResult.turnId === null) {
-        throw new Error(`${name}.lastResult.turnId is required for a linked result`);
+      const resultWithoutTurn = normalized.results.findIndex((result) => result.turnId === null);
+      if (resultWithoutTurn !== -1) {
+        throw new Error(`${name}.results[${resultWithoutTurn}].turnId is required for a linked result`);
       }
     }
   }
@@ -793,7 +814,7 @@ async function validateDispatchShape(dispatch, name = "task") {
   if (RESULT_STATUSES.has(normalized.status) && normalized.summary === null) {
     throw new Error(`${name}.summary is required for status ${normalized.status}`);
   }
-  if (normalized.schemaVersion >= CURRENT_TASK_SCHEMA_VERSION) {
+  if (normalized.schemaVersion >= PREVIOUS_TASK_SCHEMA_VERSION) {
     if (RESULT_STATUSES.has(normalized.status)) {
       if (
         normalized.lastResult === null
@@ -829,6 +850,34 @@ async function validateDispatchShape(dispatch, name = "task") {
       throw new Error(`${name}.turnId must be newer than lastResult.turnId while working`);
     }
   }
+  const seenResultTurns = new Set();
+  const nullTurnKey = Symbol("null turn");
+  for (const [index, result] of normalized.results.entries()) {
+    const turnKey = result.turnId ?? nullTurnKey;
+    if (seenResultTurns.has(turnKey)) {
+      throw new Error(`${name}.results contains duplicate turnId: ${result.turnId ?? "null"}`);
+    }
+    seenResultTurns.add(turnKey);
+    if (Date.parse(result.updatedAt) < Date.parse(normalized.createdAt)) {
+      throw new Error(`${name}.results[${index}].updatedAt must not be earlier than createdAt`);
+    }
+    if (Date.parse(result.updatedAt) > Date.parse(normalized.updatedAt)) {
+      throw new Error(`${name}.results[${index}].updatedAt must not be later than updatedAt`);
+    }
+    if (
+      index > 0
+      && Date.parse(result.updatedAt) < Date.parse(normalized.results[index - 1].updatedAt)
+    ) {
+      throw new Error(`${name}.results must be ordered by updatedAt`);
+    }
+    if (
+      isSelfLinkingRecord
+      && index > 0
+      && result.turnId <= normalized.results[index - 1].turnId
+    ) {
+      throw new Error(`${name}.results must be ordered by turnId`);
+    }
+  }
   if (
     Date.parse(normalized.updatedAt) < Date.parse(normalized.createdAt)
   ) {
@@ -911,6 +960,70 @@ export async function parseTaskLogContent(workspaceRoot, content) {
   return (await parseDispatchRecordsUnlocked(root, content)).map((record) => record.normalized);
 }
 
+function schema6Task(dispatch, patch = {}) {
+  const { lastResult: _lastResult, ...persisted } = dispatch;
+  return {
+    ...persisted,
+    schemaVersion: CURRENT_TASK_SCHEMA_VERSION,
+    results: dispatch.results ?? [],
+    ...patch,
+  };
+}
+
+export async function migrateTaskLog(workspaceRoot, {
+  now = () => new Date().toISOString(),
+  writeTaskLog = writeTextAtomic,
+} = {}) {
+  const root = await realpath(path.resolve(workspaceRoot));
+  return withWorkspaceLock(root, async () => {
+    const dispatchPath = path.join(root, DISPATCH_FILE_NAME);
+    if (!(await managedRegularFileExists(dispatchPath))) {
+      throw new Error(`task log does not exist: ${dispatchPath}`);
+    }
+    const original = await readFile(dispatchPath, "utf8");
+    const records = await parseDispatchRecordsUnlocked(root, original);
+    const migratedCount = records.filter(
+      (record) => record.raw.schemaVersion !== CURRENT_TASK_SCHEMA_VERSION,
+    ).length;
+    if (migratedCount === 0) {
+      return {
+        schemaVersion: CURRENT_TASK_SCHEMA_VERSION,
+        action: "unchanged",
+        taskCount: records.length,
+        migratedCount: 0,
+        backupPath: null,
+      };
+    }
+    const lines = records.map((record) => JSON.stringify(schema6Task(record.normalized)));
+    const migrated = lines.length === 0 ? "" : `${lines.join("\n")}\n`;
+    await parseDispatchRecordsUnlocked(root, migrated);
+    const timestamp = requireTimestamp(now(), "migration timestamp")
+      .replaceAll(":", "-")
+      .replaceAll(".", "-");
+    const backupPath = `${dispatchPath}.pre-v6-${timestamp}-${randomUUID()}.bak`;
+    await writeFile(backupPath, original, { encoding: "utf8", mode: 0o600, flag: "wx" });
+    if (await readFile(backupPath, "utf8") !== original) {
+      throw new Error(`task log backup validation failed: ${backupPath}`);
+    }
+    try {
+      await writeTaskLog(dispatchPath, migrated);
+      await parseDispatchRecordsUnlocked(root, await readFile(dispatchPath, "utf8"));
+    } catch (error) {
+      throw new Error(
+        `task log migration failed after recovery backup ${backupPath}: ${error.message}`,
+        { cause: error },
+      );
+    }
+    return {
+      schemaVersion: CURRENT_TASK_SCHEMA_VERSION,
+      action: "migrated",
+      taskCount: records.length,
+      migratedCount,
+      backupPath,
+    };
+  });
+}
+
 export async function recordTask(workspaceRoot, input, { now } = {}) {
   requireExactFields(input, RECORD_DISPATCH_FIELDS, "task input");
   const root = await realpath(path.resolve(workspaceRoot));
@@ -933,7 +1046,7 @@ export async function recordTask(workspaceRoot, input, { now } = {}) {
       turnId: null,
       updatedAt: createdAt,
       updatedBy: "dispatcher",
-      lastResult: null,
+      results: [],
     });
     const existing = await readDispatchesUnlocked(root);
     if (existing.some((item) => item.id === dispatch.id)) {
@@ -975,13 +1088,11 @@ export async function linkTask(workspaceRoot, taskId, threadId, { now } = {}) {
         throw new Error(`task instruction does not contain its exact TaskChef marker: ${id}`);
       }
       if (dispatch.threadId === durableThreadId) return dispatch;
-      const canonical = await validateDispatchShape({
-        ...dispatch,
-        schemaVersion: CURRENT_TASK_SCHEMA_VERSION,
+      const canonical = await validateDispatchShape(schema6Task(dispatch, {
         threadId: durableThreadId,
         updatedAt: transitionTimestamp(now, dispatch.updatedAt),
         updatedBy: "mcp",
-      });
+      }));
       const lines = records.map((record, recordIndex) => recordIndex === index
         ? dispatchLineWithState(canonical, {})
         : record.line);
@@ -1006,13 +1117,11 @@ export async function linkTask(workspaceRoot, taskId, threadId, { now } = {}) {
     ))) {
       throw new Error(`threadId is already recorded: ${durableThreadId}`);
     }
-    const linked = await validateDispatchShape({
-      ...dispatch,
-      schemaVersion: CURRENT_TASK_SCHEMA_VERSION,
+    const linked = await validateDispatchShape(schema6Task(dispatch, {
       threadId: durableThreadId,
       updatedAt: transitionTimestamp(now, dispatch.updatedAt),
       updatedBy: "mcp",
-    });
+    }));
     const lines = records.map((record, recordIndex) => recordIndex === index
       ? dispatchLineWithState(linked, {})
       : record.line);
@@ -1022,11 +1131,7 @@ export async function linkTask(workspaceRoot, taskId, threadId, { now } = {}) {
 }
 
 function dispatchLineWithState(dispatch, patch) {
-  return JSON.stringify({
-    ...dispatch,
-    schemaVersion: CURRENT_TASK_SCHEMA_VERSION,
-    ...patch,
-  });
+  return JSON.stringify(schema6Task(dispatch, patch));
 }
 
 function normalizeTaskStateInput(input, { allowWorking }) {
@@ -1108,7 +1213,7 @@ async function reportTaskStateInternal(
       if (!compatibilityAlias) {
         const rawSchemaVersion = records[index].raw.schemaVersion;
         const hasCurrentMarker = rawSchemaVersion
-          >= PREVIOUS_SELF_LINKING_TASK_SCHEMA_VERSION
+          >= FIRST_SELF_LINKING_TASK_SCHEMA_VERSION
           && parseTaskChefMarker(dispatch.instruction) === dispatch.id;
         const isFreshCreationFailure = hasCurrentMarker
           && dispatch.status === "working"
@@ -1147,31 +1252,24 @@ async function reportTaskStateInternal(
         }
       }
       const updatedAt = transitionTimestamp(now, dispatch.updatedAt);
-      const updated = await validateDispatchShape({
-        ...dispatch,
-        schemaVersion: CURRENT_TASK_SCHEMA_VERSION,
+      const updated = await validateDispatchShape(schema6Task(dispatch, {
         status,
         summary: null,
         turnId: stateTurnId,
         updatedAt,
         updatedBy: "mcp",
-        lastResult: dispatch.lastResult,
-      });
+      }));
       const lines = records.map((record, recordIndex) => recordIndex === index
         ? dispatchLineWithState(updated, {})
         : record.line);
       await writeDispatchLinesAtomic(root, lines);
       return updated;
     }
-    if (
-      dispatch.status === status
-      && dispatch.turnId === stateTurnId
-      && dispatch.summary === summary
-      && sameLastResult(dispatch.lastResult, { status, summary, turnId: stateTurnId })
-    ) {
+    const priorTurnResult = dispatch.results.find((result) => result.turnId === stateTurnId);
+    if (priorTurnResult && sameLastResult(priorTurnResult, { status, summary, turnId: stateTurnId })) {
       return dispatch;
     }
-    if (dispatch.turnId === stateTurnId && dispatch.status !== "working") {
+    if (priorTurnResult || (dispatch.turnId === stateTurnId && dispatch.status !== "working")) {
       throw new Error(`task turn already has a different semantic result: ${id}`);
     }
     if (compatibilityAlias) {
@@ -1190,16 +1288,14 @@ async function reportTaskStateInternal(
     }
     const updatedAt = transitionTimestamp(now, dispatch.updatedAt);
     const lastResult = { status, summary, turnId: stateTurnId, updatedAt };
-    const candidate = {
-      ...dispatch,
-      schemaVersion: CURRENT_TASK_SCHEMA_VERSION,
+    const candidate = schema6Task(dispatch, {
       status,
       summary,
       turnId: stateTurnId,
       updatedAt,
       updatedBy: "mcp",
-      lastResult,
-    };
+      results: [...dispatch.results, lastResult],
+    });
     const updated = await validateDispatchShape(candidate);
     const lines = records.map((record, recordIndex) => recordIndex === index
       ? dispatchLineWithState(updated, {})