taskchef 7.8.0 → 7.9.1

package/src/dashboard/state.js

@@ -31,6 +31,37 @@ export function taskStatusLabel(task) {
   return task.status === null ? "unresolved" : task.status.replaceAll("_", " ");
 }
 
+export function latestTurnPresentation(task) {
+  const turn = task.latestTurn ?? null;
+  const result = turn?.result ?? null;
+  const requestSummary = turn?.requestSummary
+    ?? (turn ? "Request not recorded by this TaskChef version." : task.title);
+  return {
+    turnId: turn?.turnId ?? task.turnId ?? null,
+    startedAt: turn?.startedAt ?? task.updatedAt ?? task.createdAt ?? null,
+    requestSummary,
+    resultStatus: result?.status ?? (task.status === "working" ? "working" : task.status),
+    resultSummary: result?.summary
+      ?? (task.status === "working"
+        ? "In progress"
+        : task.lastResult?.summary ?? task.summary ?? "No result reported."),
+    resultUpdatedAt: result?.updatedAt ?? null,
+  };
+}
+
+export function mergeProjectedTurns(task, preservedTurns = []) {
+  if (Array.isArray(task.turns)) return task.turns;
+  if (!task.latestTurn) return preservedTurns;
+  const turns = [...preservedTurns];
+  const lastIndex = turns.length - 1;
+  if (lastIndex >= 0 && turns[lastIndex].turnId === task.latestTurn.turnId) {
+    turns[lastIndex] = task.latestTurn;
+  } else {
+    turns.push(task.latestTurn);
+  }
+  return turns;
+}
+
 export function notificationTitle(notification) {
   return NOTIFICATION_TITLES.get(notification.event) ?? "Task updated";
 }

package/src/dashboard/styles.css

