taskchef 7.8.0 → 7.9.0

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "taskchef",
-  "version": "7.8.0",
+  "version": "7.9.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 every semantic result
-while projecting the latest one for compact navigation and reporting.
+work, approvals, and follow-ups happen; TaskChef pairs each turn's request with
+its semantic result while projecting the latest pair for compact navigation.
 
 ```text
-request -> recorded TaskChef task -> Codex executor -> current state + result history
+request -> recorded TaskChef task -> Codex executor -> request/result turn timeline
 ```
 
 ## 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 task snapshot per line (schema 6; schema 4/5 migration supported)
+tasks.jsonl     one task snapshot per line (schema 7; schema 4/5/6 migration supported)
 ```
 
 List or change routing targets conversationally:
@@ -119,12 +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 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.
+When work starts, the executor reports a concise request summary. TaskChef
+appends a `turns` entry that pairs that request with a null result while working,
+then fills the same entry with the semantic outcome. A follow-up therefore shows
+its own request with “In progress,” never the preceding turn's result. Returned
+tasks still derive `results` and `lastResult` as compatibility projections.
+TaskChef does not store transcripts, hidden reasoning, 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
@@ -174,8 +174,9 @@ taskchef dashboard --port 3211
 ```
 
 The loopback dashboard watches `tasks.jsonl`, groups current states, and opens
-linked Codex tasks. List snapshots and SSE events carry only the latest-result
-projection; opening task details fetches the full newest-first result history.
+linked Codex tasks. List snapshots and SSE events carry only the latest
+request/result pair; opening task details fetches the full newest-first activity
+timeline.
 The header shows the running TaskChef package version reported by the same
 bounded health identity used for compatible-listener checks.
 Task and result times are relative through 29 days (with minute detail for the
@@ -203,7 +204,7 @@ no task data, credentials, environment variables, process control, or secrets.
 
 ![Immutable event-time dashboard notifications](docs/images/notification-event-snapshots.jpg)
 
-![Task detail result history](docs/images/result-history-dashboard.jpg)
+![Task detail activity timeline](docs/images/result-history-dashboard.jpg)
 
 ## Common recovery
 
@@ -218,8 +219,8 @@ taskchef doctor
 
 `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`
+4/5/6 task lines to schema 7 under the workspace lock. It validates the complete
+source and converted log before writing, creates an exclusive `tasks.jsonl.pre-v7-*.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
@@ -230,7 +231,7 @@ 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.
 
-Schemas other than 4, 5, and 6 remain unsupported. Retain such a workspace
+Schemas other than 4, 5, 6, and 7 remain unsupported. Retain such a workspace
 unchanged and create a current workspace; the migration command deliberately
 does not guess how to convert unknown formats.
 

package/docs/spec.md

@@ -23,7 +23,7 @@ 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. |
-| **Result history** | The ordered collection of every accepted `completed`, `needs_input`, or `failed` per-turn outcome. |
+| **Turn timeline** | The ordered collection pairing each turn's concise request summary with its eventual semantic result. |
 | **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. |
@@ -69,8 +69,8 @@ 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, 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
+schema-6, or schema-7 records, one per line. Schemas 4 through 6 are supported
+migration/read formats; every new record and state mutation MUST write schema 7. 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
@@ -82,7 +82,7 @@ Every record MUST contain exactly these fields:
 
 | Field | Contract |
 | --- | --- |
-| `schemaVersion` | Integer `6`; schema-4/5 records remain readable until explicit migration or their next mutation. |
+| `schemaVersion` | Integer `7`; schema-4/5/6 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. |
@@ -94,13 +94,12 @@ 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`. |
-| `results` | Ordered oldest-first array of `{status, summary, turnId, updatedAt}` semantic results, with unique turn IDs and nondecreasing timestamps. |
+| `turns` | Ordered oldest-first array of `{turnId, requestSummary, startedAt, result}`. `requestSummary` is null only for migrated/compatibility turns; `result` is null only for the latest working turn or is `{status, summary, updatedAt}`. Canonical self-linking turn IDs are unique. A migrated low-level opaque record may retain one final reused ID to represent its legacy completed-result-plus-working-state ambiguity. |
 
-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)`.
+Returned Task objects MUST additionally expose `latestTurn` as null for an empty
+timeline or the final `turns` entry. They MUST derive `results` from completed
+turns and `lastResult` from the final derived result. These projections MUST NOT
+be persisted in schema 7 and remain compatibility aliases for existing callers.
 
 Task IDs and non-null thread identities MUST be unique. The immutable intent
 fields MUST NOT change after recording.
@@ -238,8 +237,8 @@ new preparation values, though it writes no state.
 
 **Structured output:** `{ task: Task }`.
 
-The returned task has schema 6, `working`, null summary/turn/thread/lastResult,
-an empty `results` array,
+The returned task has schema 7, `working`, null summary/turn/thread/latestTurn/lastResult,
+empty `turns` and derived `results` arrays,
 `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.
@@ -268,7 +267,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 `results`.
+**Mutation:** replaces the current state atomically and preserves `turns`.
 
 **Input:**
 
@@ -279,6 +278,7 @@ marker, or ineligible state fails.
 | `turnId` | Current canonical Codex UUIDv7 for a linked MCP journey; null only for creation failure. Maximum 256 characters at the MCP boundary. |
 | `status` | `working`, `needs_input`, `completed`, or `failed`. |
 | `summary` | Omitted or null for `working`; required non-empty string of at most 2,000 characters otherwise. |
+| `requestSummary` | Concise current request of at most 1,000 characters for `working`; optional for backward compatibility and omitted for semantic states. |
 
 **Structured output:** `{ task: Task }`.
 
@@ -286,10 +286,10 @@ For a linked self-linking journey, `working` MUST identify a turn newer than
 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
-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
+creation `failed` state with both IDs null. Starting work appends one turn with
+its request and a null result; the semantic report fills that same turn's result.
+An identical retry for any settled turn returns success without an append. A
+different request or result for the same turn, a stale turn, or a semantic
 result that does not match the active working turn MUST fail.
 
 **Annotations:** `readOnlyHint: false`, `destructiveHint: true`,
