opencode-manifold 0.5.6 → 0.5.8

package/dist/index.js

@@ -320,342 +320,206 @@ function extractTaskFromPlan(planContent, taskNumber) {
   }
   return null;
 }
-function runDispatcherLogic(args, state, settings) {
-  const isNewTask = args.newTask === true;
-  const taskNumber = args.task_number || (state?.task_number || 0);
-  const planFile = args.plan_file || (state?.plan_file || "");
+function runDispatcherLogic(args, state, settings, taskDescription) {
+  const taskNumber = args.task_number || state?.task_number || 0;
   const slug = state?.slug || "";
-  let currentState;
-  if (isNewTask || !state) {
-    currentState = {
+  if (!state || state.phase === "init" || state.phase === "complete" || state.phase === "escalated") {
+    const newState = {
       task_number: taskNumber,
-      plan_file: planFile,
+      plan_file: args.plan_file || state?.plan_file || "",
       slug,
+      phase: "awaiting_execution",
+      senior_output: "",
+      clerk_summary: "",
       loops: 0,
-      clerkRetries: 0,
-      researchSummary: "",
-      implementationOutput: "",
-      reviewFeedback: "",
-      debugAnalysis: ""
+      clerk_retries: 0
     };
-  } else {
-    currentState = { ...state };
-  }
-  if (args.researchSummary)
-    currentState.researchSummary = args.researchSummary;
-  if (args.implementationOutput)
-    currentState.implementationOutput = args.implementationOutput;
-  if (args.reviewFeedback)
-    currentState.reviewFeedback = args.reviewFeedback;
-  if (args.debugAnalysis)
-    currentState.debugAnalysis = args.debugAnalysis;
-  if (isNewTask) {
     return {
-      route: "research",
+      route: "execute",
       agent: "clerk",
-      prompt: buildResearchPrompt(args, currentState, settings),
-      state: {
-        task_id: `${currentState.slug}-${currentState.task_number.toString().padStart(3, "0")}`,
-        loops: 0,
-        maxLoops: settings.maxLoops,
-        clerkRetries: 0
-      },
-      message: "Researching codebase and wiki context"
-    };
-  }
-  if (args.researchComplete === true && !args.hasImplementation) {
-    return {
-      route: "implement",
-      agent: "senior-dev",
-      prompt: buildScopedPrompt(currentState.researchSummary, args),
-      state: {
-        task_id: `${currentState.slug}-${currentState.task_number.toString().padStart(3, "0")}`,
-        loops: 0,
-        maxLoops: settings.maxLoops,
-        clerkRetries: 0
-      },
-      message: "Sending to senior-dev for implementation"
-    };
-  }
-  if (args.hasImplementation === true && args.reviewDone === false) {
-    return {
-      route: "review",
-      agent: "junior-dev",
-      prompt: buildReviewPrompt(currentState.implementationOutput, args),
+      prompt: buildExecutePrompt(taskNumber, taskDescription),
       state: {
-        task_id: `${currentState.slug}-${currentState.task_number.toString().padStart(3, "0")}`,
-        loops: 0,
-        maxLoops: settings.maxLoops,
-        clerkRetries: 0
+        task_id: `${slug}-${taskNumber.toString().padStart(3, "0")}`,
+        phase: "awaiting_execution"
       },
-      message: "Sending to junior-dev for review"
+      message: "Ready to execute task"
     };
   }
-  if (args.reviewDone === true && args.reviewPassed === true) {
+  if (state.phase === "awaiting_execution") {
     return {
-      route: "logging",
+      route: "outcome_check",
       agent: "clerk",
-      prompt: buildLoggingPrompt(currentState, args),
+      prompt: buildOutcomeCheckPrompt(),
       state: {
-        task_id: `${currentState.slug}-${currentState.task_number.toString().padStart(3, "0")}`,
-        loops: currentState.loops,
-        maxLoops: settings.maxLoops,
-        clerkRetries: currentState.clerkRetries
+        task_id: `${slug}-${taskNumber.toString().padStart(3, "0")}`,
+        phase: "awaiting_outcome"
       },
-      message: "Logging task to wiki and graph"
+      message: "Waiting for senior dev outcome"
     };
   }
-  if (args.reviewDone === true && args.reviewPassed === false) {
-    currentState.loops++;
-    if (currentState.loops >= settings.maxLoops) {
-      if (!args.debugComplete && currentState.clerkRetries === 0) {
+  if (state.phase === "awaiting_outcome") {
+    const isSuccess = args.success === true;
+    if (isSuccess) {
+      return {
+        route: "logging",
+        agent: "clerk",
+        prompt: buildLoggingPrompt(state, taskDescription),
+        state: {
+          task_id: `${slug}-${taskNumber.toString().padStart(3, "0")}`,
+          phase: "logging"
+        },
+        message: "Task succeeded - logging results"
+      };
+    } else {
+      if (state.clerk_retries < settings.maxRetries) {
         return {
-          route: "debug",
-          agent: "debug",
-          prompt: buildDebugPrompt(currentState, args),
+          route: "reprompt",
+          agent: "clerk",
+          prompt: buildRePromptPrompt(state, taskDescription),
           state: {
-            task_id: `${currentState.slug}-${currentState.task_number.toString().padStart(3, "0")}`,
-            loops: currentState.loops,
-            maxLoops: settings.maxLoops,
-            clerkRetries: 0
+            task_id: `${slug}-${taskNumber.toString().padStart(3, "0")}`,
+            phase: "awaiting_execution"
           },
-          message: `Loop ${currentState.loops}/${settings.maxLoops} - escalating to debug`
+          message: `Retrying task (attempt ${state.clerk_retries + 1}/${settings.maxRetries})`
         };
-      }
-      if (args.debugComplete === true && settings.clerkRetryEnabled && currentState.clerkRetries === 0) {
-        currentState.clerkRetries = 1;
-        currentState.loops = 0;
+      } else {
         return {
-          route: "re-research",
-          agent: "clerk",
-          prompt: buildReResearchPrompt(currentState, args),
+          route: "escalate",
+          agent: null,
+          prompt: buildEscalationPrompt(state, taskDescription),
           state: {
-            task_id: `${currentState.slug}-${currentState.task_number.toString().padStart(3, "0")}`,
-            loops: 0,
-            maxLoops: settings.maxLoops,
-            clerkRetries: 1
+            task_id: `${slug}-${taskNumber.toString().padStart(3, "0")}`,
+            phase: "escalated"
           },
-          message: "Clerk re-researching with failure context"
+          message: "Escalating to user - all retries exhausted"
         };
       }
-      return {
-        route: "escalate_user",
-        agent: null,
-        prompt: `Task ${taskNumber} has exhausted all loops (${settings.maxLoops}) and debug analysis. Last feedback: ${currentState.reviewFeedback}`,
-        state: {
-          task_id: `${currentState.slug}-${currentState.task_number.toString().padStart(3, "0")}`,
-          loops: currentState.loops,
-          maxLoops: settings.maxLoops,
-          clerkRetries: currentState.clerkRetries
-        },
-        message: "ESCALATING TO USER - all loops exhausted"
-      };
     }
-    return {
-      route: "re-implement",
-      agent: "senior-dev",
-      prompt: buildReImplementPrompt(currentState, args),
-      state: {
-        task_id: `${currentState.slug}-${currentState.task_number.toString().padStart(3, "0")}`,
-        loops: currentState.loops,
-        maxLoops: settings.maxLoops,
-        clerkRetries: currentState.clerkRetries
-      },
-      message: `Loop ${currentState.loops}/${settings.maxLoops} - re-implementing with junior feedback`
-    };
-  }
-  if (args.debugComplete === true && args.reResearched === false) {
-    return {
-      route: "re-implement",
-      agent: "senior-dev",
-      prompt: buildDebugImplementPrompt(currentState, args),
-      state: {
-        task_id: `${currentState.slug}-${currentState.task_number.toString().padStart(3, "0")}`,
-        loops: currentState.loops,
-        maxLoops: settings.maxLoops,
-        clerkRetries: currentState.clerkRetries
-      },
-      message: "Re-implementing with debug suggestion"
-    };
-  }
-  if (args.reResearched === true) {
-    currentState.loops = 0;
-    return {
-      route: "implement",
-      agent: "senior-dev",
-      prompt: buildScopedPrompt(currentState.researchSummary, args),
-      state: {
-        task_id: `${currentState.slug}-${currentState.task_number.toString().padStart(3, "0")}`,
-        loops: 0,
-        maxLoops: settings.maxLoops,
-        clerkRetries: currentState.clerkRetries
-      },
-      message: "Starting fresh loop with new research"
-    };
   }
   return {
-    route: "escalate_user",
+    route: "escalate",
     agent: null,
-    prompt: "Dispatcher encountered an unexpected state combination",
+    prompt: "Dispatcher encountered unexpected state",
     state: {
-      task_id: `${currentState.slug}-${currentState.task_number.toString().padStart(3, "0")}`,
-      loops: currentState.loops,
-      maxLoops: settings.maxLoops,
-      clerkRetries: currentState.clerkRetries
+      task_id: `${slug}-${taskNumber.toString().padStart(3, "0")}`,
+      phase: "escalated"
     },
-    message: "ESCALATING TO USER - unexpected state"
+    message: "Unexpected state - escalating"
   };
 }
-function buildResearchPrompt(args, state, settings) {
-  const needsTodo = args.needsDecomposition === true;
-  return `You are the Clerk. Research this task and compose a scoped prompt.
-
-Task ${state.task_number}: ${args.description}
-
-Research steps:
-1. Use codebase-index to search for relevant code (max ${settings.maxResults} results)
-2. Read graph files from Manifold/graph/ for relevant files
-3. Read recent task logs from Manifold/tasks/ (${settings.recentTaskCount} most recent)
-${needsTodo ? `4. Read the full plan file (${args.plan_file}) for project-wide context` : ""}
-
-${needsTodo ? `IMPORTANT: This task requires project-wide decomposition. After researching, you will need to:
-- Identify all files that need to be created or modified
-- Break the work into logical subtasks
-- Prepare context for each subtask` : ""}
-
-Output Format - STRICTLY FOLLOW THIS:
-
-===SCOPED_PROMPT_START===
-[Your composed scoped prompt - include task goal, relevant code snippets, prior decisions, design guidelines]
-===SCOPED_PROMPT_END===
-
-===CONTEXT_USED_START===
-[List of context documents you used - file paths and brief descriptions]
-===CONTEXT_USED_END===`;
+function buildExecutePrompt(taskNumber, taskDescription) {
+  return `CLERK - EXECUTE TASK
+TASK NUMBER: ${taskNumber}
+TASK: ${taskDescription}
+
+INSTRUCTIONS:
+
+1. RESEARCH
+   Use the Research skill with the given task to gather potentially relevant context.
+
+2. COMPOSE SCOPED PROMPT
+   Combine into a scoped prompt:
+   - Task goal (what Senior Dev must accomplish)
+   - Relevant code snippets from research (3-10, include file paths)
+   - Prior decisions from wiki logs
+   - Design guidelines (language/framework conventions, patterns)
+   Balance: enough to be useful, not overwhelming. Target ~800 words max.
+
+3. APPLY FRAMING
+   - Prefer "what data goes in and what comes out" framing when it makes the goal clearer
+   - If task has purity tag ([pure], [shell], [mixed]):
+     - [pure]: Frame as data transformation, specify input/output types, emphasize no IO/side effects
+     - [shell]: Clarify IO boundary, what external system involved
+     - [mixed]: Note where logic/IO boundary falls
+   - Don't force functional style if task is naturally imperative
+
+4. CREATE TASK LOG
+   Write initial entry to \`Manifold/tasks/<slug>-<task-number>.md\` (e.g., auth-fix-001.md):
+   - Header: Date, Status=IN_PROGRESS, Task Description
+   - Include the scoped prompt you composed
+   - List context documents used (files, wiki logs, graphs)
+
+5. CALL SENIOR-DEV
+   Call @senior-dev with the finalized scoped prompt. Wait for response.
+
+6. REPORT OUTCOME
+   When senior-dev returns, determine if it reported "task complete" or "task failure".
+   Call dispatchTask() again (no arguments needed - the tool will ask for the result next).
+
+CONSTRAINTS:
+- Do not make autonomous decisions about the task lifecycle.
+- Wait for the dispatcher's next instruction after senior-dev completes.`;
 }
-function buildScopedPrompt(researchSummary, args) {
-  return `You are the Senior Developer. Implement this task.
-
-Task: ${args.description}
-
-Research Context:
-${researchSummary}
-
-Implement the task following the requirements and patterns from the research context.`;
-}
-function buildReviewPrompt(implementation, args) {
-  return `You are the Junior Developer reviewing the Senior Developer's implementation.
-
-Task: ${args.description}
-
-Senior Developer's Implementation:
-${implementation}
-
-Review the implementation against the task requirements. Your response MUST begin with exactly "COMPLETE" or "QUESTIONS" as the first word.
-
-If COMPLETE: Briefly explain why the implementation is acceptable.
-If QUESTIONS: List specific issues blocking approval with actionable feedback.`;
-}
-function buildReImplementPrompt(state, args) {
-  return `You are the Senior Developer. Re-implement this task addressing the Junior Developer's feedback.
-
-Task: ${args.description}
-
-Original Scoped Prompt:
-${state.researchSummary}
-
-Junior Developer's Feedback:
-${state.reviewFeedback}
-
-Address these issues and resubmit your implementation.`;
-}
-function buildDebugPrompt(state, args) {
-  return `You are the Debug Agent. The Senior/Junior loop has failed ${state.loops} times.
-
-Task: ${args.description}
-
-Research Context:
-${state.researchSummary}
-
-Failed Implementation:
-${state.implementationOutput}
-
-Junior Developer's Feedback:
-${state.reviewFeedback}
-
-Analyze why the loop is stuck and suggest a concrete alternative approach.`;
-}
-function buildDebugImplementPrompt(state, args) {
-  return `You are the Senior Developer. Implement the Debug Agent's suggestion.
-
-Task: ${args.description}
-
-Debug Agent's Analysis:
-${state.debugAnalysis}
-
-Implement the task following the Debug agent's suggestion.`;
+function buildOutcomeCheckPrompt() {
+  return `CLERK - OUTCOME CHECK
+INSTRUCTIONS:
+1. Based on the senior-dev's response you just received, determine the outcome:
+   - If senior-dev said "task complete" (or similar), pass \`success: true\` on your next dispatchTask call
+   - If senior-dev said "task failure" (or similar), pass \`success: false\` on your next dispatchTask call
+
+NEXT CALL:
+Call dispatchTask({ success: true }) or dispatchTask({ success: false }) based on the outcome.`;
 }
-function buildReResearchPrompt(state, args) {
-  return `You are the Clerk. The previous implementation attempt failed. Re-research with failure context.
-
-Original Task: ${args.description}
-
-Previous Implementation (failed):
-${state.implementationOutput}
-
-Junior Developer's Feedback:
-${state.reviewFeedback}
-
-Debug Agent's Suggestion (also didn't work):
-${state.debugAnalysis}
-
-Re-research the task with this failure context and compose a new scoped prompt that addresses the underlying issues.`;
-}
-function buildLoggingPrompt(state, args) {
+function buildLoggingPrompt(state, taskDescription) {
   const taskId = `${state.slug}-${state.task_number.toString().padStart(3, "0")}`;
   const date = new Date().toISOString().split("T")[0];
-  return `You are the Clerk. Log the completed task to the project wiki.
-
-Task ID: ${taskId}
-Task Description: ${args.description}
-Date: ${date}
-Status: COMPLETED
-Loops: ${state.loops}
-
-Scoped Prompt Used:
-${state.researchSummary}
-
-Senior Developer's Final Implementation:
-${state.implementationOutput}
-
-Junior Developer's Approval Response:
-${state.reviewFeedback}
-
-Please perform the following logging actions:
-
-1. Create/Update Task File at \`Manifold/tasks/${taskId}.md\`:
-   - Header with date, status, loops, task description
-   - Scoped Prompt section
-   - Design Decisions section (extract from Senior's implementation reasoning)
-   - Files Touched section (extract file paths from Senior's implementation)
-   - Complete Loop History section
-
-2. Update \`Manifold/index.md\`:
-   - Add entry under the plan's section:
-   \`- [[${taskId}]] — ${args.description} | ${date} | COMPLETED\`
+  return `CLERK - LOGGING PHASE
+TASK: ${taskDescription}
+TASK ID: ${taskId}
+
+INSTRUCTIONS:
+1. Update task log at \`Manifold/tasks/${taskId}.md\`:
+   - Change Status from IN_PROGRESS to COMPLETED (or FAILED if applicable)
+   - Add senior-dev's final implementation summary
+   - Document what was done and files changed
+   - If failed: document what was tried and why it failed
+
+2. Update index at \`Manifold/index.md\`:
+   - Add: \`- [[${taskId}]] — ${taskDescription} | ${date} | COMPLETED\`
+
+3. Append to log at \`Manifold/log.md\`:
+   - Add: \`## [${date}] ${taskId} | ${taskDescription} | COMPLETED\`
+
+4. Update graph files for touched files:
+   - For each file touched, update/add \`Manifold/graph/<graph-name>.md\`
+   - Add task ID to "Tasks That Edited" section
+   - Replace \`/\` with \`__SL__\` and \`.\` with \`__DT__\` in filenames
+   - Example: \`src/middleware/auth.ts\` → \`Manifold/graph/src__SL__middleware__SL__auth__DT__ts.md\`
+
+AFTER COMPLETING LOGGING:
+Call dispatchTask() with no arguments. The dispatcher will complete the task and reset state.`;
+}
+function buildRePromptPrompt(state, taskDescription) {
+  const attemptNumber = state.clerk_retries + 1;
+  return `CLERK - RECOVERY ATTEMPT ${attemptNumber}
+TASK: ${taskDescription}
+PREVIOUS ATTEMPT FAILED
+
+INSTRUCTIONS:
+1. Call @senior-dev again with the same task description
+2. Include context from the previous failure:
+   - The previous implementation was not accepted
+   - Senior-dev should try a different approach
+3. Senior-dev will again manage the review loop internally
+
+NEXT:
+After senior-dev completes, call dispatchTask() again to report outcome.`;
+}
+function buildEscalationPrompt(state, taskDescription) {
+  return `CLERK - ESCALATION
+TASK: ${taskDescription}
 
-3. Append to \`Manifold/log.md\`:
-   \`## [${date}] ${taskId} | ${args.description} | COMPLETED | ${state.loops} loops\`
+The task has failed after ${state.clerk_retries} recovery attempts.
 
-4. Update graph files for each touched file:
-   - Read the implementation and identify all files that were created or modified
-   - For each file, create or update \`Manifold/graph/<graph-name>.md\`
-   - Add the task ID to the "Tasks That Edited" section
-   - Do NOT populate "Calls" or "Depends On" sections — those are synced automatically from the codebase index
-   - Graph filename format: replace \`/\` with \`__SL__\` and \`.\` with \`__DT__\`, append \`.md\`
-   - Example: \`src/middleware/auth.ts\` → \`src__SL__middleware__SL__auth__DT__ts.md\`
+INSTRUCTIONS:
+1. Log the failure to \`Manifold/tasks/<task-id>.md\` with status=FAILED
+2. Report to the user:
+   - Task description: ${taskDescription}
+   - Status: FAILED
+   - Attempts made: ${state.clerk_retries}
+   - Summary of what was tried and why it failed
 
-Extract the list of files touched from the Senior's implementation and include it in your response.`;
+This task cannot be completed automatically. Human intervention required.`;
 }
 function getClient() {
   if (!pluginClient) {
@@ -664,44 +528,38 @@ function getClient() {
   return pluginClient;
 }
 var dispatchTaskTool = tool({
-  description: "Dispatcher for the multi-agent development system. Returns routing instructions based on bool state. Clerk calls this to determine the next step in the task workflow.",
+  description: "Dispatcher for the multi-agent development system. Returns routing instructions based on task state. Clerk calls this with no arguments to get next prompt.",
   args: {
-    task_number: tool.schema.number().optional().describe("Sequential task number (required on first call)"),
-    plan_file: tool.schema.string().optional().describe("Path to the plan document (required on first call)"),
-    newTask: tool.schema.boolean().optional().describe("TRUE: First call for this task. Resets all state."),
-    researchComplete: tool.schema.boolean().optional().describe("TRUE: Clerk has finished researching the codebase"),
-    hasImplementation: tool.schema.boolean().optional().describe("TRUE: Senior-dev returned working code"),
-    reviewDone: tool.schema.boolean().optional().describe("TRUE: Junior-dev has responded (regardless of pass/fail)"),
-    reviewPassed: tool.schema.boolean().optional().describe("TRUE: Junior-dev responded with COMPLETE"),
-    needsDecomposition: tool.schema.boolean().optional().describe("TRUE: Task requires project-wide decomposition"),
-    debugComplete: tool.schema.boolean().optional().describe("TRUE: Debug agent has finished analyzing"),
-    reResearched: tool.schema.boolean().optional().describe("TRUE: Clerk has re-researched with failure context"),
-    researchSummary: tool.schema.string().optional().describe("Clerk's research findings"),
-    implementationOutput: tool.schema.string().optional().describe("Senior-dev's full output"),
-    reviewFeedback: tool.schema.string().optional().describe("Junior-dev's full response"),
-    debugAnalysis: tool.schema.string().optional().describe("Debug agent's full analysis"),
-    notes: tool.schema.string().optional().describe("Optional free-text reasoning")
+    task_number: tool.schema.number().optional().describe("Task number"),
+    plan_file: tool.schema.string().optional().describe("Path to plan document"),
+    description: tool.schema.string().optional().describe("Task description"),
+    success: tool.schema.boolean().optional().describe("TRUE if senior-dev completed task successfully, FALSE if failed"),
+    senior_output: tool.schema.string().optional().describe("Senior dev's output/summary"),
+    clerk_summary: tool.schema.string().optional().describe("Clerk's summary of the task")
   },
   async execute(args, context) {
-    const { task_number, plan_file } = args;
+    const { task_number, plan_file, description } = args;
     const client = getClient();
     const directory = context.directory;
     await client.app.log({
       body: {
         service: "opencode-manifold",
         level: "info",
-        message: `dispatchTask called: task ${task_number || "unknown"} - ${args.newTask ? "new task" : "continuing"}`
+        message: `dispatchTask called: task ${task_number || "unknown"}`
       }
     });
     const settings = await readSettings(directory);
     const existingState = task_number ? await readDispatcherState(directory, task_number) : null;
-    let taskInfo = null;
-    if (args.newTask && plan_file) {
+    let taskDescription = description || "";
+    if (!taskDescription && args.plan_file && task_number) {
       try {
-        const planPath = join2(directory, plan_file);
+        const planPath = join2(directory, args.plan_file);
         if (existsSync2(planPath)) {
           const planContent = await readFile2(planPath, "utf-8");
-          taskInfo = extractTaskFromPlan(planContent, task_number);
+          const taskInfo = extractTaskFromPlan(planContent, task_number);
+          if (taskInfo) {
+            taskDescription = taskInfo.description;
+          }
         }
       } catch (error) {
         await client.app.log({
@@ -713,24 +571,46 @@ var dispatchTaskTool = tool({
         });
       }
     }
-    const mergedArgs = {
-      ...args,
-      description: taskInfo?.description || args.description
-    };
-    const result = runDispatcherLogic(mergedArgs, existingState, settings);
+    const result = runDispatcherLogic(args, existingState, settings, taskDescription);
+    let newPhase = "init";
+    if (result.route === "execute")
+      newPhase = "awaiting_execution";
+    else if (result.route === "outcome_check")
+      newPhase = "awaiting_outcome";
+    else if (result.route === "logging")
+      newPhase = "logging";
+    else if (result.route === "complete")
+      newPhase = "complete";
+    else if (result.route === "escalate")
+      newPhase = "escalated";
+    else if (result.route === "reprompt")
+      newPhase = "awaiting_execution";
     if (task_number && result.state.task_id) {
-      const newState = {
-        task_number,
-        plan_file: plan_file || "",
-        slug: result.state.task_id.split("-")[0],
-        loops: result.state.loops,
-        clerkRetries: result.state.clerkRetries,
-        researchSummary: args.researchSummary || existingState?.researchSummary || "",
-        implementationOutput: args.implementationOutput || existingState?.implementationOutput || "",
-        reviewFeedback: args.reviewFeedback || existingState?.reviewFeedback || "",
-        debugAnalysis: args.debugAnalysis || existingState?.debugAnalysis || ""
-      };
-      await writeDispatcherState(directory, newState);
+      if (result.route === "logging" || result.route === "escalate") {
+        const newState = {
+          task_number,
+          plan_file: plan_file || "",
+          slug: result.state.task_id.split("-")[0],
+          phase: newPhase,
+          senior_output: args.senior_output || existingState?.senior_output || "",
+          clerk_summary: args.clerk_summary || existingState?.clerk_summary || "",
+          loops: existingState?.loops || 0,
+          clerk_retries: existingState?.clerk_retries || 0
+        };
+        await writeDispatcherState(directory, newState);
+      } else {
+        const newState = {
+          task_number,
+          plan_file: plan_file || "",
+          slug: result.state.task_id.split("-")[0],
+          phase: newPhase,
+          senior_output: args.senior_output || existingState?.senior_output || "",
+          clerk_summary: args.clerk_summary || existingState?.clerk_summary || "",
+          loops: existingState?.loops || 0,
+          clerk_retries: existingState?.clerk_retries || 0
+        };
+        await writeDispatcherState(directory, newState);
+      }
     }
     await client.app.log({
       body: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-manifold",
-  "version": "0.5.6",
+  "version": "0.5.8",
   "description": "Multi-agent development system for opencode with persistent knowledge",
   "main": "dist/index.js",
   "type": "module",