taskchef 7.0.0 → 7.1.0

package/.codex-plugin/plugin.json

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

package/README.md

@@ -7,7 +7,7 @@ work, approvals, and follow-ups happen; TaskChef keeps the latest compact
 snapshot for navigation and reporting.
 
 ```text
-request -> recorded TaskChef task -> Codex executor -> latest semantic result
+request -> recorded TaskChef task -> Codex executor -> current state + last result
 ```
 
 ## Which document should I read?
@@ -48,7 +48,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 snapshot per task
+tasks.jsonl     one schema-4/5 snapshot per task (new writes use schema 5)
 ```
 
 List or change routing targets conversationally:
@@ -92,17 +92,22 @@ outcomes may become separate executors; dependent work should stay together.
 
 ## Work with and report executors
 
-Open an executor as an ordinary Codex task. Each executor reports its latest
-semantic outcome:
+Open an executor as an ordinary Codex task. Each executor reports `working`
+when a turn starts and one semantic outcome before that same turn ends:
 
-- `completed`: the requested outcome is complete.
-- `needs_input`: a real user decision or missing fact blocks progress.
-- `failed`: execution or executor creation failed.
+- `completed`: the requested outcome is complete;
+- `needs_input`: a real user decision or missing fact blocks progress;
+- `failed`: the executor or creation attempt ended unsuccessfully.
 
-A native approval prompt is live Codex state, not `needs_input`. TaskChef
-stores a concise summary, never a transcript or hidden reasoning.
+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.
 
-Ask for a current report:
+## View and report tasks
+
+Ask the dispatcher for an on-demand report:
 
 ```text
 Report on the work TaskChef has dispatched.

package/docs/firstmate-taskchef-comparison.md

@@ -161,9 +161,11 @@ backends have different verification or experimental status.
 ### TaskChef
 
 **Fact:** Persisted statuses are `working`, `needs_input`, `completed`, and
-`failed`. Executors report one
-latest semantic result with a concise summary. `needs_input` is reserved for a
-real semantic decision, not a native approval prompt.
+`failed`. Executors report
+`working` at turn start and a semantic state before ending. Schema 5 preserves
+the last concise semantic result separately while a newer turn is working.
+`needs_input` is reserved for a real semantic decision, not a native approval
+prompt.
 
 **Fact:** The report skill treats cached results as evidence, takes one recent
 Codex metadata snapshot, and performs targeted exact-thread reads only for
@@ -189,7 +191,7 @@ can be substituted for the other without changing product responsibility.
 **Fact:** The loopback dashboard watches `tasks.jsonl`, streams stable validated
 snapshots, filters and orders tasks, shows notifications and details, and opens
 a task directly in Codex when its stored thread ID has a supported UUID shape.
-This navigation check does not prove schema 4 self-link provenance. The
+This navigation check does not prove schema 4 or 5 self-link provenance. The
 dashboard does not refresh native task state, submit replies, or show
 transcripts or token usage.
 
@@ -214,7 +216,7 @@ harness adapter.
 | Codex | Built around native Codex projects, tasks, thread reads, and desktop deep links. | Codex is one verified harness; desktop tasks are not its worker runtime. |
 | GitHub | Configured repository URLs aid routing; delivery remains the executor project's concern. | GitHub CLI, PR state, and configured delivery modes are part of supervised shipping workflows. |
 | Skills | Three plugin skills with narrow bootstrap, delegate, and report responsibilities. | Internal firstmate-only skills plus standalone public skills; AGENTS.md routes conditional procedures. |
-| MCP | Four focused local TaskChef tools own deterministic identity and result writes. | FirstMate describes itself as an agent distribution rather than an MCP product; deterministic behavior lives largely in scripts. |
+| MCP | Four primary local TaskChef tools plus one deprecated compatibility alias own deterministic identity and state writes. | FirstMate describes itself as an agent distribution rather than an MCP product; deterministic behavior lives largely in scripts. |
 | Runtime extensions | Extend plugin skills/MCP/CLI/dashboard or compose native Codex capabilities. | Add or verify harness adapters, session backends, dispatch profiles, operational scripts, and optional integrations. |
 
 ## Trust and security boundaries

package/docs/spec.md

@@ -22,7 +22,8 @@ is dated research, not contract.
 | **Record-before-create** | Persisting a link-pending task before asking Codex to create its executor. |
 | **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`. |
-| **Semantic result** | The executor's latest `completed`, `needs_input`, or `failed` outcome with a concise summary and current turn identity. |
+| **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. |
 | **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`, or `taskchef-report`. |
@@ -35,7 +36,8 @@ is dated research, not contract.
   It MUST return after creation and MUST NOT poll, supervise, or infer identity.
 - `taskchef-report` MUST own on-demand reporting. It MUST NOT poll or persist
   inferred state.
-- The MCP server MUST expose exactly the four lifecycle tools specified below.
+- The MCP server MUST expose four primary lifecycle tools plus the deprecated
+  `report_result` compatibility alias specified below.
 - The CLI MAY administer and inspect the workspace, but MUST NOT provide a
   second agent lifecycle protocol.
 - The dashboard MUST be read-only with respect to dispatcher files.
