taskchef 7.9.1 → 7.10.0

package/.codex-plugin/plugin.json

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

package/README.md

@@ -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 7; schema 4/5/6 migration supported)
+tasks.jsonl     one task snapshot per line (schema 8; schema 4/5/6/7 migration supported)
 ```
 
 List or change routing targets conversationally:
@@ -123,7 +123,12 @@ 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.
+If Codex crashes, an MCP call is lost, or the app restarts before that terminal
+report, the next newer `working` report atomically marks the unfinished turn
+`interrupted` and appends the new active turn. `interrupted` is TaskChef-authored
+timeline evidence, not semantic `failed`, and it never enters `results` or
+`lastResult`. TaskChef stores only a fixed interruption summary; it does not
+store transcripts, hidden reasoning, crash output, or other 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
@@ -175,7 +180,7 @@ 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
 request/result pair; opening task details fetches the full newest-first activity
-timeline.
+timeline, including clearly labeled interrupted turns.
 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
@@ -205,6 +210,8 @@ no task data, credentials, environment variables, process control, or secrets.
 
 ![Task detail activity timeline](docs/images/result-history-dashboard.jpg)
 
+![Interrupted turn followed by active recovery](docs/images/interrupted-turn-recovery.jpg)
+
 ## Common recovery
 
 Check the managed workspace:
@@ -218,8 +225,8 @@ taskchef doctor
 
 `doctor` is read-only. `workspace init` creates missing files and refreshes
 managed instructions. `workspace migrate` explicitly upgrades supported schema
-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`
+4/5/6/7 task lines to schema 8 under the workspace lock. It validates the complete
+source and converted log before writing, creates an exclusive `tasks.jsonl.pre-v8-*.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 +237,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, 6, and 7 remain unsupported. Retain such a workspace
+Schemas other than 4, 5, 6, 7, and 8 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/firstmate-taskchef-comparison.md

@@ -162,8 +162,11 @@ backends have different verification or experimental status.
 
 **Fact:** Persisted statuses are `working`, `needs_input`, `completed`, and
 `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.
+`working` at turn start and a semantic state before ending. Schema 8 preserves
+the paired turn timeline and semantic-only compatibility results while a newer
+turn is working. If a terminal report is lost, the next valid working start
+closes the predecessor with a timeline-only `interrupted` outcome rather than
+semantic `failed`.
 `needs_input` is reserved for a real semantic decision, not a native approval
 prompt.
 

package/docs/spec.md

@@ -23,7 +23,8 @@ is dated research, not contract.
 | **Self-linking** | The executor's one-way registration of its own canonical Codex UUIDv7 from `CODEX_THREAD_ID`. |
 | **Link-pending** | A working task whose `threadId` is null and `updatedBy` is `dispatcher`. |
 | **Current execution state** | The latest reported executor turn and its `working`, `needs_input`, `completed`, or `failed` status. |
-| **Turn timeline** | The ordered collection pairing each turn's concise request summary with its eventual semantic result. |
+| **Turn timeline** | The ordered collection pairing each turn's concise request summary with its semantic result, TaskChef-generated interruption outcome, or current in-progress state. |
+| **Interrupted turn** | A formerly active turn that lacked a terminal report when a newer valid turn started; TaskChef closes it with the fixed timeline-only `interrupted` outcome. |
 | **Last semantic result** | The final result-history entry, exposed through the derived `lastResult` compatibility alias. |
 | **Current turn ID** | The canonical Codex UUIDv7 returned by an exact native read of the linked executor for the turn being reported. |
 | **Dashboard** | The loopback, read-only UI derived from validated workspace snapshots and bounded native actions. |
@@ -68,9 +69,9 @@ 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, schema-5,
-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
+`tasks.jsonl` MUST contain zero or more newline-terminated schema-4 through
+schema-8 records, one per line. Schemas 4 through 7 are supported
+migration/read formats; every new record and state mutation MUST write schema 8. 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 +83,7 @@ Every record MUST contain exactly these fields:
 
 | Field | Contract |
 | --- | --- |
