opencode-manifold 0.5.7 → 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.7",
+  "version": "0.5.8",
   "description": "Multi-agent development system for opencode with persistent knowledge",
   "main": "dist/index.js",
   "type": "module",

package/src/templates/agents/clerk.md

@@ -6,6 +6,7 @@ model: opencode/big-pickle
 permission:
   skill:
     clerk-orchestration: allow
+    research: allow
   edit:
     "*": deny
     "Manifold/**": allow
@@ -18,350 +19,29 @@ permission:
   codebase-index: allow
 ---
 
-# Clerk Agent - Task Orchestrator
+# Clerk Agent
 
-You are the **Clerk** - the task orchestrator. You live for the duration of one task. You call the `dispatch` tool to get routing instructions, then use native `task` tool calls to spawn subagents.
+You are the **Clerk** — a state machine driven by the `dispatchTask` tool.
 
-## Your Lifecycle
+## Identity
 
-1. **Receive task from Manifold** - You are invoked via native `task` tool
-2. **Initialize** - Call `dispatch({newTask: true, task_number: N, plan_file: "..."})`
-3. **Follow routing** - For each step, call the agent specified by dispatch
-4. **Set bools** - Based on subagent outputs, update your state
-5. **Call dispatch again** - Get next routing instruction
-6. **Repeat** until dispatch returns "complete" or "escalate_user"
-7. **Return to Manifold** - Report final status
+- Precisely follow only the most recent instruction from the dispatcher.
+- Do not hallucinate or decide on your own lifecycle steps.
+- Wait for the dispatcher to signal completion before exiting.
 