@@ -62,9 +64,11 @@ 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 records,
-one per line. Unsupported schemas or fields MUST be rejected without
-conversion. Reads and writes MUST reject symlinked managed files. Mutations
+`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.
+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.
 
@@ -74,7 +78,7 @@ Every record MUST contain exactly these fields:
 
 | Field | Contract |
 | --- | --- |
-| `schemaVersion` | Integer `4`. |
+| `schemaVersion` | Integer `5`; schema-4 records remain readable until their next mutation. |
 | `id` | Unique safe TaskChef ID; delegation uses a lowercase full UUID. |
 | `project` | Immutable configured-project snapshot. |
 | `title` | Non-empty display title. |
@@ -82,10 +86,11 @@ Every record MUST contain exactly these fields:
 | `threadId` | Null while link-pending; after self-link, canonical Codex UUIDv7. Low-level current-schema direct records may hold another durable non-provisional ID but are outside the MCP delegation journey. |
 | `createdAt` | ISO 8601 creation timestamp. |
 | `status` | `working`, `needs_input`, `completed`, or `failed`. |
-| `summary` | Null while working; non-empty and at most 2,000 characters for a semantic result. |
-| `turnId` | Null before a result; linked MCP journeys use a canonical Codex UUIDv7 for the reporting turn. |
-| `updatedAt` | ISO 8601 timestamp not earlier than `createdAt`. |
+| `summary` | Null while working; otherwise the current semantic state's non-empty summary of at most 2,000 characters. |
+| `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. |
 
 Task IDs and non-null thread identities MUST be unique. The immutable intent
 fields MUST NOT change after recording.
@@ -100,12 +105,15 @@ fields MUST NOT change after recording.
 5. It MUST create exactly one native Codex executor and return immediately.
 6. The executor MUST read its own `CODEX_THREAD_ID` and call `link_task`
    before substantive work. It MUST NOT use parent/session identity or guess.
-7. Before ending a semantic turn, the executor MUST exactly read its linked
-   task, use that turn's ID, and call `report_result`.
-8. A follow-up MUST use its new current turn ID. It MUST NOT reuse a prior turn.
+7. After initial linking, the executor MUST exactly read its linked task and
+   call `report_state` with that turn ID, `working`, and no summary before work.
+8. Before ending, it MUST call `report_state` for the same working turn with a
+   semantic status and concise summary.
+9. A follow-up MUST report `working` with its new current turn ID before work.
+   It MUST NOT reuse a prior turn.
 
 If native creation fails after recording, the dispatcher MUST call
-`report_result` with `failed`, null thread/turn IDs, and a bounded summary.
+`report_state` with `failed`, null thread/turn IDs, and a bounded summary.
 A link failure MUST remain visible and retryable; the executor MUST report it
 visibly and MUST NOT continue substantive work.
 
@@ -163,7 +171,7 @@ new preparation values, though it writes no state.
 
 **Structured output:** `{ task: Task }`.
 
-The returned task has schema 4, `working`, null summary/turn/thread,
+The returned task has schema 5, `working`, null summary/turn/thread/lastResult,
 `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.
@@ -189,10 +197,10 @@ marker, or ineligible state fails.
 **Annotations:** `readOnlyHint: false`, `destructiveHint: false`,
 `openWorldHint: false`.
 
-### `report_result`
+### `report_state`
 
 **Caller:** executor, or dispatcher only for native creation failure.
-**Mutation:** replaces the latest semantic-result fields atomically.
+**Mutation:** replaces the current state atomically and preserves `lastResult`.
 
 **Input:**
 
@@ -201,20 +209,31 @@ marker, or ineligible state fails.
 | `taskId` | Non-empty string. |
 | `threadId` | Matching non-empty ID for a linked task; null only for creation failure. |
 | `turnId` | Current canonical Codex UUIDv7 for a linked MCP journey; null only for creation failure. Maximum 256 characters at the MCP boundary. |
-| `status` | `needs_input`, `completed`, or `failed`. |
-| `summary` | Non-empty string, at most 2,000 characters. |
+| `status` | `working`, `needs_input`, `completed`, or `failed`. |
+| `summary` | Omitted or null for `working`; required non-empty string of at most 2,000 characters otherwise. |
 
 **Structured output:** `{ task: Task }`.
 
-For a linked self-linking journey, the stored identity MUST match and the turn
-MUST be newer than the stored turn. Repeating the same turn with the same
-status and summary is idempotent; changing the result for that turn fails.
-A null-identity record accepts only `failed` with both IDs null. Success sets
-status, summary, turn, `updatedAt`, and `updatedBy: mcp`.
+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
+preserves the semantic state in `lastResult`; starting newer work does not erase
+that result.
 
 **Annotations:** `readOnlyHint: false`, `destructiveHint: true`,
 `openWorldHint: false`.
 
+### `report_result` (deprecated)
+
+`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
+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.
+
 ## Reporting and dashboard
 
 A semantic result is cached evidence, not permanent live truth. Reports SHOULD

package/docs/workflows.md

@@ -13,7 +13,7 @@ research.
 | `skills/taskchef-delegate/SKILL.md` | Split, route, record-before-create, create, return. |
 | `skills/taskchef-bootstrap/SKILL.md` | Initialize current workspace and configure projects. |
 | `skills/taskchef-report/SKILL.md` | Select cached tasks and perform bounded live checks. |
-| `src/mcp.js` | Four structured lifecycle tools and MCP annotations. |
+| `src/mcp.js` | Four primary lifecycle tools, one deprecated alias, and MCP annotations. |
 | `src/delegation.js` | UUID marker, executor contract paragraphs, 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. |
@@ -49,7 +49,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-4 snapshot
+  W->>W: Lock, validate, append schema-5 snapshot
   W-->>M: working link-pending task
   M-->>D: task
   D->>C: Create executor with marked instruction
@@ -67,10 +67,11 @@ Record-before-create makes native creation failure observable. Executor
 self-linking removes dispatcher-side polling, task search, title matching, and
 parent/child identity inference.
 
-## Result reporting
+## State reporting
 
 The executor obtains the turn identity from an exact native read of its own
