taskchef 6.1.3 → 7.1.0

package/docs/workflows.md

@@ -0,0 +1,249 @@
+# TaskChef workflows
+
+This developer and advanced-agent guide explains how the current implementation
+moves data through TaskChef. The [specification](spec.md) is normative; the
+[README](../README.md) owns user operation. The
+[FirstMate comparison](firstmate-taskchef-comparison.md) is non-normative
+research.
+
+## Implementation map
+
+| Surface | Responsibility |
+| --- | --- |
+| `skills/taskchef-delegate/SKILL.md` | Split, route, record-before-create, create, return. |
+| `skills/taskchef-bootstrap/SKILL.md` | Initialize current workspace and configure projects. |
+| `skills/taskchef-report/SKILL.md` | Select cached tasks and perform bounded live checks. |
+| `src/mcp.js` | Four primary lifecycle tools, one deprecated alias, and MCP annotations. |
+| `src/delegation.js` | UUID marker, executor contract paragraphs, and creation-failure handling. |
+| `src/workspace.js` | Current schemas, validation, locking, atomic JSONL writes, linking, and result freshness. |
+| `src/cli.js` | Administration, inspection, diagnostics, and dashboard startup. |
+| `src/dashboard.js` | Validated snapshots, SSE fan-out, and bounded open actions. |
+
+The MCP process resolves `TASKCHEF_WORKSPACE` once and never accepts a model
+supplied path. The CLI resolves `--workspace`, then the environment, then the
+per-user default.
+
+## Normal delegation and self-linking
+
+The dispatcher uses native Codex project discovery for routing and MCP for
+TaskChef state. It never supplies executor identity.
+
+```mermaid
+sequenceDiagram
+  autonumber
+  actor U as User
+  participant D as Dispatcher skill
+  participant M as TaskChef MCP
+  participant W as workspace.js
+  participant C as Native Codex
+  participant E as Executor
+  U->>D: Request outcome
+  par Route once
+    D->>C: List native projects
+  and Prepare each outcome
+    D->>M: prepare_dispatch()
+    M->>W: prepareDispatch()
+    W-->>M: UUID, marker, projects
+    M-->>D: preparation
+  end
+  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-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
+  E->>E: Read own CODEX_THREAD_ID
+  E->>M: link_task(taskId, threadId)
+  M->>W: linkTask()
+  W->>W: Lock and replace null identity atomically
+  W-->>E: linked working task
+```
+
+Record-before-create makes native creation failure observable. Executor
+self-linking removes dispatcher-side polling, task search, title matching, and
+parent/child identity inference.
+
+## 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 last
+semantic result separately.
+
+```mermaid
+sequenceDiagram
+  autonumber
+  participant E as Executor
+  participant C as Native Codex task API
+  participant M as TaskChef MCP
+  participant W as workspace.js
+  E->>C: Exact read of linked executor
+  C-->>E: Current turn ID
+  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 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
+    W-->>M: Existing task
+    M-->>E: Idempotent success
+  else Conflict or stale turn
+    W-->>M: Tool error
+    M-->>E: Visible failure
+  end
+```
+
+A native approval prompt is not a semantic result. `needs_input` is reserved
+for a user decision or fact required to proceed.
+
+## Follow-up turns
+
+Turn IDs are freshness tokens for semantic callbacks. Lexical UUIDv7 order lets
+the workspace reject a callback from an older executor turn.
+
+```mermaid
+sequenceDiagram
+  autonumber
+  actor U as User
+  participant E as Linked executor
+  participant C as Native Codex task API
+  participant M as TaskChef MCP
+  participant W as workspace.js
+  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_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-->>M: Error: turn is not newer
+  M-->>E: Visible tool error
+```
+
+The executor contract therefore requires a new exact read on every follow-up;
+cached or inherited turn IDs are invalid.
+
+## Link-pending and failure paths
+
+A failed or interrupted link never authorizes substantive work. The record
+remains a visible retry point for the same executor.
+
+```mermaid
+sequenceDiagram
+  autonumber
+  participant E as Executor
+  participant M as TaskChef MCP
+  participant W as workspace.js
+  E->>M: link_task(taskId, assertedThreadId)
+  M->>W: linkTask()
+  alt Exact eligible record and unused canonical UUIDv7
+    W->>W: Atomic null-to-thread transition
+    W-->>E: Linked task
+  else MCP unavailable or call interrupted
+    M--xE: Visible failure
+    Note over E,W: Record remains link-pending
+  else Wrong task, marker, state, or identity
+    W-->>E: Validation error
+    Note over E,W: No mutation
+  end
+  E->>E: Retry linking on a later turn before work
+```
+
+If `CODEX_THREAD_ID` is missing, the executor reports the problem visibly and
+does not substitute `CODEX_SESSION_ID`, a parent ID, or search results.
+
+Native creation can fail after the durable record exists:
+
+```mermaid
+sequenceDiagram
+  autonumber
+  participant D as Dispatcher
+  participant M as TaskChef MCP
+  participant W as workspace.js
+  participant C as Native Codex
+  D->>M: record_task(..., threadId null)
+  M->>W: Append working record
+  W-->>D: Recorded task
+  D->>C: Create executor
+  C--xD: Creation error
+  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
+```
+
+The summary is bounded and excludes secrets, transcripts, and raw command
+output. A creation-failure record cannot later be linked.
+
+## Dashboard update flow
+
+Every mutation rewrites `tasks.jsonl` atomically under the workspace lock.
+The monitor tolerates replacement races, validates a complete snapshot, and
+publishes only the newest state to each SSE client.
+
+```mermaid
+sequenceDiagram
+  autonumber
+  participant M as MCP writer
+  participant W as workspace.js
+  participant F as tasks.jsonl
+  participant D as Dashboard monitor
+  participant B as Browser client
+  participant C as Native Codex
+  M->>W: link_task or report_state
+  W->>W: Acquire shared lock
+  W->>F: Atomic replacement
+  W-->>M: Updated task
+  F-->>D: Filesystem change
+  D->>F: Bounded read from one descriptor
+  D->>D: Validate current schema and sort
+  D-->>B: SSE snapshot
+  B->>D: Open task action
+  alt Canonical Codex UUIDv7
+    D->>C: Direct thread navigation
+  else Null or non-native durable ID
+    D->>D: Revalidate current project configuration
+    D->>C: Open configured project
+  end
+```
+
+The dashboard binds to `127.0.0.1`, has no shared session state, limits
+request bodies, and checks origin/authority for stateful local actions. Historical
+project paths are untrusted until matched against current configuration.
+
+## Concurrency and trust boundaries
+
+Configuration and task mutations use the same `proper-lockfile` lock. ID and
+identity uniqueness checks, link eligibility, and result freshness occur
+inside the critical section. Writes use temporary files/hard links and atomic
+rename so readers see complete snapshots.
+
+The dispatcher controls routing and immutable intent. The executor controls its
+cooperatively asserted identity and semantic result. Neither identity nor
+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 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

