taskchef 7.0.0 → 7.2.0

package/skills/taskchef-report/SKILL.md

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

package/src/cli.js

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

package/src/dashboard/app.js

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

package/src/dashboard/state.js

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

package/src/dashboard.js

@@ -131,6 +131,8 @@ function assertDashboardTaskBounds(tasks, maximumTasks) {
     boundedText(task.summary, 2_000, `${name} summary`);
     boundedText(task.threadId, 512, `${name} thread ID`);
     boundedText(task.turnId, 512, `${name} turn ID`);
+    boundedText(task.lastResult?.summary, 2_000, `${name} last result summary`);
+    boundedText(task.lastResult?.turnId, 512, `${name} last result turn ID`);
     boundedText(task.project.name, 1_000, `${name} project name`);
     boundedText(task.project.path, 8_192, `${name} project path`);
     boundedText(task.project.description, 4_000, `${name} project description`);

package/src/delegation.js

@@ -1,8 +1,14 @@
 import { randomUUID } from "node:crypto";
 
+/** @deprecated Historical v7 inline-prompt snapshot. New delegations use taskchef-executor. */
 export const EXECUTOR_OWNERSHIP_PARAGRAPH = "This task owns the delegated assignment. Execute it in this task; do not re-dispatch it merely because it concerns TaskChef or a configured project. Explicit requests to delegate separate work remain valid.";
+/** @deprecated Historical v7 inline-prompt snapshot. New delegations use taskchef-executor. */
 export const EXECUTOR_LINK_PARAGRAPH = "Before any other work, read this executor's own durable Codex thread ID from the current task's CODEX_THREAD_ID environment value and call the TaskChef link_task MCP tool with that thread ID and the marked TaskChef task ID. Never use CODEX_SESSION_ID or the parent or delegator thread ID. If linking fails, CODEX_THREAD_ID is unavailable, or the tool is unavailable, report the failure visibly and retry on a later turn; do not guess an identity or continue substantive work while the task is link-pending.";
-export const EXECUTOR_RESULT_PARAGRAPH = "Before ending, call the TaskChef report_result MCP tool with the marked task ID, this executor's self-linked thread ID, the current turn ID from an exact native read of that same thread, completed, needs_input, or failed, and a concise summary. Never reuse a prior turn ID after a follow-up. Use needs_input only for a semantic decision or information the user must provide; a native approval prompt is live Codex state, not a TaskChef result. Do not include secrets, transcripts, or raw command output.";
+/** @deprecated Historical v7 inline-prompt snapshot. New delegations use taskchef-executor. */
+export const EXECUTOR_WORKING_PARAGRAPH = "After a successful initial link, and at the start of every follow-up turn before substantive work, read this exact Codex thread natively to obtain the current turn ID and call TaskChef report_state with the marked task ID, the self-linked thread ID, that current turn ID, status working, and summary omitted or null. link_task remains the first TaskChef action on the initial turn; do not report working before identity is linked. Never reuse a prior turn ID after a follow-up.";
+/** @deprecated Historical v7 inline-prompt snapshot. New delegations use taskchef-executor. */
+export const EXECUTOR_RESULT_PARAGRAPH = "Before ending, read this exact Codex thread again and call TaskChef report_state for the same current working turn with status completed, needs_input, or failed and a concise summary. Use needs_input only for a semantic decision or information the user must provide; a native approval prompt is live Codex state, not a TaskChef result. Do not include secrets, transcripts, or raw command output.";
+export const EXECUTOR_SKILL_INVOCATION = "Use $taskchef-executor to execute and report this delegated TaskChef assignment.";
 
 const UUID_SOURCE = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
 const UUID_PATTERN = new RegExp(`^${UUID_SOURCE}$`);
@@ -86,17 +92,23 @@ export function parseTaskChefMarker(instruction) {
   const firstLine = instruction.split(/\r?\n/, 1)[0];
   const currentMatch = firstLine.match(TASKCHEF_MARKER_PATTERN);
   if (currentMatch === null) return null;
-  const prefix = instruction.match(/^([^\r\n]*)(\r?\n)\2/);
-  return prefix === null ? null : currentMatch[1];
+  return /^[^\r\n]*\r?\n[\s\S]+$/.test(instruction) ? currentMatch[1] : null;
 }
 
 export function prepareDelegation(instruction, { taskId = randomUUID() } = {}) {
-  requireString(instruction, "instruction");
-  if (parseTaskChefMarker(instruction) !== null) throw new Error("instruction already contains a TaskChef marker");
+  const rawBody = requireString(instruction, "instruction");
+  if (/^[^\S\r\n]*(?:\r\n|\r|\n)/.test(rawBody)) {
+    throw new Error("instruction must begin with useful task content on its first line");
+  }
+  const body = rawBody.replace(/(?:(?:\r\n|\r|\n)[^\S\r\n]*)+$/, "");
+  if (parseTaskChefMarker(body) !== null) throw new Error("instruction already contains a TaskChef marker");
+  if (/\$taskchef-executor\b/i.test(body)) {
+    throw new Error("instruction contains a reserved TaskChef executor skill reference");
+  }
   const id = requireUuid(taskId);
   return {
     id,
-    instruction: `${taskChefMarker(id)}\n\n${EXECUTOR_OWNERSHIP_PARAGRAPH}\n\n${EXECUTOR_LINK_PARAGRAPH}\n\n${EXECUTOR_RESULT_PARAGRAPH}\n\n${instruction}`,
+    instruction: `${taskChefMarker(id)}\n${body}\n\n${EXECUTOR_SKILL_INVOCATION}`,
   };
 }
 

package/src/mcp.js

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