opencode-manifold 0.5.14 → 0.5.16

package/dist/index.js

@@ -1,3 +1,4 @@
+import { createRequire } from "node:module";
 var __defProp = Object.defineProperty;
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
@@ -13,11 +14,12 @@ var __export = (target, all) => {
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/tools/get-model-path.ts
 var exports_get_model_path = {};
 __export(exports_get_model_path, {
-  setPluginContext: () => setPluginContext2,
+  setPluginContext: () => setPluginContext,
   getModelPathTool: () => getModelPathTool,
   getModelPath: () => getModelPath
 });
@@ -71,16 +73,16 @@ async function getModelPath(client, sessionID) {
   }
   return "No active model found";
 }
-function setPluginContext2(client) {
-  pluginClient2 = client;
+function setPluginContext(client) {
+  pluginClient = client;
 }
 function getModelPathClient() {
-  if (!pluginClient2) {
+  if (!pluginClient) {
     throw new Error("Plugin client not initialized");
   }
-  return pluginClient2;
+  return pluginClient;
 }
-var pluginClient2 = null, getModelPathTool;
+var pluginClient = null, getModelPathTool;
 var init_get_model_path = __esm(() => {
   getModelPathTool = tool2({
     description: "Returns the model path (provider/model) for the currently active session. Use this to get the correct model string for agent MD file model: attributes.",
@@ -99,50 +101,23 @@ import { existsSync } from "fs";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 import { homedir } from "os";
-import { createRequire } from "module";
+import { createRequire as createRequire2 } from "module";
 var __dirname2 = dirname(fileURLToPath(import.meta.url));
-var require2 = createRequire(import.meta.url);
-var bundledTemplatesDir = join(__dirname2, "..", "src", "templates");
-var globalTemplatesDir = join(homedir(), ".config", "opencode", "manifold");
-async function getPluginVersion() {
-  try {
-    const packageJson = require2(join(__dirname2, "..", "package.json"));
-    return packageJson.version || "unknown";
-  } catch {
-    return "unknown";
+var require2 = createRequire2(import.meta.url);
+function getBundledTemplatesDir() {
+  const possiblePaths = [
+    join(__dirname2, "..", "src", "templates"),
+    join(__dirname2, "templates"),
+    join(__dirname2, "..", "templates")
+  ];
+  for (const p of possiblePaths) {
+    if (existsSync(p))
+      return p;
   }
+  return possiblePaths[0];
 }
-async function dirHasContent(dirPath) {
-  if (!existsSync(dirPath))
-    return false;
-  try {
-    const entries = await readdir(dirPath);
-    return entries.length > 0;
-  } catch {
-    return false;
-  }
-}
-async function copyMissingFiles(src, dest) {
-  if (!existsSync(src))
-    return [];
-  await mkdir(dest, { recursive: true });
-  const copied = [];
-  const entries = await readdir(src, { withFileTypes: true });
-  for (const entry of entries) {
-    const srcPath = join(src, entry.name);
-    const destPath = join(dest, entry.name);
-    if (entry.isDirectory()) {
-      const subCopied = await copyMissingFiles(srcPath, destPath);
-      if (subCopied.length > 0) {
-        copied.push(entry.name);
-      }
-    } else if (!existsSync(destPath)) {
-      await writeFile(destPath, await readFile(srcPath));
-      copied.push(entry.name);
-    }
-  }
-  return copied;
-}
+var bundledTemplatesDir = getBundledTemplatesDir();
+var globalTemplatesDir = join(homedir(), ".config", "opencode", "manifold");
 async function copyFiles(src, dest) {
   if (!existsSync(src))
     return [];
@@ -206,461 +181,349 @@ async function ensureGlobalTemplates(ctx) {
     }
   });
 }
-async function initProject(directory, client) {
-  const initialized = [];
-  await client.app.log({
-    body: {
-      service: "opencode-manifold",
-      level: "info",
-      message: `Running /manifold-init in ${directory}`
+
+// src/tools/execute-task.ts
+import { tool } from "@opencode-ai/plugin";
+import { z } from "zod";
+
+// src/lib/agent-invoker.ts
+async function invokeAgent(client, options) {
+  const {
+    agent,
+    prompt,
+    model,
+    tools,
+    system,
+    maxPollAttempts = 300,
+    pollIntervalMs = 1000
+  } = options;
+  let sessionID;
+  try {
+    const createRes = await client.session.create({
+      body: { title: `manifold-${agent}` }
+    });
+    if (createRes.error || !createRes.data) {
+      throw new Error(`Failed to create session: ${JSON.stringify(createRes.error)}`);
     }
-  });
-  if (!await dirHasContent(globalTemplatesDir)) {
+    sessionID = createRes.data.id;
+    await client.app.log({
+      body: {
+        service: "opencode-manifold",
+        level: "info",
+        message: `Invoking agent "${agent}" in session ${sessionID}`
+      }
+    });
+    const promptBody = {
+      agent,
+      parts: [{ type: "text", text: prompt }]
+    };
+    if (model)
+      promptBody.model = model;
+    if (tools)
+      promptBody.tools = tools;
+    if (system)
+      promptBody.system = system;
+    const promptRes = await client.session.promptAsync({
+      path: { id: sessionID },
+      body: promptBody
+    });
+    if (promptRes.error) {
+      throw new Error(`Failed to send prompt: ${JSON.stringify(promptRes.error)}`);
+    }
+    const text = await pollForResponse(client, sessionID, maxPollAttempts, pollIntervalMs);
+    await client.app.log({
+      body: {
+        service: "opencode-manifold",
+        level: "info",
+        message: `Agent "${agent}" completed in session ${sessionID}`
+      }
+    });
+    return { success: true, text, sessionID };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
     await client.app.log({
       body: {
         service: "opencode-manifold",
         level: "error",
-        message: `Global templates not found at ${globalTemplatesDir}. Plugin may not have loaded correctly.`
+        message: `Agent "${agent}" failed: ${message}`
       }
     });
-    return initialized;
-  }
-  const agentsCopied = await copyMissingFiles(join(globalTemplatesDir, "agents"), join(directory, ".opencode", "agents"));
-  if (agentsCopied.length > 0) {
-    initialized.push(`agents (${agentsCopied.join(", ")})`);
-  }
-  const skillsCopied = await copyMissingFiles(join(globalTemplatesDir, "skills"), join(directory, ".opencode", "skills"));
-  if (skillsCopied.length > 0) {
-    initialized.push(`skills (${skillsCopied.join(", ")})`);
-  }
-  const manifoldCopied = await copyMissingFiles(join(globalTemplatesDir, "manifold"), join(directory, "Manifold"));
-  if (manifoldCopied.length > 0) {
-    initialized.push(`Manifold/ (${manifoldCopied.join(", ")})`);
-  }
-  const projectCommandsDir = join(directory, ".opencode", "commands");
-  const commandsToCopy = [];
-  const commandsInitialized = [];
-  for (const cmd of commandsToCopy) {
-    const src = join(globalTemplatesDir, "commands", cmd);
-    const dest = join(projectCommandsDir, cmd);
-    if (existsSync(src) && !existsSync(dest)) {
-      await copyFile(src, dest);
-      commandsInitialized.push(cmd);
+    return { success: false, text: "", sessionID: sessionID || "", error: message };
+  } finally {
+    if (sessionID) {
+      try {
+        await client.session.delete({ path: { id: sessionID } });
+      } catch {}
     }
   }
-  if (commandsInitialized.length > 0) {
-    initialized.push(`commands (${commandsInitialized.join(", ")})`);
-  }
-  const version = await getPluginVersion();
-  await writeFile(join(directory, "Manifold", "VERSION"), version + `
-`);
-  await client.app.log({
-    body: {
-      service: "opencode-manifold",
-      level: "info",
-      message: `/manifold-init complete: ${initialized.join(", ") || "already initialized"}`
-    }
-  });
-  return initialized;
-}
-
-// src/tools/dispatch-task.ts
-import { tool } from "@opencode-ai/plugin";
-import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import { existsSync as existsSync2 } from "fs";
-import { join as join2 } from "path";
-var pluginClient = null;
-function setPluginContext(client) {
-  pluginClient = client;
 }
-async function readSettings(directory) {
-  const settingsPath = join2(directory, "Manifold", "settings.json");
-  if (existsSync2(settingsPath)) {
-    const content = await readFile2(settingsPath, "utf-8");
-    return JSON.parse(content);
+async function pollForResponse(client, sessionID, maxAttempts, intervalMs) {
+  let lastMessageCount = 0;
+  for (let attempt = 0;attempt < maxAttempts; attempt++) {
+    await sleep(intervalMs);
+    const messagesRes = await client.session.messages({
+      path: { id: sessionID }
+    });
+    if (messagesRes.error || !messagesRes.data)
+      continue;
+    const messages = messagesRes.data;
+    if (messages.length <= lastMessageCount)
+      continue;
+    lastMessageCount = messages.length;
+    for (let i = messages.length - 1;i >= 0; i--) {
+      const msg = messages[i];
+      const info = msg.info;
+      if (info?.role === "assistant") {
+        return extractText(msg.parts);
+      }
+    }
   }
-  return {
-    maxLoops: 3,
-    maxRetries: 1,
-    maxResults: 10,
-    recentTaskCount: 3,
-    clerkRetryEnabled: true,
-    timeout: 300,
-    testCommand: null
-  };
+  throw new Error(`Timed out waiting for agent response after ${maxAttempts} attempts`);
 }
-async function readDispatcherState(directory, taskNumber) {
-  const statePath = join2(directory, "Manifold", "dispatcher-state.json");
-  if (existsSync2(statePath)) {
-    const content = await readFile2(statePath, "utf-8");
-    const states = JSON.parse(content);
-    return states[taskNumber] || null;
-  }
-  return null;
+function extractText(parts) {
+  return parts.filter((p) => p.type === "text").map((p) => p.text).join("");
 }
-async function writeDispatcherState(directory, state) {
-  const statePath = join2(directory, "Manifold", "dispatcher-state.json");
-  let states = {};
-  if (existsSync2(statePath)) {
-    const content = await readFile2(statePath, "utf-8");
-    states = JSON.parse(content);
-  }
-  states[state.task_number] = state;
-  await writeFile2(statePath, JSON.stringify(states, null, 2));
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
-function extractTaskFromPlan(planContent, taskNumber) {
-  const taskPattern = /###?\s*Task\s+(\d+):\s*(.+)/gi;
-  let match;
-  while ((match = taskPattern.exec(planContent)) !== null) {
-    if (parseInt(match[1]) === taskNumber) {
-      const description = match[2].trim();
-      const slug = description.toLowerCase().replace(/[^a-z0-9]+/g, "-").substring(0, 30);
-      return { description, slug };
+
+// src/tools/execute-task.ts
+import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+var TaskSchema = z.object({
+  task_number: z.number().describe("The task number from the todo list"),
+  title: z.string().describe("Short task title"),
+  description: z.string().describe("Full task description"),
+  context_notes: z.string().describe("Pre-loaded context from Todo agent research: relevant files, patterns, prior work, gotchas"),
+  plan_file: z.string().describe("Path to the todo.md file")
+});
+var executeTaskTool = (client, directory) => tool(TaskSchema, {
+  async execute(params) {
+    const { task_number, title, description, context_notes, plan_file } = params;
+    await client.app.log({
+      body: {
+        service: "opencode-manifold",
+        level: "info",
+        message: `Task ${task_number}: ${title}`
+      }
+    });
+    const priorTasks = await readPriorTasks(directory, 3);
+    const directive = buildDirective(title, description, context_notes, priorTasks);
+    await client.app.log({
+      body: { service: "opencode-manifold", level: "info", message: `Initiating Socratic Dialectic...` }
+    });
+    const [erlangResult, systemsResult] = await Promise.all([
+      invokeAgent(client, {
+        agent: "erlang",
+        prompt: `TASK: ${title}
+${directive}`
+      }),
+      invokeAgent(client, {
+        agent: "systems",
+        prompt: `TASK: ${title}
+${directive}`
+      })
+    ]);
+    if (!erlangResult.success || !systemsResult.success) {
+      const msg2 = `Initial Parallel Phase failed: Erlang(${erlangResult.success}), Systems(${systemsResult.success})`;
+      await logResult(directory, task_number, title, "escalated", msg2, "");
+      return { task_number, status: "escalated", summary: msg2, loops: 1 };
     }
-  }
-  return null;
-}
-function runDispatcherLogic(args, state, settings, taskDescription) {
-  const taskNumber = args.task_number || state?.task_number || 0;
-  const slug = state?.slug || "";
-  if (!state || state.phase === "init" || state.phase === "complete" || state.phase === "escalated") {
-    const newState = {
-      task_number: taskNumber,
-      plan_file: args.plan_file || state?.plan_file || "",
-      slug,
-      phase: "awaiting_execution",
-      senior_output: "",
-      clerk_summary: "",
-      loops: 0,
-      clerk_retries: 0
-    };
-    return {
-      route: "execute",
-      agent: "clerk",
-      prompt: buildExecutePrompt(taskNumber, taskDescription),
-      state: {
-        task_id: `${slug}-${taskNumber.toString().padStart(3, "0")}`,
-        phase: "awaiting_execution"
-      },
-      message: "Ready to execute task"
-    };
-  }
-  if (state.phase === "awaiting_execution") {
-    return {
-      route: "outcome_check",
-      agent: "clerk",
-      prompt: buildOutcomeCheckPrompt(),
-      state: {
-        task_id: `${slug}-${taskNumber.toString().padStart(3, "0")}`,
-        phase: "awaiting_outcome"
-      },
-      message: "Waiting for senior dev outcome"
-    };
-  }
-  if (state.phase === "awaiting_outcome") {
-    const isSuccess = args.success === true;
-    if (isSuccess) {
+    await client.app.log({
+      body: { service: "opencode-manifold", level: "info", message: `Synthesizing Consensus...` }
+    });
+    const leadResult = await invokeAgent(client, {
+      agent: "lead",
+      prompt: `TASK: ${title}
+
+ORIGINAL DIRECTIVE:
+${directive}
+
+--- SOLUTION A (ERLANG/DX) ---
+${erlangResult.text}
+
+--- SOLUTION B (SYSTEMS/SECURITY) ---
+${systemsResult.text}`
+    });
+    if (!leadResult.success) {
+      const msg2 = `Synthesis Phase failed: ${leadResult.error}`;
+      await logResult(directory, task_number, title, "escalated", msg2, "");
+      return { task_number, status: "escalated", summary: msg2, loops: 1 };
+    }
+    const finalImplementation = leadResult.text;
+    const reviewResult = await invokeAgent(client, {
+      agent: "lead",
+      prompt: `Review the following implementation against the original task: "${title}". 
+Original Task: ${description}
+Implementation: ${finalImplementation}
+
+If it is complete and correct, respond ONLY with "COMPLETE". If there are glaring errors or missing pieces, describe the questions/fixes needed starting with "QUESTIONS".`
+    });
+    const review = reviewResult.success ? reviewResult.text.trim() : "QUESTIONS: Review failed.";
+    const firstWord = review.split(/\s+/)[0].toUpperCase();
+    if (firstWord === "COMPLETE") {
+      await logResult(directory, task_number, title, "completed", extractSummary(finalImplementation), finalImplementation);
+      await markTodoDone(join2(directory, plan_file), task_number);
       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"
+        task_number,
+        status: "completed",
+        summary: extractSummary(finalImplementation),
+        loops: 1,
+        files_changed: extractFiles(finalImplementation)
       };
-    } else {
-      if (state.clerk_retries < settings.maxRetries) {
-        return {
-          route: "reprompt",
-          agent: "clerk",
-          prompt: buildRePromptPrompt(state, taskDescription),
-          state: {
-            task_id: `${slug}-${taskNumber.toString().padStart(3, "0")}`,
-            phase: "awaiting_execution"
-          },
-          message: `Retrying task (attempt ${state.clerk_retries + 1}/${settings.maxRetries})`
-        };
-      } else {
-        return {
-          route: "escalate",
-          agent: null,
-          prompt: buildEscalationPrompt(state, taskDescription),
-          state: {
-            task_id: `${slug}-${taskNumber.toString().padStart(3, "0")}`,
-            phase: "escalated"
-          },
-          message: "Escalating to user - all retries exhausted"
-        };
-      }
     }
+    const msg = `Socratic Synthesis requires refinement: ${review}`;
+    await logResult(directory, task_number, title, "escalated", msg, finalImplementation);
+    return { task_number, status: "escalated", summary: msg, loops: 1 };
   }
-  return {
-    route: "escalate",
-    agent: null,
-    prompt: "Dispatcher encountered unexpected state",
-    state: {
-      task_id: `${slug}-${taskNumber.toString().padStart(3, "0")}`,
-      phase: "escalated"
-    },
-    message: "Unexpected state - escalating"
-  };
-}
-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.
+});
+function buildDirective(title, description, contextNotes, priorTasks) {
+  return `## Directive
 
-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.
+**Task:** ${title}
 
-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
+**Description:**
+${description}
 
-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)
+**Context Notes (from pre-planning research):**
+${contextNotes}
 
-5. CALL SENIOR-DEV
-   Call @senior-dev with the finalized scoped prompt. Wait for response.
+**Prior Tasks (compound knowledge):**
+${priorTasks}
 
-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.`;
+**Implement this task. Follow the Context Notes. Use \`codebase_search\` if you need to clarify something the Context Notes don't cover.**`;
 }
-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.`;
+async function readPriorTasks(directory, n) {
+  const tasksDir = join2(directory, "Manifold", "tasks");
+  if (!existsSync2(tasksDir))
+    return "No prior tasks.";
+  const { readdir: readdir2 } = await import("fs/promises");
+  const entries = await readdir2(tasksDir);
+  const md = entries.filter((e) => e.endsWith(".md")).sort().reverse();
+  const selected = md.slice(0, n);
+  if (selected.length === 0)
+    return "No prior tasks.";
+  let out = "";
+  for (const f of selected) {
+    const content = await readFile2(join2(tasksDir, f), "utf-8").catch(() => "");
+    const summaryMatch = content.match(/## Summary\n([\s\S]*?)(?=\n## |$)/);
+    const filesMatch = content.match(/## Files Touched\n([\s\S]*?)(?=\n## |$)/);
+    out += `
+--- ${f} ---
+`;
+    if (summaryMatch)
+      out += `Summary: ${summaryMatch[1].trim()}
+`;
+    if (filesMatch)
+      out += `Files: ${filesMatch[1].trim()}
+`;
+  }
+  return out || "Prior tasks exist but no summaries extracted.";
 }
-function buildLoggingPrompt(state, taskDescription) {
-  const taskId = `${state.slug}-${state.task_number.toString().padStart(3, "0")}`;
+async function logResult(directory, taskNumber, title, status, summary, implementation) {
   const date = new Date().toISOString().split("T")[0];
-  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
+  const tasksDir = join2(directory, "Manifold", "tasks");
+  await mkdir2(tasksDir, { recursive: true });
+  const taskPath = join2(tasksDir, `${taskNumber.toString().padStart(3, "0")}-${slugify(title)}.md`);
+  let content = `# Task ${taskNumber}: ${title}
 
-2. Update index at \`Manifold/index.md\`:
-   - Add: \`- [[${taskId}]] — ${taskDescription} | ${date} | COMPLETED\`
+`;
+  content += `**Date:** ${date}
+`;
+  content += `**Status:** ${status.toUpperCase()}
 
-3. Append to log at \`Manifold/log.md\`:
-   - Add: \`## [${date}] ${taskId} | ${taskDescription} | COMPLETED\`
+`;
+  content += `## Summary
+${summary}
 
-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
+`;
+  if (implementation) {
+    content += `## Implementation
 
-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
+${implementation}
 
-NEXT:
-After senior-dev completes, call dispatchTask() again to report outcome.`;
-}
-function buildEscalationPrompt(state, taskDescription) {
-  return `CLERK - ESCALATION
-TASK: ${taskDescription}
-
-The task has failed after ${state.clerk_retries} recovery attempts.
-
-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
+`;
+  }
+  const files = extractFiles(implementation);
+  if (files.length > 0) {
+    content += `## Files Touched
+${files.map((f) => `- \`${f}\``).join(`
+`)}
 
-This task cannot be completed automatically. Human intervention required.`;
+`;
+  }
+  await writeFile2(taskPath, content);
+  const memoryPath = join2(directory, "Manifold", "memory.md");
+  let memory = "";
+  if (existsSync2(memoryPath)) {
+    memory = await readFile2(memoryPath, "utf-8");
+  }
+  memory += `
+## ${date} task-${taskNumber}
+`;
+  memory += `**${title}** — ${status.toUpperCase()}
+`;
+  memory += `- ${summary.substring(0, 300)}
+`;
+  if (files.length > 0) {
+    memory += `- Files: ${files.join(", ")}
+`;
+  }
+  await writeFile2(memoryPath, memory.trim() + `
+`);
 }
-function getClient() {
-  if (!pluginClient) {
-    throw new Error("Plugin client not initialized");
+async function markTodoDone(planPath, taskNumber) {
+  if (!existsSync2(planPath))
+    return;
+  const content = await readFile2(planPath, "utf-8");
+  const regex = new RegExp(`^(## Task ${taskNumber}:.*)$`, "gm");
+  const updated = content.replace(regex, "$1 [x]");
+  if (updated !== content) {
+    await writeFile2(planPath, updated);
   }
-  return pluginClient;
 }
-var dispatchTaskTool = tool({
-  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("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")
-  },
-  async execute(args, context) {
-    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"}`
-      }
-    });
-    const settings = await readSettings(directory);
-    const existingState = task_number ? await readDispatcherState(directory, task_number) : null;
-    let taskDescription = description || "";
-    if (!taskDescription && args.plan_file && task_number) {
-      try {
-        const planPath = join2(directory, args.plan_file);
-        if (existsSync2(planPath)) {
-          const planContent = await readFile2(planPath, "utf-8");
-          const taskInfo = extractTaskFromPlan(planContent, task_number);
-          if (taskInfo) {
-            taskDescription = taskInfo.description;
-          }
-        }
-      } catch (error) {
-        await client.app.log({
-          body: {
-            service: "opencode-manifold",
-            level: "error",
-            message: `Failed to read plan file: ${error}`
-          }
-        });
-      }
-    }
-    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) {
-      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: {
-        service: "opencode-manifold",
-        level: "info",
-        message: `dispatchTask result: ${result.route} → ${result.agent || "none"} (${result.message})`
-      }
-    });
-    return JSON.stringify(result);
+function extractSummary(implementation) {
+  const lines = implementation.split(`
+`).filter((l) => l.trim());
+  const marker = lines.find((l) => /^(?:Summary|IMPLEMENTATION SUMMARY|What was done):/i.test(l));
+  if (marker) {
+    return marker.replace(/^(?:Summary|IMPLEMENTATION SUMMARY|What was done):\s*/i, "").trim();
   }
-});
+  return lines[0]?.substring(0, 200) || "No summary";
+}
+function extractFiles(implementation) {
+  const files = [];
+  const mdMatches = implementation.matchAll(/\[`([^`]+)`\]/g);
+  for (const m of mdMatches)
+    files.push(m[1]);
+  const pathMatches = implementation.matchAll(/(?:src|lib|test|spec)\/[^:\s)]+\.(?:ts|tsx|js|jsx|py|rs|go)\b/g);
+  for (const m of pathMatches)
+    files.push(m[0]);
+  return [...new Set(files)];
+}
+function slugify(s) {
+  return s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").substring(0, 40);
+}
 
 // src/index.ts
 init_get_model_path();
 var ManifoldPlugin = async (ctx) => {
   setPluginContext(ctx.client);
-  setPluginContext2(ctx.client);
+  const { client, directory } = ctx;
   await ensureGlobalTemplates(ctx);
-  await ctx.client.app.log({
+  await client.app.log({
     body: {
       service: "opencode-manifold",
       level: "info",
-      message: "Open Manifold plugin loaded"
+      message: "Open Manifold v2.1 loaded"
     }
   });
   return {
     tool: {
-      dispatchTask: dispatchTaskTool,
-      getModelPath: getModelPathTool
-    },
-    "command.execute.before": async (input, output) => {
-      if (input.command === "manifold-init") {
-        const initialized = await initProject(ctx.directory, ctx.client);
-        if (initialized.length > 0) {
-          output.parts = [
-            {
-              type: "text",
-              text: `Manifold initialized: ${initialized.join(", ")}`
-            }
-          ];
-        } else {
-          output.parts = [
-            {
-              type: "text",
-              text: "All Manifold files already present. To reset a specific component, delete the corresponding file(s) from `.opencode/agents/`, `.opencode/skills/`, or `Manifold/`, then run `/manifold-init` again."
-            }
-          ];
-        }
-      } else if (input.command === "manifold-model-path") {
-        const modelPath = await getModelPath(ctx.client, input.sessionID || undefined);
-        output.parts = [{ type: "text", text: modelPath }];
-      }
+      execute_task: executeTaskTool(client, directory)
     }
   };
 };