@locusai/sdk 0.12.0 → 0.12.1

package/dist/index-node.js

@@ -522,9 +522,6 @@ var init_src = __esm(() => {
 
 // src/core/config.ts
 function getLocusPath(projectPath, fileName) {
-  if (fileName === "projectContextFile" || fileName === "projectProgressFile") {
-    return import_node_path.join(projectPath, LOCUS_CONFIG.dir, LOCUS_CONFIG.projectDir, LOCUS_CONFIG[fileName]);
-  }
   return import_node_path.join(projectPath, LOCUS_CONFIG.dir, LOCUS_CONFIG[fileName]);
 }
 function getAgentArtifactsPath(projectPath, agentId) {
@@ -552,14 +549,12 @@ var init_config = __esm(() => {
     settingsFile: "settings.json",
     indexFile: "codebase-index.json",
     contextFile: "LOCUS.md",
+    learningsFile: "LEARNINGS.md",
     artifactsDir: "artifacts",
     documentsDir: "documents",
     sessionsDir: "sessions",
     reviewsDir: "reviews",
-    plansDir: "plans",
-    projectDir: "project",
-    projectContextFile: "context.md",
-    projectProgressFile: "progress.md"
+    plansDir: "plans"
   };
   LOCUS_GITIGNORE_PATTERNS = [
     "# Locus AI - Session data (user-specific, can grow large)",
@@ -577,11 +572,8 @@ var init_config = __esm(() => {
     "# Locus AI - Settings (contains API key, telegram config, etc.)",
     ".locus/settings.json",
     "",
-    "# Locus AI - Configuration (contains project context, progress, etc.)",
-    ".locus/config.json",
-    "",
-    "# Locus AI - Project progress (contains project progress, etc.)",
-    ".locus/project/progress.md"
+    "# Locus AI - Configuration (contains project context, etc.)",
+    ".locus/config.json"
   ];
 });
 
@@ -820,17 +812,22 @@ class ClaudeRunner {
       });
     });
   }
