taskchef 7.8.0 → 7.9.1

package/.codex-plugin/plugin.json

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

package/README.md

@@ -3,11 +3,11 @@
 TaskChef is a local dispatch desk for Codex. Give one dispatcher a request and
 it records each independently useful outcome, creates a normal Codex task in
 the right project, and returns immediately. The executor task is where live
-work, approvals, and follow-ups happen; TaskChef keeps every semantic result
-while projecting the latest one for compact navigation and reporting.
+work, approvals, and follow-ups happen; TaskChef pairs each turn's request with
+its semantic result while projecting the latest pair for compact navigation.
 
 ```text
-request -> recorded TaskChef task -> Codex executor -> current state + result history
+request -> recorded TaskChef task -> Codex executor -> request/result turn timeline
 ```
 
 ## Which document should I read?
@@ -49,7 +49,7 @@ The canonical workspace is `~/.agents/taskchef`. TaskChef owns only:
 ```text
 AGENTS.md       managed dispatcher instructions plus user additions
 taskchef.json   schema-2 configured projects and routing metadata
-tasks.jsonl     one task snapshot per line (schema 6; schema 4/5 migration supported)
+tasks.jsonl     one task snapshot per line (schema 7; schema 4/5/6 migration supported)
 ```
 
 List or change routing targets conversationally:
@@ -104,7 +104,6 @@ For example, TaskChef generates this shape:
 
 ```text
 Fix duplicate charges after a retry and add a regression test.
-
 <!-- taskchef_id=c0f010ff-84f2-4838-a69d-0ff1f5d721d7 -->
 Use $taskchef-executor to execute and report this delegated TaskChef assignment.
 ```
@@ -119,12 +118,12 @@ when a turn starts and one semantic outcome before that same turn ends:
 - `failed`: the executor or creation attempt ended unsuccessfully.
 
 A native approval prompt is live Codex state, not `needs_input`.
-TaskChef stores the current reported execution state and appends every concise
-semantic result to `results`. A follow-up therefore appears as `working`
-immediately without erasing any prior outcome. The final entry is exposed as a
-derived `lastResult` compatibility alias; it is not persisted independently and
-is planned for removal in the next major version after callers move to
-`results.at(-1)`. TaskChef does not store transcripts or non-semantic events.
+When work starts, the executor reports a concise request summary. TaskChef
+appends a `turns` entry that pairs that request with a null result while working,
+then fills the same entry with the semantic outcome. A follow-up therefore shows
+its own request with “In progress,” never the preceding turn's result. Returned
+tasks still derive `results` and `lastResult` as compatibility projections.
+TaskChef does not store transcripts, hidden reasoning, or non-semantic events.
 
 Delegated tasks created by earlier TaskChef versions remain compatible: their
 inline executor protocol still parses, self-links, and may use the deprecated