@@ -79,7 +79,8 @@ select { min-width: 180px; padding: 9px 34px 9px 11px; border: 1px solid var(--b
 .task-title:hover { color: var(--accent); text-decoration: underline; text-underline-offset: 3px; }
 .task-project { margin: 3px 0 12px; font-size: 0.86rem; }
 .task-title, .task-summary { overflow-wrap: anywhere; }
-.task-summary { max-width: 78ch; margin-bottom: 14px; }
+.task-summary { display: grid; max-width: 78ch; margin-bottom: 14px; gap: 3px; }
+.task-summary strong { margin-top: 5px; color: var(--muted); font-size: 0.72rem; letter-spacing: 0.04em; text-transform: uppercase; }
 time, .timestamp-missing { font-size: 0.78rem; }
 .timestamp-toggle { padding: 2px 0; border: 0; background: none; cursor: pointer; text-align: left; }
 .timestamp-toggle:hover time { color: var(--text); text-decoration: underline; text-underline-offset: 3px; }
@@ -133,6 +134,7 @@ dialog section + section { margin-top: 24px; }
 .result-history-header { display: flex; align-items: center; justify-content: space-between; gap: 12px; margin-bottom: 9px; }
 .result-history-item p { margin-bottom: 7px; }
 .result-history-item p:last-child { margin-bottom: 0; }
+.result-history-item h4 { margin: 10px 0 3px; color: var(--muted); font-size: 0.72rem; letter-spacing: 0.04em; text-transform: uppercase; }
 .result-history-turn, .result-history-empty { color: var(--muted); font-size: 0.78rem; overflow-wrap: anywhere; }
 .result-history-empty { margin: 0; }
 pre { max-height: 280px; margin: 0; padding: 14px; overflow: auto; border-radius: 7px; background: var(--surface-muted); white-space: pre-wrap; overflow-wrap: anywhere; font: 0.86rem/1.55 ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; }

package/src/dashboard.js

@@ -139,6 +139,17 @@ function assertDashboardTaskBounds(tasks, maximumTasks) {
     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.latestTurn?.requestSummary, 1_000, `${name} latest request summary`);
+    boundedText(task.latestTurn?.turnId, 512, `${name} latest turn ID`);
+    const turns = task.turns ?? [];
+    if (turns.length > 10_000) {
+      throw new Error(`${name} has too many turns for the dashboard`);
+    }
+    for (const [turnIndex, turn] of turns.entries()) {
+      boundedText(turn.requestSummary, 1_000, `${name} turn ${turnIndex + 1} request summary`);
+      boundedText(turn.turnId, 512, `${name} turn ${turnIndex + 1} turn ID`);
+      boundedText(turn.result?.summary, 2_000, `${name} turn ${turnIndex + 1} result summary`);
+    }
     const results = task.results ?? [];
     if (results.length > 10_000) {
       throw new Error(`${name} has too many results for the dashboard`);
@@ -160,7 +171,7 @@ function assertDashboardTaskBounds(tasks, maximumTasks) {
 }
 
 function taskListProjection(task) {
-  const { results: _results, ...projection } = task;
+  const { turns: _turns, results: _results, ...projection } = task;
   return projection;
 }
 

package/src/delegation.js

@@ -5,7 +5,7 @@ export const EXECUTOR_OWNERSHIP_PARAGRAPH = "This task owns the delegated assign
 /** @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.";
 /** @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.";
+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, summary omitted or null, and a concise requestSummary for this turn. 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.";
@@ -162,14 +162,18 @@ export function parseTaskChefMarker(instruction) {
     return hasHistoricalAssignment() ? id : null;
   }
   const executorSkillReferences = instruction.match(/\$taskchef-executor\b/gi) ?? [];
+  const hasCompactBoundary = index >= 1
+    && lines.at(index - 1).trim().length > 0;
+  const hasHistoricalBlankBoundary = index >= 2
+    && lines.at(index - 1) === ""
+    && lines.at(index - 2).trim().length > 0;
+  const assignmentEnd = hasCompactBoundary ? index : index - 1;
   const isTrailingScaffold = index === lines.length - 2
-    && index >= 2
+    && (hasCompactBoundary || hasHistoricalBlankBoundary)
     && lines[0].trim().length > 0
-    && lines.at(-3) === ""
-    && lines.at(-4).trim().length > 0
     && lines.at(-1) === EXECUTOR_SKILL_INVOCATION
-    && hasTaskSpecificContent(lines.slice(0, index - 1))
-    && !lines.slice(0, index - 1).some((line) => HISTORICAL_EXECUTOR_SCAFFOLD_LINES.has(line))
+    && hasTaskSpecificContent(lines.slice(0, assignmentEnd))
+    && !lines.slice(0, assignmentEnd).some((line) => HISTORICAL_EXECUTOR_SCAFFOLD_LINES.has(line))
     && executorSkillReferences.length === 1;
   return isTrailingScaffold ? id : null;
 }
@@ -198,7 +202,7 @@ export function prepareDelegation(instruction, { taskId = randomUUID() } = {}) {
   const id = requireUuid(taskId);
   return {
     id,
-    instruction: `${body}\n\n${taskChefMarker(id)}\n${EXECUTOR_SKILL_INVOCATION}`,
+    instruction: `${body}\n${taskChefMarker(id)}\n${EXECUTOR_SKILL_INVOCATION}`,
   };
 }
 

package/src/mcp.js

@@ -21,7 +21,7 @@ const projectSchema = z.object({
 });
 
 const taskSchema = z.object({
-  schemaVersion: z.union([z.literal(4), z.literal(5), z.literal(6)]),
+  schemaVersion: z.union([z.literal(4), z.literal(5), z.literal(6), z.literal(7)]),
   id: z.string(),
   project: projectSchema,
   title: z.string(),
@@ -33,6 +33,26 @@ const taskSchema = z.object({
   turnId: z.string().nullable(),
   updatedAt: z.string(),
   updatedBy: z.enum(["dispatcher", "mcp"]),
+  turns: z.array(z.object({
+    turnId: z.string().nullable(),
+    requestSummary: z.string().nullable(),
+    startedAt: z.string(),
+    result: z.object({
+      status: z.enum(["needs_input", "completed", "failed"]),
+      summary: z.string(),
+      updatedAt: z.string(),
+    }).nullable(),
+  })),
+  latestTurn: z.object({
+    turnId: z.string().nullable(),
+    requestSummary: z.string().nullable(),
+    startedAt: z.string(),
+    result: z.object({
+      status: z.enum(["needs_input", "completed", "failed"]),
+      summary: z.string(),
+      updatedAt: z.string(),
+    }).nullable(),
+  }).nullable(),
   results: z.array(z.object({
     status: z.enum(["needs_input", "completed", "failed"]),
     summary: z.string(),
@@ -203,13 +223,14 @@ export function createTaskChefMcpServer({
     {
       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.",
+        "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 and a concise requestSummary. Before ending the same turn, report needs_input, completed, or failed with a concise semantic summary and requestSummary omitted. 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(),
+        requestSummary: z.string().min(1).max(1_000).nullable().optional(),
       },
       outputSchema: { task: taskSchema },
       annotations: {

package/src/workspace.js

@@ -38,8 +38,8 @@ const DISPATCH_FILE_NAME = "tasks.jsonl";
 const WORKSPACE_LOCK_NAME = ".taskchef-workspace.lock";
 const SAFE_ID = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
 const CURRENT_CONFIG_SCHEMA_VERSION = 2;
-const CURRENT_TASK_SCHEMA_VERSION = 6;
-const PREVIOUS_TASK_SCHEMA_VERSION = 5;
+const CURRENT_TASK_SCHEMA_VERSION = 7;
+const PREVIOUS_TASK_SCHEMA_VERSION = 6;
 const FIRST_SELF_LINKING_TASK_SCHEMA_VERSION = 4;
 const CONFIG_FIELDS = new Set(["schemaVersion", "projects"]);
 const PROJECT_FIELDS = new Set([
@@ -65,7 +65,8 @@ const STATEFUL_DISPATCH_FIELDS = new Set([
   "updatedBy",
 ]);
 const SCHEMA_5_DISPATCH_FIELDS = new Set([...STATEFUL_DISPATCH_FIELDS, "lastResult"]);
-const DISPATCH_FIELDS = new Set([...STATEFUL_DISPATCH_FIELDS, "results"]);
+const SCHEMA_6_DISPATCH_FIELDS = new Set([...STATEFUL_DISPATCH_FIELDS, "results"]);
+const DISPATCH_FIELDS = new Set([...STATEFUL_DISPATCH_FIELDS, "turns"]);
 const RECORD_DISPATCH_FIELDS = new Set([
   "id",
   "project",
@@ -77,7 +78,10 @@ const RESULT_STATUSES = new Set(["needs_input", "completed", "failed"]);
 const TASK_STATUSES = new Set(["working", ...RESULT_STATUSES]);
 const TASK_UPDATE_SOURCES = new Set(["dispatcher", "mcp"]);
 const MAX_RESULT_SUMMARY_LENGTH = 2_000;
+const MAX_REQUEST_SUMMARY_LENGTH = 1_000;
 const RESULT_FIELDS = new Set(["status", "summary", "turnId", "updatedAt"]);
+const TURN_RESULT_FIELDS = new Set(["status", "summary", "updatedAt"]);
+const TURN_FIELDS = new Set(["turnId", "requestSummary", "startedAt", "result"]);
 
 function requireExactFields(value, fields, name) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -224,7 +228,7 @@ async function appendDispatchesAtomic(workspaceRoot, dispatches) {
   const dispatchPath = path.join(workspaceRoot, DISPATCH_FILE_NAME);
   const content = await readFile(dispatchPath, "utf8");
   const appended = dispatches
-    .map((dispatch) => `${JSON.stringify(schema6Task(dispatch))}\n`)
+    .map((dispatch) => `${JSON.stringify(schema7Task(dispatch))}\n`)
     .join("");
   await writeTextAtomic(dispatchPath, `${content}${appended}`);
 }
@@ -684,6 +688,7 @@ export async function removeProject(workspaceRoot, name) {
 async function validateDispatchShape(dispatch, name = "task") {
   const supportedVersions = [
     FIRST_SELF_LINKING_TASK_SCHEMA_VERSION,
+    5,
     PREVIOUS_TASK_SCHEMA_VERSION,
     CURRENT_TASK_SCHEMA_VERSION,
   ];
@@ -695,6 +700,8 @@ async function validateDispatchShape(dispatch, name = "task") {
     dispatch.schemaVersion === CURRENT_TASK_SCHEMA_VERSION
       ? DISPATCH_FIELDS
       : dispatch.schemaVersion === PREVIOUS_TASK_SCHEMA_VERSION
+        ? SCHEMA_6_DISPATCH_FIELDS
+        : dispatch.schemaVersion === 5
         ? SCHEMA_5_DISPATCH_FIELDS
         : STATEFUL_DISPATCH_FIELDS,
     name,
@@ -735,20 +742,77 @@ async function validateDispatchShape(dispatch, name = "task") {
     }
     return normalizedResult;
   };
-  let results = [];
+  const normalizeTurnResult = (result, resultName) => {
+    if (result === null) return null;
+    requireExactFields(result, TURN_RESULT_FIELDS, resultName);
+    const normalizedResult = {
+      status: requireEnum(result.status, RESULT_STATUSES, `${resultName}.status`),
+      summary: optionalString(result.summary, `${resultName}.summary`, {
+        maxLength: MAX_RESULT_SUMMARY_LENGTH,
+      }),
+      updatedAt: requireTimestamp(result.updatedAt, `${resultName}.updatedAt`),
+    };
+    if (normalizedResult.summary === null) {
+      throw new Error(`${resultName}.summary must be a non-empty string`);
+    }
+    return normalizedResult;
+  };
+  const normalizeTurn = (turn, turnName) => {
+    requireExactFields(turn, TURN_FIELDS, turnName);
+    return {
+      turnId: optionalString(turn.turnId, `${turnName}.turnId`, { maxLength: 256 }),
+      requestSummary: optionalString(turn.requestSummary, `${turnName}.requestSummary`, {
+        maxLength: MAX_REQUEST_SUMMARY_LENGTH,
+      }),
+      startedAt: requireTimestamp(turn.startedAt, `${turnName}.startedAt`),
+      result: normalizeTurnResult(turn.result, `${turnName}.result`),
+    };
+  };
+  let legacyResults = [];
+  let turns = [];
   if (dispatch.schemaVersion === CURRENT_TASK_SCHEMA_VERSION) {
+    if (!Array.isArray(dispatch.turns)) throw new Error(`${name}.turns must be an array`);
+    turns = dispatch.turns.map((turn, index) => normalizeTurn(turn, `${name}.turns[${index}]`));
+  } else if (dispatch.schemaVersion === PREVIOUS_TASK_SCHEMA_VERSION) {
     if (!Array.isArray(dispatch.results)) throw new Error(`${name}.results must be an array`);
-    results = dispatch.results.map((result, index) => (
+    legacyResults = dispatch.results.map((result, index) => (
       normalizeResult(result, `${name}.results[${index}]`)
     ));
-  } else if (dispatch.schemaVersion === PREVIOUS_TASK_SCHEMA_VERSION) {
+  } else if (dispatch.schemaVersion === 5) {
     if (dispatch.lastResult !== null) {
-      results = [normalizeResult(dispatch.lastResult, `${name}.lastResult`)];
+      legacyResults = [normalizeResult(dispatch.lastResult, `${name}.lastResult`)];
     }
   } else if (RESULT_STATUSES.has(status)) {
-    results = [{ status, summary, turnId, updatedAt }];
+    legacyResults = [{ status, summary, turnId, updatedAt }];
   }
+  if (dispatch.schemaVersion !== CURRENT_TASK_SCHEMA_VERSION) {
+    turns = legacyResults.map((result) => ({
+      turnId: result.turnId,
+      requestSummary: null,
+      startedAt: result.updatedAt,
+      result: {
+        status: result.status,
+        summary: result.summary,
+        updatedAt: result.updatedAt,
+      },
+    }));
+    if (
+      status === "working"
+      && turnId !== null
+      && (
+        turns.at(-1)?.turnId !== turnId
+        || turns.at(-1)?.result !== null
+      )
+    ) {
+      turns.push({ turnId, requestSummary: null, startedAt: updatedAt, result: null });
+    }
+  }
+  const results = turns.flatMap((turn) => turn.result === null ? [] : [{
+    ...turn.result,
+    turnId: turn.turnId,
+  }]);
   const lastResult = results.at(-1) ?? null;
+  const latestTurn = turns.at(-1) ?? null;
   const normalized = {
     schemaVersion: dispatch.schemaVersion,
     id,
@@ -764,6 +828,8 @@ async function validateDispatchShape(dispatch, name = "task") {
     turnId,
     updatedAt,
     updatedBy: requireEnum(dispatch.updatedBy, TASK_UPDATE_SOURCES, `${name}.updatedBy`),
+    turns,
+    latestTurn,
     results,
     lastResult,
   };
@@ -773,14 +839,20 @@ async function validateDispatchShape(dispatch, name = "task") {
     if (normalized.turnId !== null) {
       normalized.turnId = normalizeCodexThreadId(normalized.turnId, `${name}.turnId`);
     }
-    for (const [index, result] of normalized.results.entries()) {
-      if (result.turnId != null) {
-        result.turnId = normalizeCodexThreadId(
-          result.turnId,
-          `${name}.results[${index}].turnId`,
+    for (const [index, turn] of normalized.turns.entries()) {
+      if (turn.turnId != null) {
+        turn.turnId = normalizeCodexThreadId(
+          turn.turnId,
+          `${name}.turns[${index}].turnId`,
         );
       }
     }
+    normalized.results = normalized.turns.flatMap((turn) => turn.result === null ? [] : [{
+      ...turn.result,
+      turnId: turn.turnId,
+    }]);
+    normalized.lastResult = normalized.results.at(-1) ?? null;
+    normalized.latestTurn = normalized.turns.at(-1) ?? null;
   }
   if (normalized.schemaVersion >= FIRST_SELF_LINKING_TASK_SCHEMA_VERSION) {
     if (normalized.threadId === null) {
@@ -814,7 +886,7 @@ async function validateDispatchShape(dispatch, name = "task") {
   if (RESULT_STATUSES.has(normalized.status) && normalized.summary === null) {
     throw new Error(`${name}.summary is required for status ${normalized.status}`);
   }
-  if (normalized.schemaVersion >= PREVIOUS_TASK_SCHEMA_VERSION) {
+  if (normalized.schemaVersion >= 5) {
     if (RESULT_STATUSES.has(normalized.status)) {
       if (
         normalized.lastResult === null
@@ -850,32 +922,76 @@ async function validateDispatchShape(dispatch, name = "task") {
       throw new Error(`${name}.turnId must be newer than lastResult.turnId while working`);
     }
   }
-  const seenResultTurns = new Set();
+  if (normalized.status === "working") {
+    if (normalized.turnId === null) {
+      if (normalized.turns.length !== 0) {
+        throw new Error(`${name}.turns must be empty before the first working turn`);
+      }
+    } else if (
+      normalized.latestTurn === null
+      || normalized.latestTurn.turnId !== normalized.turnId
+      || normalized.latestTurn.result !== null
+    ) {
+      throw new Error(`${name}.latestTurn must match the current working turn`);
+    }
+  }
+  if (RESULT_STATUSES.has(normalized.status)) {
+    if (
+      normalized.latestTurn === null
+      || normalized.latestTurn.turnId !== normalized.turnId
+      || normalized.latestTurn.result === null
+      || normalized.latestTurn.result.status !== normalized.status
+      || normalized.latestTurn.result.summary !== normalized.summary
+      || normalized.latestTurn.result.updatedAt !== normalized.updatedAt
+    ) {
+      throw new Error(`${name}.latestTurn must match the current semantic state`);
+    }
+  }
+  const seenTurnIds = new Set();
   const nullTurnKey = Symbol("null turn");
-  for (const [index, result] of normalized.results.entries()) {
-    const turnKey = result.turnId ?? nullTurnKey;
-    if (seenResultTurns.has(turnKey)) {
-      throw new Error(`${name}.results contains duplicate turnId: ${result.turnId ?? "null"}`);
+  for (const [index, turn] of normalized.turns.entries()) {
+    const turnKey = turn.turnId ?? nullTurnKey;
+    const isLegacyOpaqueWorkingReuse = (
+      !isSelfLinkingRecord
+      && normalized.status === "working"
+      && index === normalized.turns.length - 1
+      && turn.result === null
+      && index > 0
+      && normalized.turns[index - 1].turnId === turn.turnId
+      && normalized.turns[index - 1].result !== null
+    );
+    if (seenTurnIds.has(turnKey) && !isLegacyOpaqueWorkingReuse) {
+      throw new Error(`${name}.turns contains duplicate turnId: ${turn.turnId ?? "null"}`);
     }
-    seenResultTurns.add(turnKey);
-    if (Date.parse(result.updatedAt) < Date.parse(normalized.createdAt)) {
-      throw new Error(`${name}.results[${index}].updatedAt must not be earlier than createdAt`);
+    seenTurnIds.add(turnKey);
+    if (Date.parse(turn.startedAt) < Date.parse(normalized.createdAt)) {
+      throw new Error(`${name}.turns[${index}].startedAt must not be earlier than createdAt`);
     }
-    if (Date.parse(result.updatedAt) > Date.parse(normalized.updatedAt)) {
-      throw new Error(`${name}.results[${index}].updatedAt must not be later than updatedAt`);
+    if (Date.parse(turn.startedAt) > Date.parse(normalized.updatedAt)) {
+      throw new Error(`${name}.turns[${index}].startedAt must not be later than updatedAt`);
     }
     if (
       index > 0
-      && Date.parse(result.updatedAt) < Date.parse(normalized.results[index - 1].updatedAt)
+      && Date.parse(turn.startedAt) < Date.parse(normalized.turns[index - 1].startedAt)
     ) {
-      throw new Error(`${name}.results must be ordered by updatedAt`);
+      throw new Error(`${name}.turns must be ordered by startedAt`);
     }
     if (
       isSelfLinkingRecord
       && index > 0
-      && result.turnId <= normalized.results[index - 1].turnId
+      && turn.turnId <= normalized.turns[index - 1].turnId
     ) {
-      throw new Error(`${name}.results must be ordered by turnId`);
+      throw new Error(`${name}.turns must be ordered by turnId`);
+    }
+    if (turn.result !== null) {
+      if (Date.parse(turn.result.updatedAt) < Date.parse(turn.startedAt)) {
+        throw new Error(`${name}.turns[${index}].result.updatedAt must not be earlier than startedAt`);
+      }
+      if (Date.parse(turn.result.updatedAt) > Date.parse(normalized.updatedAt)) {
+        throw new Error(`${name}.turns[${index}].result.updatedAt must not be later than updatedAt`);
+      }
+    } else if (index !== normalized.turns.length - 1) {
+      throw new Error(`${name}.turns may contain an unfinished turn only at the end`);
     }
   }
   if (
@@ -960,12 +1076,17 @@ export async function parseTaskLogContent(workspaceRoot, content) {
   return (await parseDispatchRecordsUnlocked(root, content)).map((record) => record.normalized);
 }
 
-function schema6Task(dispatch, patch = {}) {
-  const { lastResult: _lastResult, ...persisted } = dispatch;
+function schema7Task(dispatch, patch = {}) {
+  const {
+    latestTurn: _latestTurn,
+    results: _results,
+    lastResult: _lastResult,
+    ...persisted
+  } = dispatch;
   return {
     ...persisted,
     schemaVersion: CURRENT_TASK_SCHEMA_VERSION,
-    results: dispatch.results ?? [],
+    turns: dispatch.turns ?? [],
     ...patch,
   };
 }
@@ -994,13 +1115,13 @@ export async function migrateTaskLog(workspaceRoot, {
         backupPath: null,
       };
     }
-    const lines = records.map((record) => JSON.stringify(schema6Task(record.normalized)));
+    const lines = records.map((record) => JSON.stringify(schema7Task(record.normalized)));
     const migrated = lines.length === 0 ? "" : `${lines.join("\n")}\n`;
     await parseDispatchRecordsUnlocked(root, migrated);
     const timestamp = requireTimestamp(now(), "migration timestamp")
       .replaceAll(":", "-")
       .replaceAll(".", "-");
-    const backupPath = `${dispatchPath}.pre-v6-${timestamp}-${randomUUID()}.bak`;
+    const backupPath = `${dispatchPath}.pre-v7-${timestamp}-${randomUUID()}.bak`;
     await writeFile(backupPath, original, { encoding: "utf8", mode: 0o600, flag: "wx" });
     if (await readFile(backupPath, "utf8") !== original) {
       throw new Error(`task log backup validation failed: ${backupPath}`);
@@ -1046,7 +1167,7 @@ export async function recordTask(workspaceRoot, input, { now } = {}) {
       turnId: null,
       updatedAt: createdAt,
       updatedBy: "dispatcher",
-      results: [],
+      turns: [],
     });
     const existing = await readDispatchesUnlocked(root);
     if (existing.some((item) => item.id === dispatch.id)) {
@@ -1088,7 +1209,7 @@ export async function linkTask(workspaceRoot, taskId, threadId, { now } = {}) {
         throw new Error(`task instruction does not contain its exact TaskChef marker: ${id}`);
       }
       if (dispatch.threadId === durableThreadId) return dispatch;
-      const canonical = await validateDispatchShape(schema6Task(dispatch, {
+      const canonical = await validateDispatchShape(schema7Task(dispatch, {
         threadId: durableThreadId,
         updatedAt: transitionTimestamp(now, dispatch.updatedAt),
         updatedBy: "mcp",
@@ -1117,7 +1238,7 @@ export async function linkTask(workspaceRoot, taskId, threadId, { now } = {}) {
     ))) {
       throw new Error(`threadId is already recorded: ${durableThreadId}`);
     }
-    const linked = await validateDispatchShape(schema6Task(dispatch, {
+    const linked = await validateDispatchShape(schema7Task(dispatch, {
       threadId: durableThreadId,
       updatedAt: transitionTimestamp(now, dispatch.updatedAt),
       updatedBy: "mcp",
@@ -1131,11 +1252,13 @@ export async function linkTask(workspaceRoot, taskId, threadId, { now } = {}) {
 }
 
 function dispatchLineWithState(dispatch, patch) {
-  return JSON.stringify(schema6Task(dispatch, patch));
+  return JSON.stringify(schema7Task(dispatch, patch));
 }
 
 function normalizeTaskStateInput(input, { allowWorking }) {
-  const fields = new Set(["taskId", "threadId", "turnId", "status", "summary"]);
+  const fields = new Set([
+    "taskId", "threadId", "turnId", "status", "summary", "requestSummary",
+  ]);
   if (!input || typeof input !== "object" || Array.isArray(input)) {
     throw new Error("task state must be an object");
   }
@@ -1157,13 +1280,21 @@ function normalizeTaskStateInput(input, { allowWorking }) {
   const summary = optionalString("summary" in input ? input.summary : null, "summary", {
     maxLength: MAX_RESULT_SUMMARY_LENGTH,
   });
+  const requestSummary = optionalString(
+    "requestSummary" in input ? input.requestSummary : null,
+    "requestSummary",
+    { maxLength: MAX_REQUEST_SUMMARY_LENGTH },
+  );
   if (status === "working" && summary !== null) {
     throw new Error("summary must be null while status is working");
   }
   if (status !== "working" && summary === null) {
     throw new Error(`summary is required for status ${status}`);
   }
-  return { id, threadId, turnId, status, summary };
+  if (status !== "working" && requestSummary !== null) {
+    throw new Error(`requestSummary is accepted only for status working`);
+  }
+  return { id, threadId, turnId, status, summary, requestSummary };
 }
 
 function sameLastResult(lastResult, { status, summary, turnId }) {
@@ -1178,7 +1309,7 @@ async function reportTaskStateInternal(
   input,
   { now, compatibilityAlias = false } = {},
 ) {
-  const { id, threadId, turnId, status, summary } = normalizeTaskStateInput(input, {
+  const { id, threadId, turnId, status, summary, requestSummary } = normalizeTaskStateInput(input, {
     allowWorking: !compatibilityAlias,
   });
   const root = await realpath(path.resolve(workspaceRoot));
@@ -1242,22 +1373,51 @@ async function reportTaskStateInternal(
       }
     }
     if (status === "working") {
-      if (dispatch.status === "working" && stateTurnId === dispatch.turnId) return dispatch;
+      const sameWorkingTurn = dispatch.status === "working" && stateTurnId === dispatch.turnId;
+      if (sameWorkingTurn) {
+        const storedRequest = dispatch.latestTurn?.requestSummary ?? null;
+        if (
+          requestSummary !== null
+          && storedRequest !== null
+          && requestSummary !== storedRequest
+        ) {
+          throw new Error(`working turn already has a different requestSummary: ${id}`);
+        }
+        if (
+          records[index].raw.schemaVersion === CURRENT_TASK_SCHEMA_VERSION
+          && (requestSummary === null || storedRequest === requestSummary)
+        ) {
+          return dispatch;
+        }
+      }
       if (isSelfLinkingJourney) {
-        if (dispatch.turnId !== null && stateTurnId <= dispatch.turnId) {
+        if (!sameWorkingTurn && dispatch.turnId !== null && stateTurnId <= dispatch.turnId) {
           throw new Error(`working turnId must be newer than the current task turnId: ${id}`);
         }
-        if (dispatch.lastResult?.turnId != null && stateTurnId <= dispatch.lastResult.turnId) {
+        if (!sameWorkingTurn && dispatch.lastResult?.turnId != null && stateTurnId <= dispatch.lastResult.turnId) {
           throw new Error(`working turnId must be newer than the last result turnId: ${id}`);
         }
       }
-      const updatedAt = transitionTimestamp(now, dispatch.updatedAt);
-      const updated = await validateDispatchShape(schema6Task(dispatch, {
+      const updatedAt = sameWorkingTurn
+        ? dispatch.updatedAt
+        : transitionTimestamp(now, dispatch.updatedAt);
+      const turns = sameWorkingTurn
+        ? dispatch.turns.map((turn, turnIndex) => turnIndex === dispatch.turns.length - 1
+          ? { ...turn, requestSummary: turn.requestSummary ?? requestSummary }
+          : turn)
+        : [...dispatch.turns, {
+          turnId: stateTurnId,
+          requestSummary,
+          startedAt: updatedAt,
+          result: null,
+        }];
+      const updated = await validateDispatchShape(schema7Task(dispatch, {
         status,
         summary: null,
         turnId: stateTurnId,
         updatedAt,
         updatedBy: "mcp",
+        turns,
       }));
       const lines = records.map((record, recordIndex) => recordIndex === index
         ? dispatchLineWithState(updated, {})
@@ -1265,7 +1425,10 @@ async function reportTaskStateInternal(
       await writeDispatchLinesAtomic(root, lines);
       return updated;
     }
-    const priorTurnResult = dispatch.results.find((result) => result.turnId === stateTurnId);
+    const priorTurn = dispatch.turns.find((turn) => turn.turnId === stateTurnId);
+    const priorTurnResult = priorTurn?.result === null || priorTurn === undefined
+      ? null
+      : { ...priorTurn.result, turnId: priorTurn.turnId };
     if (priorTurnResult && sameLastResult(priorTurnResult, { status, summary, turnId: stateTurnId })) {
       return dispatch;
     }
@@ -1287,14 +1450,28 @@ async function reportTaskStateInternal(
       throw new Error(`task result must match the current working turnId: ${id}`);
     }
     const updatedAt = transitionTimestamp(now, dispatch.updatedAt);
-    const lastResult = { status, summary, turnId: stateTurnId, updatedAt };
-    const candidate = schema6Task(dispatch, {
+    const turnResult = { status, summary, updatedAt };
+    const currentTurnIndex = dispatch.turns.findIndex((turn) => turn.turnId === stateTurnId);
+    let turns;
+    if (currentTurnIndex === -1) {
+      turns = [...dispatch.turns, {
+        turnId: stateTurnId,
+        requestSummary: null,
+        startedAt: updatedAt,
+        result: turnResult,
+      }];
+    } else {
+      turns = dispatch.turns.map((turn, turnIndex) => turnIndex === currentTurnIndex
+        ? { ...turn, result: turnResult }
+        : turn);
+    }
+    const candidate = schema7Task(dispatch, {
       status,
       summary,
       turnId: stateTurnId,
       updatedAt,
       updatedBy: "mcp",
-      results: [...dispatch.results, lastResult],
+      turns,
     });
     const updated = await validateDispatchShape(candidate);
     const lines = records.map((record, recordIndex) => recordIndex === index