@@ -299,10 +299,10 @@ result that does not match the active working turn MUST fail.
 
 `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/5 records and
+stores its semantic result in a request-unknown turn, including for supported schema-4/5/6 records and
 low-level opaque direct records. It does not accept `working`. New executor
-instructions MUST use `report_state`. Successful mutation upgrades schema 4/5
-to schema 6; unsupported schemas remain rejected.
+instructions MUST use `report_state`. Successful mutation upgrades schema 4/5/6
+to schema 7; unsupported schemas remain rejected.
 
 ## Reporting and dashboard
 
@@ -324,9 +324,9 @@ 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.
+Snapshot and SSE list payloads MUST omit full `turns` and derived `results`
+history and include `latestTurn`. The bounded per-task detail endpoint MAY
+return the full validated task so the dialog can render the paired timeline newest first.
 Dashboard notifications MUST capture an immutable event-time projection of the
 task title, lifecycle state and event, turn ID when present, event timestamp,
 and relevant concise summary. Rendering MUST NOT resolve historical notice text
@@ -358,12 +358,12 @@ its displayed summary when present, event time, and missing-task state.
 
 ## 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,
+`workspace migrate` MUST explicitly convert every supported schema-4/5/6 record
+under the shared lock. Each legacy semantic result becomes a request-unknown
+completed turn; a newer working state becomes a final unfinished turn. Migration
+MUST validate the complete source and complete schema-7 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
+and validate the installed result. A fully schema-7 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.

package/docs/workflows.md

@@ -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-6 snapshot
+  W->>W: Lock, validate, append schema-7 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 ordered
-semantic result history.
+linked task. `report_state` records live turn state as a paired request/result
+timeline.
 
 ```mermaid
 sequenceDiagram
@@ -128,15 +128,15 @@ sequenceDiagram
   participant W as workspace.js
   E->>C: Exact read of linked executor
   C-->>E: Current turn ID
-  E->>M: report_state(..., working, null)
+  E->>M: report_state(..., working, requestSummary)
   M->>W: reportTaskState()
-  W->>W: Store current turn and preserve results
+  W->>W: Append turn with request and null result
   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: Append semantic result and derive lastResult
+    W->>W: Fill that turn's result and derive compatibility results
     W-->>M: Updated task
     M-->>E: Recorded result
   else Same turn and same result
@@ -171,11 +171,11 @@ sequenceDiagram
   U->>E: Provide decision
   E->>C: Read exact executor after follow-up
   C-->>E: turnB
-  E->>M: report_state(..., turnB, working, null)
+  E->>M: report_state(..., turnB, working, requestB)
   M->>W: reportTaskState()
-  W->>W: Require turnB greater and preserve results
-  W-->>M: working snapshot plus history A
-  M-->>E: working snapshot plus history A
+  W->>W: Require turnB greater and append request B
+  W-->>M: working snapshot plus paired timeline
+  M-->>E: working snapshot plus paired timeline
   E->>M: report_state(..., turnB, completed, summaryB)
   M->>W: reportTaskState()
   W-->>M: completed snapshot plus result B
@@ -263,7 +263,7 @@ sequenceDiagram
   F-->>D: Filesystem change
   D->>F: Bounded read from one descriptor
   D->>D: Validate current schema and sort
-  D-->>B: Compact SSE snapshot without results
+  D-->>B: Compact SSE snapshot with latestTurn only
   B->>D: GET task detail on demand
   D-->>B: Full validated history
   B->>D: Open task action
@@ -279,8 +279,8 @@ 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
+snapshot/SSE list projections omit `turns` and derived `results` so repeated
+updates do not resend unnecessary history. A read-only per-task endpoint returns the full timeline only
 when the dialog opens. Historical project paths are untrusted until matched
 against current configuration.
 
@@ -306,14 +306,14 @@ all, and ordinary rerendering do not re-announce retained history. Toast action
 labels remain concise while `aria-describedby` connects the visible summary,
 event time, and missing-task explanation for assistive technology.
 
-## Schema 4/5 migration
+## Schema 4/5/6 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
+writers, validates the complete legacy log, converts schema-4/5/6 results into
+request-unknown completed turns and preserves a newer working turn, 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
+`tasks.jsonl.pre-v7-*.bak` file. The task log is replaced atomically and
+validated again. A second run sees only schema 7 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.
 
@@ -330,7 +330,8 @@ 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, 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.
+Configuration schema 2 and task schemas 4, 5, 6, and 7 are accepted. Schemas
+4/5/6 are read/migration compatibility until an explicit migration or lifecycle
+mutation upgrades each record to schema 7. Schema 7 persists `turns` and derives
+`results`, `lastResult`, and `latestTurn` for compact compatibility. Other schemas
+are rejected without rewrite.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taskchef",
-  "version": "7.8.0",
+  "version": "7.9.0",
   "description": "A non-blocking interactive dispatcher for visible Codex tasks.",
   "license": "MIT",
   "author": "Favo Yang",

package/skills/taskchef-executor/SKILL.md

@@ -31,7 +31,8 @@ Complete this lifecycle setup before substantive assignment work:
 3. Read this exact Codex thread natively and obtain the current turn ID. Do not
    infer it or reuse an earlier turn ID.
 4. Call TaskChef `report_state` with the marked task ID, self-linked thread ID,
-   current turn ID, `status: working`, and an omitted or null summary.
+   current turn ID, `status: working`, an omitted or null result summary, and a
+   concise `requestSummary` describing this turn's assignment or follow-up.
 
 If `CODEX_THREAD_ID`, exact native thread reading, or a required TaskChef tool
 is unavailable, or if linking or the working-state report fails, report the
@@ -56,7 +57,7 @@ turn, run the start lifecycle with its new current turn ID and report that
 turn's actual outcome. Say reporting failures visibly instead of claiming a
 tracked outcome.
 
-Summaries must omit secrets, transcripts, raw command output, hidden reasoning,
+Request and result summaries must omit secrets, transcripts, raw command output, hidden reasoning,
 and unnecessary personal data. Identical lifecycle retries are safe; never
 replace a same-turn report with different content or let an older turn
 overwrite newer state.