@@ -174,8 +173,9 @@ taskchef dashboard --port 3211
 ```
 
 The loopback dashboard watches `tasks.jsonl`, groups current states, and opens
-linked Codex tasks. List snapshots and SSE events carry only the latest-result
-projection; opening task details fetches the full newest-first result history.
+linked Codex tasks. List snapshots and SSE events carry only the latest
+request/result pair; opening task details fetches the full newest-first activity
+timeline.
 The header shows the running TaskChef package version reported by the same
 bounded health identity used for compatible-listener checks.
 Task and result times are relative through 29 days (with minute detail for the
@@ -203,7 +203,7 @@ no task data, credentials, environment variables, process control, or secrets.
 
 ![Immutable event-time dashboard notifications](docs/images/notification-event-snapshots.jpg)
 
-![Task detail result history](docs/images/result-history-dashboard.jpg)
+![Task detail activity timeline](docs/images/result-history-dashboard.jpg)
 
 ## Common recovery
 
@@ -218,8 +218,8 @@ taskchef doctor
 
 `doctor` is read-only. `workspace init` creates missing files and refreshes
 managed instructions. `workspace migrate` explicitly upgrades supported schema
-4/5 task lines to schema 6 under the workspace lock. It validates the complete
-source and converted log before writing, creates an exclusive `tasks.jsonl.pre-v6-*.bak`
+4/5/6 task lines to schema 7 under the workspace lock. It validates the complete
+source and converted log before writing, creates an exclusive `tasks.jsonl.pre-v7-*.bak`
 backup, atomically replaces the log, validates the result, and becomes an
 idempotent no-op after migration. If replacement fails, the original remains
 or the reported backup can be restored; unsupported or invalid input is rejected
@@ -230,7 +230,7 @@ executor so its first action can retry `link_task`. Do not guess an identity
 or edit `tasks.jsonl`. If native task creation failed, the record is retained
 as `failed` with null thread and turn IDs.
 
-Schemas other than 4, 5, and 6 remain unsupported. Retain such a workspace
+Schemas other than 4, 5, 6, and 7 remain unsupported. Retain such a workspace
 unchanged and create a current workspace; the migration command deliberately
 does not guess how to convert unknown formats.
 

package/docs/spec.md

@@ -23,7 +23,7 @@ is dated research, not contract.
 | **Self-linking** | The executor's one-way registration of its own canonical Codex UUIDv7 from `CODEX_THREAD_ID`. |
 | **Link-pending** | A working task whose `threadId` is null and `updatedBy` is `dispatcher`. |
 | **Current execution state** | The latest reported executor turn and its `working`, `needs_input`, `completed`, or `failed` status. |
-| **Result history** | The ordered collection of every accepted `completed`, `needs_input`, or `failed` per-turn outcome. |
+| **Turn timeline** | The ordered collection pairing each turn's concise request summary with its eventual semantic result. |
 | **Last semantic result** | The final result-history entry, exposed through the derived `lastResult` compatibility alias. |
 | **Current turn ID** | The canonical Codex UUIDv7 returned by an exact native read of the linked executor for the turn being reported. |
 | **Dashboard** | The loopback, read-only UI derived from validated workspace snapshots and bounded native actions. |
@@ -69,8 +69,8 @@ Repository URLs MUST canonicalize to `https://github.com/<owner>/<repository>`
 and be case-insensitively deduplicated.
 
 `tasks.jsonl` MUST contain zero or more newline-terminated schema-4, schema-5,
-or schema-6 records, one per line. Schemas 4 and 5 are supported migration/read
-formats; every new record and state mutation MUST write schema 6. Other schemas
+schema-6, or schema-7 records, one per line. Schemas 4 through 6 are supported
+migration/read formats; every new record and state mutation MUST write schema 7. Other schemas
 or unsupported fields MUST be rejected without conversion.
 Reads and writes MUST reject symlinked managed files. Mutations
 MUST hold the shared workspace lock and replace state atomically; read-only
@@ -82,7 +82,7 @@ Every record MUST contain exactly these fields:
 
 | Field | Contract |
 | --- | --- |
-| `schemaVersion` | Integer `6`; schema-4/5 records remain readable until explicit migration or their next mutation. |
+| `schemaVersion` | Integer `7`; schema-4/5/6 records remain readable until explicit migration or their next mutation. |
 | `id` | Unique safe TaskChef ID; delegation uses a lowercase full UUID. |
 | `project` | Immutable configured-project snapshot. |
 | `title` | Non-empty display title. |
@@ -94,13 +94,12 @@ Every record MUST contain exactly these fields:
 | `turnId` | Null before turn reporting; otherwise the current reported turn. Linked MCP journeys use a canonical Codex UUIDv7. |
 | `updatedAt` | ISO 8601 timestamp not earlier than `createdAt` or the prior `updatedAt`; clock rollback cannot backdate a transition. |
 | `updatedBy` | `dispatcher` or `mcp`. |
-| `results` | Ordered oldest-first array of `{status, summary, turnId, updatedAt}` semantic results, with unique turn IDs and nondecreasing timestamps. |
+| `turns` | Ordered oldest-first array of `{turnId, requestSummary, startedAt, result}`. `requestSummary` is null only for migrated/compatibility turns; `result` is null only for the latest working turn or is `{status, summary, updatedAt}`. Canonical self-linking turn IDs are unique. A migrated low-level opaque record may retain one final reused ID to represent its legacy completed-result-plus-working-state ambiguity. |
 
