taskchef 6.1.3 → 7.1.0

package/src/delegation.js

@@ -2,13 +2,13 @@ import { randomUUID } from "node:crypto";
 
 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.";
 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.";
+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.";
+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.";
 
 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}$`);
 const CODEX_UUID_V7_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
 const TASKCHEF_MARKER_PATTERN = new RegExp(`^<!-- taskchef_id=(${UUID_SOURCE}) -->$`);
-const LEGACY_TASKCHEF_MARKER_PATTERN = new RegExp(`^# taskchef_id=(${UUID_SOURCE})$`);
 
 function requireObject(value, name) {
   if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${name} must be an object`);
@@ -82,16 +82,13 @@ export function taskChefMarker(taskId) {
   return `<!-- taskchef_id=${requireUuid(taskId)} -->`;
 }
 
-export function parseTaskChefMarker(instruction, { allowLegacyHeading = false } = {}) {
+export function parseTaskChefMarker(instruction) {
   if (typeof instruction !== "string") return null;
   const firstLine = instruction.split(/\r?\n/, 1)[0];
   const currentMatch = firstLine.match(TASKCHEF_MARKER_PATTERN);
-  if (currentMatch !== null) {
-    const prefix = instruction.match(/^([^\r\n]*)(\r?\n)\2/);
-    return prefix === null ? null : currentMatch[1];
-  }
-  if (!allowLegacyHeading) return null;
-  return firstLine.match(LEGACY_TASKCHEF_MARKER_PATTERN)?.[1] ?? null;
+  if (currentMatch === null) return null;
+  const prefix = instruction.match(/^([^\r\n]*)(\r?\n)\2/);
+  return prefix === null ? null : currentMatch[1];
 }
 
 export function prepareDelegation(instruction, { taskId = randomUUID() } = {}) {
@@ -100,7 +97,7 @@ export function prepareDelegation(instruction, { taskId = randomUUID() } = {}) {
   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\n${EXECUTOR_OWNERSHIP_PARAGRAPH}\n\n${EXECUTOR_LINK_PARAGRAPH}\n\n${EXECUTOR_WORKING_PARAGRAPH}\n\n${EXECUTOR_RESULT_PARAGRAPH}\n\n${instruction}`,
   };
 }
 

package/src/github.js

@@ -59,11 +59,7 @@ export function canonicalGithubRepository(value, name = "githubRepos") {
 export function normalizeGithubRepositories(
   value,
   name = "githubRepos",
-  { allowLegacyScalar = false } = {},
 ) {
-  if (allowLegacyScalar && (value === null || typeof value === "string")) {
-    value = value === null ? [] : [value];
-  }
   if (!Array.isArray(value)) throw new Error(`${name} must be an array of GitHub repository URLs`);
   const repositories = [];
   const seen = new Set();

package/src/mcp.js

@@ -4,6 +4,7 @@ import {
   prepareDispatch,
   linkTask,
   recordTask,
+  reportTaskState,
   reportTaskResult,
 } from "./workspace.js";
 import { parseTaskChefMarker } from "./delegation.js";
@@ -18,22 +19,28 @@ const projectSchema = z.object({
 });
 
 const taskSchema = z.object({
-  schemaVersion: z.number(),
+  schemaVersion: z.union([z.literal(4), z.literal(5)]),
   id: z.string(),
   project: projectSchema,
   title: z.string(),
   instruction: z.string(),
   threadId: z.string().nullable(),
   createdAt: z.string(),
-  status: z.enum(["working", "needs_input", "completed", "failed"]).nullable(),
+  status: z.enum(["working", "needs_input", "completed", "failed"]),
   summary: z.string().nullable(),
   turnId: z.string().nullable(),
-  updatedAt: z.string().nullable(),
-  updatedBy: z.enum(["dispatcher", "hook", "mcp"]).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({
-  schemaVersion: z.number(),
+  schemaVersion: z.literal(1),
   workspace: z.string(),
   taskId: z.string(),
   preparedAt: z.string(),
@@ -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. The executor must call link_task first, report_state working at the start of each execution turn, and report_state with a semantic outcome before ending.",
     },
   );
 
@@ -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(),