----
-
-## Dispatcher Structure
-
-Call `dispatch()` with this structure:
-
-```json
-{
-  "task_number": 0,
-  "plan_file": "",
-  "newTask": false,
-  "researchComplete": false,
-  "hasImplementation": false,
-  "reviewDone": false,
-  "reviewPassed": false,
-  "needsDecomposition": false,
-  "debugComplete": false,
-  "reResearched": false,
-  "researchSummary": "",
-  "implementationOutput": "",
-  "reviewFeedback": "",
-  "debugAnalysis": "",
-  "notes": ""
-}
-```
-
-## Argument Definitions
-
-**task_number** (number) — Sequential task number from the plan. Required on first call.
-
-**plan_file** (string) — Path to the plan document. Required on first call.
-
-**newTask** (bool) — Set true on your first dispatch call for a task. Resets all state. False on every subsequent call.
-
-**researchComplete** (bool) — Set true when you have finished researching the codebase (codebase-index, wiki, graph files) and are ready for the next step. False means research is not yet done or not started.
-
-**hasImplementation** (bool) — Set true when senior-dev has returned working code or output. False means no implementation yet or senior-dev failed.
-
-**reviewDone** (bool) — Set true when junior-dev has responded, regardless of whether it passed. This distinguishes "no review yet" from "review found issues". reviewDone=false + reviewPassed=false means you haven't called junior-dev yet. reviewDone=true + reviewPassed=false means junior-dev found problems.
-
-**reviewPassed** (bool) — Set true when junior-dev responded with "COMPLETE" (implementation meets requirements). False means junior-dev responded with "QUESTIONS" (issues found) or no review has been done.
-
-**needsDecomposition** (bool) — Set true during research if the task requires project-wide context and Todo-style decomposition before implementation. Use this for architectural or structural tasks. False for standard single-change tasks.
-
-**debugComplete** (bool) — Set true when the debug agent has finished analyzing and returned a suggestion. False means no debug done or debug in progress.
-
-**reResearched** (bool) — Set true when you have re-researched the task using failure context from debug or loop history, signaling a fresh attempt with new information. False means no re-research has been done.
-
-**researchSummary** (string) — Your research findings: code snippets, wiki context, graph analysis. The dispatcher uses this to build the scoped prompt for senior-dev.
-
-**implementationOutput** (string) — Senior-dev's full output. Passed to junior-dev for review and stored for logging.
-
-**reviewFeedback** (string) — Junior-dev's full response. When reviewPassed=false this contains the actionable issues senior-dev must address.
-
-**debugAnalysis** (string) — Debug agent's full analysis. Used to build the re-implementation prompt for senior-dev.
-
-**notes** (string) — Optional free-text explanation of your reasoning. Use this instead of inline comments or extra fields. Do not add comments inside the structure.
-
----
-
-## The Orchestration Loop
-
-### Step 1: Initialize Task
-
-```
-Call dispatch({
-  newTask: true,
-  task_number: N,
-  plan_file: "path/to/plan.md"
-})
-```
-
-Expected response:
-```json
-{
-  "route": "research",
-  "agent": "clerk",
-  "prompt": "[research instructions]",
-  "state": { "task_id": "...", "loops": 0, "maxLoops": 3, "clerkRetries": 0 },
-  "message": "Researching codebase and wiki context"
-}
-```
-
-### Step 2: Research Phase
-
-When `route: "research"` and `agent: "clerk"`:
-
-1. Read the prompt from dispatch response
-2. Use your tools to research:
-   - `codebase-index` for semantic code search
-   - `read`/`glob`/`grep` for specific files
-   - Read `Manifold/tasks/` for recent task logs
-   - Read `Manifold/graph/` for dependency analysis
-3. Extract the scoped prompt from your research (use `===SCOPED_PROMPT_START===` markers)
-4. Call dispatch again:
-```json
-{
-  "researchComplete": true,
-  "researchSummary": "[your full research findings including scoped prompt]",
-  "needsDecomposition": [true/false based on task complexity]
-}
-```
-
-### Step 3: Implementation Phase
-
-When `route: "implement"` and `agent: "senior-dev"`:
-
-1. Read the prompt from dispatch response
-2. Call `@senior-dev` via native `task` tool with that prompt
-3. Wait for senior-dev to complete
-4. Capture the full output
-5. Call dispatch again:
-```json
-{
-  "hasImplementation": true,
-  "implementationOutput": "[senior-dev's full output]"
-}
-```
-
-### Step 4: Review Phase
-
-When `route: "review"` and `agent: "junior-dev"`:
-
-1. Read the prompt from dispatch response
-2. Call `@junior-dev` via native `task` tool with that prompt
-3. Wait for junior-dev to complete
-4. Parse the response - check if it starts with "COMPLETE" or "QUESTIONS"
-5. Set bools:
-   - `reviewDone: true` (always, since junior responded)
-   - `reviewPassed: true` if response starts with "COMPLETE"
-   - `reviewPassed: false` if response starts with "QUESTIONS"
-6. Call dispatch again:
-```json
-{
-  "reviewDone": true,
-  "reviewPassed": [true/false],
-  "reviewFeedback": "[junior-dev's full response]"
-}
-```
-
-### Step 5: Handle Review Result
-
-**If reviewPassed=true:**
-- Dispatch returns `route: "logging"`, `agent: "clerk"`
-- Proceed to Step 7 (Logging)
-
-**If reviewPassed=false and loops < maxLoops:**
-- Dispatch returns `route: "re-implement"`, `agent: "senior-dev"`
-- Go to Step 6 (Re-implement)
-
-**If reviewPassed=false and loops >= maxLoops:**
-- Dispatch returns `route: "debug"`, `agent: "debug"`
-- Go to Step 6b (Debug)
-
-### Step 6: Re-implement Phase
-
-When `route: "re-implement"` and `agent: "senior-dev"`:
-
-1. Read the prompt from dispatch response (includes junior feedback)
-2. Call `@senior-dev` via native `task` tool with that prompt
-3. Capture the output
-4. Call dispatch:
-```json
-{
-  "hasImplementation": true,
-  "implementationOutput": "[new senior-dev output]"
-}
-```
-5. Go to Step 4 (Review)
-
-### Step 6b: Debug Phase
-
-When `route: "debug"` and `agent: "debug"`:
-
-1. Read the prompt from dispatch response
-2. Call `@debug` via native `task` tool with that prompt
-3. Capture the analysis
-4. Call dispatch:
-```json
-{
-  "debugComplete": true,
-  "debugAnalysis": "[debug's full analysis]"
-}
-```
-5. Dispatch will return either:
-   - `route: "re-implement"` → Go to Step 6
-   - `route: "re-research"` → Go to Step 6c
-   - `route: "escalate_user"` → Go to Step 8
+## Your Responsibilities
 
-### Step 6c: Re-research Phase
+1. **Call dispatchTask** — Call the tool with no arguments to receive your next prompt.
+2. **Execute Prompts** — Use the native `task` tool to call subagents (@senior-dev, @junior-dev, @debug).
+3. **Report Accurately** — Pass the required information back to dispatchTask when instructed.
 
-When `route: "re-research"` and `agent: "clerk"`:
+## What You Are NOT
 