-| `schemaVersion` | Integer `7`; schema-4/5/6 records remain readable until explicit migration or their next mutation. |
+| `schemaVersion` | Integer `8`; schema-4/5/6/7 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,12 +95,14 @@ 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`. |
-| `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. |
+| `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, a semantic `{status, summary, updatedAt}` result, or the TaskChef-generated `{status: "interrupted", summary: "Turn interrupted before a terminal report.", updatedAt}` outcome. 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 `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.
+timeline or the final `turns` entry. They MUST derive `results` only from
+semantic `needs_input`, `completed`, and `failed` turn results and `lastResult`
+from the final derived semantic result. Interrupted outcomes MUST be excluded.
+These projections MUST NOT be persisted in schema 8 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.
@@ -129,7 +132,9 @@ the final link, preserving the delegate skill's immediate-return contract.
 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.
+   It MUST NOT reuse a prior turn. If the preceding turn is still unfinished,
+   TaskChef MUST atomically close it as `interrupted` before appending the new
+   working turn; the executor MUST NOT report semantic `failed` for recovery.
 
 If native creation fails after recording, the dispatcher MUST call
 `report_state` with `failed`, null thread/turn IDs, and a bounded summary.
@@ -238,7 +243,7 @@ new preparation values, though it writes no state.
 
 **Structured output:** `{ task: Task }`.
 
-The returned task has schema 7, `working`, null summary/turn/thread/latestTurn/lastResult,
+The returned task has schema 8, `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
@@ -283,16 +288,23 @@ marker, or ineligible state fails.
 
 **Structured output:** `{ task: Task }`.
 
-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
+For a linked self-linking journey, a new `working` state MUST identify a turn
+newer than the current turn and last semantic result. An exact retry of any
+already-recorded working start MUST return the current task without mutation.
+A semantic state MUST match the current working turn. Conflicting or stale
+state fails. A null-identity record accepts only a fresh executor
 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.
+its request and a null result. When the previous latest turn is unfinished, the
+same locked atomic rewrite MUST first fill it with the fixed TaskChef-generated
+`interrupted` outcome. The semantic report fills the active 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.
 
+`interrupted` MUST NOT be accepted as MCP input or projected as task `status`.
+It MUST NOT alter `summary`, `results`, or `lastResult`, and its fixed summary
+MUST contain no crash output, transcript, user text, or inferred failure cause.
+
 **Annotations:** `readOnlyHint: false`, `destructiveHint: true`,
 `openWorldHint: false`.
 
@@ -302,8 +314,8 @@ result that does not match the active working turn MUST fail.
 temporary compatibility alias. It implicitly accepts a fresh supplied turn 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/6
-to schema 7; unsupported schemas remain rejected.
+instructions MUST use `report_state`. Successful mutation upgrades schema 4/5/6/7
+to schema 8; unsupported schemas remain rejected.
 
 ## Reporting and dashboard
 
@@ -359,12 +371,13 @@ its displayed summary when present, event time, and missing-task state.
 
 ## Task-log migration
 
-`workspace migrate` MUST explicitly convert every supported schema-4/5/6 record
+`workspace migrate` MUST explicitly convert every supported schema-4/5/6/7 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,
+completed turn; a newer working state becomes a final unfinished turn, and a
+schema-7 timeline is preserved losslessly. Migration MUST validate the complete
+source and complete schema-8 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-7 log MUST be an idempotent
+and validate the installed result. A fully schema-8 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-7 snapshot
+  W->>W: Lock, validate, append schema-8 snapshot
   W-->>M: working link-pending task
   M-->>D: task
   D->>C: Create executor with marked instruction
@@ -189,6 +189,43 @@ sequenceDiagram
 The executor contract therefore requires a new exact read on every follow-up;
 cached or inherited turn IDs are invalid.
 
+## Interrupted-turn recovery
+
+A crash, MCP failure, app restart, or upgrade can leave the latest turn with a
+null result. A newer valid `working` report is the durable recovery signal. The
+workspace handles it inside the same lock and atomic replacement as every
+other lifecycle mutation:
+
+```mermaid
+sequenceDiagram
+  autonumber
+  participant E as Resumed executor
+  participant M as TaskChef MCP
+  participant W as workspace.js
+  participant F as tasks.jsonl
+  E->>M: report_state(..., turnB, working, requestB)
+  M->>W: reportTaskState()
+  W->>W: Acquire workspace lock and validate turnB > turnA
+  W->>W: Close unfinished turnA as interrupted
+  W->>W: Append turnB with requestB and null result
+  W->>F: One atomic schema-8 replacement
+  W-->>M: working task projected from turnB
+  M-->>E: Idempotent recovery success
+  E->>M: late semantic result for turnA
+  M->>W: Validate active turn and historical outcome
+  W-->>M: Reject stale result
+  M-->>E: Visible tool error
+```
+
+The interrupted outcome uses only the fixed TaskChef-authored summary. It is
+visible in CLI and detail timelines but excluded from semantic `results` and
+`lastResult`. Compact dashboard cards therefore show request B with “In
+progress.” Notification reconciliation observes one new working event and does
+not manufacture a failed-result event. Exact retries of either working start
+return the current snapshot without reopening or duplicating a turn. Concurrent
+newer starts serialize under the lock, leaving one ordered timeline whose only
+unfinished entry is the latest turn.
+
 ## Link-pending and failure paths
 
 A failed or interrupted link never authorizes substantive work. The record
@@ -306,14 +343,15 @@ 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/6 migration
+## Schema 4/5/6/7 migration
 
 `taskchef workspace migrate` acquires the same workspace lock as lifecycle
 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-v7-*.bak` file. The task log is replaced atomically and