-Returned Task objects MUST additionally expose `lastResult` as null for an empty
-history or the final `results` entry. `lastResult` MUST be derived and MUST NOT
-be persisted in schema 6. It is a compatibility alias for schema-4/5, CLI,
-MCP, reporting-skill, and dashboard-list callers, with removal planned for the
-next major version after callers migrate to `results.at(-1)`.
+Returned Task objects MUST additionally expose `latestTurn` as null for an empty
+timeline or the final `turns` entry. They MUST derive `results` from completed
+turns and `lastResult` from the final derived result. These projections MUST NOT
+be persisted in schema 7 and remain compatibility aliases for existing callers.
 
 Task IDs and non-null thread identities MUST be unique. The immutable intent
 fields MUST NOT change after recording.
@@ -117,10 +116,10 @@ the final link, preserving the delegate skill's immediate-return contract.
 1. The dispatcher MUST call `prepare_dispatch` once per outcome.
 2. It MUST choose exactly one configured project and exact native-project path.
 3. It MUST build the instruction with the user's outcome beginning on line 1
-   and remaining uninterrupted, followed by one blank line, the returned
-   marker, and exactly one concise explicit `$taskchef-executor` invocation on
-   the final line. It MUST NOT inline the executor protocol into a new
-   instruction.
+   and remaining uninterrupted, followed by exactly one newline, the returned
+   marker, one newline, and exactly one concise explicit `$taskchef-executor`
+   invocation on the final line. It MUST NOT place a blank line before or after
+   the marker or inline the executor protocol into a new instruction.
 4. It MUST call `record_task` with `threadId: null` before native creation.
 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`
@@ -137,9 +136,10 @@ If native creation fails after recording, the dispatcher MUST call
 A link failure MUST remain visible and retryable; the executor MUST report it
 visibly and MUST NOT continue substantive work.
 
-Previously recorded instructions with a first-line HTML marker, the older
-first-line `# taskchef_id=<full UUID>` heading, or the former blank line and
-inline executor protocol MUST remain marker-readable and executable. Their
+Previously recorded instructions with the former blank line before a trailing
+marker, a first-line HTML marker, the older first-line
+`# taskchef_id=<full UUID>` heading, or the former blank line and inline
+executor protocol MUST remain marker-readable and executable. Their
 `report_result` calls MUST remain supported by the deprecated alias. New
 instructions MUST use the trailing marker and explicit executor skill contract
 above. A historical first-line instruction with an executor-skill invocation
@@ -238,8 +238,8 @@ new preparation values, though it writes no state.
 
 **Structured output:** `{ task: Task }`.
 
-The returned task has schema 6, `working`, null summary/turn/thread/lastResult,
-an empty `results` array,
+The returned task has schema 7, `working`, null summary/turn/thread/latestTurn/lastResult,
+empty `turns` and derived `results` arrays,
 `updatedBy: dispatcher`, and equal creation/update timestamps. Duplicate IDs,
 unknown projects, malformed markers, and invalid input fail. Repeating a
 successful call is not idempotent; it fails as a duplicate.
@@ -268,7 +268,7 @@ marker, or ineligible state fails.
 ### `report_state`
 
 **Caller:** executor, or dispatcher only for native creation failure.
-**Mutation:** replaces the current state atomically and preserves `results`.
+**Mutation:** replaces the current state atomically and preserves `turns`.
 
 **Input:**
 
@@ -279,6 +279,7 @@ marker, or ineligible state fails.
 | `turnId` | Current canonical Codex UUIDv7 for a linked MCP journey; null only for creation failure. Maximum 256 characters at the MCP boundary. |
 | `status` | `working`, `needs_input`, `completed`, or `failed`. |
 | `summary` | Omitted or null for `working`; required non-empty string of at most 2,000 characters otherwise. |
+| `requestSummary` | Concise current request of at most 1,000 characters for `working`; optional for backward compatibility and omitted for semantic states. |
 
 **Structured output:** `{ task: Task }`.
 