package/skills/taskchef-report/SKILL.md

@@ -44,15 +44,14 @@ 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 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. Schema 4/5 snapshots normalize zero or one
-   semantic result into `results` and `lastResult` without rewriting their log line.
+4. In schema 7, treat `turns` as the ordered request/result timeline. Each turn
+   pairs a bounded `requestSummary` with either one semantic `result` or null
+   while work is in progress. `latestTurn` is the compact current pair.
+   `results` and `lastResult` remain derived compatibility projections; do not
+   pair the latest request with an earlier result. Treat a failed result with
+   null thread and turn IDs as a fresh executor-creation failure. Schema 4/5/6
+   snapshots normalize their semantic results into legacy turns with a null
+   request summary 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.

package/src/cli.js

@@ -183,10 +183,10 @@ 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)}`
+    `Turn count: ${task.turns.length}`,
+    "Activity timeline (newest first):",
+    ...[...task.turns].reverse().map((turn) => (
+      `- ${singleLineDetail(turn.startedAt)} | ${singleLineDetail(turn.result?.status ?? "working")} | turn ${singleLineDetail(turn.turnId ?? "-")} | request: ${singleLineDetail(turn.requestSummary ?? "not recorded")} | result: ${singleLineDetail(turn.result?.summary ?? "in progress")}`
     )),
     "Instruction:",
     task.instruction,

package/src/dashboard/app.js

@@ -3,6 +3,8 @@ import {
   dismissNotification,
   findCurrentTask,
   KNOWN_TASK_STATUSES,
+  latestTurnPresentation,
+  mergeProjectedTurns,
   nextDateFilterRefreshDelay,
   notificationDismissLabel,
   notificationOpenLabel,
@@ -222,34 +224,44 @@ function detailRow(term, value) {
   return [dt, dd];
 }
 
-function resultHistory(taskId, results) {
-  if (results.length === 0) {
+function turnTimeline(task) {
+  if (task.turns.length === 0) {
     const empty = document.createElement("p");
     empty.className = "result-history-empty";
-    empty.textContent = "No semantic result has been reported yet.";
+    empty.textContent = "No executor turn has been reported yet.";
     return [empty];
   }
-  return [...results].reverse().map((result, index) => {
+  return [...task.turns].reverse().map((turn, 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 resultKey = result.turnId ?? `${result.status}:${index}`;
-    const timestamp = timestampControl(result.updatedAt, {
-      accessibleName: `Result updated time for ${result.status.replaceAll("_", " ")}`,
-      key: `detail:${taskId}:result:${resultKey}`,
+    const turnStatus = turn.result?.status ?? "working";
+    status.className = `status status-${turnStatus}`;
+    status.textContent = turnStatus.replaceAll("_", " ");
+    const turnKey = turn.turnId ?? `no-turn:${index}`;
+    const timestamp = timestampControl(turn.result?.updatedAt ?? turn.startedAt, {
+      accessibleName: `Turn updated time for ${turnStatus.replaceAll("_", " ")}`,
+      key: `detail:${task.id}:turn:${turnKey}`,
     });
     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);
+    const requestLabel = document.createElement("h4");
+    requestLabel.textContent = "Request";
+    const request = document.createElement("p");
+    request.className = "preserve-lines";
+    request.textContent = turn.requestSummary ?? "Request not recorded by this TaskChef version.";
+    const resultLabel = document.createElement("h4");
+    resultLabel.textContent = "Result";
+    const result = document.createElement("p");
+    result.className = "preserve-lines";
+    result.textContent = turn.result?.summary ?? "In progress";
+    const turnMetadata = document.createElement("p");
+    turnMetadata.className = "result-history-turn";
+    turnMetadata.textContent = turn.turnId
+      ? `Turn ${turn.turnId}`
+      : "No turn ID (creation failure)";
+    item.append(header, requestLabel, request, resultLabel, result, turnMetadata);
     return item;
   });
 }
@@ -260,12 +272,13 @@ function renderDialog(task) {
     : null;
   const detailedTask = {
     ...task,
+    turns: mergeProjectedTurns(task, state.selectedTask?.turns ?? []),
     results: task.results ?? preservedResults ?? [],
   };
   state.selectedTask = detailedTask;
   elements.dialogProject.textContent = task.project.name;
   elements.dialogTitle.textContent = task.title;
-  elements.dialogResults.replaceChildren(...resultHistory(task.id, detailedTask.results));
+  elements.dialogResults.replaceChildren(...turnTimeline(detailedTask));
   elements.dialogInstruction.textContent = task.instruction;
   elements.copyThreadId.disabled = !task.threadId;
   elements.dialogMetadata.replaceChildren(
@@ -313,7 +326,7 @@ async function openDialog(task) {
     }
   } catch {
     if (state.selectedTask?.id === task.id) {
-      showMessage("Task result history is temporarily unavailable.");
+      showMessage("Task activity timeline is temporarily unavailable.");
     }
   }
 }
@@ -337,7 +350,18 @@ function taskCard(task) {
   project.textContent = task.project.name;
   const summary = document.createElement("p");
   summary.className = "task-summary";
-  summary.textContent = task.lastResult?.summary ?? "No semantic result reported yet.";
+  const latest = latestTurnPresentation(task);
+  const requestLabel = document.createElement("strong");
+  requestLabel.textContent = "Request";
+  const request = document.createElement("span");
+  request.className = "preserve-lines";
+  request.textContent = latest.requestSummary;
+  const resultLabel = document.createElement("strong");
+  resultLabel.textContent = "Result";
+  const result = document.createElement("span");
+  result.className = "preserve-lines";
+  result.textContent = latest.resultSummary;
+  summary.replaceChildren(requestLabel, request, resultLabel, result);
   const time = timestampControl(
     task.meaningfulUpdatedAt ?? task.updatedAt ?? task.createdAt,
     {

package/src/dashboard/index.html

@@ -94,7 +94,7 @@
         <button id="copy-thread-id" class="secondary-button" type="button">Copy thread ID</button>
       </div>
       <section>
-        <h3>Result history</h3>
+        <h3>Activity timeline</h3>
         <div id="dialog-results" class="result-history"></div>
       </section>
       <section>

package/src/dashboard/state.js

@@ -31,6 +31,37 @@ export function taskStatusLabel(task) {
   return task.status === null ? "unresolved" : task.status.replaceAll("_", " ");
 }
 
+export function latestTurnPresentation(task) {
+  const turn = task.latestTurn ?? null;
+  const result = turn?.result ?? null;
+  const requestSummary = turn?.requestSummary
+    ?? (turn ? "Request not recorded by this TaskChef version." : task.title);
+  return {
+    turnId: turn?.turnId ?? task.turnId ?? null,
+    startedAt: turn?.startedAt ?? task.updatedAt ?? task.createdAt ?? null,
+    requestSummary,
+    resultStatus: result?.status ?? (task.status === "working" ? "working" : task.status),
+    resultSummary: result?.summary
+      ?? (task.status === "working"
+        ? "In progress"
+        : task.lastResult?.summary ?? task.summary ?? "No result reported."),
+    resultUpdatedAt: result?.updatedAt ?? null,
+  };
+}
+
+export function mergeProjectedTurns(task, preservedTurns = []) {
+  if (Array.isArray(task.turns)) return task.turns;
+  if (!task.latestTurn) return preservedTurns;
+  const turns = [...preservedTurns];
+  const lastIndex = turns.length - 1;
+  if (lastIndex >= 0 && turns[lastIndex].turnId === task.latestTurn.turnId) {
+    turns[lastIndex] = task.latestTurn;
+  } else {
+    turns.push(task.latestTurn);
+  }
+  return turns;
+}
+
 export function notificationTitle(notification) {
   return NOTIFICATION_TITLES.get(notification.event) ?? "Task updated";
 }

package/src/dashboard/styles.css

@@ -79,7 +79,8 @@ select { min-width: 180px; padding: 9px 34px 9px 11px; border: 1px solid var(--b
 .task-title:hover { color: var(--accent); text-decoration: underline; text-underline-offset: 3px; }
 .task-project { margin: 3px 0 12px; font-size: 0.86rem; }
 .task-title, .task-summary { overflow-wrap: anywhere; }
-.task-summary { max-width: 78ch; margin-bottom: 14px; }
+.task-summary { display: grid; max-width: 78ch; margin-bottom: 14px; gap: 3px; }
+.task-summary strong { margin-top: 5px; color: var(--muted); font-size: 0.72rem; letter-spacing: 0.04em; text-transform: uppercase; }
 time, .timestamp-missing { font-size: 0.78rem; }
 .timestamp-toggle { padding: 2px 0; border: 0; background: none; cursor: pointer; text-align: left; }
 .timestamp-toggle:hover time { color: var(--text); text-decoration: underline; text-underline-offset: 3px; }
@@ -133,6 +134,7 @@ dialog section + section { margin-top: 24px; }
 .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-item h4 { margin: 10px 0 3px; color: var(--muted); font-size: 0.72rem; letter-spacing: 0.04em; text-transform: uppercase; }
 .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; }

package/src/dashboard.js

@@ -139,6 +139,17 @@ 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`);
+    boundedText(task.latestTurn?.requestSummary, 1_000, `${name} latest request summary`);
+    boundedText(task.latestTurn?.turnId, 512, `${name} latest turn ID`);
+    const turns = task.turns ?? [];
+    if (turns.length > 10_000) {
+      throw new Error(`${name} has too many turns for the dashboard`);
+    }
+    for (const [turnIndex, turn] of turns.entries()) {
+      boundedText(turn.requestSummary, 1_000, `${name} turn ${turnIndex + 1} request summary`);
+      boundedText(turn.turnId, 512, `${name} turn ${turnIndex + 1} turn ID`);
+      boundedText(turn.result?.summary, 2_000, `${name} turn ${turnIndex + 1} result summary`);
+    }
     const results = task.results ?? [];
     if (results.length > 10_000) {
       throw new Error(`${name} has too many results for the dashboard`);
@@ -160,7 +171,7 @@ function assertDashboardTaskBounds(tasks, maximumTasks) {
 }
 
 function taskListProjection(task) {
-  const { results: _results, ...projection } = task;
+  const { turns: _turns, results: _results, ...projection } = task;
   return projection;
 }
 

package/src/delegation.js

@@ -5,7 +5,7 @@ export const EXECUTOR_OWNERSHIP_PARAGRAPH = "This task owns the delegated assign
 /** @deprecated Historical v7 inline-prompt snapshot. New delegations use taskchef-executor. */
 export const EXECUTOR_LINK_PARAGRAPH = "Before any other work, read this executor's own durable Codex thread ID from the current task's CODEX_THREAD_ID environment value and call the TaskChef link_task MCP tool with that thread ID and the marked TaskChef task ID. Never use CODEX_SESSION_ID or the parent or delegator thread ID. If linking fails, CODEX_THREAD_ID is unavailable, or the tool is unavailable, report the failure visibly and retry on a later turn; do not guess an identity or continue substantive work while the task is link-pending.";
 /** @deprecated Historical v7 inline-prompt snapshot. New delegations use taskchef-executor. */
-export const EXECUTOR_WORKING_PARAGRAPH = "After a successful initial link, and at the start of every follow-up turn before substantive work, read this exact Codex thread natively to obtain the current turn ID and call TaskChef report_state with the marked task ID, the self-linked thread ID, that current turn ID, status working, and summary omitted or null. link_task remains the first TaskChef action on the initial turn; do not report working before identity is linked. Never reuse a prior turn ID after a follow-up.";
+export const EXECUTOR_WORKING_PARAGRAPH = "After a successful initial link, and at the start of every follow-up turn before substantive work, read this exact Codex thread natively to obtain the current turn ID and call TaskChef report_state with the marked task ID, the self-linked thread ID, that current turn ID, status working, summary omitted or null, and a concise requestSummary for this turn. link_task remains the first TaskChef action on the initial turn; do not report working before identity is linked. Never reuse a prior turn ID after a follow-up.";
 /** @deprecated Historical v7 inline-prompt snapshot. New delegations use taskchef-executor. */
 export const EXECUTOR_RESULT_PARAGRAPH = "Before ending, read this exact Codex thread again and call TaskChef report_state for the same current working turn with status completed, needs_input, or failed and a concise summary. Use needs_input only for a semantic decision or information the user must provide; a native approval prompt is live Codex state, not a TaskChef result. Do not include secrets, transcripts, or raw command output.";
 export const EXECUTOR_SKILL_INVOCATION = "Use $taskchef-executor to execute and report this delegated TaskChef assignment.";

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), z.literal(6)]),
+  schemaVersion: z.union([z.literal(4), z.literal(5), z.literal(6), z.literal(7)]),
   id: z.string(),
   project: projectSchema,
   title: z.string(),