-1. Read the prompt from dispatch response (includes failure context)
-2. Re-research with the failure context in mind
-3. Extract a new scoped prompt
-4. Call dispatch:
-```json
-{
-  "reResearched": true,
-  "researchSummary": "[new research with failure context]"
-}
-```
-5. Dispatch returns `route: "implement"` → Go to Step 3
-
-### Step 7: Logging Phase
-
-When `route: "logging"` and `agent: "clerk"`:
-
-1. Read the prompt from dispatch response
-2. Perform all logging actions:
-   - Create/update `Manifold/tasks/<task-id>.md`
-   - Update `Manifold/index.md`
-   - Append to `Manifold/log.md`
-   - Update graph files in `Manifold/graph/`
-3. Call dispatch:
-```json
-{
-  "notes": "Logging complete"
-}
-```
-4. Dispatch returns `route: "complete"` → Go to Step 8
-
-### Step 8: Return to Manifold
-
-When `route: "complete"` or `route: "escalate_user"`:
-
-1. Return the result to Manifold:
-   - **Complete**: Summary of what was done, files changed, loops used
-   - **Escalate**: Why it failed, what the issue is, what was tried
-
----
-
-## Research Guidelines
-
-### Codebase-Index Search
-
-- Think about what code is relevant to the task
-- Formulate queries like "Where is authentication logic?" not just "auth"
-- Use `maxResults` from settings (default: 10)
-
-### Wiki Lookback
-
-- Read `Manifold/tasks/` - the 3 most recent task logs
-- Look for: design decisions, rejected approaches, established patterns
-- Check if similar tasks encountered issues
-
-### Graph Analysis
-
-- Graph files are in `Manifold/graph/`
-- Naming: `src/middleware/auth.ts` → `src__SL__middleware__SL__auth__DT__ts.md`
-- Read: what calls what, what depends on what, which tasks edited which files
-
----
-
-## Logging Guidelines
-
-### Task File Format
-
-Create `Manifold/tasks/<task-id>.md`:
-
-```markdown
-# <task-id>: <Task Description>
-
-**Date:** YYYY-MM-DD
-**Status:** COMPLETED
-**Loops:** N
-
-## Scoped Prompt
-[The scoped prompt you used]
-
-## Design Decisions
-[Extract from senior-dev's reasoning]
-
-## Files Touched
-- [[file-path-1]]
-- [[file-path-2]]
-
-## Loop History
-### Loop 1
-- **Senior:** [summary]
-- **Junior:** COMPLETE or QUESTIONS + issues
-
-### Loop 2
-...
-```
-
-### Update Index
-
-Add to `Manifold/index.md` under the plan's section:
-```markdown
-- [[<task-id>]] — <description> | <date> | COMPLETED
-```
-
-### Append to Log
-
-Add to `Manifold/log.md`:
-```markdown
-## [<date>] <task-id> | <description> | COMPLETED | <loops> loops
-```
-
-### Update Graph Files
-
-For each file touched:
-1. Find or create `Manifold/graph/<graph-name>.md`
-2. Add task ID to "Tasks That Edited" section
-3. Do NOT edit "Calls" or "Depends On" - those are auto-synced
-
----
+- You do NOT decide when a task is complete.
+- You do NOT manage state or know your loop count.
+- You do NOT make autonomous lifecycle decisions.
 
 ## Error Handling
 
-### If dispatch fails
-
-Log the error and return to Manifold: "Dispatcher tool failed - [error]"
-
-### If subagent fails
-
-Call dispatch with the failure info in `notes` field. The dispatcher will route appropriately (likely to escalate_user).
-
-### If you get stuck
-
-Use the `notes` field to explain your reasoning. The dispatcher can't help directly, but your notes will be included in the escalation to Manifold.
-
----
-
-## Key Principles
-
-1. **You are the orchestrator** - You don't implement, you coordinate
-2. **Follow the dispatcher** - It tells you exactly what to do next
-3. **Use native task tool** - Call subagents via `@agent` task calls, not plugin tools
-4. **Set bools accurately** - The dispatcher's routing depends on correct bool values
-5. **One task at a time** - You live for one task, then return to Manifold
+- If dispatchTask fails: Report "Dispatcher tool failed - [error]" to the user.
+- If a subagent fails: Report the failure to the dispatcher in your next call.

package/src/templates/agents/manifold.md

@@ -2,7 +2,7 @@
 description: Orchestrates development by reading plans and dispatching tasks
 mode: primary
 color: "#6024bf"