-linked task. `report_result` updates only the latest semantic snapshot.
+linked task. `report_state` records live turn state while preserving the last
+semantic result separately.
 
 ```mermaid
 sequenceDiagram
@@ -79,14 +80,17 @@ sequenceDiagram
   participant C as Native Codex task API
   participant M as TaskChef MCP
   participant W as workspace.js
-  E->>E: Finish or reach semantic decision
   E->>C: Exact read of linked executor
   C-->>E: Current turn ID
-  E->>M: report_result(taskId, threadId, turnId, status, summary)
-  M->>W: reportTaskResult()
+  E->>M: report_state(..., working, null)
+  M->>W: reportTaskState()
+  W->>W: Store current turn and preserve lastResult
+  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 Fresh result
-    W->>W: Replace status, summary, turnId, updatedAt, updatedBy
+  alt Same current working turn
+    W->>W: Store semantic state and lastResult
     W-->>M: Updated task
     M-->>E: Recorded result
   else Same turn and same result
@@ -114,18 +118,26 @@ sequenceDiagram
   participant C as Native Codex task API
   participant M as TaskChef MCP
   participant W as workspace.js
-  E->>M: report_result(..., turnA, needs_input, summaryA)
-  M->>W: Store turnA
-  W-->>E: needs_input snapshot
+  E->>M: report_state(..., turnA, needs_input, summaryA)
+  M->>W: reportTaskState()
+  W-->>M: needs_input snapshot
+  M-->>E: needs_input snapshot
   U->>E: Provide decision
   E->>C: Read exact executor after follow-up
   C-->>E: turnB
-  E->>M: report_result(..., turnB, completed, summaryB)
-  M->>W: Require turnB greater than turnA
-  W-->>E: completed snapshot
-  E->>M: report_result(..., turnA, completed, staleSummary)
+  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
+  E->>M: report_state(..., turnB, completed, summaryB)
+  M->>W: reportTaskState()
+  W-->>M: completed snapshot plus result B
+  M-->>E: completed snapshot plus result B
+  E->>M: report_state(..., turnA, completed, staleSummary)
   M->>W: Validate freshness
-  W-->>E: Error: turn is not newer
+  W-->>M: Error: turn is not newer
+  M-->>E: Visible tool error
 ```
 
 The executor contract therefore requires a new exact read on every follow-up;
@@ -174,7 +186,7 @@ sequenceDiagram
   W-->>D: Recorded task
   D->>C: Create executor
   C--xD: Creation error
-  D->>M: report_result(taskId, null, null, failed, boundedSummary)
+  D->>M: report_state(taskId, null, null, failed, boundedSummary)
   M->>W: Lock and store creation failure
   W-->>D: Failed task with null IDs
   D-->>D: Preserve original creation error and task ID
@@ -198,7 +210,7 @@ sequenceDiagram
   participant D as Dashboard monitor
   participant B as Browser client
   participant C as Native Codex
-  M->>W: link_task or report_result
+  M->>W: link_task or report_state
   W->>W: Acquire shared lock
   W->>F: Atomic replacement
   W-->>M: Updated task
@@ -232,5 +244,6 @@ 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.
 
-Only current configuration schema 2 and task schema 4 are accepted.
-Unsupported data is rejected without rewrite.
+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.

package/index.js