@@ -286,10 +287,10 @@ For a linked self-linking journey, `working` MUST identify a turn newer than
 the current turn and last semantic result. A semantic state MUST match the
 current working turn. Repeating an identical state is idempotent; conflicting
 or older state fails. A null-identity record accepts only a fresh executor
-creation `failed` state with both IDs null. Success sets the current state and
-appends a semantic result to `results`; starting newer work preserves the entire
-collection. An identical retry for any settled turn returns success without an
-append. A different result for a settled turn, a stale turn, or a semantic
+creation `failed` state with both IDs null. Starting work appends one turn with
+its request and a null result; the semantic report fills that same turn's result.
+An identical retry for any settled turn returns success without an append. A
+different request or result for the same turn, a stale turn, or a semantic
 result that does not match the active working turn MUST fail.
 
 **Annotations:** `readOnlyHint: false`, `destructiveHint: true`,
@@ -299,10 +300,10 @@ result that does not match the active working turn MUST fail.
 
 `report_result` retains the prior semantic-only input shape and statuses as a
 temporary compatibility alias. It implicitly accepts a fresh supplied turn and
-stores its semantic result, including for supported schema-4/5 records and
+stores its semantic result in a request-unknown turn, including for supported schema-4/5/6 records and
 low-level opaque direct records. It does not accept `working`. New executor
-instructions MUST use `report_state`. Successful mutation upgrades schema 4/5
-to schema 6; unsupported schemas remain rejected.
+instructions MUST use `report_state`. Successful mutation upgrades schema 4/5/6
+to schema 7; unsupported schemas remain rejected.
 
 ## Reporting and dashboard
 
@@ -324,9 +325,9 @@ startup safely. Direct thread navigation
 MUST require a canonical Codex UUIDv7. Otherwise it MAY open the revalidated
 configured project. Project paths from task history MUST be matched against
 current configuration before use.
-Snapshot and SSE list payloads MUST omit full `results` history and include the
-derived latest-result projection. The bounded per-task detail endpoint MAY
-return the full validated task so the dialog can render history newest first.
+Snapshot and SSE list payloads MUST omit full `turns` and derived `results`
+history and include `latestTurn`. The bounded per-task detail endpoint MAY
+return the full validated task so the dialog can render the paired timeline newest first.
 Dashboard notifications MUST capture an immutable event-time projection of the
 task title, lifecycle state and event, turn ID when present, event timestamp,
 and relevant concise summary. Rendering MUST NOT resolve historical notice text
@@ -358,12 +359,12 @@ its displayed summary when present, event time, and missing-task state.
 
 ## Task-log migration
 
-`workspace migrate` MUST explicitly convert every supported schema-4/5 record
-under the shared lock. A legacy `lastResult`, or a schema-4 current semantic
-state, becomes zero or one initial `results` entry. Migration MUST validate the
-complete source and complete schema-6 candidate before changing the task log,
+`workspace migrate` MUST explicitly convert every supported schema-4/5/6 record
+under the shared lock. Each legacy semantic result becomes a request-unknown
+completed turn; a newer working state becomes a final unfinished turn. Migration
+MUST validate the complete source and complete schema-7 candidate before changing the task log,
 create and read back an exclusive recovery backup, atomically replace the log,
-and validate the installed result. A fully schema-6 log MUST be an idempotent
+and validate the installed result. A fully schema-7 log MUST be an idempotent
 no-op without another backup. Invalid/unsupported input MUST remain untouched;
 failures after backup creation MUST report the backup path and MUST never
 partially rewrite individual lines.

package/docs/workflows.md

@@ -89,7 +89,7 @@ sequenceDiagram
   D->>D: Choose one configured and native project
   D->>M: record_task(id, project, title, instruction, null)
   M->>W: recordTask()
-  W->>W: Lock, validate, append schema-6 snapshot
+  W->>W: Lock, validate, append schema-7 snapshot
   W-->>M: working link-pending task
   M-->>D: task
   D->>C: Create executor with marked instruction