-validated again. A second run sees only schema 7 and returns unchanged without
+`tasks.jsonl.pre-v8-*.bak` file. Schema-7 timelines are copied losslessly into
+schema 8. The task log is replaced atomically and validated again. A second run
+sees only schema 8 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,8 +368,9 @@ 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, 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
+Configuration schema 2 and task schemas 4, 5, 6, 7, and 8 are accepted. Schemas
+4/5/6/7 are read/migration compatibility until an explicit migration or lifecycle
+mutation upgrades each record to schema 8. Schema 8 persists `turns`, including
+timeline-only interrupted outcomes, and derives semantic-only `results` and
+`lastResult` plus `latestTurn` for compact compatibility. Other schemas
 are rejected without rewrite.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taskchef",
-  "version": "7.9.1",
+  "version": "7.10.0",
   "description": "A non-blocking interactive dispatcher for visible Codex tasks.",
   "license": "MIT",
   "author": "Favo Yang",
@@ -29,6 +29,7 @@
     "docs/images/dashboard-identity.jpg",
     "docs/images/notification-event-snapshots.jpg",
     "docs/images/result-history-dashboard.jpg",
+    "docs/images/interrupted-turn-recovery.jpg",
     "index.js",
     "mcp",
     "scripts/benchmark-dispatch-prepare.js",

package/skills/taskchef-executor/SKILL.md

@@ -35,6 +35,12 @@ Complete this lifecycle setup before substantive assignment work:
    current turn ID, `status: working`, an omitted or null result summary, and a
    concise `requestSummary` describing this turn's assignment or follow-up.
 
+If the preceding TaskChef turn is still unfinished because its terminal report
+was lost, this newer valid working report atomically records that predecessor
+as interrupted and starts the current turn. Continue the real assignment from
+the current request. Do not manufacture a semantic `failed` result for the old
+turn and do not retry an old terminal report.
+
 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
 failure visibly and stop before substantive work. Retry on a later turn. Never
@@ -53,10 +59,11 @@ the current turn with one semantic status and a concise summary:
 A live native approval prompt is Codex state, not semantic `needs_input`; leave
 the approval live instead of storing it as a TaskChef result. Never invent or
 reuse a turn ID after a follow-up. If a final-report response is lost, an
-identical retry is safe only while the same turn remains current. On a later
-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.
+identical terminal retry is safe only while the same turn remains current. On
+a later turn, run the start lifecycle with its new current turn ID; TaskChef
+will preserve the predecessor as interrupted, and only the new turn may receive
+a semantic result. Say reporting failures visibly instead of claiming a tracked
+outcome.
 
 Request and result summaries must omit secrets, transcripts, raw command output, hidden reasoning,
 and unnecessary personal data. Identical lifecycle retries are safe; never

package/skills/taskchef-report/SKILL.md