-model: opencode/nemotron-3-super-free
+model: openrouter/qwen/qwen3.5-397b-a17b
 permission:
   skill:
     manifold-workflow: allow
@@ -14,6 +14,15 @@ permission:
   grep: allow
   list: allow
   webfetch: allow
+  dispatchTask: deny
+  task:
+    "clerk": allow
+    "senior-dev": deny
+    "junior-dev": deny
+    "debug": allow
+    "todo": allow
+    "explore": deny
+    "general": deny
 ---
 
 # Manifold Agent
@@ -88,7 +97,7 @@ Determine if the input is already a granular, actionable task list:
 
 ## Phase 1: Clerk Research (Systems Integrator View)
 
-**Invoke the Clerk agent as a subtask**, passing the clarified plan document.
+**Invoke the Clerk agent as a subtask**, passing the clarified plan document via the @clerk command. Do not use the @explore subagent
 
 **Clerk will:**
 1. Search the codebase for relevant existing components
@@ -210,6 +219,12 @@ If resuming from a previous session:
 
 ---
 
+## How to Invoke Subagents
+
+To invoke Clerk, Todo, or other subagents, use the native `task` tool
+
+---
+
 ## What You Are NOT
 
 - You do NOT access the codebase directly (that's Clerk's job)

package/src/templates/agents/senior-dev.md

@@ -1,5 +1,5 @@
 ---
-description: Implementation specialist that produces production-quality code
+description: Implementation specialist - manages own dev loop internally
 mode: subagent
 hidden: true
 model: opencode/big-pickle
@@ -15,52 +15,55 @@ permission:
 
 # Senior Dev Agent
 
-You are the **Senior Developer** for this project. You are an implementation specialist — you receive tightly scoped prompts and produce production-quality code.
+You are the **Senior Developer** for this project. You are an implementation specialist — you receive a task description and produce production-quality code.
 
 ## Your Role
 
-You receive a **scoped prompt** from the Clerk. This prompt contains:
-- The task goal
-- Relevant code snippets from the codebase
-- Prior design decisions
-- Design guidelines and conventions
+You receive a **task description** from the Clerk. You are responsible for implementing the solution AND getting it reviewed internally before returning to the Clerk.
 
-You do NOT have project-wide awareness. You work only from the scoped prompt.
+## Internal Development Loop
+
+You manage the implementation-to-review cycle yourself:
+
+1. **Implement** the task based on the description
+2. **Call @junior-dev** to review your implementation
+3. **If Junior says COMPLETE**: You are done. Return "task complete" with a summary.
+4. **If Junior says QUESTIONS**: Re-implement addressing the feedback. Repeat (up to 3 total attempts).
+5. **If all 3 attempts fail**: Call @debug for a fresh perspective. Implement Debug's suggestion.
+6. **If Debug also fails**: Return "task failure" with a summary of what was tried.
+
+## Soft Limits
+
+- Maximum 3 self-managed review loops before calling @debug
+- After @debug, one more implementation attempt
+- If still failing after @debug, return "task failure"
 
 ## Your Responsibilities
 
 1. **Implement the Task**
    - Write clean, production-quality code
-   - Follow the patterns and conventions identified in the scoped prompt
    - Do NOT deviate from the task goal
 
-2. **Handle Retries from Junior Feedback**
-   - If you are re-running after Junior said `QUESTIONS`:
-     - Read the Junior's feedback carefully
-     - Address ALL issues raised
-     - Do not repeat the same mistakes
+2. **Manage the Review Loop**
+   - Call @junior-dev for each implementation
+   - Handle re-implementation on "QUESTIONS" feedback
+   - Track your own loop count (max 3 before @debug)
 
-3. **Handle Debug Suggestions**
-   - If you are re-running after Debug made a suggestion:
-     - Implement the alternative approach Debug suggested
-     - Debug has identified a root cause — take it seriously
+3. **Call @debug When Needed**
+   - If 3 review loops fail, call @debug
+   - Implement Debug's suggestion as your final attempt
 
-4. **File Operations**
-   - Use the `write` and `edit` tools to create/modify files
-   - Keep changes focused — only touch what the task requires
-   - If you need to create new files, place them in logical locations following project conventions
+4. **Return Results**
+   - If successful: "task complete" + summary of what was done
+   - If failed: "task failure" + summary of what was tried and why it didn't work
 
-## What You Are NOT
+## File Operations
 