@@ -116,8 +116,8 @@ semantic callbacks.
 ## State reporting
 
 The executor obtains the turn identity from an exact native read of its own
-linked task. `report_state` records live turn state while preserving the ordered
-semantic result history.
+linked task. `report_state` records live turn state as a paired request/result
+timeline.
 
 ```mermaid
 sequenceDiagram
@@ -128,15 +128,15 @@ sequenceDiagram
   participant W as workspace.js
   E->>C: Exact read of linked executor
   C-->>E: Current turn ID
-  E->>M: report_state(..., working, null)
+  E->>M: report_state(..., working, requestSummary)
   M->>W: reportTaskState()
-  W->>W: Store current turn and preserve results
+  W->>W: Append turn with request and null result
   E->>E: Work, finish, or reach semantic decision
   E->>M: report_state(..., semantic status, summary)
   M->>W: reportTaskState()
   W->>W: Lock and validate identity and freshness
   alt Same current working turn
-    W->>W: Append semantic result and derive lastResult
+    W->>W: Fill that turn's result and derive compatibility results
     W-->>M: Updated task
     M-->>E: Recorded result
   else Same turn and same result
@@ -171,11 +171,11 @@ sequenceDiagram
   U->>E: Provide decision
   E->>C: Read exact executor after follow-up
   C-->>E: turnB
-  E->>M: report_state(..., turnB, working, null)
+  E->>M: report_state(..., turnB, working, requestB)
   M->>W: reportTaskState()
-  W->>W: Require turnB greater and preserve results
-  W-->>M: working snapshot plus history A
-  M-->>E: working snapshot plus history A
+  W->>W: Require turnB greater and append request B
+  W-->>M: working snapshot plus paired timeline
+  M-->>E: working snapshot plus paired timeline
   E->>M: report_state(..., turnB, completed, summaryB)
   M->>W: reportTaskState()
   W-->>M: completed snapshot plus result B
@@ -263,7 +263,7 @@ sequenceDiagram
   F-->>D: Filesystem change
   D->>F: Bounded read from one descriptor
   D->>D: Validate current schema and sort
-  D-->>B: Compact SSE snapshot without results
+  D-->>B: Compact SSE snapshot with latestTurn only
   B->>D: GET task detail on demand
   D-->>B: Full validated history
   B->>D: Open task action
@@ -279,8 +279,8 @@ The dashboard binds to `127.0.0.1`, has no shared session state, limits task
 count, file size, result count, and display fields, and checks origin/authority
 for stateful local actions. Its bounded identity endpoint contains no task data
 or secrets. The monitor already validates the complete log, but
-snapshot/SSE list projections omit `results` so repeated updates do not resend
-unnecessary history. A read-only per-task endpoint returns full history only
+snapshot/SSE list projections omit `turns` and derived `results` so repeated
+updates do not resend unnecessary history. A read-only per-task endpoint returns the full timeline only
 when the dialog opens. Historical project paths are untrusted until matched
 against current configuration.
 
@@ -306,14 +306,14 @@ all, and ordinary rerendering do not re-announce retained history. Toast action
 labels remain concise while `aria-describedby` connects the visible summary,
 event time, and missing-task explanation for assistive technology.
 
-## Schema 4/5 migration
+## Schema 4/5/6 migration
 
 `taskchef workspace migrate` acquires the same workspace lock as lifecycle
-writers, validates the complete legacy log, converts each schema-4/5 latest
-result into zero or one initial schema-6 `results` entry, then validates the
+writers, validates the complete legacy log, converts schema-4/5/6 results into
+request-unknown completed turns and preserves a newer working turn, then validates the
 complete candidate. Before replacement it writes and reads back an exclusive
-`tasks.jsonl.pre-v6-*.bak` file. The task log is replaced atomically and
-validated again. A second run sees only schema 6 and returns unchanged without
+`tasks.jsonl.pre-v7-*.bak` file. The task log is replaced atomically and
+validated again. A second run sees only schema 7 and returns unchanged without
 another backup. Unsupported or malformed input fails before backup/rewrite;
 after a later filesystem failure, the reported backup is the recovery source.
 
@@ -330,7 +330,8 @@ summary is cryptographically authenticated; this is a local single-user trust
 model. Managed files, instructions, project snapshots, MCP inputs, and dashboard
 requests are validated at every action boundary.
 
-Configuration schema 2 and task schemas 4, 5, and 6 are accepted. Schemas 4/5
-are read/migration compatibility until an explicit migration or lifecycle
-mutation upgrades each record to schema 6. Schema 6 persists `results` only and
-derives `lastResult` for compatibility. Other schemas are rejected without rewrite.
+Configuration schema 2 and task schemas 4, 5, 6, and 7 are accepted. Schemas
+4/5/6 are read/migration compatibility until an explicit migration or lifecycle
+mutation upgrades each record to schema 7. Schema 7 persists `turns` and derives
+`results`, `lastResult`, and `latestTurn` for compact compatibility. Other schemas
+are rejected without rewrite.

package/package.json

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

package/skills/taskchef-delegate/SKILL.md

@@ -52,8 +52,9 @@ stop and report that the TaskChef plugin must be reloaded or installed.
 
    - Begin with the actual assignment on the first line and keep its complete
      body uninterrupted.
-   - After the assignment, add one blank line and the preparation's exact
-     marker on its own line.
+   - After the assignment's final character, add exactly one newline and the
+     preparation's exact marker on its own line. Do not add a blank line before
+     or after the marker.
    - Immediately after the marker, end the instruction with exactly:
      `Use $taskchef-executor to execute and report this delegated TaskChef assignment.`
    - Include exactly one marker and exactly one executor-skill invocation.

package/skills/taskchef-executor/SKILL.md

@@ -9,12 +9,13 @@ Own and execute the delegated assignment in the current Codex task. Do not
 re-dispatch it merely because it concerns TaskChef or a configured project.
 Explicit requests to delegate separate work remain valid.
 
-New instructions present the complete assignment first, followed by one blank
-line, the exact `<!-- taskchef_id=<full UUID> -->` marker, and the final
-explicit skill invocation. Treat that UUID as the TaskChef task ID. The
-assignment is everything before the blank line that precedes the marker; the
-marker and invocation are lifecycle scaffolding, not part of the deliverable.
-Require exactly one marker and do not infer an ID from similar prose.
+New instructions present the complete assignment first, followed by exactly one
+newline, the exact `<!-- taskchef_id=<full UUID> -->` marker, one newline, and
+the final explicit skill invocation. There is no blank line before or after the
+marker. Treat that UUID as the TaskChef task ID. The assignment is everything
+before the marker; the marker and invocation are lifecycle scaffolding, not
+part of the deliverable. Require exactly one marker and do not infer an ID from
+similar prose.
 
 ## Start every execution turn
 
@@ -31,7 +32,8 @@ Complete this lifecycle setup before substantive assignment work:
 3. Read this exact Codex thread natively and obtain the current turn ID. Do not
    infer it or reuse an earlier turn ID.
 4. Call TaskChef `report_state` with the marked task ID, self-linked thread ID,
-   current turn ID, `status: working`, and an omitted or null summary.
+   current turn ID, `status: working`, an omitted or null result summary, and a
+   concise `requestSummary` describing this turn's assignment or follow-up.
 
 If `CODEX_THREAD_ID`, exact native thread reading, or a required TaskChef tool
 is unavailable, or if linking or the working-state report fails, report the
@@ -56,7 +58,7 @@ turn, run the start lifecycle with its new current turn ID and report that
 turn's actual outcome. Say reporting failures visibly instead of claiming a
 tracked outcome.
 
-Summaries must omit secrets, transcripts, raw command output, hidden reasoning,
+Request and result summaries must omit secrets, transcripts, raw command output, hidden reasoning,
 and unnecessary personal data. Identical lifecycle retries are safe; never
 replace a same-turn report with different content or let an older turn
 overwrite newer state.
@@ -68,12 +70,13 @@ Existing delegated tasks may include the former inline ownership, linking, and
 re-dispatching. Prefer `report_state` when available. If an older installed
 TaskChef exposes only `report_result`, follow its inline protocol; after an
 upgrade, the deprecated `report_result` alias remains available for exact
-legacy retries. Also accept historical instructions whose exact HTML marker is
-the first line, with or without the former blank line, and the older exact
-first-line `# taskchef_id=<full UUID>` heading. These compatibility forms do
-not change the identity or lifecycle rules above. For either first-line form,
-the assignment follows the marker. Ignore the final executor invocation and
-any recognizable former inline ownership, linking, working-state, or
+legacy retries. Also accept historical instructions with the former blank line
+before a trailing marker, an exact HTML marker on the first line with or
+without the former blank line, or the older exact
+first-line `# taskchef_id=<full UUID>` heading. These compatibility forms do not
+change the identity or lifecycle rules above. For either first-line form, the
+assignment follows the marker. Ignore the final executor invocation and any
+recognizable former inline ownership, linking, working-state, or
 result-reporting paragraphs as lifecycle scaffolding; execute the remaining
 task-specific body. Require non-whitespace task-specific content and never
 treat an invocation by itself as an assignment.