@@ -44,14 +44,18 @@ 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 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.
+4. In schema 8, treat `turns` as the ordered request/result timeline. Each turn
+   pairs a bounded `requestSummary` with one semantic result, a TaskChef-generated
+   `interrupted` outcome, or null while work is in progress. Describe an
+   interrupted historical turn plainly as interrupted/abandoned, never failed.
+   `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
+   expect interrupted outcomes in either projection and 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.
+   request summary without rewriting their log line. Schema 7 timelines remain
+   readable but cannot contain the schema-8 interrupted outcome.
    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/dashboard/app.js

@@ -12,6 +12,7 @@ import {
   reconcileNotifications,
   taskStatusLabel,
   taskWithinDateFilter,
+  turnPresentation,
 } from "./state.js";
 import { openTaskFromControl } from "./actions.js";
 import { formatRelativeTime, RelativeTimeController, parsedTimestamp } from "./time.js";
@@ -237,11 +238,12 @@ function turnTimeline(task) {
     const header = document.createElement("div");
     header.className = "result-history-header";
     const status = document.createElement("span");
-    const turnStatus = turn.result?.status ?? "working";
+    const presentation = turnPresentation(turn);
+    const turnStatus = presentation.status;
     status.className = `status status-${turnStatus}`;
     status.textContent = turnStatus.replaceAll("_", " ");
     const turnKey = turn.turnId ?? `no-turn:${index}`;
-    const timestamp = timestampControl(turn.result?.updatedAt ?? turn.startedAt, {
+    const timestamp = timestampControl(presentation.updatedAt, {
       accessibleName: `Turn updated time for ${turnStatus.replaceAll("_", " ")}`,
       key: `detail:${task.id}:turn:${turnKey}`,
     });
@@ -255,7 +257,7 @@ function turnTimeline(task) {
     resultLabel.textContent = "Result";
     const result = document.createElement("p");
     result.className = "preserve-lines";
-    result.textContent = turn.result?.summary ?? "In progress";
+    result.textContent = presentation.summary;
     const turnMetadata = document.createElement("p");
     turnMetadata.className = "result-history-turn";
     turnMetadata.textContent = turn.turnId

package/src/dashboard/state.js

@@ -1,4 +1,5 @@
 export const MAX_NOTIFICATIONS = 50;
+const INTERRUPTED_TURN_SUMMARY = "Turn interrupted before a terminal report.";
 export const KNOWN_TASK_STATUSES = [
   "working",
   "needs input",
@@ -49,6 +50,15 @@ export function latestTurnPresentation(task) {
   };
 }
 
+export function turnPresentation(turn) {
+  const result = turn.result ?? null;
+  return {
+    status: result?.status ?? "working",
+    summary: result?.summary ?? "In progress",
+    updatedAt: result?.updatedAt ?? turn.startedAt,
+  };
+}
+
 export function mergeProjectedTurns(task, preservedTurns = []) {
   if (Array.isArray(task.turns)) return task.turns;
   if (!task.latestTurn) return preservedTurns;
@@ -57,6 +67,20 @@ export function mergeProjectedTurns(task, preservedTurns = []) {
   if (lastIndex >= 0 && turns[lastIndex].turnId === task.latestTurn.turnId) {
     turns[lastIndex] = task.latestTurn;
   } else {
+    if (
+      task.schemaVersion === 8
+      && lastIndex >= 0
+      && turns[lastIndex].result === null
+    ) {
+      turns[lastIndex] = {
+        ...turns[lastIndex],
+        result: {
+          status: "interrupted",
+          summary: INTERRUPTED_TURN_SUMMARY,
+          updatedAt: task.latestTurn.startedAt,
+        },
+      };
+    }
     turns.push(task.latestTurn);
   }
   return turns;

package/src/dashboard/styles.css

@@ -94,6 +94,7 @@ time, .timestamp-missing { font-size: 0.78rem; }
 .status-completed { background: var(--accent-soft); color: var(--accent); }
 .status-failed { background: #f3dfdd; color: var(--danger); }
 .status-needs_input { background: #f4e9ce; color: var(--warning); }
+.status-interrupted { background: #e8e5df; color: #625d54; }
 
 .empty-state { padding: 60px 20px; border: 1px dashed var(--border); border-radius: 10px; text-align: center; color: var(--muted); }
 .empty-state h2 { margin-bottom: 6px; color: var(--text); }
@@ -177,4 +178,5 @@ pre { max-height: 280px; margin: 0; padding: 14px; overflow: auto; border-radius
   .dashboard-message { border-color: #66592e; background: #38321d; color: #f1d98c; }
   .status-failed { background: #4e2927; }
   .status-needs_input { background: #4c3b20; }
+  .status-interrupted { background: #37332f; color: #d6d0c7; }
 }

package/src/mcp.js

@@ -21,7 +21,9 @@ const projectSchema = z.object({
 });
 
 const taskSchema = z.object({
-  schemaVersion: z.union([z.literal(4), z.literal(5), z.literal(6), z.literal(7)]),
+  schemaVersion: z.union([
+    z.literal(4), z.literal(5), z.literal(6), z.literal(7), z.literal(8),
+  ]),
   id: z.string(),
   project: projectSchema,
   title: z.string(),
@@ -38,7 +40,7 @@ const taskSchema = z.object({
     requestSummary: z.string().nullable(),
     startedAt: z.string(),
     result: z.object({
-      status: z.enum(["needs_input", "completed", "failed"]),
+      status: z.enum(["needs_input", "completed", "failed", "interrupted"]),
       summary: z.string(),
       updatedAt: z.string(),
     }).nullable(),
@@ -48,7 +50,7 @@ const taskSchema = z.object({
     requestSummary: z.string().nullable(),
     startedAt: z.string(),
     result: z.object({
-      status: z.enum(["needs_input", "completed", "failed"]),
+      status: z.enum(["needs_input", "completed", "failed", "interrupted"]),
       summary: z.string(),
       updatedAt: z.string(),
     }).nullable(),

package/src/workspace.js

@@ -38,8 +38,9 @@ const DISPATCH_FILE_NAME = "tasks.jsonl";
 const WORKSPACE_LOCK_NAME = ".taskchef-workspace.lock";
 const SAFE_ID = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
 const CURRENT_CONFIG_SCHEMA_VERSION = 2;
-const CURRENT_TASK_SCHEMA_VERSION = 7;
-const PREVIOUS_TASK_SCHEMA_VERSION = 6;
+const CURRENT_TASK_SCHEMA_VERSION = 8;
+const PREVIOUS_TASK_SCHEMA_VERSION = 7;
+const LEGACY_RESULTS_TASK_SCHEMA_VERSION = 6;
 const FIRST_SELF_LINKING_TASK_SCHEMA_VERSION = 4;
 const CONFIG_FIELDS = new Set(["schemaVersion", "projects"]);
 const PROJECT_FIELDS = new Set([
@@ -75,6 +76,7 @@ const RECORD_DISPATCH_FIELDS = new Set([
   "threadId",
 ]);
 const RESULT_STATUSES = new Set(["needs_input", "completed", "failed"]);
+const TURN_RESULT_STATUSES = new Set([...RESULT_STATUSES, "interrupted"]);
 const TASK_STATUSES = new Set(["working", ...RESULT_STATUSES]);
 const TASK_UPDATE_SOURCES = new Set(["dispatcher", "mcp"]);
 const MAX_RESULT_SUMMARY_LENGTH = 2_000;
@@ -82,6 +84,7 @@ 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"]);
+const INTERRUPTED_TURN_SUMMARY = "Turn interrupted before a terminal report.";
 
 function requireExactFields(value, fields, name) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -228,7 +231,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(schema7Task(dispatch))}\n`)
