taskchef 7.0.0 → 7.2.0

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "taskchef",
-  "version": "7.0.0",
+  "version": "7.2.0",
   "description": "Dispatch work from a data-only workspace to visible Codex project tasks.",
   "author": {
     "name": "Favo Yang",
@@ -31,6 +31,7 @@
     "defaultPrompt": [
       "$taskchef-bootstrap Set up TaskChef in this folder.",
       "$taskchef-delegate Dispatch this request to the right project.",
+      "$taskchef-executor Execute this delegated TaskChef assignment.",
       "$taskchef-report Report on work in the TaskChef task history."
     ],
     "brandColor": "#D97706",

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?
@@ -31,7 +31,7 @@ codex plugin add taskchef@favoyang-plugins
 npm install --global taskchef
 ```
 
-The plugin provides three skills and a local MCP server. The npm installation
+The plugin provides four skills and a local MCP server. The npm installation
 puts the `taskchef` CLI on `PATH`. TaskChef installs no hooks, schedules,
 daemons, or background identity search.
 
@@ -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:
@@ -86,23 +86,44 @@ $taskchef-delegate In payments, add structured logs for failed retries and test
 ```
 
 TaskChef prepares a UUID and marker, persists the task before native creation,
-creates the executor, and returns its task link. The executor reads its own
-`CODEX_THREAD_ID` and self-links before substantive work. Independent
-outcomes may become separate executors; dependent work should stay together.
+creates the executor, and returns its task link. New executor instructions keep
+the assignment visible immediately after the marker and end with an explicit
+`$taskchef-executor` invocation. That skill reads the executor's own
+`CODEX_THREAD_ID`, self-links, and reports lifecycle state. Independent outcomes
+may become separate executors; dependent work should stay together.
+
+For example, TaskChef generates this shape:
+
+```text
+<!-- taskchef_id=c0f010ff-84f2-4838-a69d-0ff1f5d721d7 -->
+Fix duplicate charges after a retry and add a regression test.
+
+Use $taskchef-executor to execute and report this delegated TaskChef assignment.
+```
 
 ## 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`: the executor or creation attempt ended unsuccessfully.
+
+A native approval prompt is live Codex state, not `needs_input`.
+TaskChef stores the current reported execution state and separately preserves
+the last concise semantic result. A follow-up therefore appears as `working`
+immediately without erasing the previous outcome. TaskChef does not store the
+transcript or a lifecycle event log.
 
-- `completed`: the requested outcome is complete.
-- `needs_input`: a real user decision or missing fact blocks progress.
-- `failed`: execution or executor creation failed.
+Delegated tasks created by earlier TaskChef versions remain compatible: their
+inline executor protocol still parses, self-links, and may use the deprecated
+`report_result` alias. The v7 inline-paragraph named exports remain as deprecated
+historical snapshots, but new delegations use the executor skill and `report_state`.
 
-A native approval prompt is live Codex state, not `needs_input`. TaskChef
-stores a concise summary, never a transcript or hidden reasoning.
+## View and report tasks
 
-Ask for a current report:
+Ask the dispatcher for an on-demand report:
 
 ```text
 Report on the work TaskChef has dispatched.

package/docs/firstmate-taskchef-comparison.md

@@ -70,7 +70,7 @@ responsibility until an outcome is landed, transferred, or safely preserved.
 | Dimension | TaskChef 7 | FirstMate at `038d0f7` |
 | --- | --- | --- |
 | Primary goal | Put multi-project work into the right visible Codex task and make it findable later. | Let one person direct a supervised crew across projects through one liaison. |
-| Product form | Codex plugin: three skills, local MCP server, data CLI, and loopback dashboard. | Cloneable agent distribution: instructions, internal skills, scripts, policies, and private on-disk state. |
+| Product form | Codex plugin: four skills, local MCP server, data CLI, and loopback dashboard. | Cloneable agent distribution: instructions, internal skills, scripts, policies, and private on-disk state. |
 | Runtime | Native Codex desktop tasks are the executors and live source of truth. | Harness-driven workers in tmux by default, with documented alternative session backends; Codex can be a harness, but Codex desktop is not a runtime backend. |
 | Coordinator lifetime | Dispatcher returns immediately and does not supervise. | First mate remains active and uses watcher/guard mechanisms to supervise meaningful events. |
 | Project isolation | Delegates to the configured Codex project; isolation follows native Codex/project behavior. | Ship and scout workers require separate Treehouse- or backend-managed worktrees. |
@@ -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.
 
@@ -213,8 +215,8 @@ 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. |
+| Skills | Four plugin skills with narrow bootstrap, delegate, executor, and report responsibilities. | Internal firstmate-only skills plus standalone public skills; AGENTS.md routes conditional procedures. |
+| 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

@@ -18,14 +18,15 @@ is dated research, not contract.
 | **Delegated task** | One independently useful outcome represented by one TaskChef task UUID and snapshot. |
 | **Executor** | The native Codex task created to own and perform one delegated task. |
 | **Task record** | One complete JSON object in `tasks.jsonl`; it contains immutable intent/project fields and mutable identity/result fields. |
-| **Marker** | The exact first instruction line `<!-- taskchef_id=<lowercase full UUID> -->`, followed by a blank line. |
+| **Marker** | The exact first instruction line `<!-- taskchef_id=<lowercase full UUID> -->`; new instructions begin the assignment on the next line. |
 | **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`. |
+| **Skill** | One packaged agent procedure: `taskchef-bootstrap`, `taskchef-delegate`, `taskchef-executor`, or `taskchef-report`. |
 
 ## Components and ownership
 
@@ -33,9 +34,13 @@ is dated research, not contract.
   diagnostics. It MUST NOT dispatch or report unless separately requested.
 - `taskchef-delegate` MUST own routing and record-before-create delegation.
   It MUST return after creation and MUST NOT poll, supervise, or infer identity.
+- `taskchef-executor` MUST own executor assignment ownership, self-linking,
+  exact thread/turn identity, per-turn state reporting, failure behavior,
+  privacy, and idempotency. It MUST NOT dispatch the owned assignment again.
 - `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 +67,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 +81,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 +89,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.
@@ -94,21 +102,31 @@ fields MUST NOT change after recording.
 
 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 from the returned marker, a blank line, the
-   packaged executor contract paragraphs, and the user's outcome.
+3. It MUST build the instruction with the returned marker as line 1, the user's
+   outcome beginning on line 2, and exactly one concise explicit
+   `$taskchef-executor` invocation at the end after one blank line. It MUST NOT
+   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`
    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.
 
+Previously recorded instructions with 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 explicit executor skill contract above.
+
 `needs_input` MUST mean a semantic user decision or missing fact. A native
 approval prompt MUST remain live Codex state and MUST NOT be stored as
 `needs_input`.
@@ -158,12 +176,12 @@ new preparation values, though it writes no state.
 | `id` | Non-empty string; MUST equal the instruction marker. |
 | `project` | Non-empty configured project path. |
 | `title` | Non-empty string. |
-| `instruction` | Non-empty string beginning with the exact marker and blank line. |
+| `instruction` | Non-empty string beginning with the exact marker and at least one following instruction line. |
 | `threadId` | Literal null. |
 
 **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 +207,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 +219,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

@@ -11,10 +11,11 @@ research.
 | Surface | Responsibility |
 | --- | --- |
 | `skills/taskchef-delegate/SKILL.md` | Split, route, record-before-create, create, return. |
+| `skills/taskchef-executor/SKILL.md` | Own, self-link, execute, and report every executor turn. |
 | `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/delegation.js` | UUID marker, executor contract paragraphs, and creation-failure handling. |
+| `src/mcp.js` | Four primary lifecycle tools, one deprecated alias, and MCP annotations. |
+| `src/delegation.js` | UUID marker, concise executor-skill invocation shape, and creation-failure handling. |
 | `src/workspace.js` | Current schemas, validation, locking, atomic JSONL writes, linking, and result freshness. |
 | `src/cli.js` | Administration, inspection, diagnostics, and dashboard startup. |
 | `src/dashboard.js` | Validated snapshots, SSE fan-out, and bounded open actions. |
@@ -49,13 +50,13 @@ 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
   C-->>D: Created-task reference
   D-->>U: Return immediately
-  C->>E: Start executor
+  C->>E: Start executor and load $taskchef-executor
   E->>E: Read own CODEX_THREAD_ID
   E->>M: link_task(taskId, threadId)
   M->>W: linkTask()
@@ -67,10 +68,16 @@ 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
+The generated task body begins immediately after the first-line marker and
+ends with one explicit `$taskchef-executor` invocation. Older recorded tasks
+whose marker is followed by a blank line and inline protocol remain readable;
+the deprecated `report_result` alias preserves their semantic callbacks.
+
+## 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 +86,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 +124,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 +192,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 +216,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 +250,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,8 @@ export {
   EXECUTOR_OWNERSHIP_PARAGRAPH,
   EXECUTOR_LINK_PARAGRAPH,
   EXECUTOR_RESULT_PARAGRAPH,
+  EXECUTOR_WORKING_PARAGRAPH,
+  EXECUTOR_SKILL_INVOCATION,
   createAndRecordDelegation,
   isProvisionalThreadId,
   normalizeCodexThreadId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taskchef",
-  "version": "7.0.0",
+  "version": "7.2.0",
   "description": "A non-blocking interactive dispatcher for visible Codex tasks.",
   "license": "MIT",
   "author": "Favo Yang",
@@ -33,6 +33,7 @@
     "src",
     "skills/taskchef-bootstrap",
     "skills/taskchef-delegate",
+    "skills/taskchef-executor",
     "skills/taskchef-report"
   ],
   "engines": {

package/skills/taskchef-bootstrap/SKILL.md

@@ -38,7 +38,7 @@ all deterministic workspace operations.
    `codex add` or hard-code an application bundle path.
 3. `workspace init` takes no stdin, creates an empty
    configuration when missing, creates the one-entry-per-task JSONL log, and
-   refreshes managed instructions. The installed plugin provides all three
+   refreshes managed instructions. The installed plugin provides all four
    TaskChef skills outside the dispatcher workspace.
 4. Run `doctor --json` after setup or when the user asks to diagnose the
    workspace. Doctor is read-only. Rerun `workspace init --json` to repair the

package/skills/taskchef-delegate/SKILL.md

@@ -16,10 +16,9 @@ assignment. Execute it in the current task. Do not re-dispatch it merely
 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
-required tool is unavailable, stop and report that the TaskChef plugin must be
-reloaded or installed.
+Use the bundled `prepare_dispatch`, `record_task`, and `report_state` MCP tools
+directly. Never fall back to shell writes. If a required tool is unavailable,
+stop and report that the TaskChef plugin must be reloaded or installed.
 
 ## Boundaries
 
@@ -42,14 +41,15 @@ reloaded or installed.
 3. Route against configured project `name`, `description`, and canonical
    `githubRepos`; use `path` only as checkout identity. Require exactly one
    match and an exact native-project path. Ask instead of guessing.
-4. Prefix each executor instruction with the preparation's exact marker as the
-   first line, a blank line, and these required paragraphs before the body:
+4. Build each executor instruction in this exact shape:
 
-   > 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.
-
-   > 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.
+   - Keep the preparation's exact marker as the first line.
+   - Begin the actual assignment on the second line, with no blank line after
+     the marker.
+   - End the instruction after one blank line with exactly:
+     `Use $taskchef-executor to execute and report this delegated TaskChef assignment.`
+   - Do not inline executor ownership, identity, linking, or result-reporting
+     protocol. The explicitly invoked executor skill owns those mechanics.
 
 5. Before creating each executor, call `record_task` exactly once with `id`,
    `project`, `title`, the exact marked `instruction`, and `threadId: null`.
@@ -58,23 +58,5 @@ 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
-
-The executor must make `link_task(taskId, threadId)` its first TaskChef action.
-It obtains its own durable ID from the current task's `CODEX_THREAD_ID`, never
-from the delegation's `sourceThreadId`, `CODEX_SESSION_ID`, inherited session
-metadata, title matching, or a parent task.
-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.
-
-The filesystem watcher surfaces `link_task` and `report_result` writes to the
-dashboard. The linked child ID drives the exact Codex deep link.

package/skills/taskchef-executor/SKILL.md

@@ -0,0 +1,69 @@
+---
+name: taskchef-executor
+description: "Execute an assignment whose first instruction line is an exact TaskChef task marker, including executor ownership, self-linking, per-turn lifecycle reporting, identity safety, and final semantic state. Use when explicitly invoked by a delegated TaskChef instruction or when resuming that same executor task. Do not use to dispatch work or report on other TaskChef tasks."
+---
+
+# TaskChef Executor
+
+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.
+
+The instruction's exact first line is
+`<!-- taskchef_id=<full UUID> -->`. Treat that UUID as the TaskChef task ID.
+The assignment is the remaining instruction body; the final explicit skill
+invocation is lifecycle scaffolding, not part of the requested deliverable.
+
+## Start every execution turn
+
+Complete this lifecycle setup before substantive assignment work:
+
+1. Read this task's own durable Codex thread ID from `CODEX_THREAD_ID`. Never
+   use `CODEX_SESSION_ID`, `sourceThreadId`, a parent or delegator ID,
+   inherited metadata, title matching, recent-task search, transcripts, or a
+   provisional client ID.
+2. On the initial turn, call TaskChef `link_task` with the marked task ID and
+   that exact thread ID as the first TaskChef action. An identical retry is
+   idempotent. On a follow-up, retry the same link only when the prior link
+   cannot be established from the task context.
+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.
+
+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
+guess identity or bypass a link-pending state.
+
+## Finish every execution turn
+
+Before ending, read this exact Codex thread again and call `report_state` for
+the current turn with one semantic status and a concise summary:
+
+- `completed` only when the assignment is genuinely complete.
+- `needs_input` only when a semantic decision or missing information must come
+  from the user.
+- `failed` when the requested outcome cannot be completed or safely resumed.
+
+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.
+
+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.
+
+## Compatibility
+
+Existing delegated tasks may include the former inline ownership, linking, and
+`report_result` paragraphs. Continue executing those tasks here without
+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.

package/skills/taskchef-executor/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "TaskChef Executor"
+  short_description: "Run and report a delegated TaskChef assignment."
+  default_prompt: "Use $taskchef-executor to execute and report this delegated TaskChef assignment."