-  async* runStream(prompt) {
+  buildCliArgs() {
     const args = [
-      "--dangerously-skip-permissions",
       "--print",
-      "--verbose",
       "--output-format",
       "stream-json",
+      "--verbose",
+      "--dangerously-skip-permissions",
+      "--no-session-persistence",
       "--include-partial-messages",
       "--model",
       this.model
     ];
+    return args;
+  }
+  async* runStream(prompt) {
+    const args = this.buildCliArgs();
     const env = getAugmentedEnv({
       FORCE_COLOR: "1",
       TERM: "xterm-256color"
@@ -1070,16 +1067,7 @@ class ClaudeRunner {
   }
   executeRun(prompt) {
     return new Promise((resolve2, reject) => {
-      const args = [
-        "--dangerously-skip-permissions",
-        "--print",
-        "--verbose",
-        "--output-format",
-        "stream-json",
-        "--include-partial-messages",
-        "--model",
-        this.model
-      ];
+      const args = this.buildCliArgs();
       const env = getAugmentedEnv({
         FORCE_COLOR: "1",
         TERM: "xterm-256color"
@@ -1200,7 +1188,7 @@ class CodexRunner {
   eventEmitter;
   currentToolName;
   timeoutMs;
-  constructor(projectPath, model = DEFAULT_MODEL[PROVIDER.CODEX], log, timeoutMs, reasoningEffort) {
+  constructor(projectPath, model = DEFAULT_MODEL[PROVIDER.CODEX], log, reasoningEffort, timeoutMs) {
     this.projectPath = projectPath;
     this.model = model;
     this.log = log;
@@ -1531,7 +1519,7 @@ function createAiRunner(provider, config) {
   const model = config.model ?? DEFAULT_MODEL[resolvedProvider];
   switch (resolvedProvider) {
     case PROVIDER.CODEX:
-      return new CodexRunner(config.projectPath, model, config.log, config.timeoutMs, config.reasoningEffort ?? "high");
+      return new CodexRunner(config.projectPath, model, config.log, config.reasoningEffort ?? "high", config.timeoutMs);
     default:
       return new ClaudeRunner(config.projectPath, model, config.log, config.timeoutMs);
   }
@@ -1638,102 +1626,6 @@ var init_git_utils = __esm(() => {
   import_node_child_process3 = require("node:child_process");
 });
 
-// src/project/knowledge-base.ts
-class KnowledgeBase {
-  contextPath;
-  progressPath;
-  constructor(projectPath) {
-    this.contextPath = getLocusPath(projectPath, "projectContextFile");
-    this.progressPath = getLocusPath(projectPath, "projectProgressFile");
-  }
-  readContext() {
-    if (!import_node_fs3.existsSync(this.contextPath)) {
-      return "";
-    }
-    return import_node_fs3.readFileSync(this.contextPath, "utf-8");
-  }
-  readProgress() {
-    if (!import_node_fs3.existsSync(this.progressPath)) {
-      return "";
-    }
-    return import_node_fs3.readFileSync(this.progressPath, "utf-8");
-  }
-  updateContext(content) {
-    this.ensureDir(this.contextPath);
-    import_node_fs3.writeFileSync(this.contextPath, content);
-  }
-  updateProgress(entry) {
-    this.ensureDir(this.progressPath);
-    const existing = this.readProgress();
-    const timestamp = (entry.timestamp ?? new Date).toISOString();
-    const label = entry.role === "user" ? "User" : "Assistant";
-    const line = `**${label}** (${timestamp}):
-${entry.content}`;
-    const updated = existing ? `${existing}
-
----
-
-${line}` : `# Conversation History
-
-${line}`;
-    import_node_fs3.writeFileSync(this.progressPath, updated);
-  }
-  getFullContext() {
-    const context = this.readContext();
-    const parts = [];
-    if (context.trim()) {
-      parts.push(context.trim());
-    }
-    return parts.join(`
-
----
-
-`);
-  }
-  initialize(info) {
-    this.ensureDir(this.contextPath);
-    this.ensureDir(this.progressPath);
-    const techStackList = info.techStack.map((t) => `- ${t}`).join(`
-`);
-    const contextContent = `# Project: ${info.name}
-
-## Mission
-${info.mission}
-
-## Tech Stack
-${techStackList}
-
-## Architecture
-<!-- Describe your high-level architecture here -->
-
-## Key Decisions
-<!-- Document important technical decisions and their rationale -->
-
-## Feature Areas
-<!-- List your main feature areas and their status -->
-`;
-    const progressContent = `# Conversation History
-`;
-    import_node_fs3.writeFileSync(this.contextPath, contextContent);
-    import_node_fs3.writeFileSync(this.progressPath, progressContent);
-  }
-  get exists() {
-    return import_node_fs3.existsSync(this.contextPath) || import_node_fs3.existsSync(this.progressPath);
-  }
-  ensureDir(filePath) {
-    const dir = import_node_path5.dirname(filePath);
-    if (!import_node_fs3.existsSync(dir)) {
-      import_node_fs3.mkdirSync(dir, { recursive: true });
-    }
-  }
-}
-var import_node_fs3, import_node_path5;
-var init_knowledge_base = __esm(() => {
-  init_config();
-  import_node_fs3 = require("node:fs");
-  import_node_path5 = require("node:path");
-});
-
 // src/agent/git-workflow.ts
 class GitWorkflow {
   config;
@@ -1985,223 +1877,157 @@ class PromptBuilder {
   constructor(projectPath) {
     this.projectPath = projectPath;
   }
-  async build(task, options = {}) {
-    let prompt = `# Task: ${task.title}
-
-`;
+  async build(task) {
     const roleText = this.roleToText(task.assigneeRole);
+    const description = task.description || "No description provided.";
+    const context = this.getProjectContext();
+    const learnings = this.getLearningsContent();
+    const knowledgeBase = this.getKnowledgeBaseSection();
+    let sections = "";
     if (roleText) {
-      prompt += `## Role
+      sections += `
+<role>
 You are acting as a ${roleText}.
-
+</role>
 `;
     }
-    prompt += `## Description
-${task.description || "No description provided."}
-
-`;
-    const projectConfig = this.getProjectConfig();
-    if (projectConfig) {
-      prompt += `## Project Metadata
-`;
-      prompt += `- Version: ${projectConfig.version || "Unknown"}
-`;
-      prompt += `- Created At: ${projectConfig.createdAt || "Unknown"}
-
-`;
-    }
-    let serverContext = null;
-    if (options.taskContext) {
-      try {
-        serverContext = JSON.parse(options.taskContext);
-      } catch {
-        serverContext = { context: options.taskContext };
-      }
-    }
-    const contextPath = getLocusPath(this.projectPath, "contextFile");
-    let hasLocalContext = false;
-    if (import_node_fs4.existsSync(contextPath)) {
-      try {
-        const context = import_node_fs4.readFileSync(contextPath, "utf-8");
-        if (context.trim().length > 20) {
-          prompt += `## Project Context (Local)
+    if (context) {
+      sections += `
+<project_context>
 ${context}
-
+</project_context>
 `;
-          hasLocalContext = true;
-        }
-      } catch (err) {
-        console.warn(`Warning: Could not read context file: ${err}`);
-      }
     }
-    if (!hasLocalContext) {
-      const fallback = this.getFallbackContext();
-      if (fallback) {
-        prompt += `## Project Context (README Fallback)
-${fallback}
-
+    sections += `
+<knowledge_base>
+${knowledgeBase}
+</knowledge_base>
 `;
-      }
-    }
-    if (serverContext) {
-      prompt += `## Project Context (Server)
-`;
-      const project = serverContext.project;
-      if (project) {
-        prompt += `- Project: ${project.name || "Unknown"}
-`;
-        if (!hasLocalContext && project.techStack?.length) {
-          prompt += `- Tech Stack: ${project.techStack.join(", ")}
-`;
-        }
-      }
-      if (serverContext.context) {
-        prompt += `
-${serverContext.context}
-`;
-      }
-      prompt += `
+    if (learnings) {
+      sections += `
+<learnings>
+These are accumulated lessons from past tasks. Follow them to avoid repeating mistakes:
+${learnings}
+</learnings>
 `;
     }
-    prompt += this.getProjectStructure();
-    prompt += `## Project Knowledge Base
-`;
-    prompt += `You have access to the following documentation directories for context:
-`;
-    prompt += `- Artifacts: \`.locus/artifacts\`
-`;
-    prompt += `- Documents: \`.locus/documents\`
-`;
-    prompt += `If you need more information about the project strategies, plans, or architecture, please read files in these directories.
-
-`;
     if (task.docs && task.docs.length > 0) {
-      prompt += `## Attached Documents (Summarized)
-`;
-      prompt += `> Full content available on server. Rely on Task Description for specific requirements.
-
-`;
+      let docsContent = "";
       for (const doc of task.docs) {
         const content = doc.content || "";
         const limit = 800;
         const preview = content.slice(0, limit);
         const isTruncated = content.length > limit;
-        prompt += `### Doc: ${doc.title}
+        docsContent += `### ${doc.title}
 ${preview}${isTruncated ? `
 ...(truncated)...` : ""}
 
 `;
       }
+      sections += `
+<documents>
+${docsContent.trimEnd()}
+</documents>
+`;
     }
     if (task.acceptanceChecklist && task.acceptanceChecklist.length > 0) {
-      prompt += `## Acceptance Criteria
-`;
+      let criteria = "";
       for (const item of task.acceptanceChecklist) {
-        prompt += `- ${item.done ? "[x]" : "[ ]"} ${item.text}
+        criteria += `- ${item.done ? "[x]" : "[ ]"} ${item.text}
 `;
       }
-      prompt += `
+      sections += `
+<acceptance_criteria>
+${criteria.trimEnd()}
+</acceptance_criteria>
 `;
     }
     if (task.comments && task.comments.length > 0) {
       const filteredComments = task.comments.filter((comment) => comment.author !== "system");
       const comments = filteredComments.slice(0, 3);
-      prompt += `## Task Comments & Feedback
+      if (comments.length > 0) {
+        let commentsContent = "";
+        for (const comment of comments) {
+          const date = new Date(comment.createdAt).toLocaleString();
+          commentsContent += `- ${comment.author} (${date}): ${comment.text}
 `;
-      for (const comment of comments) {
-        const date = new Date(comment.createdAt).toLocaleString();
-        prompt += `- ${comment.author} (${date}): ${comment.text}
+        }
+        sections += `
+<feedback>
+${commentsContent.trimEnd()}
+</feedback>
 `;
       }
-      prompt += `
-`;
     }
-    prompt += `## Instructions
-1. Complete this task.
-2. **Artifact Management**: If you create any high-level documentation (PRDs, technical drafts, architecture docs), you MUST save them in \`.locus/artifacts/\`. Do NOT create them in the root directory.
-3. **Paths**: Use relative paths from the project root at all times. Do NOT use absolute local paths (e.g., /Users/...).
-4. **Git**: Do NOT run \`git add\`, \`git commit\`, \`git push\`, or create branches. The Locus system handles all git operations automatically after your execution completes.
-5. **Progress**: Do NOT modify \`.locus/project/progress.md\`. The system updates it automatically.`;
-    return prompt;
+    return `<task_execution>
+Complete this task: ${task.title}
+
+<description>
+${description}
+</description>
+${sections}
+<rules>
+- Complete the task as described
+- Save any high-level documentation (PRDs, technical drafts, architecture docs) in \`.locus/artifacts/\`
+- Use relative paths from the project root at all times — no absolute local paths
+- Do NOT run \`git add\`, \`git commit\`, \`git push\`, or create branches — Locus handles git automatically
+</rules>
+</task_execution>`;
   }
   async buildGenericPrompt(query) {
-    let prompt = `# Direct Execution
-
-`;
-    prompt += `## Prompt
-${query}
-
-`;
-    const projectConfig = this.getProjectConfig();
-    if (projectConfig) {
-      prompt += `## Project Metadata
+    const context = this.getProjectContext();
+    const learnings = this.getLearningsContent();
+    const knowledgeBase = this.getKnowledgeBaseSection();
+    let sections = "";
+    if (context) {
+      sections += `
+<project_context>
+${context}
+</project_context>
 `;
-      prompt += `- Version: ${projectConfig.version || "Unknown"}
+    }
+    sections += `
+<knowledge_base>
+${knowledgeBase}
+</knowledge_base>
 `;
-      prompt += `- Created At: ${projectConfig.createdAt || "Unknown"}
-
+    if (learnings) {
+      sections += `
+<learnings>
+These are accumulated lessons from past tasks. Follow them to avoid repeating mistakes:
+${learnings}
+</learnings>
 `;
     }
+    return `<direct_execution>
+Execute this prompt: ${query}
+${sections}
+<rules>
+- Execute the prompt based on the provided project context
+- Use relative paths from the project root at all times — no absolute local paths
+- Do NOT run \`git add\`, \`git commit\`, \`git push\`, or create branches — Locus handles git automatically
+</rules>
+</direct_execution>`;
+  }
+  getProjectContext() {
     const contextPath = getLocusPath(this.projectPath, "contextFile");
-    let hasLocalContext = false;
-    if (import_node_fs4.existsSync(contextPath)) {
+    if (import_node_fs3.existsSync(contextPath)) {
       try {
-        const context = import_node_fs4.readFileSync(contextPath, "utf-8");
+        const context = import_node_fs3.readFileSync(contextPath, "utf-8");
         if (context.trim().length > 20) {
-          prompt += `## Project Context (Local)
-${context}
-
-`;
-          hasLocalContext = true;
+          return context;
         }
       } catch (err) {
         console.warn(`Warning: Could not read context file: ${err}`);
       }
     }
-    if (!hasLocalContext) {
-      const fallback = this.getFallbackContext();
-      if (fallback) {
-        prompt += `## Project Context (README Fallback)
-${fallback}
-
-`;
-      }
-    }
-    prompt += this.getProjectStructure();
-    prompt += `## Project Knowledge Base
-`;
-    prompt += `You have access to the following documentation directories for context:
-`;
-    prompt += `- Artifacts: \`.locus/artifacts\` (local-only, not synced to cloud)
-`;
-    prompt += `- Documents: \`.locus/documents\` (synced from cloud)
-`;
-    prompt += `If you need more information about the project strategies, plans, or architecture, please read files in these directories.
-
-`;
-    prompt += `## Instructions
-1. Execute the prompt based on the provided project context.
-2. **Paths**: Use relative paths from the project root at all times. Do NOT use absolute local paths (e.g., /Users/...).
-3. **Git**: Do NOT run \`git add\`, \`git commit\`, \`git push\`, or create branches. The Locus system handles all git operations automatically after your execution completes.
-4. **Progress**: Do NOT modify \`.locus/project/progress.md\`. The system updates it automatically.`;
-    return prompt;
-  }
-  getProjectConfig() {
-    const configPath = getLocusPath(this.projectPath, "configFile");
-    if (import_node_fs4.existsSync(configPath)) {
-      try {
-        return JSON.parse(import_node_fs4.readFileSync(configPath, "utf-8"));
-      } catch {
-        return null;
-      }
-    }
-    return null;
+    return this.getFallbackContext() || null;
   }
   getFallbackContext() {
-    const readmePath = import_node_path6.join(this.projectPath, "README.md");
-    if (import_node_fs4.existsSync(readmePath)) {
+    const readmePath = import_node_path5.join(this.projectPath, "README.md");
+    if (import_node_fs3.existsSync(readmePath)) {
       try {
-        const content = import_node_fs4.readFileSync(readmePath, "utf-8");
+        const content = import_node_fs3.readFileSync(readmePath, "utf-8");
         const limit = 1000;
         return content.slice(0, limit) + (content.length > limit ? `
 ...(truncated)...` : "");
@@ -2211,32 +2037,28 @@ ${fallback}
     }
     return "";
   }
-  getProjectStructure() {
+  getKnowledgeBaseSection() {
+    return `You have access to the following documentation directories for context:
+- Artifacts: \`.locus/artifacts\` (local-only, not synced to cloud)
+- Documents: \`.locus/documents\` (synced from cloud)
+If you need more information about the project strategies, plans, or architecture, read files in these directories.`;
+  }
+  getLearningsContent() {
+    const learningsPath = getLocusPath(this.projectPath, "learningsFile");
+    if (!import_node_fs3.existsSync(learningsPath)) {
+      return null;
+    }
     try {
-      const entries = import_node_fs4.readdirSync(this.projectPath);
-      const folders = entries.filter((e) => {
-        if (e.startsWith(".") || e === "node_modules")
-          return false;
-        try {
-          return import_node_fs4.statSync(import_node_path6.join(this.projectPath, e)).isDirectory();
-        } catch {
-          return false;
-        }
-      });
-      if (folders.length === 0)
-        return "";
-      let structure = `## Project Structure
-`;
-      structure += `Key directories in this project:
-`;
-      for (const folder of folders) {
-        structure += `- \`${folder}/\`
-`;
+      const content = import_node_fs3.readFileSync(learningsPath, "utf-8");
+      const lines = content.split(`
+`).filter((l) => l.startsWith("- "));
+      if (lines.length === 0) {
+        return null;
       }
-      return `${structure}
-`;
+      return lines.join(`
+`);
     } catch {
-      return "";
+      return null;
     }
   }
   roleToText(role) {
@@ -2259,11 +2081,11 @@ ${fallback}
     }
   }
 }
-var import_node_fs4, import_node_path6, import_shared2;
+var import_node_fs3, import_node_path5, import_shared2;
 var init_prompt_builder = __esm(() => {
   init_config();
-  import_node_fs4 = require("node:fs");
-  import_node_path6 = require("node:path");
+  import_node_fs3 = require("node:fs");
+  import_node_path5 = require("node:path");
   import_shared2 = require("@locusai/shared");
 });
 
@@ -2381,7 +2203,6 @@ class AgentWorker {
   client;
   aiRunner;
   taskExecutor;
-  knowledgeBase;
   gitWorkflow;
   maxTasks = 50;
   tasksCompleted = 0;
@@ -2421,7 +2242,6 @@ class AgentWorker {
       projectPath,
       log
     });
-    this.knowledgeBase = new KnowledgeBase(projectPath);
     this.gitWorkflow = new GitWorkflow(config, log);
     const providerLabel = provider === "codex" ? "Codex" : "Claude";
     this.log(`Using ${providerLabel} CLI for all phases`, "info");
@@ -2495,20 +2315,6 @@ class AgentWorker {
       };
     }
   }
-  updateProgress(task, summary) {
-    try {
-      this.knowledgeBase.updateProgress({
-        role: "user",
-        content: task.title
-      });
-      this.knowledgeBase.updateProgress({
-        role: "assistant",
-        content: summary
-      });
-    } catch (err) {
-      this.log(`Failed to update progress: ${err instanceof Error ? err.message : String(err)}`, "warn");
-    }
-  }
   startHeartbeat() {
     this.sendHeartbeat();
     this.heartbeatInterval = setInterval(() => this.sendHeartbeat(), 60000);
@@ -2583,7 +2389,6 @@ Branch: \`${result.branch}\`` : "";
           this.tasksCompleted++;
           this.completedTaskList.push({ title: task.title, id: task.id });
           this.taskSummaries.push(result.summary);
-          this.updateProgress(task, result.summary);
         }
       } else {
         this.log(`Failed: ${task.title} - ${result.summary}`, "error");
@@ -2628,7 +2433,6 @@ var init_worker = __esm(() => {
   init_config();
   init_git_utils();
   init_src();
-  init_knowledge_base();
   init_colors();
   init_git_workflow();
   init_task_executor();
@@ -2653,6 +2457,7 @@ __export(exports_index_node, {
   sprintPlanToMarkdown: () => sprintPlanToMarkdown,
   plannedTasksToCreatePayloads: () => plannedTasksToCreatePayloads,
   parseSprintPlanFromAI: () => parseSprintPlanFromAI,
+  parseJsonWithSchema: () => parseJsonWithSchema,
   getRemoteUrl: () => getRemoteUrl,
   getLocusPath: () => getLocusPath,
   getDefaultBranch: () => getDefaultBranch,
@@ -2681,7 +2486,6 @@ __export(exports_index_node, {
   LOCUS_SCHEMAS: () => LOCUS_SCHEMAS,
   LOCUS_GITIGNORE_PATTERNS: () => LOCUS_GITIGNORE_PATTERNS,
   LOCUS_CONFIG: () => LOCUS_CONFIG,
-  KnowledgeBase: () => KnowledgeBase,
   InvitationsModule: () => InvitationsModule,
   HistoryManager: () => HistoryManager,
   GitWorkflow: () => GitWorkflow,
@@ -2705,8 +2509,8 @@ module.exports = __toCommonJS(exports_index_node);
 
 // src/core/indexer.ts
 var import_node_crypto2 = require("node:crypto");
-var import_node_fs5 = require("node:fs");
-var import_node_path7 = require("node:path");
+var import_node_fs4 = require("node:fs");
+var import_node_path6 = require("node:path");
 var import_globby = require("globby");
 
 class CodebaseIndexer {
@@ -2715,7 +2519,7 @@ class CodebaseIndexer {
   fullReindexRatioThreshold = 0.2;
   constructor(projectPath) {
     this.projectPath = projectPath;
-    this.indexPath = import_node_path7.join(projectPath, ".locus", "codebase-index.json");
+    this.indexPath = import_node_path6.join(projectPath, ".locus", "codebase-index.json");
   }
   async index(onProgress, treeSummarizer, force = false) {
     if (!treeSummarizer) {
@@ -2771,11 +2575,11 @@ class CodebaseIndexer {
     }
   }
   async getFileTree() {
-    const gitmodulesPath = import_node_path7.join(this.projectPath, ".gitmodules");
+    const gitmodulesPath = import_node_path6.join(this.projectPath, ".gitmodules");
     const submoduleIgnores = [];
-    if (import_node_fs5.existsSync(gitmodulesPath)) {
+    if (import_node_fs4.existsSync(gitmodulesPath)) {
       try {
-        const content = import_node_fs5.readFileSync(gitmodulesPath, "utf-8");
+        const content = import_node_fs4.readFileSync(gitmodulesPath, "utf-8");
         const lines = content.split(`
 `);
         for (const line of lines) {
@@ -2831,9 +2635,9 @@ class CodebaseIndexer {
     });
   }
   loadIndex() {
-    if (import_node_fs5.existsSync(this.indexPath)) {
+    if (import_node_fs4.existsSync(this.indexPath)) {
       try {
-        return JSON.parse(import_node_fs5.readFileSync(this.indexPath, "utf-8"));
+        return JSON.parse(import_node_fs4.readFileSync(this.indexPath, "utf-8"));
       } catch {
         return null;
       }
@@ -2841,11 +2645,11 @@ class CodebaseIndexer {
     return null;
   }
   saveIndex(index) {
-    const dir = import_node_path7.dirname(this.indexPath);
-    if (!import_node_fs5.existsSync(dir)) {
-      import_node_fs5.mkdirSync(dir, { recursive: true });
+    const dir = import_node_path6.dirname(this.indexPath);
+    if (!import_node_fs4.existsSync(dir)) {
+      import_node_fs4.mkdirSync(dir, { recursive: true });
     }
-    import_node_fs5.writeFileSync(this.indexPath, JSON.stringify(index, null, 2));
+    import_node_fs4.writeFileSync(this.indexPath, JSON.stringify(index, null, 2));
   }
   cloneIndex(index) {
     return JSON.parse(JSON.stringify(index));
@@ -2861,7 +2665,7 @@ class CodebaseIndexer {
   }
   hashFile(filePath) {
     try {
-      const content = import_node_fs5.readFileSync(import_node_path7.join(this.projectPath, filePath), "utf-8");
+      const content = import_node_fs4.readFileSync(import_node_path6.join(this.projectPath, filePath), "utf-8");
       return import_node_crypto2.createHash("sha256").update(content).digest("hex").slice(0, 16);
     } catch {
       return null;
@@ -2925,43 +2729,42 @@ class CodebaseIndexer {
 // src/utils/json-extractor.ts
 function extractJsonFromLLMOutput(raw) {
   const trimmed = raw.trim();
-  const codeBlockMatch = trimmed.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
-  if (codeBlockMatch) {
-    return codeBlockMatch[1]?.trim() || "";
-  }
-  const startIdx = trimmed.indexOf("{");
-  if (startIdx === -1) {
-    return trimmed;
-  }
-  let depth = 0;
-  let inString = false;
-  let escaped = false;
-  for (let i = startIdx;i < trimmed.length; i++) {
-    const ch = trimmed[i];
-    if (escaped) {
-      escaped = false;
-      continue;
-    }
-    if (inString) {
+  const fenceMatch = trimmed.match(/```(?:json)?\s*\n?([\s\S]*?)\n?\s*```/);
+  if (fenceMatch) {
+    return fenceMatch[1].trim();
+  }
+  const start = trimmed.indexOf("{");
+  if (start !== -1) {
+    let depth = 0;
+    let inString = false;
+    let isEscape = false;
+    for (let i = start;i < trimmed.length; i++) {
+      const ch = trimmed[i];
+      if (isEscape) {
+        isEscape = false;
+        continue;
+      }
       if (ch === "\\") {
-        escaped = true;
-      } else if (ch === '"') {
-        inString = false;
+        isEscape = true;
+        continue;
+      }
+      if (ch === '"') {
+        inString = !inString;
+        continue;
       }
-      continue;
-    }
-    if (ch === '"') {
-      inString = true;
-    } else if (ch === "{") {
-      depth++;
-    } else if (ch === "}") {
-      depth--;
-      if (depth === 0) {
-        return trimmed.slice(startIdx, i + 1);
+      if (inString)
+        continue;
+      if (ch === "{")
+        depth++;
+      else if (ch === "}") {
+        depth--;
+        if (depth === 0) {
+          return trimmed.slice(start, i + 1);
+        }
       }
     }
   }
-  return trimmed.slice(startIdx);
+  return trimmed;
 }
 
 // src/agent/codebase-indexer-service.ts
@@ -2975,22 +2778,30 @@ class CodebaseIndexerService {
   async reindex(force = false) {
     try {
       const index = await this.indexer.index((msg) => this.deps.log(msg, "info"), async (tree) => {
-        const prompt = `You are a codebase analysis expert. Analyze the file tree and extract:
-1. Key symbols (classes, functions, types) and their locations
-2. Responsibilities of each directory/file
-3. Overall project structure
+        const prompt = `<codebase_analysis>
+Analyze this codebase file tree and extract key information.
 
-Analyze this file tree and provide a JSON response with:
-- "symbols": object mapping symbol names to file paths (array)
-- "responsibilities": object mapping paths to brief descriptions
-
-File tree:
+<file_tree>
 ${tree}
+</file_tree>
+
+<rules>
+- Extract key symbols (classes, functions, types) and their file locations
+- Identify responsibilities of each directory/file
+- Map overall project structure
+</rules>
 
-Return ONLY valid JSON, no markdown formatting.`;
+<output>
+Return ONLY valid JSON (no code fences, no markdown):
+{
+  "symbols": { "symbolName": ["file/path.ts"] },
+  "responsibilities": { "path": "brief description" }
+}
+</output>
+</codebase_analysis>`;
         const response = await this.deps.aiRunner.run(prompt);
-        const jsonStr = extractJsonFromLLMOutput(response);
         try {
+          const jsonStr = extractJsonFromLLMOutput(response);
           return JSON.parse(jsonStr);
         } catch {
           return { symbols: {}, responsibilities: {}, lastIndexed: "" };
@@ -3009,8 +2820,8 @@ Return ONLY valid JSON, no markdown formatting.`;
 }
 // src/agent/document-fetcher.ts
 init_config();
-var import_node_fs6 = require("node:fs");
-var import_node_path8 = require("node:path");
+var import_node_fs5 = require("node:fs");
+var import_node_path7 = require("node:path");
 
 class DocumentFetcher {
   deps;
@@ -3019,8 +2830,8 @@ class DocumentFetcher {
   }
   async fetch() {
     const documentsDir = getLocusPath(this.deps.projectPath, "documentsDir");
-    if (!import_node_fs6.existsSync(documentsDir)) {
-      import_node_fs6.mkdirSync(documentsDir, { recursive: true });
+    if (!import_node_fs5.existsSync(documentsDir)) {
+      import_node_fs5.mkdirSync(documentsDir, { recursive: true });
     }
     try {
       const groups = await this.deps.client.docs.listGroups(this.deps.workspaceId);
@@ -3033,14 +2844,14 @@ class DocumentFetcher {
           continue;
         }
         const groupName = groupMap.get(doc.groupId || "") || "General";
-        const groupDir = import_node_path8.join(documentsDir, groupName);
-        if (!import_node_fs6.existsSync(groupDir)) {
-          import_node_fs6.mkdirSync(groupDir, { recursive: true });
+        const groupDir = import_node_path7.join(documentsDir, groupName);
+        if (!import_node_fs5.existsSync(groupDir)) {
+          import_node_fs5.mkdirSync(groupDir, { recursive: true });
         }
         const fileName = `${doc.title}.md`;
-        const filePath = import_node_path8.join(groupDir, fileName);
-        if (!import_node_fs6.existsSync(filePath) || import_node_fs6.readFileSync(filePath, "utf-8") !== doc.content) {
-          import_node_fs6.writeFileSync(filePath, doc.content || "");
+        const filePath = import_node_path7.join(groupDir, fileName);
+        if (!import_node_fs5.existsSync(filePath) || import_node_fs5.readFileSync(filePath, "utf-8") !== doc.content) {
+          import_node_fs5.writeFileSync(filePath, doc.content || "");
           fetchedCount++;
         }
       }
@@ -3356,7 +3167,6 @@ class PrService {
 
 // src/agent/reviewer-worker.ts
 init_src();
-init_knowledge_base();
 init_colors();
 function resolveProvider2(value) {
   if (!value || value.startsWith("--"))
@@ -3371,7 +3181,6 @@ class ReviewerWorker {
   client;
   aiRunner;
   prService;
-  knowledgeBase;
   heartbeatInterval = null;
   currentTaskId = null;
   maxReviews = 50;
@@ -3397,7 +3206,6 @@ class ReviewerWorker {
       log
     });
     this.prService = new PrService(projectPath, log);
-    this.knowledgeBase = new KnowledgeBase(projectPath);
     const providerLabel = provider === "codex" ? "Codex" : "Claude";
     this.log(`Reviewer agent using ${providerLabel} CLI`, "info");
   }
@@ -3513,17 +3321,6 @@ ${summary}`;
       this.sendHeartbeat();
       const result = await this.reviewPr(pr);
       if (result.reviewed) {
-        const status = result.approved ? "APPROVED" : "CHANGES REQUESTED";
-        try {
-          this.knowledgeBase.updateProgress({
-            role: "user",
-            content: `Review PR #${pr.number}: ${pr.title}`
-          });
-          this.knowledgeBase.updateProgress({
-            role: "assistant",
-            content: `${status}: ${result.summary}`
-          });
-        } catch {}
         this.reviewsCompleted++;
       } else {
         this.log(`Review skipped: ${result.summary}`, "warn");
@@ -4002,8 +3799,8 @@ class ExecEventEmitter {
 }
 // src/exec/history-manager.ts
 init_config();
-var import_node_fs7 = require("node:fs");
-var import_node_path9 = require("node:path");
+var import_node_fs6 = require("node:fs");
+var import_node_path8 = require("node:path");
 var DEFAULT_MAX_SESSIONS = 30;
 function generateSessionId2() {
   const timestamp = Date.now().toString(36);
@@ -4015,30 +3812,30 @@ class HistoryManager {
   historyDir;
   maxSessions;
   constructor(projectPath, options) {
-    this.historyDir = options?.historyDir ?? import_node_path9.join(projectPath, LOCUS_CONFIG.dir, LOCUS_CONFIG.sessionsDir);
+    this.historyDir = options?.historyDir ?? import_node_path8.join(projectPath, LOCUS_CONFIG.dir, LOCUS_CONFIG.sessionsDir);
     this.maxSessions = options?.maxSessions ?? DEFAULT_MAX_SESSIONS;
     this.ensureHistoryDir();
   }
   ensureHistoryDir() {
-    if (!import_node_fs7.existsSync(this.historyDir)) {
-      import_node_fs7.mkdirSync(this.historyDir, { recursive: true });
+    if (!import_node_fs6.existsSync(this.historyDir)) {
+      import_node_fs6.mkdirSync(this.historyDir, { recursive: true });
     }
   }
   getSessionPath(sessionId) {
-    return import_node_path9.join(this.historyDir, `${sessionId}.json`);
+    return import_node_path8.join(this.historyDir, `${sessionId}.json`);
   }
   saveSession(session) {
     const filePath = this.getSessionPath(session.id);
     session.updatedAt = Date.now();
-    import_node_fs7.writeFileSync(filePath, JSON.stringify(session, null, 2), "utf-8");
+    import_node_fs6.writeFileSync(filePath, JSON.stringify(session, null, 2), "utf-8");
   }
   loadSession(sessionId) {
     const filePath = this.getSessionPath(sessionId);
-    if (!import_node_fs7.existsSync(filePath)) {
+    if (!import_node_fs6.existsSync(filePath)) {
       return null;
     }
     try {
-      const content = import_node_fs7.readFileSync(filePath, "utf-8");
+      const content = import_node_fs6.readFileSync(filePath, "utf-8");
       return JSON.parse(content);
     } catch {
       return null;
@@ -4046,18 +3843,18 @@ class HistoryManager {
   }
   deleteSession(sessionId) {
     const filePath = this.getSessionPath(sessionId);
-    if (!import_node_fs7.existsSync(filePath)) {
+    if (!import_node_fs6.existsSync(filePath)) {
       return false;
     }
     try {
-      import_node_fs7.rmSync(filePath);
+      import_node_fs6.rmSync(filePath);
       return true;
     } catch {
       return false;
     }
   }
   listSessions(options) {
-    const files = import_node_fs7.readdirSync(this.historyDir);
+    const files = import_node_fs6.readdirSync(this.historyDir);
     let sessions = [];
     for (const file of files) {
       if (file.endsWith(".json")) {
@@ -4130,11 +3927,11 @@ class HistoryManager {
     return deleted;
   }
   getSessionCount() {
-    const files = import_node_fs7.readdirSync(this.historyDir);
+    const files = import_node_fs6.readdirSync(this.historyDir);
     return files.filter((f) => f.endsWith(".json")).length;
   }
   sessionExists(sessionId) {
-    return import_node_fs7.existsSync(this.getSessionPath(sessionId));
+    return import_node_fs6.existsSync(this.getSessionPath(sessionId));
   }
   findSessionByPartialId(partialId) {
     const sessions = this.listSessions();
@@ -4148,12 +3945,12 @@ class HistoryManager {
     return this.historyDir;
   }
   clearAllSessions() {
-    const files = import_node_fs7.readdirSync(this.historyDir);
+    const files = import_node_fs6.readdirSync(this.historyDir);
     let deleted = 0;
     for (const file of files) {
       if (file.endsWith(".json")) {
         try {
-          import_node_fs7.rmSync(import_node_path9.join(this.historyDir, file));
+          import_node_fs6.rmSync(import_node_path8.join(this.historyDir, file));
           deleted++;
         } catch {}
       }
@@ -4429,8 +4226,8 @@ init_src();
 init_colors();
 init_resolve_bin();
 var import_node_child_process7 = require("node:child_process");
-var import_node_fs8 = require("node:fs");
-var import_node_path10 = require("node:path");
+var import_node_fs7 = require("node:fs");
+var import_node_path9 = require("node:path");
 var import_node_url = require("node:url");
 var import_shared4 = require("@locusai/shared");
 var import_events4 = require("events");
@@ -4698,14 +4495,14 @@ ${agentId} finished (exit code: ${code})`);
   }
   resolveWorkerPath() {
     const currentModulePath = import_node_url.fileURLToPath("file:///home/runner/work/locusai/locusai/packages/sdk/src/orchestrator/index.ts");
-    const currentModuleDir = import_node_path10.dirname(currentModulePath);
+    const currentModuleDir = import_node_path9.dirname(currentModulePath);
     const potentialPaths = [
-      import_node_path10.join(currentModuleDir, "..", "agent", "worker.js"),
-      import_node_path10.join(currentModuleDir, "agent", "worker.js"),
-      import_node_path10.join(currentModuleDir, "worker.js"),
-      import_node_path10.join(currentModuleDir, "..", "agent", "worker.ts")
+      import_node_path9.join(currentModuleDir, "..", "agent", "worker.js"),
+      import_node_path9.join(currentModuleDir, "agent", "worker.js"),
+      import_node_path9.join(currentModuleDir, "worker.js"),
+      import_node_path9.join(currentModuleDir, "..", "agent", "worker.ts")
     ];
-    return potentialPaths.find((p) => import_node_fs8.existsSync(p));
+    return potentialPaths.find((p) => import_node_fs7.existsSync(p));
   }
 }
 function killProcessTree(proc) {
@@ -4724,12 +4521,58 @@ function sleep(ms) {
 }
 // src/planning/plan-manager.ts
 init_config();
-init_knowledge_base();
-var import_node_fs9 = require("node:fs");
-var import_node_path11 = require("node:path");
+var import_node_fs8 = require("node:fs");
+var import_node_path10 = require("node:path");
 
 // src/planning/sprint-plan.ts
 var import_shared5 = require("@locusai/shared");
+var import_zod = require("zod");
+
+// src/utils/structured-output.ts
+function parseJsonWithSchema(raw, schema) {
+  const jsonStr = extractJsonFromLLMOutput(raw);
+  let parsed;
+  try {
+    parsed = JSON.parse(jsonStr);
+  } catch (err) {
+    const preview = jsonStr.slice(0, 200);
+    throw new Error(`Failed to parse JSON from LLM output: ${err instanceof Error ? err.message : String(err)}
+Extracted text preview: ${preview}`);
+  }
+  const result = schema.safeParse(parsed);
+  if (!result.success) {
+    const issues = result.error.issues.map((issue) => `  - ${issue.path.join(".")}: ${issue.message}`).join(`
+`);
+    throw new Error(`LLM output failed schema validation:
+${issues}
+Parsed JSON preview: ${JSON.stringify(parsed).slice(0, 300)}`);
+  }
+  return result.data;
+}
+
+// src/planning/sprint-plan.ts
+var PlannedTaskSchema = import_zod.z.object({
+  title: import_zod.z.string().default("Untitled Task"),
+  description: import_zod.z.string().default(""),
+  assigneeRole: import_zod.z.enum(["BACKEND", "FRONTEND", "QA", "PM", "DESIGN"]).default("BACKEND"),
+  priority: import_zod.z.enum(["CRITICAL", "HIGH", "MEDIUM", "LOW"]).default("MEDIUM"),
+  complexity: import_zod.z.number().min(1).max(5).default(3),
+  acceptanceCriteria: import_zod.z.array(import_zod.z.string()).default([]),
+  labels: import_zod.z.array(import_zod.z.string()).default([])
+});
+var SprintPlanRiskSchema = import_zod.z.object({
+  description: import_zod.z.string().default(""),
+  mitigation: import_zod.z.string().default(""),
+  severity: import_zod.z.enum(["low", "medium", "high"]).default("medium")
+});
+var PlannerOutputSchema = import_zod.z.object({
+  name: import_zod.z.string().default("Unnamed Sprint"),
+  goal: import_zod.z.string().default(""),
+  estimatedDays: import_zod.z.number().default(1),
+  tasks: import_zod.z.array(PlannedTaskSchema).default([]),
+  risks: import_zod.z.array(SprintPlanRiskSchema).default([])
+});
+var SprintPlanAIOutputSchema = PlannerOutputSchema;
 function sprintPlanToMarkdown(plan) {
   const lines = [];
   lines.push(`# Sprint Plan: ${plan.name}`);
@@ -4804,42 +4647,31 @@ function plannedTasksToCreatePayloads(plan, sprintId) {
   }));
 }
 function parseSprintPlanFromAI(raw, directive) {
-  const jsonStr = extractJsonFromLLMOutput(raw);
-  let parsed;
-  try {
-    parsed = JSON.parse(jsonStr);
-  } catch (err) {
-    const preview = jsonStr.slice(0, 200);
-    throw new Error(`Failed to parse sprint plan JSON: ${err instanceof Error ? err.message : String(err)}
-Extracted JSON preview: ${preview}`);
-  }
-  if (parsed.revisedPlan) {
-    parsed = parsed.revisedPlan;
-  }
+  const planData = parseJsonWithSchema(raw, SprintPlanAIOutputSchema);
   const now = new Date().toISOString();
   const id = `plan-${Date.now()}`;
-  const tasks2 = (parsed.tasks || []).map((t, i) => ({
+  const tasks2 = planData.tasks.map((t, i) => ({
     index: i + 1,
-    title: t.title || `Task ${i + 1}`,
-    description: t.description || "",
-    assigneeRole: t.assigneeRole || "BACKEND",
-    priority: t.priority || "MEDIUM",
-    complexity: t.complexity || 3,
-    acceptanceCriteria: t.acceptanceCriteria || [],
-    labels: t.labels || []
+    title: t.title,
+    description: t.description,
+    assigneeRole: t.assigneeRole,
+    priority: t.priority,
+    complexity: t.complexity,
+    acceptanceCriteria: t.acceptanceCriteria,
+    labels: t.labels
   }));
   return {
     id,
-    name: parsed.name || "Unnamed Sprint",
-    goal: parsed.goal || directive,
+    name: planData.name,
+    goal: planData.goal || directive,
     directive,
     tasks: tasks2,
-    risks: (parsed.risks || []).map((r) => ({
-      description: r.description || "",
-      mitigation: r.mitigation || "",
-      severity: r.severity || "medium"
+    risks: planData.risks.map((r) => ({
+      description: r.description,
+      mitigation: r.mitigation,
+      severity: r.severity
     })),
-    estimatedDays: parsed.estimatedDays || 1,
+    estimatedDays: planData.estimatedDays,
     status: "pending",
     createdAt: now,
     updatedAt: now
@@ -4848,28 +4680,26 @@ Extracted JSON preview: ${preview}`);
 
 // src/planning/plan-manager.ts
 class PlanManager {
-  projectPath;
   plansDir;
   constructor(projectPath) {
-    this.projectPath = projectPath;
     this.plansDir = getLocusPath(projectPath, "plansDir");
   }
   save(plan) {
     this.ensurePlansDir();
     const slug = this.slugify(plan.name);
-    const jsonPath = import_node_path11.join(this.plansDir, `${slug}.json`);
-    const mdPath = import_node_path11.join(this.plansDir, `sprint-${slug}.md`);
-    import_node_fs9.writeFileSync(jsonPath, JSON.stringify(plan, null, 2), "utf-8");
-    import_node_fs9.writeFileSync(mdPath, sprintPlanToMarkdown(plan), "utf-8");
+    const jsonPath = import_node_path10.join(this.plansDir, `${slug}.json`);
+    const mdPath = import_node_path10.join(this.plansDir, `sprint-${slug}.md`);
+    import_node_fs8.writeFileSync(jsonPath, JSON.stringify(plan, null, 2), "utf-8");
+    import_node_fs8.writeFileSync(mdPath, sprintPlanToMarkdown(plan), "utf-8");
     return plan.id;
   }
   load(idOrSlug) {
     this.ensurePlansDir();
-    const files = import_node_fs9.readdirSync(this.plansDir).filter((f) => f.endsWith(".json"));
+    const files = import_node_fs8.readdirSync(this.plansDir).filter((f) => f.endsWith(".json"));
     for (const file of files) {
-      const filePath = import_node_path11.join(this.plansDir, file);
+      const filePath = import_node_path10.join(this.plansDir, file);
       try {
-        const plan = JSON.parse(import_node_fs9.readFileSync(filePath, "utf-8"));
+        const plan = JSON.parse(import_node_fs8.readFileSync(filePath, "utf-8"));
         if (plan.id === idOrSlug || this.slugify(plan.name) === idOrSlug) {
           return plan;
         }
@@ -4879,11 +4709,11 @@ class PlanManager {
   }
   list(status) {
     this.ensurePlansDir();
-    const files = import_node_fs9.readdirSync(this.plansDir).filter((f) => f.endsWith(".json"));
+    const files = import_node_fs8.readdirSync(this.plansDir).filter((f) => f.endsWith(".json"));
     const plans = [];
     for (const file of files) {
       try {
-        const plan = JSON.parse(import_node_fs9.readFileSync(import_node_path11.join(this.plansDir, file), "utf-8"));
+        const plan = JSON.parse(import_node_fs8.readFileSync(import_node_path10.join(this.plansDir, file), "utf-8"));
         if (!status || plan.status === status) {
           plans.push(plan);
         }
@@ -4913,15 +4743,6 @@ class PlanManager {
     plan.status = "approved";
     plan.updatedAt = new Date().toISOString();
     this.save(plan);
-    const kb = new KnowledgeBase(this.projectPath);
-    kb.updateProgress({
-      role: "user",
-      content: `Start sprint: ${plan.name}`
-    });
-    kb.updateProgress({
-      role: "assistant",
-      content: `Sprint started with ${tasks2.length} tasks. Goal: ${plan.goal}`
-    });
     return { sprint, tasks: tasks2 };
   }
   reject(idOrSlug, feedback) {
@@ -4949,18 +4770,18 @@ class PlanManager {
   }
   delete(idOrSlug) {
     this.ensurePlansDir();
-    const files = import_node_fs9.readdirSync(this.plansDir);
+    const files = import_node_fs8.readdirSync(this.plansDir);
     for (const file of files) {
-      const filePath = import_node_path11.join(this.plansDir, file);
+      const filePath = import_node_path10.join(this.plansDir, file);
       if (!file.endsWith(".json"))
         continue;
       try {
-        const plan = JSON.parse(import_node_fs9.readFileSync(filePath, "utf-8"));
+        const plan = JSON.parse(import_node_fs8.readFileSync(filePath, "utf-8"));
         if (plan.id === idOrSlug || this.slugify(plan.name) === idOrSlug) {
-          import_node_fs9.unlinkSync(filePath);
-          const mdPath = import_node_path11.join(this.plansDir, `sprint-${this.slugify(plan.name)}.md`);
-          if (import_node_fs9.existsSync(mdPath)) {
-            import_node_fs9.unlinkSync(mdPath);
+          import_node_fs8.unlinkSync(filePath);
+          const mdPath = import_node_path10.join(this.plansDir, `sprint-${this.slugify(plan.name)}.md`);
+          if (import_node_fs8.existsSync(mdPath)) {
+            import_node_fs8.unlinkSync(mdPath);
           }
           return;
         }
@@ -4974,8 +4795,8 @@ class PlanManager {
     return sprintPlanToMarkdown(plan);
   }
   ensurePlansDir() {
-    if (!import_node_fs9.existsSync(this.plansDir)) {
-      import_node_fs9.mkdirSync(this.plansDir, { recursive: true });
+    if (!import_node_fs8.existsSync(this.plansDir)) {
+      import_node_fs8.mkdirSync(this.plansDir, { recursive: true });
     }
   }
   slugify(name) {
@@ -4983,222 +4804,77 @@ class PlanManager {
   }
 }
 // src/planning/planning-meeting.ts
-init_knowledge_base();
-
-// src/planning/agents/cross-task-reviewer.ts
-function buildCrossTaskReviewerPrompt(input) {
-  let prompt = `# Role: Cross-Task Reviewer (Architect + Engineer + Planner)
-
-You are a combined Architect, Senior Engineer, and Sprint Planner performing a FINAL review of a sprint plan. Your focus is ensuring that tasks are correctly ordered, well-scoped, and will execute successfully in sequence.
-
-## Context
-
-In this system, tasks are executed SEQUENTIALLY by a single agent on ONE branch:
-- Tasks run one at a time, in the order they appear in the array
-- Each task's changes are committed before the next task starts
-- Later tasks can see and build on earlier tasks' work
-- The final result is a single branch with all changes, which becomes a pull request
-
-This means:
-- Task ordering is critical — a task must NOT depend on a later task's output
-- Foundation work (config, schemas, shared code) must come first
-- Each task should be a focused, logical unit of work
-
-## CEO Directive
-> ${input.directive}
-`;
-  if (input.feedback) {
-    prompt += `
-## CEO Feedback on Previous Plan
-> ${input.feedback}
-
-IMPORTANT: Ensure the reviewed plan still addresses this feedback.
-`;
-  }
-  prompt += `
-## Project Context
-${input.projectContext || "No project context available."}
-
-## Sprint Plan to Review
-${input.plannerOutput}
-
-## Your Review Checklist
-
-Go through EACH task and check for:
-
-### 1. Ordering & Dependency Analysis
-For each task, verify:
-- Does it depend on any task that appears LATER in the list? If so, reorder.
-- Are foundational tasks (config, schemas, shared code) at the beginning?
-- Is the overall execution order logical?
-
-### 2. Scope & Completeness
-For each task, verify:
-- Is the task well-scoped? Not too large, not too trivial?
-- Does it include ALL changes needed for its goal (given earlier tasks are done)?
-- Are there any missing tasks that should be added?
-
-### 3. Description Quality Validation
-For each task, verify the description is a clear, actionable implementation guide. Each description must specify:
-- **What to do** — the specific goal and expected behavior/outcome
-- **Where to do it** — specific files, modules, or directories to modify or create
-- **How to do it** — implementation approach, patterns to follow, existing utilities to use
-- **Boundaries** — what is NOT in scope for this task
-
-If any description is vague (e.g., "Add authentication", "Update the API", "Fix the frontend"), rewrite it with concrete implementation details. The executing agent receives ONLY the task title, description, and acceptance criteria as its instructions.
-
-### 4. Risk Assessment
-- Are there tasks that might fail or have unknowns?
-- Is the sprint scope realistic for sequential execution?
-
-## Output Format
-
-Your entire response must be a single JSON object — no text before it, no text after it, no markdown code blocks, no explanation. Start your response with the "{" character:
-
-{
-  "hasIssues": true | false,
-  "issues": [
-    {
-      "type": "wrong_order" | "missing_task" | "scope_issue" | "vague_description",
-      "description": "string describing the specific issue",
-      "affectedTasks": ["Task Title 1", "Task Title 2"],
-      "resolution": "string describing how to fix it"
-    }
-  ],
-  "revisedPlan": {
-    "name": "string (2-4 words)",
-    "goal": "string (1 paragraph)",
-    "estimatedDays": 3,
-    "tasks": [
-      {
-        "title": "string",
-        "description": "string (detailed implementation guide: what to do, where to do it, how to do it, and boundaries)",
-        "assigneeRole": "BACKEND | FRONTEND | QA | PM | DESIGN",
-        "priority": "CRITICAL | HIGH | MEDIUM | LOW",
-        "labels": ["string"],
-        "acceptanceCriteria": ["string"],
-        "complexity": 3
-      }
-    ],
-    "risks": [
-      {
-        "description": "string",
-        "mitigation": "string",
-        "severity": "low | medium | high"
-      }
-    ]
-  }
-}
-
-IMPORTANT:
-- If hasIssues is true, the revisedPlan MUST contain the corrected task list with issues resolved (reordered, descriptions rewritten, missing tasks added, etc.)
-- If hasIssues is false, the revisedPlan should be identical to the input plan (no changes needed)
-- The revisedPlan is ALWAYS required — it becomes the final plan
-- Ensure every task description is a detailed implementation guide (what, where, how, boundaries) — rewrite vague descriptions
-- Tasks execute sequentially — the array order IS the execution order`;
-  return prompt;
-}
+init_config();
+var import_node_fs9 = require("node:fs");
+var import_node_path11 = require("node:path");
 
 // src/planning/agents/planner.ts
 function buildPlannerPrompt(input) {
-  let prompt = `# Role: Sprint Planner
-
-You are a Sprint Planner — an expert engineer, architect, and project organizer rolled into one. Your job is to take a CEO directive and produce a complete, ready-to-execute sprint plan in a single pass.
-
-## CEO Directive
-> ${input.directive}
-`;
+  let feedbackSection = "";
   if (input.feedback) {
-    prompt += `
-## CEO Feedback on Previous Plan
-> ${input.feedback}
-
-IMPORTANT: Incorporate this feedback into your plan. The CEO has reviewed a previous plan and wants changes.
+    feedbackSection = `
+<ceo_feedback>
+The CEO has reviewed a previous plan and wants changes. Incorporate this feedback:
+${input.feedback}
+</ceo_feedback>
 `;
   }
-  prompt += `
-## Project Context
-${input.projectContext || "No project context available."}
-
-## Your Task
-
-Analyze the directive and produce a **complete sprint plan** with the following:
-
-1. **Sprint Name** — A concise, memorable name (2-4 words)
-2. **Sprint Goal** — One paragraph describing what this sprint delivers
-3. **Duration Estimate** — How many days this sprint will take with a single agent working sequentially
-4. **Task Breakdown** — An ordered list of tasks that fully implement the directive
-5. **Risk Assessment** — Potential risks with mitigations
-
-### Task Requirements
-
-For each task, provide:
-- **Title** — Clear, action-oriented (e.g., "Implement user registration API endpoint")
-- **Description** — A detailed, actionable implementation guide (see below)
-- **Assignee Role** — BACKEND, FRONTEND, QA, PM, or DESIGN
-- **Priority** — CRITICAL, HIGH, MEDIUM, or LOW
-- **Complexity** — 1 (trivial) to 5 (very complex)
-- **Labels** — Relevant tags (e.g., "api", "database", "ui", "auth")
-- **Acceptance Criteria** — Specific, testable conditions for completion
-
-### CRITICAL: Task Description Requirements
-
-Each task description will be handed to an INDEPENDENT agent as its primary instruction. The agent will have access to the codebase but NO context about the planning meeting. Each description MUST include:
-
-1. **What to do** — Clearly state the goal and expected behavior/outcome
-2. **Where to do it** — List specific files, modules, or directories to modify or create. Reference existing code paths when extending functionality
-3. **How to do it** — Key implementation details: which patterns to follow, which existing utilities or services to use, what the data flow looks like
-4. **Boundaries** — What is NOT in scope for this task to prevent overlap with other tasks
-
-Bad example: "Add authentication to the API."
-Good example: "Implement JWT-based authentication middleware in src/middleware/auth.ts. Create a verifyToken middleware that extracts the Bearer token from the Authorization header, validates it using the existing JWT_SECRET from env config, and attaches the decoded user payload to req.user. Apply this middleware to all routes in src/routes/protected/. This task does NOT include user registration or password reset — those are handled separately."
-
-### CRITICAL: Task Ordering Rules
-
-Tasks are executed SEQUENTIALLY by a single agent on ONE branch. The agent works through tasks in array order. Therefore:
-
-1. **Foundation first.** Place foundational tasks (schemas, config, shared code) at the beginning. Later tasks can build on earlier ones since they run in sequence.
-2. **No forward dependencies.** A task must NOT depend on a task that appears later in the list.
-3. **Each task is self-contained for its scope.** A task can depend on earlier tasks but must include all changes needed for its own goal.
-4. **Keep tasks focused.** Each task should do one logical unit of work. Avoid trivially small or overly large tasks.
-5. **Merge related trivial work.** If two pieces of work are trivially small and tightly related, combine them into one task.
-
-### Sprint Scope Guidelines
-
-- If the sprint would exceed 12 tasks, reduce scope or merge related tasks
-- Ensure acceptance criteria are specific and testable
-- Keep the sprint focused on the directive — avoid scope creep
-
-## Output Format
-
-Your entire response must be a single JSON object — no text before it, no text after it, no markdown code blocks, no explanation. Start your response with the "{" character:
-
+  const now = new Date().toISOString();
+  return `<sprint_planning>
+Create a sprint plan for this directive: ${input.directive}
+${feedbackSection}
+<rules>
+- Tasks execute sequentially by one agent on one branch
+- Each task must be self-contained with clear What/Where/How
+- No forward dependencies (task N can't need task N+1)
+- Foundation first (shared code, types, schemas before features)
+- Be specific: exact file paths, function names, implementation details
+- Each task description is the ONLY instruction an independent agent receives — include all context it needs
+- Merge trivially small related work into one task
+- Assign appropriate roles: BACKEND, FRONTEND, QA, PM, or DESIGN
+</rules>
+
+<output>
+Write the sprint plan as a JSON file to: ${input.plansDir}/${input.fileName}.json
+
+The JSON file must contain this exact structure:
 {
-  "name": "string (2-4 words)",
-  "goal": "string (1 paragraph)",
-  "estimatedDays": 3,
+  "id": "${input.planId}",
+  "name": "2-4 words",
+  "goal": "One paragraph of what this delivers",
+  "directive": ${JSON.stringify(input.directive)},
+  "estimatedDays": number,
+  "status": "pending",
+  "createdAt": "${now}",
+  "updatedAt": "${now}",
   "tasks": [
     {
-      "title": "string",
-      "description": "string (detailed implementation guide: what, where, how, boundaries)",
-      "assigneeRole": "BACKEND | FRONTEND | QA | PM | DESIGN",
-      "priority": "CRITICAL | HIGH | MEDIUM | LOW",
-      "labels": ["string"],
-      "acceptanceCriteria": ["string"],
-      "complexity": 3
+      "index": 1,
+      "title": "Action-oriented title",
+      "description": "What: goal\\nWhere: files to modify\\nHow: implementation details\\nBoundaries: what's excluded",
+      "assigneeRole": "BACKEND|FRONTEND|QA|PM|DESIGN",
+      "priority": "CRITICAL|HIGH|MEDIUM|LOW",
+      "labels": ["tags"],
+      "acceptanceCriteria": ["testable conditions"],
+      "complexity": 1-5
     }
   ],
   "risks": [
     {
-      "description": "string",
-      "mitigation": "string",
-      "severity": "low | medium | high"
+      "description": "What could go wrong",
+      "mitigation": "How to handle it",
+      "severity": "low|medium|high"
     }
   ]
 }
 
-IMPORTANT: Tasks are executed sequentially by a single agent. The array order IS the execution order — ensure foundational work comes first and dependent tasks come after their prerequisites.`;
-  return prompt;
+IMPORTANT:
+- Write the file directly using your file writing tool. Do NOT output the JSON as text.
+- Tasks must have sequential "index" values starting at 1.
+- The file must be valid JSON with no comments or trailing commas.
+- Do not create any other files. Only create the single JSON file specified above.
+</output>
+</sprint_planning>`;
 }
 
 // src/planning/planning-meeting.ts
@@ -5214,42 +4890,41 @@ class PlanningMeeting {
     });
   }
   async run(directive, feedback) {
-    const projectContext = this.getProjectContext();
-    this.log("Phase 1/2: Planner building sprint plan...", "info");
-    const plannerPrompt = buildPlannerPrompt({
-      directive,
-      projectContext,
-      feedback
-    });
-    console.log(plannerPrompt);
-    const plannerOutput = await this.aiRunner.run(plannerPrompt);
-    this.log("Planner phase complete.", "success");
-    this.log("Phase 2/2: Reviewer checking for conflicts and quality...", "info");
-    const crossTaskReviewerPrompt = buildCrossTaskReviewerPrompt({
+    this.log("Planning sprint...", "info");
+    const plansDir = getLocusPath(this.projectPath, "plansDir");
+    if (!import_node_fs9.existsSync(plansDir)) {
+      import_node_fs9.mkdirSync(plansDir, { recursive: true });
+    }
+    const ts = Date.now();
+    const planId = `plan-${ts}`;
+    const fileName = `plan-${ts}`;
+    const prompt = buildPlannerPrompt({
       directive,
-      projectContext,
-      plannerOutput,
-      feedback
+      feedback,
+      plansDir,
+      planId,
+      fileName
     });
-    const reviewOutput = await this.aiRunner.run(crossTaskReviewerPrompt);
-    this.log("Review phase complete.", "success");
-    const plan = parseSprintPlanFromAI(reviewOutput, directive);
+    const response = await this.aiRunner.run(prompt);
+    this.log("Planning meeting complete.", "success");
+    const expectedPath = import_node_path11.join(plansDir, `${fileName}.json`);
+    let plan = null;
+    if (import_node_fs9.existsSync(expectedPath)) {
+      try {
+        plan = JSON.parse(import_node_fs9.readFileSync(expectedPath, "utf-8"));
+      } catch {}
+    }
+    if (!plan) {
+      throw new Error("Planning agent did not create the expected plan JSON file. " + "Check the agent output for errors.");
+    }
     if (feedback) {
       plan.feedback = feedback;
     }
     return {
       plan,
-      phaseOutputs: {
-        planner: plannerOutput,
-        review: reviewOutput
-      }
+      rawOutput: response
     };
   }
-  getProjectContext() {
-    const kb = new KnowledgeBase(this.projectPath);
-    return kb.getFullContext();
-  }
 }
 // src/index-node.ts
-init_knowledge_base();
 init_colors();