+    .map((dispatch) => `${JSON.stringify(currentSchemaTask(dispatch))}\n`)
     .join("");
   await writeTextAtomic(dispatchPath, `${content}${appended}`);
 }
@@ -689,6 +692,7 @@ async function validateDispatchShape(dispatch, name = "task") {
   const supportedVersions = [
     FIRST_SELF_LINKING_TASK_SCHEMA_VERSION,
     5,
+    LEGACY_RESULTS_TASK_SCHEMA_VERSION,
     PREVIOUS_TASK_SCHEMA_VERSION,
     CURRENT_TASK_SCHEMA_VERSION,
   ];
@@ -697,9 +701,9 @@ async function validateDispatchShape(dispatch, name = "task") {
   }
   requireExactFields(
     dispatch,
-    dispatch.schemaVersion === CURRENT_TASK_SCHEMA_VERSION
+    dispatch.schemaVersion >= PREVIOUS_TASK_SCHEMA_VERSION
       ? DISPATCH_FIELDS
-      : dispatch.schemaVersion === PREVIOUS_TASK_SCHEMA_VERSION
+      : dispatch.schemaVersion === LEGACY_RESULTS_TASK_SCHEMA_VERSION
         ? SCHEMA_6_DISPATCH_FIELDS
         : dispatch.schemaVersion === 5
         ? SCHEMA_5_DISPATCH_FIELDS
@@ -746,7 +750,13 @@ async function validateDispatchShape(dispatch, name = "task") {
     if (result === null) return null;
     requireExactFields(result, TURN_RESULT_FIELDS, resultName);
     const normalizedResult = {
-      status: requireEnum(result.status, RESULT_STATUSES, `${resultName}.status`),
+      status: requireEnum(
+        result.status,
+        dispatch.schemaVersion === CURRENT_TASK_SCHEMA_VERSION
+          ? TURN_RESULT_STATUSES
+          : RESULT_STATUSES,
+        `${resultName}.status`,
+      ),
       summary: optionalString(result.summary, `${resultName}.summary`, {
         maxLength: MAX_RESULT_SUMMARY_LENGTH,
       }),
@@ -755,6 +765,12 @@ async function validateDispatchShape(dispatch, name = "task") {
     if (normalizedResult.summary === null) {
       throw new Error(`${resultName}.summary must be a non-empty string`);
     }
+    if (
+      normalizedResult.status === "interrupted"
+      && normalizedResult.summary !== INTERRUPTED_TURN_SUMMARY
+    ) {
+      throw new Error(`${resultName}.summary must use the TaskChef interrupted-turn summary`);
+    }
     return normalizedResult;
   };
   const normalizeTurn = (turn, turnName) => {
@@ -770,10 +786,10 @@ async function validateDispatchShape(dispatch, name = "task") {
   };
   let legacyResults = [];
   let turns = [];
-  if (dispatch.schemaVersion === CURRENT_TASK_SCHEMA_VERSION) {
+  if (dispatch.schemaVersion >= PREVIOUS_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) {
+  } else if (dispatch.schemaVersion === LEGACY_RESULTS_TASK_SCHEMA_VERSION) {
     if (!Array.isArray(dispatch.results)) throw new Error(`${name}.results must be an array`);
     legacyResults = dispatch.results.map((result, index) => (
       normalizeResult(result, `${name}.results[${index}]`)
@@ -785,7 +801,7 @@ async function validateDispatchShape(dispatch, name = "task") {
   } else if (RESULT_STATUSES.has(status)) {
     legacyResults = [{ status, summary, turnId, updatedAt }];
   }
-  if (dispatch.schemaVersion !== CURRENT_TASK_SCHEMA_VERSION) {
+  if (dispatch.schemaVersion < PREVIOUS_TASK_SCHEMA_VERSION) {
     turns = legacyResults.map((result) => ({
       turnId: result.turnId,
       requestSummary: null,
@@ -807,7 +823,9 @@ async function validateDispatchShape(dispatch, name = "task") {
       turns.push({ turnId, requestSummary: null, startedAt: updatedAt, result: null });
     }
   }
-  const results = turns.flatMap((turn) => turn.result === null ? [] : [{
+  const results = turns.flatMap((turn) => (
+    turn.result === null || !RESULT_STATUSES.has(turn.result.status)
+  ) ? [] : [{
     ...turn.result,
     turnId: turn.turnId,
   }]);
@@ -847,7 +865,9 @@ async function validateDispatchShape(dispatch, name = "task") {
         );
       }
     }
-    normalized.results = normalized.turns.flatMap((turn) => turn.result === null ? [] : [{
+    normalized.results = normalized.turns.flatMap((turn) => (
+      turn.result === null || !RESULT_STATUSES.has(turn.result.status)
+    ) ? [] : [{
       ...turn.result,
       turnId: turn.turnId,
     }]);
@@ -1076,7 +1096,7 @@ export async function parseTaskLogContent(workspaceRoot, content) {
   return (await parseDispatchRecordsUnlocked(root, content)).map((record) => record.normalized);
 }
 
-function schema7Task(dispatch, patch = {}) {
+function currentSchemaTask(dispatch, patch = {}) {
   const {
     latestTurn: _latestTurn,
     results: _results,
@@ -1115,13 +1135,13 @@ export async function migrateTaskLog(workspaceRoot, {
         backupPath: null,
       };
     }
-    const lines = records.map((record) => JSON.stringify(schema7Task(record.normalized)));
+    const lines = records.map((record) => JSON.stringify(currentSchemaTask(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-v7-${timestamp}-${randomUUID()}.bak`;
+    const backupPath = `${dispatchPath}.pre-v8-${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}`);
@@ -1209,7 +1229,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(schema7Task(dispatch, {
+      const canonical = await validateDispatchShape(currentSchemaTask(dispatch, {
         threadId: durableThreadId,
         updatedAt: transitionTimestamp(now, dispatch.updatedAt),
         updatedBy: "mcp",
@@ -1238,7 +1258,7 @@ export async function linkTask(workspaceRoot, taskId, threadId, { now } = {}) {
     ))) {
       throw new Error(`threadId is already recorded: ${durableThreadId}`);
     }
-    const linked = await validateDispatchShape(schema7Task(dispatch, {
+    const linked = await validateDispatchShape(currentSchemaTask(dispatch, {
       threadId: durableThreadId,
       updatedAt: transitionTimestamp(now, dispatch.updatedAt),
       updatedBy: "mcp",
@@ -1252,7 +1272,7 @@ export async function linkTask(workspaceRoot, taskId, threadId, { now } = {}) {
 }
 
 function dispatchLineWithState(dispatch, patch) {
-  return JSON.stringify(schema7Task(dispatch, patch));
+  return JSON.stringify(currentSchemaTask(dispatch, patch));
 }
 
 function normalizeTaskStateInput(input, { allowWorking }) {
@@ -1374,6 +1394,21 @@ async function reportTaskStateInternal(
     }
     if (status === "working") {
       const sameWorkingTurn = dispatch.status === "working" && stateTurnId === dispatch.turnId;
+      const recordedTurn = dispatch.turns.find((turn) => turn.turnId === stateTurnId);
+      if (!sameWorkingTurn && recordedTurn) {
+        if (
+          requestSummary !== null
+          && recordedTurn.requestSummary !== requestSummary
+        ) {
+          throw new Error(`working turn already has a different requestSummary: ${id}`);
+        }
+        if (
+          recordedTurn.requestSummary !== null
+          || recordedTurn.result?.status === "interrupted"
+        ) {
+          return dispatch;
+        }
+      }
       if (sameWorkingTurn) {
         const storedRequest = dispatch.latestTurn?.requestSummary ?? null;
         if (
@@ -1401,17 +1436,33 @@ async function reportTaskStateInternal(
       const updatedAt = sameWorkingTurn
         ? dispatch.updatedAt
         : transitionTimestamp(now, dispatch.updatedAt);
+      const recoveredTurns = (
+        !sameWorkingTurn
+        && dispatch.status === "working"
+        && dispatch.latestTurn?.result === null
+      )
+        ? dispatch.turns.map((turn, turnIndex) => turnIndex === dispatch.turns.length - 1
+          ? {
+            ...turn,
+            result: {
+              status: "interrupted",
+              summary: INTERRUPTED_TURN_SUMMARY,
+              updatedAt,
+            },
+          }
+          : turn)
+        : dispatch.turns;
       const turns = sameWorkingTurn
         ? dispatch.turns.map((turn, turnIndex) => turnIndex === dispatch.turns.length - 1
           ? { ...turn, requestSummary: turn.requestSummary ?? requestSummary }
           : turn)
-        : [...dispatch.turns, {
+        : [...recoveredTurns, {
           turnId: stateTurnId,
           requestSummary,
           startedAt: updatedAt,
           result: null,
         }];
-      const updated = await validateDispatchShape(schema7Task(dispatch, {
+      const updated = await validateDispatchShape(currentSchemaTask(dispatch, {
         status,
         summary: null,
         turnId: stateTurnId,
@@ -1465,7 +1516,7 @@ async function reportTaskStateInternal(
         ? { ...turn, result: turnResult }
         : turn);
     }
-    const candidate = schema7Task(dispatch, {
+    const candidate = currentSchemaTask(dispatch, {
       status,
       summary,
       turnId: stateTurnId,