opencode-manifold 0.1.0

package/dist/index.js

@@ -0,0 +1,1468 @@
+// src/setup.ts
+import { readFile, writeFile, mkdir, readdir, stat } from "fs/promises";
+import { existsSync } from "fs";
+import { join, dirname } from "path";
+var __dirname = "/Users/don/gitthings/Open_Manifold_System/src";
+async function fileExists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function copyFile(src, dest) {
+  const destDir = dirname(dest);
+  if (!existsSync(destDir)) {
+    await mkdir(destDir, { recursive: true });
+  }
+  const content = await readFile(src);
+  await writeFile(dest, content);
+}
+async function copyDirectory(src, dest) {
+  if (!existsSync(dest)) {
+    await mkdir(dest, { recursive: true });
+  }
+  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()) {
+      await copyDirectory(srcPath, destPath);
+    } else {
+      await copyFile(srcPath, destPath);
+    }
+  }
+}
+async function setupProject(directory, client) {
+  await client.app.log({
+    body: {
+      service: "opencode-manifold",
+      level: "info",
+      message: `Checking Open Manifold setup in ${directory}`
+    }
+  });
+  const manifoldPath = join(directory, "Manifold");
+  const opencodeAgentsPath = join(directory, ".opencode", "agents");
+  const opencodeSkillsPath = join(directory, ".opencode", "skills");
+  const opencodeJsonPath = join(directory, "opencode.json");
+  const pluginSourceDir = join(directory, "..", "node_modules", "opencode-manifold", "src", "templates");
+  const manifestPath = join(pluginSourceDir, "..", "..");
+  const templateSourceDir = existsSync(manifestPath) ? manifestPath : join(__dirname, "..", "templates");
+  const manifoldExists = await fileExists(manifoldPath);
+  if (!manifoldExists) {
+    await client.app.log({
+      body: {
+        service: "opencode-manifold",
+        level: "info",
+        message: "Manifold directory not found, setting up..."
+      }
+    });
+    await mkdir(manifoldPath, { recursive: true });
+    await mkdir(join(manifoldPath, ".obsidian"), { recursive: true });
+    await mkdir(join(manifoldPath, "tasks"), { recursive: true });
+    await mkdir(join(manifoldPath, "graph"), { recursive: true });
+    const templateManifold = join(templateSourceDir, "manifold");
+    if (existsSync(templateManifold)) {
+      const files = [
+        "settings.json",
+        "plans.json",
+        "state.json",
+        "index.md",
+        "log.md",
+        "schema.md"
+      ];
+      for (const file of files) {
+        const src = join(templateManifold, file);
+        if (existsSync(src)) {
+          await copyFile(src, join(manifoldPath, file));
+        }
+      }
+    }
+    await client.app.log({
+      body: {
+        service: "opencode-manifold",
+        level: "info",
+        message: "Manifold directory created"
+      }
+    });
+  }
+  const agentsExist = await fileExists(opencodeAgentsPath);
+  if (!agentsExist) {
+    await client.app.log({
+      body: {
+        service: "opencode-manifold",
+        level: "info",
+        message: "Setting up agent definitions..."
+      }
+    });
+    await mkdir(opencodeAgentsPath, { recursive: true });
+    const templateAgents = join(templateSourceDir, "agents");
+    if (existsSync(templateAgents)) {
+      const agents = [
+        "lead-dev.md",
+        "clerk.md",
+        "senior-dev.md",
+        "junior-dev.md",
+        "debug.md"
+      ];
+      for (const agent of agents) {
+        const src = join(templateAgents, agent);
+        if (existsSync(src)) {
+          await copyFile(src, join(opencodeAgentsPath, agent));
+        }
+      }
+    }
+    await client.app.log({
+      body: {
+        service: "opencode-manifold",
+        level: "info",
+        message: "Agent definitions created"
+      }
+    });
+  }
+  const skillsExist = await fileExists(opencodeSkillsPath);
+  if (!skillsExist) {
+    await client.app.log({
+      body: {
+        service: "opencode-manifold",
+        level: "info",
+        message: "Setting up skills..."
+      }
+    });
+    await mkdir(opencodeSkillsPath, { recursive: true });
+    const templateSkills = join(templateSourceDir, "skills");
+    if (existsSync(templateSkills)) {
+      const skills = [
+        "clerk-orchestration",
+        "lead-dev-workflow",
+        "wiki-ingest",
+        "wiki-query"
+      ];
+      for (const skill of skills) {
+        const skillDir = join(templateSkills, skill);
+        if (existsSync(skillDir)) {
+          await copyDirectory(skillDir, join(opencodeSkillsPath, skill));
+        }
+      }
+    }
+    await client.app.log({
+      body: {
+        service: "opencode-manifold",
+        level: "info",
+        message: "Skills created"
+      }
+    });
+  }
+  const opencodeJsonExists = await fileExists(opencodeJsonPath);
+  if (!opencodeJsonExists) {
+    await client.app.log({
+      body: {
+        service: "opencode-manifold",
+        level: "info",
+        message: "Creating opencode.json configuration..."
+      }
+    });
+    const templateConfig = join(templateSourceDir, "config", "opencode.json");
+    if (existsSync(templateConfig)) {
+      await copyFile(templateConfig, opencodeJsonPath);
+    } else {
+      const defaultConfig = {
+        $schema: "https://opencode.ai/config.json",
+        plugin: ["opencode-manifold", "opencode-codebase-index"],
+        agent: {
+          "lead-dev": {
+            model: "minimax/minimax-2.7",
+            skill: ["lead-dev-workflow"]
+          },
+          clerk: {
+            model: "minimax/minimax-2.7",
+            skill: ["clerk-orchestration", "wiki-ingest", "wiki-query"]
+          },
+          "senior-dev": {
+            model: "minimax/minimax-2.7"
+          },
+          "junior-dev": {
+            model: "qwen/qwen3.5-27b"
+          },
+          debug: {
+            model: "anthropic/claude-sonnet-4-6-20250514"
+          }
+        }
+      };
+      await writeFile(opencodeJsonPath, JSON.stringify(defaultConfig, null, 2));
+    }
+    await client.app.log({
+      body: {
+        service: "opencode-manifold",
+        level: "info",
+        message: "opencode.json created"
+      }
+    });
+  }
+  await client.app.log({
+    body: {
+      service: "opencode-manifold",
+      level: "info",
+      message: "Open Manifold initialized successfully"
+    }
+  });
+}
+
+// src/tools/dispatch-task.ts
+import { tool } from "@opencode-ai/plugin";
+import { readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
+
+// src/state-machine.ts
+import { readFile as readFile3, writeFile as writeFile3, readdir as readdir2 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+
+// src/session-spawner.ts
+async function waitForSessionIdle(client, sessionId, timeoutMs) {
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeoutMs) {
+    const statusResponse = await client.session.status({});
+    const statusData = statusResponse.data;
+    if (statusData && statusData[sessionId]) {
+      const status = statusData[sessionId];
+      if (status.type === "idle") {
+        return true;
+      }
+      if (status.type === "retry") {
+        const waitTime = status.next - Date.now();
+        if (waitTime > 0) {
+          await new Promise((resolve) => setTimeout(resolve, Math.min(waitTime, 1000)));
+        }
+        continue;
+      }
+    }
+    await new Promise((resolve) => setTimeout(resolve, 500));
+  }
+  return false;
+}
+async function getLastAssistantMessage(client, sessionId) {
+  const messagesResponse = await client.session.messages({
+    path: { id: sessionId }
+  });
+  const messages = messagesResponse.data;
+  if (!messages || !Array.isArray(messages)) {
+    return "";
+  }
+  for (let i = messages.length - 1;i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.info && msg.info.role === "assistant") {
+      if (msg.parts && Array.isArray(msg.parts)) {
+        for (const part of msg.parts) {
+          if (part.type === "text" && part.text) {
+            return part.text;
+          }
+        }
+      }
+    }
+  }
+  return "";
+}
+async function cleanupSession(client, sessionId) {
+  try {
+    await client.session.delete({ path: { id: sessionId } });
+  } catch {}
+}
+async function spawnSession(client, agent, prompt, timeoutSeconds) {
+  const timeoutMs = timeoutSeconds * 1000;
+  try {
+    const createResponse = await client.session.create({});
+    const session = createResponse.data;
+    if (!session || !session.id) {
+      return {
+        content: "",
+        success: false,
+        error: "Failed to create session"
+      };
+    }
+    const sessionId = session.id;
+    await client.app.log({
+      body: {
+        service: "opencode-manifold",
+        level: "info",
+        message: `Created session ${sessionId} for agent ${agent}`
+      }
+    });
+    try {
+      await client.session.promptAsync({
+        path: { id: sessionId },
+        body: {
+          agent,
+          noReply: true,
+          parts: [{ type: "text", text: prompt }]
+        }
+      });
+      const isIdle = await waitForSessionIdle(client, sessionId, timeoutMs);
+      if (!isIdle) {
+        await client.session.abort({ path: { id: sessionId } });
+        return {
+          content: "",
+          success: false,
+          error: `Session timed out after ${timeoutSeconds}s`
+        };
+      }
+      const content = await getLastAssistantMessage(client, sessionId);
+      await client.app.log({
+        body: {
+          service: "opencode-manifold",
+          level: "info",
+          message: `Session ${sessionId} completed, content length: ${content.length}`
+        }
+      });
+      return {
+        content,
+        success: true
+      };
+    } finally {
+      await cleanupSession(client, sessionId);
+    }
+  } catch (error) {
+    return {
+      content: "",
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function spawnClerkSession(client, prompt, agent, timeout) {
+  await client.app.log({
+    body: {
+      service: "opencode-manifold",
+      level: "info",
+      message: `Spawning Clerk session (agent: ${agent}, timeout: ${timeout}s)`
+    }
+  });
+  return spawnSession(client, agent, prompt, timeout);
+}
+async function spawnSeniorDevSession(client, prompt, agent, timeout) {
+  await client.app.log({
+    body: {
+      service: "opencode-manifold",
+      level: "info",
+      message: `Spawning Senior Dev session (agent: ${agent}, timeout: ${timeout}s)`
+    }
+  });
+  return spawnSession(client, agent, prompt, timeout);
+}
+async function spawnJuniorDevSession(client, prompt, seniorOutput, agent, timeout) {
+  await client.app.log({
+    body: {
+      service: "opencode-manifold",
+      level: "info",
+      message: `Spawning Junior Dev session (agent: ${agent}, timeout: ${timeout}s)`
+    }
+  });
+  const fullPrompt = `${prompt}
+
+---
+
+Senior Dev's Implementation:
+${seniorOutput}`;
+  return spawnSession(client, agent, fullPrompt, timeout);
+}
+async function spawnDebugSession(client, prompt, loopHistory, agent, timeout) {
+  await client.app.log({
+    body: {
+      service: "opencode-manifold",
+      level: "info",
+      message: `Spawning Debug session (agent: ${agent}, timeout: ${timeout}s)`
+    }
+  });
+  const fullPrompt = `${prompt}
+
+---
+
+Loop History:
+${loopHistory}`;
+  return spawnSession(client, agent, fullPrompt, timeout);
+}
+function parseJuniorFirstWord(response) {
+  const firstWord = response.trim().split(/\s+/)[0].toUpperCase();
+  if (firstWord === "COMPLETE") {
+    return "COMPLETE";
+  }
+  return "QUESTIONS";
+}
+
+// src/error-handler.ts
+class ModelCallError extends Error {
+  agent;
+  attempt;
+  constructor(message, agent, attempt) {
+    super(message);
+    this.agent = agent;
+    this.attempt = attempt;
+    this.name = "ModelCallError";
+  }
+}
+async function retryWithBackoff(fn, options) {
+  let lastError;
+  for (let attempt = 0;attempt <= options.maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (attempt < options.maxRetries) {
+        options.onRetry?.(attempt + 1, lastError);
+        const delay = Math.pow(2, attempt) * 100;
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+  }
+  throw lastError;
+}
+
+// src/graph.ts
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+function pathToGraphFilename(filePath) {
+  return filePath.replace(/[/.]/g, "_") + ".md";
+}
+function parseGraphContent(content) {
+  const lines = content.split(`
+`);
+  let filePath = "";
+  let inSection = null;
+  const entry = {
+    filePath: "",
+    calls: [],
+    dependsOn: [],
+    tasksThatEdited: []
+  };
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("# ")) {
+      filePath = trimmed.substring(2).trim();
+      entry.filePath = filePath;
+      continue;
+    }
+    if (trimmed === "## Calls") {
+      inSection = "calls";
+      continue;
+    }
+    if (trimmed === "## Depends On") {
+      inSection = "dependsOn";
+      continue;
+    }
+    if (trimmed === "## Tasks That Edited") {
+      inSection = "tasks";
+      continue;
+    }
+    if (trimmed.startsWith("- [[") && trimmed.endsWith("]]")) {
+      const ref = trimmed.slice(4, -2).trim();
+      if (inSection === "calls") {
+        entry.calls.push(ref);
+      } else if (inSection === "dependsOn") {
+        entry.dependsOn.push(ref);
+      } else if (inSection === "tasks") {
+        entry.tasksThatEdited.push(ref);
+      }
+    } else if (trimmed.startsWith("- `") && trimmed.endsWith("`")) {
+      const ref = trimmed.slice(3, -1).trim();
+      if (inSection === "calls" && !entry.calls.includes(ref)) {
+        entry.calls.push(ref);
+      } else if (inSection === "dependsOn" && !entry.dependsOn.includes(ref)) {
+        entry.dependsOn.push(ref);
+      }
+    } else if (trimmed.startsWith("- ")) {
+      const ref = trimmed.slice(2).trim();
+      if (inSection === "calls" && !entry.calls.includes(ref)) {
+        entry.calls.push(ref);
+      } else if (inSection === "dependsOn" && !entry.dependsOn.includes(ref)) {
+        entry.dependsOn.push(ref);
+      } else if (inSection === "tasks" && !entry.tasksThatEdited.includes(ref)) {
+        entry.tasksThatEdited.push(ref);
+      }
+    }
+  }
+  if (!entry.filePath) {
+    return null;
+  }
+  return entry;
+}
+function formatGraphContent(entry) {
+  const callsSection = entry.calls.length > 0 ? `## Calls
+` + entry.calls.map((c) => `- ${c}`).join(`
+`) : `## Calls
+`;
+  const dependsSection = entry.dependsOn.length > 0 ? `## Depends On
+` + entry.dependsOn.map((d) => `- ${d}`).join(`
+`) : `## Depends On
+`;
+  const tasksSection = entry.tasksThatEdited.length > 0 ? `## Tasks That Edited
+` + entry.tasksThatEdited.map((t) => `- [[${t}]]`).join(`
+`) : `## Tasks That Edited
+`;
+  return `# ${entry.filePath}
+
+${callsSection}
+
+${dependsSection}
+
+${tasksSection}
+`.trim();
+}
+async function readGraphFile(directory, filePath) {
+  const filename = pathToGraphFilename(filePath);
+  const graphPath = join2(directory, "Manifold", "graph", filename);
+  if (!existsSync2(graphPath)) {
+    return null;
+  }
+  try {
+    const content = await readFile2(graphPath, "utf-8");
+    return parseGraphContent(content);
+  } catch {
+    return null;
+  }
+}
+async function updateGraphFile(directory, filePath, taskId, calls, dependsOn) {
+  const filename = pathToGraphFilename(filePath);
+  const graphPath = join2(directory, "Manifold", "graph", filename);
+  let entry;
+  if (existsSync2(graphPath)) {
+    const existing = await readGraphFile(directory, filePath);
+    entry = existing || {
+      filePath,
+      calls: [],
+      dependsOn: [],
+      tasksThatEdited: []
+    };
+  } else {
+    entry = {
+      filePath,
+      calls: calls || [],
+      dependsOn: dependsOn || [],
+      tasksThatEdited: []
+    };
+  }
+  if (calls) {
+    entry.calls = [...new Set([...entry.calls, ...calls])];
+  }
+  if (dependsOn) {
+    entry.dependsOn = [...new Set([...entry.dependsOn, ...dependsOn])];
+  }
+  if (!entry.tasksThatEdited.includes(taskId)) {
+    entry.tasksThatEdited.push(taskId);
+  }
+  const content = formatGraphContent(entry);
+  await writeFile2(graphPath, content, "utf-8");
+}
+async function updateGraphFilesForTask(directory, taskId, files) {
+  for (const file of files) {
+    try {
+      await updateGraphFile(directory, file, taskId);
+    } catch (error) {
+      console.error(`Failed to update graph for ${file}:`, error);
+    }
+  }
+}
+
+// src/state-machine.ts
+async function readState(directory) {
+  const statePath = join3(directory, "Manifold", "state.json");
+  if (existsSync3(statePath)) {
+    const content = await readFile3(statePath, "utf-8");
+    return JSON.parse(content);
+  }
+  return {
+    current_task: null,
+    state: "idle",
+    loop_count: 0,
+    clerk_retry_count: 0,
+    scoped_prompt: null,
+    senior_output: null,
+    junior_response: null,
+    debug_suggestion: null,
+    loop_history: []
+  };
+}
+async function writeState(directory, state) {
+  const statePath = join3(directory, "Manifold", "state.json");
+  await writeFile3(statePath, JSON.stringify(state, null, 2));
+}
+function buildLoopHistory(state) {
+  if (state.loop_history.length === 0) {
+    return "No previous loops.";
+  }
+  return state.loop_history.map((entry, i) => `### Loop ${i + 1}
+${entry}`).join(`
+
+`);
+}
+async function readRecentTaskLogs(directory, count) {
+  const tasksDir = join3(directory, "Manifold", "tasks");
+  if (!existsSync3(tasksDir)) {
+    return [];
+  }
+  try {
+    const files = await readdir2(tasksDir);
+    const mdFiles = files.filter((f) => f.endsWith(".md")).sort();
+    const recentFiles = mdFiles.slice(-count);
+    const tasks = await Promise.all(recentFiles.map(async (filename) => {
+      const content = await readFile3(join3(tasksDir, filename), "utf-8");
+      return { filename, content };
+    }));
+    return tasks;
+  } catch {
+    return [];
+  }
+}
+async function runClerkLoggingPhase(client, task, state, settings, directory) {
+  state.state = "clerk_logging";
+  await writeState(directory, state);
+  await client.app.log({
+    body: {
+      service: "opencode-manifold",
+      level: "info",
+      message: "State: clerk_logging - Spawning Clerk for wiki logging"
+    }
+  });
+  const taskId = `${task.slug}-${task.task_number.toString().padStart(3, "0")}`;
+  const date = new Date().toISOString().split("T")[0];
+  const clerkLoggingPrompt = `You are the Clerk. Log the completed task to the project wiki.
+
+Task ID: ${taskId}
+Task Description: ${task.description}
+Date: ${date}
+Status: COMPLETED
+Loops: ${state.loop_count}
+
+Scoped Prompt Used:
+${state.scoped_prompt}
+
+Senior Developer's Final Implementation:
+${state.senior_output}
+
+Junior Developer's Approval Response:
+${state.junior_response}
+
+Loop History:
+${buildLoopHistory(state)}
+
+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}]] — ${task.description} | ${date} | COMPLETED\`
+
+3. Append to \`Manifold/log.md\`:
+   \`## [${date}] ${taskId} | ${task.description} | COMPLETED | ${state.loop_count} loops\`
+
+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
+   - Graph filename format: replace \`/\` and \`.\` with \`_\`, append \`.md\`
+   - Example: \`src/middleware/auth.ts\` → \`src_middleware_auth_ts.md\`
+
+Extract the list of files touched from the Senior's implementation and include it in your response.`;
+  const clerkLoggingResult = await retryWithBackoff(() => spawnClerkSession(client, clerkLoggingPrompt, "clerk", settings.timeout), {
+    maxRetries: settings.maxRetries,
+    onRetry: (attempt, error) => {
+      client.app.log({
+        body: {
+          service: "opencode-manifold",
+          level: "warn",
+          message: `Clerk logging retry ${attempt}: ${error.message}`
+        }
+      });
+    }
+  });
+  if (!clerkLoggingResult.success) {
+    await client.app.log({
+      body: {
+        service: "opencode-manifold",
+        level: "error",
+        message: `Clerk logging failed: ${clerkLoggingResult.error}. Task completed but wiki not updated.`
+      }
+    });
+    return { files_changed: [] };
+  }
+  const filesChanged = extractFilesFromResponse(clerkLoggingResult.content);
+  if (filesChanged.length > 0) {
+    await client.app.log({
+      body: {
+        service: "opencode-manifold",
+        level: "info",
+        message: `Updating graph files for ${filesChanged.length} files...`
+      }
+    });
+    try {
+      await updateGraphFilesForTask(directory, taskId, filesChanged);
+      await client.app.log({
+        body: {
+          service: "opencode-manifold",
+          level: "info",
+          message: `Graph files updated successfully`
+        }
+      });
+    } catch (error) {
+      await client.app.log({
+        body: {
+          service: "opencode-manifold",
+          level: "warn",
+          message: `Graph file update failed: ${error instanceof Error ? error.message : String(error)}`
+        }
+      });
+    }
+  }
+  await client.app.log({
+    body: {
+      service: "opencode-manifold",
+      level: "info",
+      message: `Clerk logging complete. Files touched: ${filesChanged.join(", ") || "none"}`
+    }
+  });
+  return { files_changed: filesChanged };
+}
+function extractFilesFromResponse(content) {
+  const files = [];
+  const patterns = [
+    /\[\[([^\]]+\.[a-zA-Z]+)\]\]/g,
+    /`([^`]+\.[a-zA-Z]+)`/g,
+    /(?:src|lib|app|components|utils|helpers)[^\s]*/gi
+  ];
+  for (const pattern of patterns) {
+    const matches = content.matchAll(pattern);
+    for (const match of matches) {
+      const file = match[1] || match[0];
+      if (file && !files.includes(file)) {
+        files.push(file);
+      }
+    }
+  }
+  return files;
+}
+function extractScopedPrompt(content) {
+  const startMarker = "===SCOPED_PROMPT_START===";
+  const endMarker = "===SCOPED_PROMPT_END===";
+  const startIdx = content.indexOf(startMarker);
+  const endIdx = content.indexOf(endMarker);
+  if (startIdx !== -1 && endIdx !== -1) {
+    return content.substring(startIdx + startMarker.length, endIdx).trim();
+  }
+  const lines = content.split(`
+`);
+  const promptLines = [];
+  let inPrompt = false;
+  for (const line of lines) {
+    if (line.includes("SCOPED_PROMPT_END")) {
+      inPrompt = false;
+    }
+    if (inPrompt) {
+      promptLines.push(line);
+    }
+    if (line.includes("SCOPED_PROMPT_START")) {
+      inPrompt = true;
+    }
+  }
+  if (promptLines.length > 0) {
+    return promptLines.join(`
+`).trim();
+  }
+  return content;
+}
+async function runStateMachine(task, settings, context) {
+  const { client, directory } = context;
+  let state = await readState(directory);
+  state.current_task = task.task_number;
+  state.state = "idle";
+  state.loop_count = 0;
+  state.clerk_retry_count = 0;
+  state.scoped_prompt = null;
+  state.senior_output = null;
+  state.junior_response = null;
+  state.debug_suggestion = null;
+  state.loop_history = [];
+  await writeState(directory, state);
+  await client.app.log({
+    body: {
+      service: "opencode-manifold",
+      level: "info",
+      message: `Starting state machine for task ${task.task_number}: ${task.description}`
+    }
+  });
+  state.state = "clerk_researched";
+  await writeState(directory, state);
+  await client.app.log({
+    body: {
+      service: "opencode-manifold",
+      level: "info",
+      message: "State: clerk_researched - Pre-reading wiki context for Clerk"
+    }
+  });
+  const recentTasks = await readRecentTaskLogs(directory, settings.recentTaskCount);
+  let recentTasksContext = "";
+  if (recentTasks.length > 0) {
+    recentTasksContext = `
+
+Recent Task Logs from Manifold:
+` + recentTasks.map((t) => `--- ${t.filename} ---
+${t.content}`).join(`
+
+`);
+  } else {
+    recentTasksContext = `
+
+(No prior task logs found - this appears to be a new project.)`;
+  }
+  await client.app.log({
+    body: {
+      service: "opencode-manifold",
+      level: "info",
+      message: `State: clerk_researched - Spawning Clerk with ${recentTasks.length} recent tasks`
+    }
+  });
+  const clerkPrompt = `You are the Clerk for this project. Research the following task and compose a scoped prompt for the Senior Developer.
+
+Task: ${task.description}
+${recentTasksContext}
+
+IMPORTANT: You also have access to:
+- The codebase-index tool for semantic code search (use it to find relevant code)
+- File reading tools to read additional context if needed
+
+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 if you find they exist
+3. Compose a scoped prompt with: task goal, relevant code snippets, prior decisions from above, design guidelines
+
+Output Format - STRICTLY FOLLOW THIS:
+
+===SCOPED_PROMPT_START===
+[Your composed scoped prompt for the Senior Developer - include task goal, 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===`;
+  const clerkResult = await retryWithBackoff(() => spawnClerkSession(client, clerkPrompt, "clerk", settings.timeout), {
+    maxRetries: settings.maxRetries,
+    onRetry: (attempt, error) => {
+      client.app.log({
+        body: {
+          service: "opencode-manifold",
+          level: "warn",
+          message: `Clerk retry ${attempt}: ${error.message}`
+        }
+      });
+    }
+  });
+  if (!clerkResult.success) {
+    state.state = "escalate_user";
+    await writeState(directory, state);
+    return {
+      status: "escalated_user",
+      summary: `Task ${task.task_number}: Clerk failed - ${clerkResult.error}`,
+      files_changed: [],
+      loops: state.loop_count,
+      wiki_entry: `Manifold/tasks/${task.slug}-${task.task_number.toString().padStart(3, "0")}.md`
+    };
+  }
+  state.scoped_prompt = extractScopedPrompt(clerkResult.content);
+  await writeState(directory, state);
+  let finalResult;
+  const runSeniorJuniorLoop = async () => {
+    state.state = "senior_done";
+    await writeState(directory, state);
+    await client.app.log({
+      body: {
+        service: "opencode-manifold",
+        level: "info",
+        message: "State: senior_done - Spawning Senior Dev"
+      }
+    });
+    const seniorPrompt = state.scoped_prompt;
+    const seniorResult = await retryWithBackoff(() => spawnSeniorDevSession(client, seniorPrompt, "senior-dev", settings.timeout), {
+      maxRetries: settings.maxRetries,
+      onRetry: (attempt, error) => {
+        client.app.log({
+          body: {
+            service: "opencode-manifold",
+            level: "warn",
+            message: `Senior Dev retry ${attempt}: ${error.message}`
+          }
+        });
+      }
+    });
+    if (!seniorResult.success) {
+      throw new ModelCallError(`Senior Dev failed: ${seniorResult.error}`, "senior-dev", 1);
+    }
+    state.senior_output = seniorResult.content;
+    await writeState(directory, state);
+    state.state = "junior_review";
+    await writeState(directory, state);
+    await client.app.log({
+      body: {
+        service: "opencode-manifold",
+        level: "info",
+        message: "State: junior_review - Spawning Junior Dev"
+      }
+    });
+    const juniorPrompt = `You are the Junior Developer reviewing the Senior Developer's implementation.
+
+Task Description:
+${state.scoped_prompt}
+
+Senior Developer's Implementation:
+${seniorResult.content}
+
+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.`;
+    const juniorResult = await retryWithBackoff(() => spawnJuniorDevSession(client, juniorPrompt, seniorResult.content, "junior-dev", settings.timeout), {
+      maxRetries: settings.maxRetries,
+      onRetry: (attempt, error) => {
+        client.app.log({
+          body: {
+            service: "opencode-manifold",
+            level: "warn",
+            message: `Junior Dev retry ${attempt}: ${error.message}`
+          }
+        });
+      }
+    });
+    if (!juniorResult.success) {
+      throw new ModelCallError(`Junior Dev failed: ${juniorResult.error}`, "junior-dev", 1);
+    }
+    state.junior_response = juniorResult.content;
+    state.loop_history.push(`**Senior:** ${seniorResult.content.substring(0, 200)}...
+**Junior:** ${juniorResult.content}`);
+    await writeState(directory, state);
+    const firstWord = parseJuniorFirstWord(juniorResult.content);
+    if (firstWord === "COMPLETE") {
+      state.state = "junior_approved";
+      await writeState(directory, state);
+      return { approved: true, seniorOutput: seniorResult.content, juniorResponse: juniorResult.content };
+    } else {
+      state.state = "junior_rejected";
+      await writeState(directory, state);
+      return { approved: false, seniorOutput: seniorResult.content, juniorResponse: juniorResult.content };
+    }
+  };
+  let loopResult = await runSeniorJuniorLoop();
+  while (!loopResult.approved) {
+    state.loop_count++;
+    await client.app.log({
+      body: {
+        service: "opencode-manifold",
+        level: "info",
+        message: `Junior rejected, loop_count: ${state.loop_count}/${settings.maxLoops}`
+      }
+    });
+    if (state.loop_count >= settings.maxLoops) {
+      state.state = "escalate_debug";
+      await writeState(directory, state);
+      await client.app.log({
+        body: {
+          service: "opencode-manifold",
+          level: "info",
+          message: "State: escalate_debug - Spawning Debug agent"
+        }
+      });
+      const debugPrompt = `You are the Debug Agent. The Senior/Junior loop has failed ${settings.maxLoops} times.
+
+Task: ${task.description}
+
+Loop History:
+${buildLoopHistory(state)}
+
+Analyze why the loop is stuck and suggest a concrete alternative approach.`;
+      const debugResult = await retryWithBackoff(() => spawnDebugSession(client, debugPrompt, buildLoopHistory(state), "debug", settings.timeout), {
+        maxRetries: settings.maxRetries,
+        onRetry: (attempt, error) => {
+          client.app.log({
+            body: {
+              service: "opencode-manifold",
+              level: "warn",
+              message: `Debug retry ${attempt}: ${error.message}`
+            }
+          });
+        }
+      });
+      if (!debugResult.success) {
+        state.state = "escalate_user";
+        await writeState(directory, state);
+        return {
+          status: "escalated_user",
+          summary: `Task ${task.task_number}: Debug failed - ${debugResult.error}`,
+          files_changed: [],
+          loops: state.loop_count,
+          wiki_entry: `Manifold/tasks/${task.slug}-${task.task_number.toString().padStart(3, "0")}.md`
+        };
+      }
+      state.debug_suggestion = debugResult.content;
+      state.loop_history.push(`**Debug Analysis:** ${debugResult.content}`);
+      await writeState(directory, state);
+      state.state = "debug_done";
+      await writeState(directory, state);
+      await client.app.log({
+        body: {
+          service: "opencode-manifold",
+          level: "info",
+          message: "State: debug_done - Senior implements Debug suggestion"
+        }
+      });
+      const debugSeniorPrompt = `You are the Senior Developer. A Debug agent has identified a root cause issue.
+
+Original Task: ${task.description}
+
+Debug Agent's Suggestion:
+${debugResult.content}
+
+Please implement the task following the Debug agent's suggestion.`;
+      const debugSeniorResult = await retryWithBackoff(() => spawnSeniorDevSession(client, debugSeniorPrompt, "senior-dev", settings.timeout), {
+        maxRetries: settings.maxRetries,
+        onRetry: (attempt, error) => {
+          client.app.log({
+            body: {
+              service: "opencode-manifold",
+              level: "warn",
+              message: `Debug Senior retry ${attempt}: ${error.message}`
+            }
+          });
+        }
+      });
+      if (!debugSeniorResult.success) {
+        state.state = "escalate_user";
+        await writeState(directory, state);
+        return {
+          status: "escalated_user",
+          summary: `Task ${task.task_number}: Debug Senior failed - ${debugSeniorResult.error}`,
+          files_changed: [],
+          loops: state.loop_count,
+          wiki_entry: `Manifold/tasks/${task.slug}-${task.task_number.toString().padStart(3, "0")}.md`
+        };
+      }
+      state.senior_output = debugSeniorResult.content;
+      state.loop_history.push(`**Debug Senior:** ${debugSeniorResult.content.substring(0, 200)}...`);
+      await writeState(directory, state);
+      state.state = "debug_review";
+      await writeState(directory, state);
+      await client.app.log({
+        body: {
+          service: "opencode-manifold",
+          level: "info",
+          message: "State: debug_review - Debug reviews implementation"
+        }
+      });
+      const debugReviewPrompt = `You are the Debug Agent reviewing the Senior Developer's implementation of your suggestion.
+
+Task: ${task.description}
+
+Your Original Suggestion:
+${state.debug_suggestion}
+
+Senior Developer's Implementation:
+${debugSeniorResult.content}
+
+Does the implementation follow your suggestion correctly? Does it resolve the issue? Respond with COMPLETE if acceptable, or QUESTIONS if there are still problems.`;
+      const debugReviewResult = await retryWithBackoff(() => spawnJuniorDevSession(client, debugReviewPrompt, debugSeniorResult.content, "debug", settings.timeout), {
+        maxRetries: settings.maxRetries,
+        onRetry: (attempt, error) => {
+          client.app.log({
+            body: {
+              service: "opencode-manifold",
+              level: "warn",
+              message: `Debug review retry ${attempt}: ${error.message}`
+            }
+          });
+        }
+      });
+      if (!debugReviewResult.success) {
+        state.state = "escalate_user";
+        await writeState(directory, state);
+        return {
+          status: "escalated_user",
+          summary: `Task ${task.task_number}: Debug review failed - ${debugReviewResult.error}`,
+          files_changed: [],
+          loops: state.loop_count,
+          wiki_entry: `Manifold/tasks/${task.slug}-${task.task_number.toString().padStart(3, "0")}.md`
+        };
+      }
+      const debugReviewWord = parseJuniorFirstWord(debugReviewResult.content);
+      if (debugReviewWord === "COMPLETE") {
+        state.state = "junior_approved";
+        await writeState(directory, state);
+        loopResult = {
+          approved: true,
+          seniorOutput: debugSeniorResult.content,
+          juniorResponse: debugReviewResult.content
+        };
+        break;
+      }
+      if (settings.clerkRetryEnabled && state.clerk_retry_count === 0) {
+        state.state = "escalate_clerk_retry";
+        await writeState(directory, state);
+        await client.app.log({
+          body: {
+            service: "opencode-manifold",
+            level: "info",
+            message: "State: escalate_clerk_retry - Clerk re-researches with failure context"
+          }
+        });
+        state.clerk_retry_count++;
+        state.loop_count = 0;
+        state.loop_history = [];
+        await writeState(directory, state);
+        const clerkRetryPrompt = `You are the Clerk. The previous implementation attempt failed. Re-research with failure context.
+
+Original Task: ${task.description}
+
+Previous Implementation (failed):
+${state.senior_output}
+
+Junior Dev's Feedback:
+${state.junior_response}
+
+Debug Agent's Suggestion (also didn't work):
+${state.debug_suggestion}
+
+Please re-research the task with this failure context and compose a new scoped prompt that addresses the underlying issues.`;
+        const clerkRetryResult = await retryWithBackoff(() => spawnClerkSession(client, clerkRetryPrompt, "clerk", settings.timeout), {
+          maxRetries: settings.maxRetries,
+          onRetry: (attempt, error) => {
+            client.app.log({
+              body: {
+                service: "opencode-manifold",
+                level: "warn",
+                message: `Clerk retry retry ${attempt}: ${error.message}`
+              }
+            });
+          }
+        });
+        if (!clerkRetryResult.success) {
+          state.state = "escalate_user";
+          await writeState(directory, state);
+          return {
+            status: "escalated_user",
+            summary: `Task ${task.task_number}: Clerk retry failed - ${clerkRetryResult.error}`,
+            files_changed: [],
+            loops: state.loop_count,
+            wiki_entry: `Manifold/tasks/${task.slug}-${task.task_number.toString().padStart(3, "0")}.md`
+          };
+        }
+        state.scoped_prompt = clerkRetryResult.content;
+        state.state = "clerk_retry";
+        await writeState(directory, state);
+        await client.app.log({
+          body: {
+            service: "opencode-manifold",
+            level: "info",
+            message: "State: clerk_retry - Starting fresh loop with new prompt"
+          }
+        });
+        loopResult = await runSeniorJuniorLoop();
+      } else {
+        state.state = "escalate_user";
+        await writeState(directory, state);
+        return {
+          status: "escalated_user",
+          summary: `Task ${task.task_number}: All loops exhausted. Last feedback: ${state.junior_response}`,
+          files_changed: [],
+          loops: state.loop_count,
+          wiki_entry: `Manifold/tasks/${task.slug}-${task.task_number.toString().padStart(3, "0")}.md`
+        };
+      }
+    } else {
+      state.state = "junior_rejected";
+      await writeState(directory, state);
+      await client.app.log({
+        body: {
+          service: "opencode-manifold",
+          level: "info",
+          message: `Junior rejected, looping back to Senior with feedback (loop ${state.loop_count + 1})`
+        }
+      });
+      const basePrompt = state.scoped_prompt ?? "";
+      const feedbackSection = `
+
+---
+
+Junior Developer Feedback (must address):
+` + (state.junior_response ?? "") + `
+
+Please address these issues and resubmit your implementation.`;
+      const seniorRetryPrompt = basePrompt + feedbackSection;
+      state.scoped_prompt = seniorRetryPrompt;
+      await writeState(directory, state);
+      loopResult = await runSeniorJuniorLoop();
+    }
+  }
+  const { files_changed } = await runClerkLoggingPhase(client, task, state, settings, directory);
+  state.state = "complete";
+  await writeState(directory, state);
+  await client.app.log({
+    body: {
+      service: "opencode-manifold",
+      level: "info",
+      message: `State: complete - Task ${task.task_number} completed in ${state.loop_count} loops`
+    }
+  });
+  return {
+    status: "completed",
+    summary: `Task ${task.task_number}: ${task.description} - Completed successfully`,
+    files_changed,
+    loops: state.loop_count,
+    wiki_entry: `Manifold/tasks/${task.slug}-${task.task_number.toString().padStart(3, "0")}.md`
+  };
+}
+
+// src/test-runner.ts
+import { spawn } from "child_process";
+async function runTest(directory, taskDescription, options) {
+  const testCommand = extractTestCommand(taskDescription) || options.testCommand;
+  if (!testCommand) {
+    return { skip: true };
+  }
+  return new Promise((resolve) => {
+    const child = spawn(testCommand, [], {
+      shell: true,
+      cwd: directory
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    const timeout = setTimeout(() => {
+      child.kill();
+      resolve({
+        skip: false,
+        result: {
+          passed: false,
+          output: `Test timed out after ${options.timeout}s`,
+          exitCode: 124
+        }
+      });
+    }, options.timeout * 1000);
+    child.on("close", (code) => {
+      clearTimeout(timeout);
+      const exitCode = code ?? 0;
+      const output = stdout + (stderr ? `
+STDERR:
+` + stderr : "");
+      resolve({
+        skip: false,
+        result: {
+          passed: exitCode === 0,
+          output: output || "No output",
+          exitCode
+        }
+      });
+    });
+    child.on("error", (error) => {
+      clearTimeout(timeout);
+      resolve({
+        skip: false,
+        result: {
+          passed: false,
+          output: error.message,
+          exitCode: 1
+        }
+      });
+    });
+  });
+}
+function extractTestCommand(taskDescription) {
+  const testPatterns = [
+    /test:\s*(.+)/i,
+    /run:\s*(.+)/i,
+    /execute:\s*(.+)/i,
+    /```bash\n(.+)\n```/,
+    /`([^`]+)`/
+  ];
+  for (const pattern of testPatterns) {
+    const match = taskDescription.match(pattern);
+    if (match && match[1]) {
+      return match[1].trim();
+    }
+  }
+  return null;
+}
+
+// src/tools/dispatch-task.ts
+var pluginClient = null;
+function setPluginContext(client) {
+  pluginClient = client;
+}
+async function readSettings(directory) {
+  const settingsPath = join4(directory, "Manifold", "settings.json");
+  if (existsSync4(settingsPath)) {
+    const content = await readFile4(settingsPath, "utf-8");
+    return JSON.parse(content);
+  }
+  return {
+    maxLoops: 3,
+    maxRetries: 1,
+    maxResults: 10,
+    recentTaskCount: 3,
+    clerkRetryEnabled: true,
+    timeout: 300,
+    testCommand: null
+  };
+}
+async function updatePlansRegistry(directory, planFile) {
+  const plansPath = join4(directory, "Manifold", "plans.json");
+  let plans = {};
+  if (existsSync4(plansPath)) {
+    const content = await readFile4(plansPath, "utf-8");
+    plans = JSON.parse(content);
+  }
+  const planSlug = planFile.replace(/[^a-zA-Z0-9]/g, "-").toLowerCase().substring(0, 30);
+  if (!plans[planSlug]) {
+    plans[planSlug] = {
+      full_title: planFile,
+      task_count: 0,
+      status: "in_progress",
+      created: new Date().toISOString().split("T")[0],
+      plan_file: planFile
+    };
+  }
+  plans[planSlug].task_count++;
+  await writeFile4(plansPath, JSON.stringify(plans, null, 2));
+  return plans[planSlug].task_count;
+}
+function getClient() {
+  if (!pluginClient) {
+    throw new Error("Plugin client not initialized");
+  }
+  return pluginClient;
+}
+var dispatchTaskTool = tool({
+  description: "Dispatch a task to the multi-agent development system. The Lead Dev agent uses this to execute tasks from a plan.",
+  args: {
+    task_number: tool.schema.number().describe("Sequential task number"),
+    description: tool.schema.string().describe("One-line task description"),
+    plan_file: tool.schema.string().describe("Path to the plan document")
+  },
+  async execute(args) {
+    const { task_number, description, plan_file } = args;
+    const client = getClient();
+    await client.app.log({
+      body: {
+        service: "opencode-manifold",
+        level: "info",
+        message: `dispatchTask called: task ${task_number} - ${description}`
+      }
+    });
+    const directory = process.cwd();
+    const settings = await readSettings(directory);
+    await updatePlansRegistry(directory, plan_file);
+    await client.app.log({
+      body: {
+        service: "opencode-manifold",
+        level: "info",
+        message: `Settings loaded: maxLoops=${settings.maxLoops}, timeout=${settings.timeout}s`
+      }
+    });
+    const slug = plan_file.replace(/[^a-zA-Z0-9]/g, "-").toLowerCase().substring(0, 30);
+    const stateMachineResult = await runStateMachine({
+      task_number,
+      description,
+      plan_file,
+      slug
+    }, settings, { client, directory });
+    await client.app.log({
+      body: {
+        service: "opencode-manifold",
+        level: "info",
+        message: `State machine completed: ${stateMachineResult.status}`
+      }
+    });
+    const testResult = await runTest(directory, description, { testCommand: settings.testCommand, timeout: settings.timeout });
+    if (!testResult.skip && testResult.result) {
+      if (testResult.result.passed) {
+        await client.app.log({
+          body: {
+            service: "opencode-manifold",
+            level: "info",
+            message: "Test passed"
+          }
+        });
+      } else {
+        await client.app.log({
+          body: {
+            service: "opencode-manifold",
+            level: "error",
+            message: `Test failed: ${testResult.result.output}`
+          }
+        });
+        return JSON.stringify({
+          status: "escalated_user",
+          summary: `Task ${task_number}: ${description} - Test failed
+
+${testResult.result.output}`,
+          files_changed: stateMachineResult.files_changed,
+          loops: stateMachineResult.loops,
+          wiki_entry: stateMachineResult.wiki_entry
+        });
+      }
+    }
+    await client.app.log({
+      body: {
+        service: "opencode-manifold",
+        level: "info",
+        message: `dispatchTask completed: task ${task_number}`
+      }
+    });
+    return JSON.stringify({
+      status: stateMachineResult.status,
+      summary: stateMachineResult.summary,
+      files_changed: stateMachineResult.files_changed,
+      loops: stateMachineResult.loops,
+      wiki_entry: stateMachineResult.wiki_entry
+    });
+  }
+});
+
+// src/index.ts
+var ManifoldPlugin = async (ctx) => {
+  setPluginContext(ctx.client);
+  await ctx.client.app.log({
+    body: {
+      service: "opencode-manifold",
+      level: "info",
+      message: "Open Manifold plugin loaded"
+    }
+  });
+  return {
+    tool: {
+      dispatchTask: dispatchTaskTool
+    },
+    event: async ({ event }) => {
+      if (event.type === "session.created") {
+        await ctx.client.app.log({
+          body: {
+            service: "opencode-manifold",
+            level: "info",
+            message: "Session created, checking for Open Manifold setup"
+          }
+        });
+        await setupProject(ctx.directory, ctx.client);
+      }
+    }
+  };
+};
+export {
+  ManifoldPlugin
+};