@@ -15,6 +15,7 @@ export {
   listTasks,
   readTask,
   recordTask,
+  reportTaskState,
   reportTaskResult,
   requireSafeId,
   removeProject,
@@ -31,6 +32,7 @@ export {
   EXECUTOR_OWNERSHIP_PARAGRAPH,
   EXECUTOR_LINK_PARAGRAPH,
   EXECUTOR_RESULT_PARAGRAPH,
+  EXECUTOR_WORKING_PARAGRAPH,
   createAndRecordDelegation,
   isProvisionalThreadId,
   normalizeCodexThreadId,

package/package.json

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

package/skills/taskchef-delegate/SKILL.md

@@ -17,7 +17,8 @@ because it concerns TaskChef or a configured project. Explicit requests to
 delegate separate work remain valid.
 
 Use the bundled `prepare_dispatch`, `record_task`, `link_task`, and
-`report_result` MCP tools directly. Never fall back to shell writes. If a
+`report_state` MCP tools directly. `report_result` is a deprecated compatibility
+alias and must not be emitted into new executor instructions. Never fall back to shell writes. If a
 required tool is unavailable, stop and report that the TaskChef plugin must be
 reloaded or installed.
 
@@ -49,7 +50,9 @@ reloaded or installed.
 
    > 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.
 
-   > Before ending, call the TaskChef report_result MCP tool with the marked task ID, this executor's self-linked thread ID, the current turn ID from an exact native read of that same thread, completed, needs_input, or failed, and a concise summary. Never reuse a prior turn ID after a follow-up. 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.
+   > 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.
+
+   > 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.
 
 5. Before creating each executor, call `record_task` exactly once with `id`,
    `project`, `title`, the exact marked `instruction`, and `threadId: null`.
@@ -58,7 +61,7 @@ reloaded or installed.
 7. Return immediately. Preserve a returned provisional client ID only for the
    created-thread directive. Do not call `link_task` from the dispatcher even
    when creation returns a durable ID; the child must self-link.
-8. If creation fails after recording, call `report_result` with `failed`, null
+8. If creation fails after recording, call `report_state` with `failed`, null
    thread/turn IDs, and a bounded summary before returning the failure.
 
 ## Executor contract
@@ -71,10 +74,12 @@ Identical retries are safe. A rejected link, unavailable tool, or interrupted
 initial turn leaves the record visibly link-pending and retryable; the executor
 must not guess or do substantive work first.
 
-For every semantic result, the executor supplies its linked thread ID and the
-current turn ID obtained by reading that exact thread. A follow-up must use the
-new turn ID. Do not reuse the initial turn ID. `needs_input` is only for a real
-user decision, not live approval UI.
+After linking on the initial turn, and before substantive work on every later
+turn, the executor reads the exact thread and calls `report_state` with
+`working`, the current turn ID, and no summary. Before ending that same turn it
+reports a semantic state with the same turn ID and a summary. A follow-up must
+use the new turn ID. `needs_input` is only for a real user decision, not live
+approval UI.
 
-The filesystem watcher surfaces `link_task` and `report_result` writes to the
+The filesystem watcher surfaces `link_task` and `report_state` writes to the
 dashboard. The linked child ID drives the exact Codex deep link.

package/skills/taskchef-report/SKILL.md

@@ -44,37 +44,37 @@ 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. Treat `updatedBy: mcp`, `status: failed`, and null thread/turn IDs as a fresh
-   executor-creation failure. No live read is possible or needed; report the
-   stored failure summary, not unresolved. Otherwise, only a snapshot with
-   `updatedBy: mcp`, a result status, a non-null summary, and a non-null turn ID
-   is a cached semantic result. Any `working` snapshot has no semantic
-   callback, including a self-linked `updatedBy: mcp` snapshot, and requires
-   one live task query when selected; if the task is inactive and no callback
-   exists, report the outcome as unknown rather than treating `working` as
-   fresh. When identity is certain and metadata says the thread is
-   inactive, trust the latest MCP result by default in a broad overview. Do not
-   read every idle terminal task in an overview merely because native
+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
+   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
+   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
    `updatedAt` is later: callbacks normally run before Codex finalizes the same
    turn, and overview performance matters more than investigating every rare
    missed callback.
 
    For a focused task, title, or project report, perform at most one detailed
    read for each selected inactive task when matched metadata `updatedAt` is
-   later than the cached result `updatedAt`, by any amount. Read once as well
+   later than `lastResult.updatedAt`, by any amount. Read once as well
    when there is no semantic callback, identity or metadata is uncertain or
    contradictory, or the user explicitly requests a fully live result. If
    focused metadata is not newer, trust the cache. Absence from the bounded
    recent snapshot is not by itself a reason to read every cached terminal
    overview entry. Batch immediate native reads with no more than eight targets
    per call. When a detailed read occurs, compare the latest structured turn ID
-   and native turn state with stored `turnId`: a newer turn without a callback
+   and native turn state with `lastResult.turnId`: a newer turn without a callback
    makes the cache stale, while an interrupted or cancelled callback turn
    cannot prove completion. Never classify assistant prose.
 5. Report each task as one of: working, needs input, awaiting native approval,
    completed, failed, unresolved, or unknown. Show the cached summary when it
    remains fresh. If a newer turn exists without a callback, describe the live
-   state and label the cached result stale rather than overwriting it.
+   state and label the preserved result historical or stale rather than overwriting it.
 6. Never edit `tasks.jsonl` directly during reporting. A null identity is
    executor link-pending and must be retried by that executor. Never persist inferred status,
    transcripts, prose classifications, or hidden reasoning. Do not poll or wait.

package/src/cli.js

@@ -166,18 +166,22 @@ function singleLineDetail(value) {
 }
 
 function taskDetails(task) {
+  const lastResult = task.lastResult;
   return [
     `Title: ${singleLineDetail(task.title)}`,
     `Project: ${singleLineDetail(task.project.name)}`,
-    `Status: ${singleLineDetail(task.status ?? "unknown")}`,
-    `Summary: ${singleLineDetail(task.summary ?? "-")}`,
+    `Current status: ${singleLineDetail(task.status ?? "unknown")}`,
+    `Current turn ID: ${singleLineDetail(task.turnId ?? "-")}`,
+    `Last result status: ${singleLineDetail(lastResult?.status ?? "-")}`,
+    `Last result summary: ${singleLineDetail(lastResult?.summary ?? "-")}`,
+    `Last result turn ID: ${singleLineDetail(lastResult?.turnId ?? "-")}`,
+    `Last result updated: ${singleLineDetail(lastResult?.updatedAt ?? "-")}`,
     `Project path: ${singleLineDetail(task.project.path)}`,
     `Created: ${singleLineDetail(task.createdAt)}`,
     `Updated: ${singleLineDetail(task.updatedAt ?? "-")}`,
     `Updated by: ${singleLineDetail(task.updatedBy ?? "-")}`,
     `Task ID: ${singleLineDetail(task.id)}`,
     `Thread ID: ${singleLineDetail(task.threadId ?? "-")}`,
-    `Turn ID: ${singleLineDetail(task.turnId ?? "-")}`,
     "Instruction:",
     task.instruction,
   ].join("\n");

package/src/dashboard/app.js

@@ -123,14 +123,18 @@ function openDialog(task) {
   state.selectedTask = task;
   elements.dialogProject.textContent = task.project.name;
   elements.dialogTitle.textContent = task.title;
-  elements.dialogSummary.textContent = task.summary ?? "No semantic result has been reported yet.";
+  elements.dialogSummary.textContent = task.lastResult?.summary
+    ?? "No semantic result has been reported yet.";
   elements.dialogInstruction.textContent = task.instruction;
   elements.copyThreadId.disabled = !task.threadId;
   elements.dialogMetadata.replaceChildren(
-    ...detailRow("Status", taskStatusLabel(task)),
+    ...detailRow("Current status", taskStatusLabel(task)),
+    ...detailRow("Current turn ID", task.turnId),
+    ...detailRow("Last result status", task.lastResult?.status?.replaceAll("_", " ")),
+    ...detailRow("Last result turn ID", task.lastResult?.turnId),
+    ...detailRow("Last result updated", formatTime(task.lastResult?.updatedAt)),
     ...detailRow("Task ID", task.id),
     ...detailRow("Thread ID", task.threadId),
-    ...detailRow("Turn ID", task.turnId),
     ...detailRow("Project path", task.project.path),
     ...detailRow("Created", formatTime(task.createdAt)),
     ...detailRow("Updated", formatTime(
@@ -160,7 +164,7 @@ function taskCard(task) {
   project.textContent = task.project.name;
   const summary = document.createElement("p");
   summary.className = "task-summary";
-  summary.textContent = task.summary ?? "No semantic result reported yet.";
+  summary.textContent = task.lastResult?.summary ?? "No semantic result reported yet.";
   const time = document.createElement("time");
   time.dateTime = task.meaningfulUpdatedAt ?? task.updatedAt ?? task.createdAt;
   time.textContent = `Updated ${formatTime(time.dateTime)}`;

package/src/dashboard/state.js

@@ -51,6 +51,7 @@ export function taskSignature(task) {
     task.turnId,
     task.updatedAt,
     task.updatedBy,
+    task.lastResult,
   ]);
 }
 

package/src/dashboard.js

@@ -131,6 +131,8 @@ function assertDashboardTaskBounds(tasks, maximumTasks) {
     boundedText(task.summary, 2_000, `${name} summary`);
     boundedText(task.threadId, 512, `${name} thread ID`);
     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.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`);

package/src/delegation.js

@@ -2,7 +2,8 @@ import { randomUUID } from "node:crypto";
 
 export const EXECUTOR_OWNERSHIP_PARAGRAPH = "This task owns the delegated assignment. Execute it in this task; do not re-dispatch it merely because it concerns TaskChef or a configured project. Explicit requests to delegate separate work remain valid.";
 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.";
-export const EXECUTOR_RESULT_PARAGRAPH = "Before ending, call the TaskChef report_result MCP tool with the marked task ID, this executor's self-linked thread ID, the current turn ID from an exact native read of that same thread, completed, needs_input, or failed, and a concise summary. Never reuse a prior turn ID after a follow-up. 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_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_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.";
 
 const UUID_SOURCE = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
 const UUID_PATTERN = new RegExp(`^${UUID_SOURCE}$`);
@@ -96,7 +97,7 @@ export function prepareDelegation(instruction, { taskId = randomUUID() } = {}) {
   const id = requireUuid(taskId);
   return {
     id,
-    instruction: `${taskChefMarker(id)}\n\n${EXECUTOR_OWNERSHIP_PARAGRAPH}\n\n${EXECUTOR_LINK_PARAGRAPH}\n\n${EXECUTOR_RESULT_PARAGRAPH}\n\n${instruction}`,
+    instruction: `${taskChefMarker(id)}\n\n${EXECUTOR_OWNERSHIP_PARAGRAPH}\n\n${EXECUTOR_LINK_PARAGRAPH}\n\n${EXECUTOR_WORKING_PARAGRAPH}\n\n${EXECUTOR_RESULT_PARAGRAPH}\n\n${instruction}`,
   };
 }
 

package/src/mcp.js

@@ -4,6 +4,7 @@ import {
   prepareDispatch,
   linkTask,
   recordTask,
+  reportTaskState,
   reportTaskResult,
 } from "./workspace.js";
 import { parseTaskChefMarker } from "./delegation.js";
@@ -18,7 +19,7 @@ const projectSchema = z.object({
 });
 
 const taskSchema = z.object({
-  schemaVersion: z.literal(4),
+  schemaVersion: z.union([z.literal(4), z.literal(5)]),
   id: z.string(),
   project: projectSchema,
   title: z.string(),
@@ -30,6 +31,12 @@ const taskSchema = z.object({
   turnId: z.string().nullable(),
   updatedAt: z.string(),
   updatedBy: z.enum(["dispatcher", "mcp"]),
+  lastResult: z.object({
+    status: z.enum(["needs_input", "completed", "failed"]),
+    summary: z.string(),
+    turnId: z.string().nullable(),
+    updatedAt: z.string(),
+  }).nullable(),
 });
 
 const preparationSchema = z.object({
@@ -54,13 +61,14 @@ export function createTaskChefMcpServer({
   prepare = prepareDispatch,
   record = recordTask,
   reportResult = reportTaskResult,
+  reportState = reportTaskState,
   link = linkTask,
 } = {}) {
   const server = new McpServer(
     { name: "taskchef", version: "1.0.0" },
     {
       instructions:
-        "Prepare with prepare_dispatch, call record_task before creating the Codex task, then create it natively and return immediately. The executor must call link_task before other work and report_result before ending.",
+        "Prepare with prepare_dispatch, call record_task before creating the Codex task, then create it natively and return immediately. The executor must call link_task first, report_state working at the start of each execution turn, and report_state with a semantic outcome before ending.",
     },
   );
 
@@ -136,12 +144,38 @@ export function createTaskChefMcpServer({
     },
   );
 
+  server.registerTool(
+    "report_state",
+    {
+      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.",
+      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(),
+      },
+      outputSchema: { task: taskSchema },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        openWorldHint: false,
+      },
+    },
+    async (input) => {
+      const task = await reportState(workspace, input);
+      return toolResult("task", task, `Recorded ${task.status} state for TaskChef task ${task.id}.`);
+    },
+  );
+
   server.registerTool(
     "report_result",
     {
-      title: "Report TaskChef result",
+      title: "Report TaskChef result (deprecated)",
       description:
-        "Store the executor's latest semantic outcome for one recorded TaskChef task. A linked executor must supply its matching durable thread ID and current turn ID. Null IDs are accepted only for a failed executor creation before a thread exists. Use needs_input only for a semantic user decision, not a transient native approval prompt. Summaries must omit secrets, transcripts, and raw command output.",
+        "Deprecated compatibility alias for semantic results. New executors must use report_state working at turn start and report_state again with needs_input, completed, or failed before ending. This alias preserves legacy callers by implicitly starting the supplied newer turn before storing its result.",
       inputSchema: {
         taskId: z.string().min(1),
         threadId: z.string().min(1).nullable(),

package/src/workspace.js

@@ -38,7 +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 = 4;
+const CURRENT_TASK_SCHEMA_VERSION = 5;
+const PREVIOUS_SELF_LINKING_TASK_SCHEMA_VERSION = 4;
 const CONFIG_FIELDS = new Set(["schemaVersion", "projects"]);
 const PROJECT_FIELDS = new Set([
   "name",
@@ -48,7 +49,7 @@ const PROJECT_FIELDS = new Set([
   "description",
 ]);
 const PROJECT_INPUT_FIELDS = new Set(["name", "path", "githubRepos", "description"]);
-const DISPATCH_FIELDS = new Set([
+const STATEFUL_DISPATCH_FIELDS = new Set([
   "schemaVersion",
   "id",
   "project",
@@ -62,6 +63,7 @@ const DISPATCH_FIELDS = new Set([
   "updatedAt",
   "updatedBy",
 ]);
+const DISPATCH_FIELDS = new Set([...STATEFUL_DISPATCH_FIELDS, "lastResult"]);
 const RECORD_DISPATCH_FIELDS = new Set([
   "id",
   "project",
@@ -73,6 +75,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"]);
 
 function requireExactFields(value, fields, name) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -100,6 +103,13 @@ function requireTimestamp(value, name) {
   return value;
 }
 
+function transitionTimestamp(now, currentUpdatedAt) {
+  const candidate = requireTimestamp(now ?? new Date().toISOString(), "transition timestamp");
+  return Date.parse(candidate) < Date.parse(currentUpdatedAt)
+    ? currentUpdatedAt
+    : candidate;
+}
+
 function optionalString(value, name, { maxLength = null } = {}) {
   if (value === null) return null;
   const normalized = requireString(value, name).trim();
@@ -668,14 +678,62 @@ export async function removeProject(workspaceRoot, name) {
 }
 
 async function validateDispatchShape(dispatch, name = "task") {
-  if (dispatch?.schemaVersion !== CURRENT_TASK_SCHEMA_VERSION) {
+  const supportedVersions = [
+    PREVIOUS_SELF_LINKING_TASK_SCHEMA_VERSION,
+    CURRENT_TASK_SCHEMA_VERSION,
+  ];
+  if (!supportedVersions.includes(dispatch?.schemaVersion)) {
     throw new Error(`unsupported ${name} schemaVersion`);
   }
-  requireExactFields(dispatch, DISPATCH_FIELDS, name);
+  requireExactFields(
+    dispatch,
+    dispatch.schemaVersion >= CURRENT_TASK_SCHEMA_VERSION
+      ? DISPATCH_FIELDS
+      : STATEFUL_DISPATCH_FIELDS,
+    name,
+  );
   const id = requireSafeId(dispatch.id, `${name}.id`);
   const project = await normalizeProject(dispatch.project, 0, { checkPath: false });
+  const status = requireEnum(dispatch.status, TASK_STATUSES, `${name}.status`);
+  const summary = optionalString(dispatch.summary, `${name}.summary`, {
+    maxLength: MAX_RESULT_SUMMARY_LENGTH,
+  });
+  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 = {
+        status: requireEnum(
+          dispatch.lastResult.status,
+          RESULT_STATUSES,
+          `${name}.lastResult.status`,
+        ),
+        summary: optionalString(
+          dispatch.lastResult.summary,
+          `${name}.lastResult.summary`,
+          { maxLength: MAX_RESULT_SUMMARY_LENGTH },
+        ),
+        turnId: optionalString(
+          dispatch.lastResult.turnId,
+          `${name}.lastResult.turnId`,
+          { maxLength: 256 },
+        ),
+        updatedAt: requireTimestamp(
+          dispatch.lastResult.updatedAt,
+          `${name}.lastResult.updatedAt`,
+        ),
+      };
+      if (lastResult.summary === null) {
+        throw new Error(`${name}.lastResult.summary must be a non-empty string`);
+      }
+    }
+  } else if (RESULT_STATUSES.has(status)) {
+    lastResult = { status, summary, turnId, updatedAt };
+  }
   const normalized = {
-    schemaVersion: CURRENT_TASK_SCHEMA_VERSION,
+    schemaVersion: dispatch.schemaVersion,
     id,
     project,
     title: requireString(dispatch.title, `${name}.title`).trim(),
@@ -684,20 +742,93 @@ async function validateDispatchShape(dispatch, name = "task") {
       ? null
       : normalizeDurableThreadId(dispatch.threadId, `${name}.threadId`),
     createdAt: requireTimestamp(dispatch.createdAt, `${name}.createdAt`),
-    status: requireEnum(dispatch.status, TASK_STATUSES, `${name}.status`),
-    summary: optionalString(dispatch.summary, `${name}.summary`, {
-      maxLength: MAX_RESULT_SUMMARY_LENGTH,
-    }),
-    turnId: optionalString(dispatch.turnId, `${name}.turnId`, { maxLength: 256 }),
-    updatedAt: requireTimestamp(dispatch.updatedAt, `${name}.updatedAt`),
+    status,
+    summary,
+    turnId,
+    updatedAt,
     updatedBy: requireEnum(dispatch.updatedBy, TASK_UPDATE_SOURCES, `${name}.updatedBy`),
+    lastResult,
   };
+  const isSelfLinkingRecord = normalized.threadId !== null
+    && parseTaskChefMarker(normalized.instruction) === normalized.id;
+  if (isSelfLinkingRecord) {
+    if (normalized.turnId !== null) {
+      normalizeCodexThreadId(normalized.turnId, `${name}.turnId`);
+    }
+    if (normalized.lastResult?.turnId != null) {
+      normalizeCodexThreadId(
+        normalized.lastResult.turnId,
+        `${name}.lastResult.turnId`,
+      );
+    }
+  }
+  if (normalized.schemaVersion >= PREVIOUS_SELF_LINKING_TASK_SCHEMA_VERSION) {
+    if (normalized.threadId === null) {
+      const isLinkPending = normalized.status === "working"
+        && normalized.summary === null
+        && normalized.turnId === null
+        && normalized.lastResult === null
+        && normalized.updatedBy === "dispatcher";
+      const isCreationFailure = normalized.status === "failed"
+        && normalized.summary !== null
+        && normalized.turnId === null
+        && normalized.lastResult?.status === "failed"
+        && normalized.lastResult.turnId === null
+        && normalized.updatedBy === "mcp";
+      if (!isLinkPending && !isCreationFailure) {
+        throw new Error(`${name} has an invalid unlinked lifecycle state`);
+      }
+    } else {
+      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`);
+      }
+    }
+  }
   if (normalized.status === "working" && normalized.summary !== null) {
     throw new Error(`${name}.summary must be null while status is working`);
   }
   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 (RESULT_STATUSES.has(normalized.status)) {
+      if (
+        normalized.lastResult === null
+        || normalized.lastResult.status !== normalized.status
+        || normalized.lastResult.summary !== normalized.summary
+        || normalized.lastResult.turnId !== normalized.turnId
+        || normalized.lastResult.updatedAt !== normalized.updatedAt
+      ) {
+        throw new Error(`${name}.lastResult must match the current semantic state`);
+      }
+    }
+    if (
+      normalized.lastResult !== null
+      && Date.parse(normalized.lastResult.updatedAt) < Date.parse(normalized.createdAt)
+    ) {
+      throw new Error(`${name}.lastResult.updatedAt must not be earlier than createdAt`);
+    }
+    if (
+      normalized.lastResult !== null
+      && Date.parse(normalized.lastResult.updatedAt) > Date.parse(normalized.updatedAt)
+    ) {
+      throw new Error(`${name}.lastResult.updatedAt must not be later than updatedAt`);
+    }
+    if (
+      normalized.status === "working"
+      && isSelfLinkingRecord
+      && normalized.lastResult?.turnId != null
+      && (
+        normalized.turnId === null
+        || normalized.turnId <= normalized.lastResult.turnId
+      )
+    ) {
+      throw new Error(`${name}.turnId must be newer than lastResult.turnId while working`);
+    }
+  }
   if (
     Date.parse(normalized.updatedAt) < Date.parse(normalized.createdAt)
   ) {
@@ -802,6 +933,7 @@ export async function recordTask(workspaceRoot, input, { now } = {}) {
       turnId: null,
       updatedAt: createdAt,
       updatedBy: "dispatcher",
+      lastResult: null,
     });
     const existing = await readDispatchesUnlocked(root);
     if (existing.some((item) => item.id === dispatch.id)) {
@@ -845,8 +977,9 @@ export async function linkTask(workspaceRoot, taskId, threadId, { now } = {}) {
       if (dispatch.threadId === durableThreadId) return dispatch;
       const canonical = await validateDispatchShape({
         ...dispatch,
+        schemaVersion: CURRENT_TASK_SCHEMA_VERSION,
         threadId: durableThreadId,
-        updatedAt: now ?? new Date().toISOString(),
+        updatedAt: transitionTimestamp(now, dispatch.updatedAt),
         updatedBy: "mcp",
       });
       const lines = records.map((record, recordIndex) => recordIndex === index
@@ -875,8 +1008,9 @@ export async function linkTask(workspaceRoot, taskId, threadId, { now } = {}) {
     }
     const linked = await validateDispatchShape({
       ...dispatch,
+      schemaVersion: CURRENT_TASK_SCHEMA_VERSION,
       threadId: durableThreadId,
-      updatedAt: now ?? new Date().toISOString(),
+      updatedAt: transitionTimestamp(now, dispatch.updatedAt),
       updatedBy: "mcp",
     });
     const lines = records.map((record, recordIndex) => recordIndex === index
@@ -895,22 +1029,53 @@ function dispatchLineWithState(dispatch, patch) {
   });
 }
 
-export async function reportTaskResult(workspaceRoot, input, { now } = {}) {
-  requireExactFields(
-    input,
-    new Set(["taskId", "threadId", "turnId", "status", "summary"]),
-    "task result",
-  );
+function normalizeTaskStateInput(input, { allowWorking }) {
+  const fields = new Set(["taskId", "threadId", "turnId", "status", "summary"]);
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    throw new Error("task state must be an object");
+  }
+  const unexpected = Object.keys(input).find((key) => !fields.has(key));
+  if (unexpected) throw new Error(`task state has unsupported field: ${unexpected}`);
+  for (const field of ["taskId", "threadId", "turnId", "status"]) {
+    if (!(field in input)) throw new Error(`task state is missing field: ${field}`);
+  }
   const id = requireSafeId(input.taskId, "taskId");
   const threadId = input.threadId === null
     ? null
     : normalizeDurableThreadId(input.threadId, "threadId");
   const turnId = optionalString(input.turnId, "turnId", { maxLength: 256 });
-  const status = requireEnum(input.status, RESULT_STATUSES, "status");
-  const summary = optionalString(input.summary, "summary", {
+  const status = requireEnum(
+    input.status,
+    allowWorking ? TASK_STATUSES : RESULT_STATUSES,
+    "status",
+  );
+  const summary = optionalString("summary" in input ? input.summary : null, "summary", {
     maxLength: MAX_RESULT_SUMMARY_LENGTH,
   });
-  if (summary === null) throw new Error("summary must be a non-empty string");
+  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 };
+}
+
+function sameLastResult(lastResult, { status, summary, turnId }) {
+  return lastResult !== null
+    && lastResult.status === status
+    && lastResult.summary === summary
+    && lastResult.turnId === turnId;
+}
+
+async function reportTaskStateInternal(
+  workspaceRoot,
+  input,
+  { now, compatibilityAlias = false } = {},
+) {
+  const { id, threadId, turnId, status, summary } = normalizeTaskStateInput(input, {
+    allowWorking: !compatibilityAlias,
+  });
   const root = await realpath(path.resolve(workspaceRoot));
   return withWorkspaceLock(root, async () => {
     const records = await readDispatchRecordsUnlocked(root);
@@ -922,45 +1087,120 @@ export async function reportTaskResult(workspaceRoot, input, { now } = {}) {
       dispatch.threadId !== null
       && parseTaskChefMarker(dispatch.instruction) === dispatch.id
     );
-    let resultTurnId = turnId;
+    if (
+      !compatibilityAlias
+      && dispatch.threadId !== null
+      && !isSelfLinkingJourney
+    ) {
+      throw new Error(`report_state accepts only self-linked task records: ${id}`);
+    }
+    let stateTurnId = turnId;
     if (isSelfLinkingJourney) {
       if (dispatch.updatedBy === "dispatcher") {
         throw new Error(`self-linking task must link before reporting a result: ${id}`);
       }
-      resultTurnId = normalizeCodexThreadId(turnId, "turnId");
+      stateTurnId = normalizeCodexThreadId(turnId, "turnId");
     }
     if (dispatch.threadId === null) {
-      if (threadId !== null || resultTurnId !== null || status !== "failed") {
+      if (threadId !== null || stateTurnId !== null || status !== "failed") {
         throw new Error(`task without a durable threadId accepts only failed with null thread/turn IDs: ${id}`);
       }
+      if (!compatibilityAlias) {
+        const rawSchemaVersion = records[index].raw.schemaVersion;
+        const hasCurrentMarker = rawSchemaVersion
+          >= PREVIOUS_SELF_LINKING_TASK_SCHEMA_VERSION
+          && parseTaskChefMarker(dispatch.instruction) === dispatch.id;
+        const isFreshCreationFailure = hasCurrentMarker
+          && dispatch.status === "working"
+          && dispatch.turnId === null
+          && dispatch.lastResult === null
+          && dispatch.updatedBy === "dispatcher";
+        const isIdenticalCreationFailureRetry = hasCurrentMarker
+          && dispatch.status === "failed"
+          && dispatch.turnId === null
+          && dispatch.updatedBy === "mcp"
+          && sameLastResult(dispatch.lastResult, {
+            status,
+            summary,
+            turnId: stateTurnId,
+          });
+        if (!isFreshCreationFailure && !isIdenticalCreationFailureRetry) {
+          throw new Error(`report_state unlinked failure requires a fresh link-pending task: ${id}`);
+        }
+      }
     } else {
       if (threadIdentityKey(threadId) !== threadIdentityKey(dispatch.threadId)) {
         throw new Error(`task result threadId does not match recorded threadId: ${id}`);
       }
-      if (resultTurnId === null) {
-        throw new Error(`task result turnId is required for a linked task: ${id}`);
+      if (stateTurnId === null) {
+        throw new Error(`task state turnId is required for a linked task: ${id}`);
       }
     }
-    if (dispatch.updatedBy === "mcp" && resultTurnId === dispatch.turnId) {
-      if (status === dispatch.status && summary === dispatch.summary) return dispatch;
-      throw new Error(`task turn already has a different semantic result: ${id}`);
+    if (status === "working") {
+      if (dispatch.status === "working" && stateTurnId === dispatch.turnId) return dispatch;
+      if (isSelfLinkingJourney) {
+        if (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) {
+          throw new Error(`working turnId must be newer than the last result turnId: ${id}`);
+        }
+      }
+      const updatedAt = transitionTimestamp(now, dispatch.updatedAt);
+      const updated = await validateDispatchShape({
+        ...dispatch,
+        schemaVersion: CURRENT_TASK_SCHEMA_VERSION,
+        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 (
-      isSelfLinkingJourney
-      && dispatch.turnId !== null
-      && resultTurnId <= dispatch.turnId
+      dispatch.status === status
+      && dispatch.turnId === stateTurnId
+      && dispatch.summary === summary
+      && sameLastResult(dispatch.lastResult, { status, summary, turnId: stateTurnId })
     ) {
-      throw new Error(`task result turnId must be newer than the stored turnId: ${id}`);
+      return dispatch;
+    }
+    if (dispatch.turnId === stateTurnId && dispatch.status !== "working") {
+      throw new Error(`task turn already has a different semantic result: ${id}`);
     }
-    const updated = await validateDispatchShape({
+    if (compatibilityAlias) {
+      const matchesWorkingTurn = dispatch.status === "working"
+        && dispatch.turnId === stateTurnId;
+      if (!matchesWorkingTurn && isSelfLinkingJourney) {
+        if (dispatch.turnId !== null && stateTurnId <= dispatch.turnId) {
+          throw new Error(`task result turnId must be newer than the stored turnId: ${id}`);
+        }
+        if (dispatch.lastResult?.turnId != null && stateTurnId <= dispatch.lastResult.turnId) {
+          throw new Error(`task result turnId must be newer than the last result turnId: ${id}`);
+        }
+      }
+    } else if (dispatch.status !== "working" || dispatch.turnId !== stateTurnId) {
+      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 = {
       ...dispatch,
       schemaVersion: CURRENT_TASK_SCHEMA_VERSION,
       status,
       summary,
-      turnId: resultTurnId,
-      updatedAt: now ?? new Date().toISOString(),
+      turnId: stateTurnId,
+      updatedAt,
       updatedBy: "mcp",
-    });
+      lastResult,
+    };
+    const updated = await validateDispatchShape(candidate);
     const lines = records.map((record, recordIndex) => recordIndex === index
       ? dispatchLineWithState(updated, {})
       : record.line);
@@ -969,6 +1209,17 @@ export async function reportTaskResult(workspaceRoot, input, { now } = {}) {
   });
 }
 
+export async function reportTaskState(workspaceRoot, input, { now } = {}) {
+  return reportTaskStateInternal(workspaceRoot, input, { now });
+}
+
+export async function reportTaskResult(workspaceRoot, input, options = {}) {
+  return reportTaskStateInternal(workspaceRoot, input, {
+    ...options,
+    compatibilityAlias: true,
+  });
+}
+
 export async function readTask(workspaceRoot, taskId) {
   const id = requireSafeId(taskId, "taskId");
   const dispatch = (await listTasks(workspaceRoot)).find((item) => item.id === id);