package/skills/taskchef-report/SKILL.md

@@ -44,15 +44,14 @@ all deterministic task-log operations.
    detailed read. Native approval is live Codex state, not a `needs_input`
    callback. An inactive status never proves semantic completion; it only
    permits a trustworthy cached MCP result to stand.
-4. In schema 6, treat `status`, `turnId`, and `updatedAt` as the latest reported
-   execution state and treat `results` as the ordered semantic history.
-   `lastResult` is the derived compatibility alias for `results.at(-1)`; prefer
-   the collection when full history matters and the alias for compact latest-state
-   reporting. A `working` state with a non-null `lastResult` means a newer executor
-   turn started after that result; show the prior result as history, not as the
-   current outcome. Treat a failed `lastResult` with null thread and turn IDs as
-   a fresh executor-creation failure. Schema 4/5 snapshots normalize zero or one
-   semantic result into `results` and `lastResult` without rewriting their log line.
+4. In schema 7, treat `turns` as the ordered request/result timeline. Each turn
+   pairs a bounded `requestSummary` with either one semantic `result` or null
+   while work is in progress. `latestTurn` is the compact current pair.
+   `results` and `lastResult` remain derived compatibility projections; do not
+   pair the latest request with an earlier result. Treat a failed result with
+   null thread and turn IDs as a fresh executor-creation failure. Schema 4/5/6
+   snapshots normalize their semantic results into legacy turns with a null
+   request summary without rewriting their log line.
    No live read is possible or needed for that creation failure. When identity is certain and
    metadata says the thread is inactive, trust the latest semantic result by
    default in a broad overview unless a newer working state makes it historical.

package/src/cli.js

@@ -183,10 +183,10 @@ function taskDetails(task) {
     `Updated by: ${singleLineDetail(task.updatedBy ?? "-")}`,
     `Task ID: ${singleLineDetail(task.id)}`,
     `Thread ID: ${singleLineDetail(task.threadId ?? "-")}`,
-    `Result count: ${task.results.length}`,
-    "Result history (newest first):",
-    ...[...task.results].reverse().map((result) => (
-      `- ${singleLineDetail(result.updatedAt)} | ${singleLineDetail(result.status)} | turn ${singleLineDetail(result.turnId ?? "-")} | ${singleLineDetail(result.summary)}`
+    `Turn count: ${task.turns.length}`,
+    "Activity timeline (newest first):",
+    ...[...task.turns].reverse().map((turn) => (
+      `- ${singleLineDetail(turn.startedAt)} | ${singleLineDetail(turn.result?.status ?? "working")} | turn ${singleLineDetail(turn.turnId ?? "-")} | request: ${singleLineDetail(turn.requestSummary ?? "not recorded")} | result: ${singleLineDetail(turn.result?.summary ?? "in progress")}`
     )),
     "Instruction:",
     task.instruction,

package/src/dashboard/app.js

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

package/src/dashboard/index.html

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