@@ -33,6 +33,26 @@ const taskSchema = z.object({
   turnId: z.string().nullable(),
   updatedAt: z.string(),
   updatedBy: z.enum(["dispatcher", "mcp"]),
+  turns: z.array(z.object({
+    turnId: z.string().nullable(),
+    requestSummary: z.string().nullable(),
+    startedAt: z.string(),
+    result: z.object({
+      status: z.enum(["needs_input", "completed", "failed"]),
+      summary: z.string(),
+      updatedAt: z.string(),
+    }).nullable(),
+  })),
+  latestTurn: z.object({
+    turnId: z.string().nullable(),
+    requestSummary: z.string().nullable(),
+    startedAt: z.string(),
+    result: z.object({
+      status: z.enum(["needs_input", "completed", "failed"]),
+      summary: z.string(),
+      updatedAt: z.string(),
+    }).nullable(),
+  }).nullable(),
   results: z.array(z.object({
     status: z.enum(["needs_input", "completed", "failed"]),
     summary: z.string(),
@@ -203,13 +223,14 @@ export function createTaskChefMcpServer({
     {
       title: "Report TaskChef state",
       description:
-        "Report this self-linked executor turn's lifecycle state. Use working before substantive work in a newly linked or follow-up turn, with summary omitted or null. Before ending the same turn, report needs_input, completed, or failed with a concise semantic summary. Exact retries are idempotent; stale or mismatched turns are rejected.",
+        "Report this self-linked executor turn's lifecycle state. Use working before substantive work in a newly linked or follow-up turn, with summary omitted or null and a concise requestSummary. Before ending the same turn, report needs_input, completed, or failed with a concise semantic summary and requestSummary omitted. Exact retries are idempotent; stale or mismatched turns are rejected.",
       inputSchema: {
         taskId: z.string().min(1),
         threadId: z.string().min(1).nullable(),
         turnId: z.string().min(1).max(256).nullable(),
         status: z.enum(["working", "needs_input", "completed", "failed"]),
         summary: z.string().min(1).max(2_000).nullable().optional(),
+        requestSummary: z.string().min(1).max(1_000).nullable().optional(),
       },
       outputSchema: { task: taskSchema },
       annotations: {

package/src/workspace.js

@@ -38,8 +38,8 @@ 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 = 6;
-const PREVIOUS_TASK_SCHEMA_VERSION = 5;
+const CURRENT_TASK_SCHEMA_VERSION = 7;
+const PREVIOUS_TASK_SCHEMA_VERSION = 6;
 const FIRST_SELF_LINKING_TASK_SCHEMA_VERSION = 4;
 const CONFIG_FIELDS = new Set(["schemaVersion", "projects"]);
 const PROJECT_FIELDS = new Set([
@@ -65,7 +65,8 @@ const STATEFUL_DISPATCH_FIELDS = new Set([
   "updatedBy",
 ]);
 const SCHEMA_5_DISPATCH_FIELDS = new Set([...STATEFUL_DISPATCH_FIELDS, "lastResult"]);
-const DISPATCH_FIELDS = new Set([...STATEFUL_DISPATCH_FIELDS, "results"]);
+const SCHEMA_6_DISPATCH_FIELDS = new Set([...STATEFUL_DISPATCH_FIELDS, "results"]);
+const DISPATCH_FIELDS = new Set([...STATEFUL_DISPATCH_FIELDS, "turns"]);
 const RECORD_DISPATCH_FIELDS = new Set([
   "id",
   "project",
@@ -77,7 +78,10 @@ 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 MAX_REQUEST_SUMMARY_LENGTH = 1_000;
 const RESULT_FIELDS = new Set(["status", "summary", "turnId", "updatedAt"]);
+const TURN_RESULT_FIELDS = new Set(["status", "summary", "updatedAt"]);
+const TURN_FIELDS = new Set(["turnId", "requestSummary", "startedAt", "result"]);
 
 function requireExactFields(value, fields, name) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -224,7 +228,7 @@ async function appendDispatchesAtomic(workspaceRoot, dispatches) {
   const dispatchPath = path.join(workspaceRoot, DISPATCH_FILE_NAME);
   const content = await readFile(dispatchPath, "utf8");
   const appended = dispatches
-    .map((dispatch) => `${JSON.stringify(schema6Task(dispatch))}\n`)
+    .map((dispatch) => `${JSON.stringify(schema7Task(dispatch))}\n`)
     .join("");
   await writeTextAtomic(dispatchPath, `${content}${appended}`);
 }
@@ -684,6 +688,7 @@ export async function removeProject(workspaceRoot, name) {
 async function validateDispatchShape(dispatch, name = "task") {
   const supportedVersions = [
     FIRST_SELF_LINKING_TASK_SCHEMA_VERSION,
+    5,
     PREVIOUS_TASK_SCHEMA_VERSION,
     CURRENT_TASK_SCHEMA_VERSION,
   ];
@@ -695,6 +700,8 @@ async function validateDispatchShape(dispatch, name = "task") {
     dispatch.schemaVersion === CURRENT_TASK_SCHEMA_VERSION
       ? DISPATCH_FIELDS
       : dispatch.schemaVersion === PREVIOUS_TASK_SCHEMA_VERSION
+        ? SCHEMA_6_DISPATCH_FIELDS
+        : dispatch.schemaVersion === 5
         ? SCHEMA_5_DISPATCH_FIELDS
         : STATEFUL_DISPATCH_FIELDS,
     name,
@@ -735,20 +742,77 @@ async function validateDispatchShape(dispatch, name = "task") {
     }
     return normalizedResult;
   };
-  let results = [];
+  const normalizeTurnResult = (result, resultName) => {
+    if (result === null) return null;
+    requireExactFields(result, TURN_RESULT_FIELDS, resultName);
+    const normalizedResult = {
+      status: requireEnum(result.status, RESULT_STATUSES, `${resultName}.status`),
+      summary: optionalString(result.summary, `${resultName}.summary`, {
+        maxLength: MAX_RESULT_SUMMARY_LENGTH,
+      }),
+      updatedAt: requireTimestamp(result.updatedAt, `${resultName}.updatedAt`),
+    };
+    if (normalizedResult.summary === null) {
+      throw new Error(`${resultName}.summary must be a non-empty string`);
+    }
+    return normalizedResult;
+  };
+  const normalizeTurn = (turn, turnName) => {
+    requireExactFields(turn, TURN_FIELDS, turnName);
+    return {
+      turnId: optionalString(turn.turnId, `${turnName}.turnId`, { maxLength: 256 }),
+      requestSummary: optionalString(turn.requestSummary, `${turnName}.requestSummary`, {
+        maxLength: MAX_REQUEST_SUMMARY_LENGTH,
+      }),
+      startedAt: requireTimestamp(turn.startedAt, `${turnName}.startedAt`),
+      result: normalizeTurnResult(turn.result, `${turnName}.result`),
+    };
+  };
+  let legacyResults = [];
+  let turns = [];
   if (dispatch.schemaVersion === CURRENT_TASK_SCHEMA_VERSION) {
+    if (!Array.isArray(dispatch.turns)) throw new Error(`${name}.turns must be an array`);
+    turns = dispatch.turns.map((turn, index) => normalizeTurn(turn, `${name}.turns[${index}]`));
+  } else if (dispatch.schemaVersion === PREVIOUS_TASK_SCHEMA_VERSION) {
     if (!Array.isArray(dispatch.results)) throw new Error(`${name}.results must be an array`);
-    results = dispatch.results.map((result, index) => (
+    legacyResults = dispatch.results.map((result, index) => (
       normalizeResult(result, `${name}.results[${index}]`)
     ));
-  } else if (dispatch.schemaVersion === PREVIOUS_TASK_SCHEMA_VERSION) {
+  } else if (dispatch.schemaVersion === 5) {
     if (dispatch.lastResult !== null) {
-      results = [normalizeResult(dispatch.lastResult, `${name}.lastResult`)];
+      legacyResults = [normalizeResult(dispatch.lastResult, `${name}.lastResult`)];
     }
   } else if (RESULT_STATUSES.has(status)) {
-    results = [{ status, summary, turnId, updatedAt }];
+    legacyResults = [{ status, summary, turnId, updatedAt }];
   }
+  if (dispatch.schemaVersion !== CURRENT_TASK_SCHEMA_VERSION) {
+    turns = legacyResults.map((result) => ({
+      turnId: result.turnId,
+      requestSummary: null,
+      startedAt: result.updatedAt,
+      result: {
+        status: result.status,
+        summary: result.summary,
+        updatedAt: result.updatedAt,
+      },
+    }));
+    if (
+      status === "working"
+      && turnId !== null
+      && (
+        turns.at(-1)?.turnId !== turnId
+        || turns.at(-1)?.result !== null
+      )
+    ) {
+      turns.push({ turnId, requestSummary: null, startedAt: updatedAt, result: null });
+    }
+  }
+  const results = turns.flatMap((turn) => turn.result === null ? [] : [{
+    ...turn.result,
+    turnId: turn.turnId,
+  }]);
   const lastResult = results.at(-1) ?? null;
+  const latestTurn = turns.at(-1) ?? null;
   const normalized = {
     schemaVersion: dispatch.schemaVersion,
     id,
@@ -764,6 +828,8 @@ async function validateDispatchShape(dispatch, name = "task") {
     turnId,
     updatedAt,
     updatedBy: requireEnum(dispatch.updatedBy, TASK_UPDATE_SOURCES, `${name}.updatedBy`),
+    turns,
+    latestTurn,
     results,
     lastResult,
   };
@@ -773,14 +839,20 @@ async function validateDispatchShape(dispatch, name = "task") {
     if (normalized.turnId !== null) {
       normalized.turnId = normalizeCodexThreadId(normalized.turnId, `${name}.turnId`);
     }
-    for (const [index, result] of normalized.results.entries()) {
-      if (result.turnId != null) {
-        result.turnId = normalizeCodexThreadId(
-          result.turnId,
-          `${name}.results[${index}].turnId`,
+    for (const [index, turn] of normalized.turns.entries()) {
+      if (turn.turnId != null) {
+        turn.turnId = normalizeCodexThreadId(
+          turn.turnId,
+          `${name}.turns[${index}].turnId`,
         );
       }
     }
+    normalized.results = normalized.turns.flatMap((turn) => turn.result === null ? [] : [{
+      ...turn.result,
+      turnId: turn.turnId,
+    }]);
+    normalized.lastResult = normalized.results.at(-1) ?? null;
+    normalized.latestTurn = normalized.turns.at(-1) ?? null;
   }
   if (normalized.schemaVersion >= FIRST_SELF_LINKING_TASK_SCHEMA_VERSION) {
     if (normalized.threadId === null) {
@@ -814,7 +886,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 >= PREVIOUS_TASK_SCHEMA_VERSION) {
+  if (normalized.schemaVersion >= 5) {
     if (RESULT_STATUSES.has(normalized.status)) {
       if (
         normalized.lastResult === null
@@ -850,32 +922,76 @@ async function validateDispatchShape(dispatch, name = "task") {
       throw new Error(`${name}.turnId must be newer than lastResult.turnId while working`);
     }
   }
-  const seenResultTurns = new Set();
+  if (normalized.status === "working") {
+    if (normalized.turnId === null) {
+      if (normalized.turns.length !== 0) {
+        throw new Error(`${name}.turns must be empty before the first working turn`);
+      }
+    } else if (
+      normalized.latestTurn === null
+      || normalized.latestTurn.turnId !== normalized.turnId
+      || normalized.latestTurn.result !== null
+    ) {
+      throw new Error(`${name}.latestTurn must match the current working turn`);
+    }
+  }
+  if (RESULT_STATUSES.has(normalized.status)) {
+    if (
+      normalized.latestTurn === null
+      || normalized.latestTurn.turnId !== normalized.turnId
+      || normalized.latestTurn.result === null
+      || normalized.latestTurn.result.status !== normalized.status
+      || normalized.latestTurn.result.summary !== normalized.summary
+      || normalized.latestTurn.result.updatedAt !== normalized.updatedAt
+    ) {
+      throw new Error(`${name}.latestTurn must match the current semantic state`);
+    }
+  }
+  const seenTurnIds = 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"}`);
+  for (const [index, turn] of normalized.turns.entries()) {
+    const turnKey = turn.turnId ?? nullTurnKey;
+    const isLegacyOpaqueWorkingReuse = (
+      !isSelfLinkingRecord
+      && normalized.status === "working"
+      && index === normalized.turns.length - 1
+      && turn.result === null
+      && index > 0
+      && normalized.turns[index - 1].turnId === turn.turnId
+      && normalized.turns[index - 1].result !== null
+    );
+    if (seenTurnIds.has(turnKey) && !isLegacyOpaqueWorkingReuse) {
+      throw new Error(`${name}.turns contains duplicate turnId: ${turn.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`);
+    seenTurnIds.add(turnKey);
+    if (Date.parse(turn.startedAt) < Date.parse(normalized.createdAt)) {
+      throw new Error(`${name}.turns[${index}].startedAt 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 (Date.parse(turn.startedAt) > Date.parse(normalized.updatedAt)) {
+      throw new Error(`${name}.turns[${index}].startedAt must not be later than updatedAt`);
     }
     if (
       index > 0
-      && Date.parse(result.updatedAt) < Date.parse(normalized.results[index - 1].updatedAt)
+      && Date.parse(turn.startedAt) < Date.parse(normalized.turns[index - 1].startedAt)
     ) {
-      throw new Error(`${name}.results must be ordered by updatedAt`);
+      throw new Error(`${name}.turns must be ordered by startedAt`);
     }
     if (
       isSelfLinkingRecord
       && index > 0
-      && result.turnId <= normalized.results[index - 1].turnId
+      && turn.turnId <= normalized.turns[index - 1].turnId
     ) {
-      throw new Error(`${name}.results must be ordered by turnId`);
+      throw new Error(`${name}.turns must be ordered by turnId`);
+    }
+    if (turn.result !== null) {
+      if (Date.parse(turn.result.updatedAt) < Date.parse(turn.startedAt)) {
+        throw new Error(`${name}.turns[${index}].result.updatedAt must not be earlier than startedAt`);
+      }
+      if (Date.parse(turn.result.updatedAt) > Date.parse(normalized.updatedAt)) {
+        throw new Error(`${name}.turns[${index}].result.updatedAt must not be later than updatedAt`);
+      }
+    } else if (index !== normalized.turns.length - 1) {
+      throw new Error(`${name}.turns may contain an unfinished turn only at the end`);
     }
   }
   if (
@@ -960,12 +1076,17 @@ export async function parseTaskLogContent(workspaceRoot, content) {
   return (await parseDispatchRecordsUnlocked(root, content)).map((record) => record.normalized);
 }
 
-function schema6Task(dispatch, patch = {}) {
-  const { lastResult: _lastResult, ...persisted } = dispatch;
+function schema7Task(dispatch, patch = {}) {
+  const {
+    latestTurn: _latestTurn,
+    results: _results,
+    lastResult: _lastResult,
+    ...persisted
+  } = dispatch;
   return {
     ...persisted,
     schemaVersion: CURRENT_TASK_SCHEMA_VERSION,
-    results: dispatch.results ?? [],
+    turns: dispatch.turns ?? [],
     ...patch,
   };
 }
@@ -994,13 +1115,13 @@ export async function migrateTaskLog(workspaceRoot, {
         backupPath: null,
       };
     }
-    const lines = records.map((record) => JSON.stringify(schema6Task(record.normalized)));
+    const lines = records.map((record) => JSON.stringify(schema7Task(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`;
+    const backupPath = `${dispatchPath}.pre-v7-${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}`);
@@ -1046,7 +1167,7 @@ export async function recordTask(workspaceRoot, input, { now } = {}) {
       turnId: null,
       updatedAt: createdAt,
       updatedBy: "dispatcher",
-      results: [],
+      turns: [],
     });
     const existing = await readDispatchesUnlocked(root);
     if (existing.some((item) => item.id === dispatch.id)) {
@@ -1088,7 +1209,7 @@ 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(schema6Task(dispatch, {
+      const canonical = await validateDispatchShape(schema7Task(dispatch, {
         threadId: durableThreadId,
         updatedAt: transitionTimestamp(now, dispatch.updatedAt),
         updatedBy: "mcp",
@@ -1117,7 +1238,7 @@ export async function linkTask(workspaceRoot, taskId, threadId, { now } = {}) {
     ))) {
       throw new Error(`threadId is already recorded: ${durableThreadId}`);
     }
-    const linked = await validateDispatchShape(schema6Task(dispatch, {
+    const linked = await validateDispatchShape(schema7Task(dispatch, {
       threadId: durableThreadId,
       updatedAt: transitionTimestamp(now, dispatch.updatedAt),
       updatedBy: "mcp",
@@ -1131,11 +1252,13 @@ export async function linkTask(workspaceRoot, taskId, threadId, { now } = {}) {
 }
 
 function dispatchLineWithState(dispatch, patch) {
-  return JSON.stringify(schema6Task(dispatch, patch));
+  return JSON.stringify(schema7Task(dispatch, patch));
 }
 
 function normalizeTaskStateInput(input, { allowWorking }) {
-  const fields = new Set(["taskId", "threadId", "turnId", "status", "summary"]);
+  const fields = new Set([
+    "taskId", "threadId", "turnId", "status", "summary", "requestSummary",
+  ]);
   if (!input || typeof input !== "object" || Array.isArray(input)) {
     throw new Error("task state must be an object");
   }
@@ -1157,13 +1280,21 @@ function normalizeTaskStateInput(input, { allowWorking }) {
   const summary = optionalString("summary" in input ? input.summary : null, "summary", {
     maxLength: MAX_RESULT_SUMMARY_LENGTH,
   });
+  const requestSummary = optionalString(
+    "requestSummary" in input ? input.requestSummary : null,
+    "requestSummary",
+    { maxLength: MAX_REQUEST_SUMMARY_LENGTH },
+  );
   if (status === "working" && summary !== null) {
     throw new Error("summary must be null while status is working");
   }
   if (status !== "working" && summary === null) {
     throw new Error(`summary is required for status ${status}`);
   }
-  return { id, threadId, turnId, status, summary };
+  if (status !== "working" && requestSummary !== null) {
+    throw new Error(`requestSummary is accepted only for status working`);
+  }
+  return { id, threadId, turnId, status, summary, requestSummary };
 }
 
 function sameLastResult(lastResult, { status, summary, turnId }) {
@@ -1178,7 +1309,7 @@ async function reportTaskStateInternal(
   input,
   { now, compatibilityAlias = false } = {},
 ) {
-  const { id, threadId, turnId, status, summary } = normalizeTaskStateInput(input, {
+  const { id, threadId, turnId, status, summary, requestSummary } = normalizeTaskStateInput(input, {
     allowWorking: !compatibilityAlias,
   });
   const root = await realpath(path.resolve(workspaceRoot));
@@ -1242,22 +1373,51 @@ async function reportTaskStateInternal(
       }
     }
     if (status === "working") {
-      if (dispatch.status === "working" && stateTurnId === dispatch.turnId) return dispatch;
+      const sameWorkingTurn = dispatch.status === "working" && stateTurnId === dispatch.turnId;
+      if (sameWorkingTurn) {
+        const storedRequest = dispatch.latestTurn?.requestSummary ?? null;
+        if (
+          requestSummary !== null
+          && storedRequest !== null
+          && requestSummary !== storedRequest
+        ) {
+          throw new Error(`working turn already has a different requestSummary: ${id}`);
+        }
+        if (
+          records[index].raw.schemaVersion === CURRENT_TASK_SCHEMA_VERSION
+          && (requestSummary === null || storedRequest === requestSummary)
+        ) {
+          return dispatch;
+        }
+      }
       if (isSelfLinkingJourney) {
-        if (dispatch.turnId !== null && stateTurnId <= dispatch.turnId) {
+        if (!sameWorkingTurn && dispatch.turnId !== null && stateTurnId <= dispatch.turnId) {
           throw new Error(`working turnId must be newer than the current task turnId: ${id}`);
         }
-        if (dispatch.lastResult?.turnId != null && stateTurnId <= dispatch.lastResult.turnId) {
+        if (!sameWorkingTurn && dispatch.lastResult?.turnId != null && stateTurnId <= dispatch.lastResult.turnId) {
           throw new Error(`working turnId must be newer than the last result turnId: ${id}`);
         }
       }
-      const updatedAt = transitionTimestamp(now, dispatch.updatedAt);
-      const updated = await validateDispatchShape(schema6Task(dispatch, {
+      const updatedAt = sameWorkingTurn
+        ? dispatch.updatedAt
+        : transitionTimestamp(now, dispatch.updatedAt);
+      const turns = sameWorkingTurn
+        ? dispatch.turns.map((turn, turnIndex) => turnIndex === dispatch.turns.length - 1
+          ? { ...turn, requestSummary: turn.requestSummary ?? requestSummary }
+          : turn)
+        : [...dispatch.turns, {
+          turnId: stateTurnId,
+          requestSummary,
+          startedAt: updatedAt,
+          result: null,
+        }];
+      const updated = await validateDispatchShape(schema7Task(dispatch, {
         status,
         summary: null,
         turnId: stateTurnId,
         updatedAt,
         updatedBy: "mcp",
+        turns,
       }));
       const lines = records.map((record, recordIndex) => recordIndex === index
         ? dispatchLineWithState(updated, {})
@@ -1265,7 +1425,10 @@ async function reportTaskStateInternal(
       await writeDispatchLinesAtomic(root, lines);
       return updated;
     }
-    const priorTurnResult = dispatch.results.find((result) => result.turnId === stateTurnId);
+    const priorTurn = dispatch.turns.find((turn) => turn.turnId === stateTurnId);
+    const priorTurnResult = priorTurn?.result === null || priorTurn === undefined
+      ? null
+      : { ...priorTurn.result, turnId: priorTurn.turnId };
     if (priorTurnResult && sameLastResult(priorTurnResult, { status, summary, turnId: stateTurnId })) {
       return dispatch;
     }
@@ -1287,14 +1450,28 @@ async function reportTaskStateInternal(
       throw new Error(`task result must match the current working turnId: ${id}`);
     }
     const updatedAt = transitionTimestamp(now, dispatch.updatedAt);
-    const lastResult = { status, summary, turnId: stateTurnId, updatedAt };
-    const candidate = schema6Task(dispatch, {
+    const turnResult = { status, summary, updatedAt };
+    const currentTurnIndex = dispatch.turns.findIndex((turn) => turn.turnId === stateTurnId);
+    let turns;
+    if (currentTurnIndex === -1) {
+      turns = [...dispatch.turns, {
+        turnId: stateTurnId,
+        requestSummary: null,
+        startedAt: updatedAt,
+        result: turnResult,
+      }];
+    } else {
+      turns = dispatch.turns.map((turn, turnIndex) => turnIndex === currentTurnIndex
+        ? { ...turn, result: turnResult }
+        : turn);
+    }
+    const candidate = schema7Task(dispatch, {
       status,
       summary,
       turnId: stateTurnId,
       updatedAt,
       updatedBy: "mcp",
-      results: [...dispatch.results, lastResult],
+      turns,
     });
     const updated = await validateDispatchShape(candidate);
     const lines = records.map((record, recordIndex) => recordIndex === index