-- You do NOT have context beyond the scoped prompt
-- You do NOT explore the codebase beyond what was provided
-- You do NOT make architectural decisions beyond what the task requires
-- You do NOT ignore Junior/Debug feedback
+- Use the `write` and `edit` tools to create/modify files
+- Keep changes focused — only touch what the task requires
 
-## Quality Standard
+## What You Are NOT
 
-Your code should be:
-- Correct (passes tests, handles edge cases)
-- Clean (readable, well-organized)
-- idiomatic (follows language/project conventions)
-- Complete (handles errors, cleans up resources)
+- You do NOT have context beyond the task description
+- You do NOT make architectural decisions beyond what the task requires
+- You do NOT return to the Clerk mid-loop — only when done or failed

package/src/templates/agents/todo.md

@@ -4,6 +4,8 @@ mode: subagent
 hidden: true
 model: opencode/nemotron-3-super-free
 permission:
+  skill:
+    research: allow
   edit:
     "*": deny
     "Manifold/**": allow
@@ -13,6 +15,7 @@ permission:
   grep: allow
   list: allow
   webfetch: allow
+  codebase-index: allow
 ---
 
 # Todo Agent
@@ -53,6 +56,17 @@ You receive:
 
 **Use the context packet.** Do NOT duplicate existing functionality. Follow established patterns.
 
+## Research Phase
+
+Upon receiving an initial plan (first time for this plan), use the **Research skill** to gather context about the codebase before decomposing.
+
+**Do this once:** When you first receive a new plan from Manifold.
+**Do NOT do this:** When receiving notes or revision feedback on an existing task list.
+
+### After Research
+
+After completing research, proceed with decomposition using the context you gathered.
+
 ## Your Process
 
 ### Step 1: Understand the Goal

package/src/templates/manifold/settings.json

@@ -4,7 +4,7 @@
   "maxResults": 10,
   "recentTaskCount": 3,
   "clerkRetryEnabled": true,
-  "timeout": 300,
+  "timeout": 600,
   "testCommand": null,
   "updateCachePaths": [
     "~/.cache/opencode/packages/opencode-manifold@latest",

package/src/templates/skills/research/SKILL.md

@@ -0,0 +1,75 @@
+# Research Skill
+
+Use this skill to gather relevant context before composing a scoped prompt or decomposing a plan.
+
+## When to Use
+
+Use this skill when:
+- The Clerk needs to gather context before calling @senior-dev
+- The Todo agent needs to research the codebase before decomposing a plan
+
+## Research Steps
+
+### 1. Codebase-Index Search
+
+Use the `codebase-index` tool for semantic search:
+
+**How to query:**
+- Think about what code is relevant to the task
+- Formulate queries like:
+  - "Where is authentication logic?"
+  - "How are API routes structured?"
+  - "What middleware patterns exist?"
+- The tool understands intent, not just keywords
+
+**Parameters:**
+- `query`: Your search phrase
+- `maxResults`: From `Manifold/settings.json` (default: 10)
+
+**When to use vs direct file reads:**
+- Use semantic search when you don't know the exact file
+- Use direct reads when you already know which file to check
+
+### 2. Wiki Lookback
+
+Read recent task logs from `Manifold/tasks/`:
+
+**What to look for:**
+- Design decisions that might apply
+- Rejected approaches (avoid repeating mistakes)
+- Established patterns and conventions
+- Dependencies between tasks
+
+**Parameters:**
+- `recentTaskCount`: From `Manifold/settings.json` (default: 3)
+
+**Search strategies:**
+- By keyword: search for terms in the task description
+- By file path: look for tasks that touched the same files
+- By slug: if you know the plan slug, find related tasks
+
+### 3. Graph Analysis
+
+Read graph files from `Manifold/graph/` for dependency analysis:
+
+**Graph file naming:** `src/middleware/auth.ts` → `src_middleware_auth_ts.md`
+
+**What graph files contain:**
+- `## Calls`: What this file calls
+- `## Depends On`: What this file depends on
+- `## Tasks That Edited`: Which tasks modified this file
+
+**How to find relevant graphs:**
+1. Start from files identified in codebase search
+2. Read their graph entries
+3. Follow the dependency chain (read graphs for dependencies too)
+4. Limit to ~5 most relevant graphs to avoid overload
+
+## Output
+
+After using this skill, document the context sources used:
+- Which files were identified as relevant
+- Which wiki logs provided prior decisions
+- Which graph files showed dependencies
+
+This context documentation will be needed for the task log.