@@ -5,7 +5,6 @@ export {
   canonicalGitRoot,
   doctorWorkspace,
   ensureWorkspaceInstructions,
-  ensureWorkspaceSkills,
   filterTasks,
   importProjects,
   initializeWorkspace,
@@ -16,8 +15,8 @@ export {
   listTasks,
   readTask,
   recordTask,
+  reportTaskState,
   reportTaskResult,
-  resolveTask,
   requireSafeId,
   removeProject,
   validateConfig,
@@ -33,6 +32,7 @@ export {
   EXECUTOR_OWNERSHIP_PARAGRAPH,
   EXECUTOR_LINK_PARAGRAPH,
   EXECUTOR_RESULT_PARAGRAPH,
+  EXECUTOR_WORKING_PARAGRAPH,
   createAndRecordDelegation,
   isProvisionalThreadId,
   normalizeCodexThreadId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taskchef",
-  "version": "6.1.3",
+  "version": "7.1.0",
   "description": "A non-blocking interactive dispatcher for visible Codex tasks.",
   "license": "MIT",
   "author": "Favo Yang",
@@ -23,10 +23,11 @@
     "assets",
     "BACKLOG.md",
     "bin",
-    "docs/delegation-design.md",
+    "docs/spec.md",
+    "docs/workflows.md",
+    "docs/firstmate-taskchef-comparison.md",
     "index.js",
     "mcp",
-    "SPEC.md",
     "scripts/benchmark-dispatch-prepare.js",
     "scripts/e2e-benchmark.js",
     "src",

package/scripts/benchmark-dispatch-prepare.js

@@ -33,10 +33,10 @@ function measure(operation) {
   return performance.now() - startedAt;
 }
 
-const legacy = [];
+const baseline = [];
 const prepared = [];
 for (let index = 0; index < sampleCount; index += 1) {
-  legacy.push(measure(() => {
+  baseline.push(measure(() => {
     runTaskChef(["workspace", "path", "--json", "--workspace", workspace]);
     runTaskChef(["project", "list", "--json", "--workspace", workspace]);
     execFileSync(process.execPath, [
@@ -66,15 +66,15 @@ function statistics(samples) {
   };
 }
 
-const legacyStats = statistics(legacy);
+const baselineStats = statistics(baseline);
 const preparedStats = statistics(prepared);
 process.stdout.write(`${JSON.stringify({
   schemaVersion: 1,
   comparison: {
-    legacy: {
+    baseline: {
       description: "workspace path + project list + external UUID/timestamp process",
       processCalls: 3,
-      ...legacyStats,
+      ...baselineStats,
     },
     dispatchPrepare: {
       description: "dispatch prepare",
@@ -82,9 +82,9 @@ process.stdout.write(`${JSON.stringify({
       ...preparedStats,
     },
     savedProcessCalls: 2,
-    medianSpeedup: Number((legacyStats.medianMs / preparedStats.medianMs).toFixed(2)),
+    medianSpeedup: Number((baselineStats.medianMs / preparedStats.medianMs).toFixed(2)),
     medianReductionPercent: Number(
-      ((1 - preparedStats.medianMs / legacyStats.medianMs) * 100).toFixed(1),
+      ((1 - preparedStats.medianMs / baselineStats.medianMs) * 100).toFixed(1),
     ),
   },
 }, null, 2)}\n`);

package/skills/taskchef-bootstrap/SKILL.md

@@ -15,8 +15,8 @@ all deterministic workspace operations.
 ## Boundaries
 
 - Keep implementation, tests, and reports in the TaskChef source repository.
-- Keep only `AGENTS.md`, `taskchef.json`, and `tasks.jsonl` in a dispatcher
-  workspace.
+- Create and manage only `AGENTS.md`, `taskchef.json`, and `tasks.jsonl` in a
+  dispatcher workspace. Preserve unrelated user-owned paths.
 - Do not dispatch tasks or report on executor threads during bootstrap unless
   the user separately requests those actions.
 - Never create hooks, schedules, polling, or daemons. TaskChef executors
@@ -37,9 +37,9 @@ all deterministic workspace operations.
    CLI discovered from the current desktop environment; never invoke
    `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, refreshes
-   managed instructions, and removes legacy TaskChef skill links. The installed
-   plugin provides all three TaskChef skills outside the dispatcher workspace.
+   configuration when missing, creates the one-entry-per-task JSONL log, and
+   refreshes managed instructions. The installed plugin provides all three
+   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
    managed scaffold.
@@ -86,6 +86,5 @@ Example managed-workspace import entry:
 }
 ```
 
-`workspace init` safely migrates schema-version-1 configuration: a string
-`githubRepo` becomes a one-item `githubRepos` list and `null` becomes
-`githubRepos: []`. All subsequent configuration writes use schema version 2.
+TaskChef accepts configuration schema version 2 only. `githubRepos` is always
+an array; unsupported configuration is rejected without being rewritten.

package/skills/taskchef-delegate/SKILL.md

@@ -17,14 +17,15 @@ because it concerns TaskChef or a configured project. Explicit requests to
 delegate separate work remain valid.
 
 Use the bundled `prepare_dispatch`, `record_task`, `link_task`, and
-`report_result` MCP tools directly. Never fall back to shell writes. If a
+`report_state` MCP tools directly. `report_result` is a deprecated compatibility
+alias and must not be emitted into new executor instructions. Never fall back to shell writes. If a
 required tool is unavailable, stop and report that the TaskChef plugin must be
 reloaded or installed.
 
 ## Boundaries
 
-- Keep only `AGENTS.md`, `taskchef.json`, and `tasks.jsonl` in the dispatcher
-  workspace.
+- Treat only `AGENTS.md`, `taskchef.json`, and `tasks.jsonl` as TaskChef-managed
+  dispatcher files. Preserve unrelated user-owned paths.
 - Use real Codex tasks, never collaboration or subagent tools.
 - Never use hooks, schedules, daemons, background monitors, recent-task
   searches, transcripts, hidden reasoning, or polling for identity.
@@ -49,7 +50,9 @@ reloaded or installed.
 
    > Before any other work, read this executor's own durable Codex thread ID from the current task's CODEX_THREAD_ID environment value and call the TaskChef link_task MCP tool with that thread ID and the marked TaskChef task ID. Never use CODEX_SESSION_ID or the parent or delegator thread ID. If linking fails, CODEX_THREAD_ID is unavailable, or the tool is unavailable, report the failure visibly and retry on a later turn; do not guess an identity or continue substantive work while the task is link-pending.
 
-   > Before ending, call the TaskChef report_result MCP tool with the marked task ID, this executor's self-linked thread ID, the current turn ID from an exact native read of that same thread, completed, needs_input, or failed, and a concise summary. Never reuse a prior turn ID after a follow-up. Use needs_input only for a semantic decision or information the user must provide; a native approval prompt is live Codex state, not a TaskChef result. Do not include secrets, transcripts, or raw command output.
+   > After a successful initial link, and at the start of every follow-up turn before substantive work, read this exact Codex thread natively to obtain the current turn ID and call TaskChef report_state with the marked task ID, the self-linked thread ID, that current turn ID, status working, and summary omitted or null. link_task remains the first TaskChef action on the initial turn; do not report working before identity is linked. Never reuse a prior turn ID after a follow-up.
+
+   > Before ending, read this exact Codex thread again and call TaskChef report_state for the same current working turn with status completed, needs_input, or failed and a concise summary. Use needs_input only for a semantic decision or information the user must provide; a native approval prompt is live Codex state, not a TaskChef result. Do not include secrets, transcripts, or raw command output.
 
 5. Before creating each executor, call `record_task` exactly once with `id`,
    `project`, `title`, the exact marked `instruction`, and `threadId: null`.
@@ -58,7 +61,7 @@ reloaded or installed.
 7. Return immediately. Preserve a returned provisional client ID only for the
    created-thread directive. Do not call `link_task` from the dispatcher even
    when creation returns a durable ID; the child must self-link.
-8. If creation fails after recording, call `report_result` with `failed`, null
+8. If creation fails after recording, call `report_state` with `failed`, null
    thread/turn IDs, and a bounded summary before returning the failure.
 
 ## Executor contract
@@ -71,17 +74,12 @@ Identical retries are safe. A rejected link, unavailable tool, or interrupted
 initial turn leaves the record visibly link-pending and retryable; the executor
 must not guess or do substantive work first.
 
-For every semantic result, the executor supplies its linked thread ID and the
-current turn ID obtained by reading that exact thread. A follow-up must use the
-new turn ID. Do not reuse the initial turn ID. `needs_input` is only for a real
-user decision, not live approval UI.
+After linking on the initial turn, and before substantive work on every later
+turn, the executor reads the exact thread and calls `report_state` with
+`working`, the current turn ID, and no summary. Before ending that same turn it
+reports a semantic state with the same turn ID and a summary. A follow-up must
+use the new turn ID. `needs_input` is only for a real user decision, not live
+approval UI.
 
-The filesystem watcher surfaces `link_task` and `report_result` writes to the
+The filesystem watcher surfaces `link_task` and `report_state` writes to the
 dashboard. The linked child ID drives the exact Codex deep link.
-
-## Legacy recovery
-
-`taskchef task resolve` exists only for unresolved records created before the
-self-linking schema. Require an exact marker match and a unique durable child
-ID. The command rejects new self-linking records. Never edit `tasks.jsonl`
-directly.

package/skills/taskchef-report/SKILL.md

@@ -29,8 +29,8 @@ all deterministic task-log operations.
    - Use the full list only when the user asks for an overview of the task history.
 2. For an overview, select only attention-worthy candidates before detailed
    reads:
-   - always include `working`, `needs_input`, null-status legacy entries, and
-     entries with a null `threadId`;
+   - always include `working`, `needs_input`, and entries with a null
+     `threadId`;
    - include `completed` and `failed` entries updated during the last seven
      days;
    - omit older terminal entries by default and report the omitted count;
@@ -44,43 +44,39 @@ all deterministic task-log operations.
    detailed read. Native approval is live Codex state, not a `needs_input`
    callback. An inactive status never proves semantic completion; it only
    permits a trustworthy cached MCP result to stand.
-4. Treat `updatedBy: mcp`, `status: failed`, and null thread/turn IDs as a fresh
-   executor-creation failure. No live read is possible or needed; report the
-   stored failure summary, not unresolved. Otherwise, only a snapshot with
-   `updatedBy: mcp`, a result status, a non-null summary, and a non-null turn ID
-   is a cached semantic result. Any `working` snapshot has no semantic
-   callback, including a self-linked `updatedBy: mcp` snapshot, and requires
-   one live task query when selected; if the task is inactive and no callback
-   exists, report the outcome as unknown rather than treating `working` as
-   fresh. When identity is certain and metadata says the thread is
-   inactive, trust the latest MCP result by default in a broad overview. Do not
-   read every idle terminal task in an overview merely because native
+4. In schema 5, treat `status`, `turnId`, and `updatedAt` as the latest reported
+   execution state and treat `lastResult` as the separately preserved semantic
+   result. A `working` state with a non-null `lastResult` means a newer executor
+   turn started after that result; show the prior result as history, not as the
+   current outcome. Treat a failed `lastResult` with null thread and turn IDs as
+   a fresh executor-creation failure. No live read is possible or needed.
+   Schema 4 snapshots normalize a structurally complete result into
+   `lastResult` without rewriting their log line. When identity is certain and
+   metadata says the thread is inactive, trust the latest semantic result by
+   default in a broad overview unless a newer working state makes it historical.
+   Do not read every idle terminal task in an overview merely because native
    `updatedAt` is later: callbacks normally run before Codex finalizes the same
    turn, and overview performance matters more than investigating every rare
    missed callback.
 
    For a focused task, title, or project report, perform at most one detailed
    read for each selected inactive task when matched metadata `updatedAt` is
-   later than the cached result `updatedAt`, by any amount. Read once as well
+   later than `lastResult.updatedAt`, by any amount. Read once as well
    when there is no semantic callback, identity or metadata is uncertain or
    contradictory, or the user explicitly requests a fully live result. If
    focused metadata is not newer, trust the cache. Absence from the bounded
    recent snapshot is not by itself a reason to read every cached terminal
    overview entry. Batch immediate native reads with no more than eight targets
    per call. When a detailed read occurs, compare the latest structured turn ID
-   and native turn state with stored `turnId`: a newer turn without a callback
+   and native turn state with `lastResult.turnId`: a newer turn without a callback
    makes the cache stale, while an interrupted or cancelled callback turn
    cannot prove completion. Never classify assistant prose.
 5. Report each task as one of: working, needs input, awaiting native approval,
    completed, failed, unresolved, or unknown. Show the cached summary when it
    remains fresh. If a newer turn exists without a callback, describe the live
-   state and label the cached result stale rather than overwriting it.
-6. Never edit `tasks.jsonl` directly during reporting. The task API preserves
-   each record's persisted `schemaVersion`: a schema 4 null identity is executor
-   link-pending and must be retried by that executor, while a schema 1-3 null
-   identity is a legacy recovery candidate. Manual recovery may call
-   `task resolve` only for the latter after one exact structured marker match.
-   Never persist inferred status,
+   state and label the preserved result historical or stale rather than overwriting it.
+6. Never edit `tasks.jsonl` directly during reporting. A null identity is
+   executor link-pending and must be retried by that executor. Never persist inferred status,
    transcripts, prose classifications, or hidden reasoning. Do not poll or wait.
 
 If the task history is empty, say that TaskChef has not recorded any tasks. If

package/src/cli.js

@@ -18,7 +18,6 @@ import {
   recordTask,
   removeProject,
   requireSafeId,
-  resolveTask,
 } from "./workspace.js";
 
 const BLANK_TABLE_CELL = Symbol("blank table cell");
@@ -167,18 +166,22 @@ function singleLineDetail(value) {
 }
 
 function taskDetails(task) {
+  const lastResult = task.lastResult;
   return [
     `Title: ${singleLineDetail(task.title)}`,
     `Project: ${singleLineDetail(task.project.name)}`,
-    `Status: ${singleLineDetail(task.status ?? "unknown")}`,
-    `Summary: ${singleLineDetail(task.summary ?? "-")}`,
+    `Current status: ${singleLineDetail(task.status ?? "unknown")}`,
+    `Current turn ID: ${singleLineDetail(task.turnId ?? "-")}`,
+    `Last result status: ${singleLineDetail(lastResult?.status ?? "-")}`,
+    `Last result summary: ${singleLineDetail(lastResult?.summary ?? "-")}`,
+    `Last result turn ID: ${singleLineDetail(lastResult?.turnId ?? "-")}`,
+    `Last result updated: ${singleLineDetail(lastResult?.updatedAt ?? "-")}`,
     `Project path: ${singleLineDetail(task.project.path)}`,
     `Created: ${singleLineDetail(task.createdAt)}`,
     `Updated: ${singleLineDetail(task.updatedAt ?? "-")}`,
     `Updated by: ${singleLineDetail(task.updatedBy ?? "-")}`,
     `Task ID: ${singleLineDetail(task.id)}`,
     `Thread ID: ${singleLineDetail(task.threadId ?? "-")}`,
-    `Turn ID: ${singleLineDetail(task.turnId ?? "-")}`,
     "Instruction:",
     task.instruction,
   ].join("\n");
@@ -241,7 +244,6 @@ async function initialize(args) {
     `Configuration: ${value.config.action}`,
     `Task log: ${value.tasks.action}`,
     `Instructions: ${value.instructions.action}`,
-    `Legacy skill links removed: ${value.legacySkills.removed.length}`,
     ...(value.registration ? [`Codex opening: ${value.registration.status}`] : []),
   ].join("\n"));
   return registrationFailed ? 5 : 0;
@@ -353,22 +355,6 @@ async function taskRecord(args) {
   return 0;
 }
 
-async function taskResolve(args) {
-  if (!args[2] || args[2].startsWith("--")) throw new Error("task resolve requires a task ID");
-  validateCommandArgs(args, 3, {
-    values: ["--thread-id", "--workspace"],
-    switches: ["--json"],
-  });
-  if (!args.includes("--thread-id")) throw new Error("task resolve requires --thread-id");
-  const task = await resolveTask(
-    workspaceRoot(args),
-    args[2],
-    option(args, "--thread-id"),
-  );
-  print(task, args, (value) => `Resolved ${value.id}: ${value.threadId}`);
-  return 0;
-}
-
 async function taskShow(args) {
   validateCommandArgs(args, 3, { values: ["--workspace"], switches: ["--json"] });
   print(await readTaskForShow(workspaceRoot(args), args[2]), args, taskDetails);
@@ -464,13 +450,11 @@ Usage:
   taskchef project remove <name> [--json] [--workspace <path>]
   taskchef dispatch prepare [--json] [--workspace <path>]
   taskchef task record [--json] [--workspace <path>]
-  taskchef task resolve <legacy-task-id> --thread-id <thread-id> [--json] [--workspace <path>]
   taskchef task show <task-id-or-8-character-prefix> [--json] [--workspace <path>]
   taskchef task list [--project <name-or-path>] [--ascending] [--full-id] [--json] [--workspace <path>]
   taskchef task summary [--json] [--workspace <path>]
 
 Task record reads one JSON value from closed, non-interactive standard input.
-Task resolve is a legacy migration command and rejects self-linking task records.
 Task show accepts a full task ID or the exact 8-character ID printed by task list.
 Task show prints human-readable details by default; --json prints the complete task object.
 Project import reads a JSON
@@ -497,7 +481,6 @@ export async function runCli(args) {
   if (args[0] === "project" && args[1] === "remove") return projectRemove(args);
   if (args[0] === "dispatch" && args[1] === "prepare") return dispatchPrepare(args);
   if (args[0] === "task" && args[1] === "record") return taskRecord(args);
-  if (args[0] === "task" && args[1] === "resolve") return taskResolve(args);
   if (args[0] === "task" && args[1] === "show" && args[2]) return taskShow(args);
   if (args[0] === "task" && args[1] === "list") return taskList(args);
   if (args[0] === "task" && args[1] === "summary") return taskSummary(args);

package/src/dashboard/app.js

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

package/src/dashboard/state.js

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

package/src/dashboard.js

@@ -131,6 +131,8 @@ function assertDashboardTaskBounds(tasks, maximumTasks) {
     boundedText(task.summary, 2_000, `${name} summary`);
     boundedText(task.threadId, 512, `${name} thread ID`);
     boundedText(task.turnId, 512, `${name} turn ID`);
+    boundedText(task.lastResult?.summary, 2_000, `${name} last result summary`);
+    boundedText(task.lastResult?.turnId, 512, `${name} last result turn ID`);
     boundedText(task.project.name, 1_000, `${name} project name`);
     boundedText(task.project.path, 8_192, `${name} project path`);
     boundedText(task.project.description, 4_000, `${name} project description`);
@@ -521,7 +523,7 @@ export async function createDashboardServer({
         else await openWorkspaceInCodex(canonicalProjectPath);
         sendJson(response, 202, {
           message: task.threadId
-            ? "Opened the project in Codex; this legacy thread ID cannot use direct navigation."
+            ? "Opened the project in Codex; this thread ID cannot use direct navigation."
             : "Opened the project in Codex; this task does not yet have a thread ID.",
         });
       } catch {