@locusai/sdk 0.12.1 → 0.13.2

package/dist/index-node.js

@@ -391,6 +391,39 @@ var init_workspaces = __esm(() => {
   };
 });
 
+// src/discussion/discussion-types.ts
+var import_zod, DiscussionMessageSchema, DiscussionInsightSchema, DiscussionSchema;
+var init_discussion_types = __esm(() => {
+  import_zod = require("zod");
+  DiscussionMessageSchema = import_zod.z.object({
+    role: import_zod.z.enum(["user", "assistant"]),
+    content: import_zod.z.string(),
+    timestamp: import_zod.z.number()
+  });
+  DiscussionInsightSchema = import_zod.z.object({
+    id: import_zod.z.string(),
+    type: import_zod.z.enum(["decision", "requirement", "idea", "concern", "learning"]),
+    title: import_zod.z.string(),
+    content: import_zod.z.string(),
+    tags: import_zod.z.array(import_zod.z.string()).default([]),
+    createdAt: import_zod.z.string()
+  });
+  DiscussionSchema = import_zod.z.object({
+    id: import_zod.z.string(),
+    title: import_zod.z.string(),
+    topic: import_zod.z.string(),
+    status: import_zod.z.enum(["active", "completed", "archived"]).default("active"),
+    messages: import_zod.z.array(DiscussionMessageSchema).default([]),
+    insights: import_zod.z.array(DiscussionInsightSchema).default([]),
+    createdAt: import_zod.z.string(),
+    updatedAt: import_zod.z.string(),
+    metadata: import_zod.z.object({
+      model: import_zod.z.string(),
+      provider: import_zod.z.string()
+    })
+  });
+});
+
 // src/index.ts
 var exports_src = {};
 __export(exports_src, {
@@ -403,6 +436,9 @@ __export(exports_src, {
   LocusClient: () => LocusClient,
   InvitationsModule: () => InvitationsModule,
   DocsModule: () => DocsModule,
+  DiscussionSchema: () => DiscussionSchema,
+  DiscussionMessageSchema: () => DiscussionMessageSchema,
+  DiscussionInsightSchema: () => DiscussionInsightSchema,
   CiModule: () => CiModule,
   AuthModule: () => AuthModule
 });
@@ -508,6 +544,7 @@ var init_src = __esm(() => {
   init_sprints();
   init_tasks();
   init_workspaces();
+  init_discussion_types();
   import_axios = __toESM(require("axios"));
   init_events();
   init_auth();
@@ -554,7 +591,8 @@ var init_config = __esm(() => {
     documentsDir: "documents",
     sessionsDir: "sessions",
     reviewsDir: "reviews",
-    plansDir: "plans"
+    plansDir: "plans",
+    discussionsDir: "discussions"
   };
   LOCUS_GITIGNORE_PATTERNS = [
     "# Locus AI - Session data (user-specific, can grow large)",
@@ -569,6 +607,9 @@ var init_config = __esm(() => {
     "# Locus AI - Plans (generated per task)",
     ".locus/plans/",
     "",
+    "# Locus AI - Discussions (AI discussion sessions)",
+    ".locus/discussions/",
+    "",
     "# Locus AI - Settings (contains API key, telegram config, etc.)",
     ".locus/settings.json",
     "",
@@ -1871,6 +1912,187 @@ var init_git_workflow = __esm(() => {
   import_node_child_process4 = require("node:child_process");
 });
 
+// src/discussion/discussion-manager.ts
+class DiscussionManager {
+  discussionsDir;
+  constructor(projectPath) {
+    this.discussionsDir = getLocusPath(projectPath, "discussionsDir");
+  }
+  create(topic, model, provider) {
+    this.ensureDir();
+    const now = new Date().toISOString();
+    const id = `disc-${Date.now()}`;
+    const discussion = {
+      id,
+      title: topic,
+      topic,
+      status: "active",
+      messages: [],
+      insights: [],
+      createdAt: now,
+      updatedAt: now,
+      metadata: { model, provider }
+    };
+    this.save(discussion);
+    return discussion;
+  }
+  save(discussion) {
+    this.ensureDir();
+    const jsonPath = import_node_path5.join(this.discussionsDir, `${discussion.id}.json`);
+    const mdPath = import_node_path5.join(this.discussionsDir, `summary-${discussion.id}.md`);
+    import_node_fs3.writeFileSync(jsonPath, JSON.stringify(discussion, null, 2), "utf-8");
+    import_node_fs3.writeFileSync(mdPath, this.toMarkdown(discussion), "utf-8");
+  }
+  load(id) {
+    this.ensureDir();
+    const filePath = import_node_path5.join(this.discussionsDir, `${id}.json`);
+    if (!import_node_fs3.existsSync(filePath)) {
+      return null;
+    }
+    try {
+      return JSON.parse(import_node_fs3.readFileSync(filePath, "utf-8"));
+    } catch {
+      return null;
+    }
+  }
+  list(status) {
+    this.ensureDir();
+    const files = import_node_fs3.readdirSync(this.discussionsDir).filter((f) => f.endsWith(".json"));
+    const discussions = [];
+    for (const file of files) {
+      try {
+        const discussion = JSON.parse(import_node_fs3.readFileSync(import_node_path5.join(this.discussionsDir, file), "utf-8"));
+        if (!status || discussion.status === status) {
+          discussions.push(discussion);
+        }
+      } catch {}
+    }
+    discussions.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    return discussions;
+  }
+  complete(id) {
+    const discussion = this.load(id);
+    if (!discussion) {
+      throw new Error(`Discussion not found: ${id}`);
+    }
+    discussion.status = "completed";
+    discussion.updatedAt = new Date().toISOString();
+    this.save(discussion);
+    return discussion;
+  }
+  archive(id) {
+    const discussion = this.load(id);
+    if (!discussion) {
+      throw new Error(`Discussion not found: ${id}`);
+    }
+    discussion.status = "archived";
+    discussion.updatedAt = new Date().toISOString();
+    this.save(discussion);
+  }
+  delete(id) {
+    this.ensureDir();
+    const jsonPath = import_node_path5.join(this.discussionsDir, `${id}.json`);
+    const mdPath = import_node_path5.join(this.discussionsDir, `summary-${id}.md`);
+    if (import_node_fs3.existsSync(jsonPath)) {
+      import_node_fs3.unlinkSync(jsonPath);
+    }
+    if (import_node_fs3.existsSync(mdPath)) {
+      import_node_fs3.unlinkSync(mdPath);
+    }
+  }
+  addMessage(id, role, content) {
+    const discussion = this.load(id);
+    if (!discussion) {
+      throw new Error(`Discussion not found: ${id}`);
+    }
+    discussion.messages.push({
+      role,
+      content,
+      timestamp: Date.now()
+    });
+    discussion.updatedAt = new Date().toISOString();
+    this.save(discussion);
+    return discussion;
+  }
+  addInsight(id, insight) {
+    const discussion = this.load(id);
+    if (!discussion) {
+      throw new Error(`Discussion not found: ${id}`);
+    }
+    discussion.insights.push(insight);
+    discussion.updatedAt = new Date().toISOString();
+    this.save(discussion);
+    return discussion;
+  }
+  getAllInsights() {
+    const discussions = this.list("completed");
+    const insights = [];
+    for (const discussion of discussions) {
+      insights.push(...discussion.insights);
+    }
+    insights.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    return insights;
+  }
+  getMarkdown(id) {
+    const discussion = this.load(id);
+    if (!discussion)
+      return null;
+    return this.toMarkdown(discussion);
+  }
+  toMarkdown(discussion) {
+    const lines = [];
+    lines.push(`# Discussion: ${discussion.title}`);
+    lines.push("");
+    lines.push(`**Status:** ${discussion.status.toUpperCase()}`);
+    lines.push(`**Topic:** ${discussion.topic}`);
+    lines.push(`**Created:** ${discussion.createdAt}`);
+    lines.push(`**Updated:** ${discussion.updatedAt}`);
+    lines.push(`**Model:** ${discussion.metadata.model} (${discussion.metadata.provider})`);
+    lines.push("");
+    if (discussion.messages.length > 0) {
+      lines.push(`## Messages (${discussion.messages.length})`);
+      lines.push("");
+      for (const msg of discussion.messages) {
+        const time = new Date(msg.timestamp).toISOString();
+        const roleLabel = msg.role === "user" ? "User" : "Assistant";
+        lines.push(`### ${roleLabel} — ${time}`);
+        lines.push("");
+        lines.push(msg.content);
+        lines.push("");
+      }
+    }
+    if (discussion.insights.length > 0) {
+      lines.push(`## Insights (${discussion.insights.length})`);
+      lines.push("");
+      for (const insight of discussion.insights) {
+        lines.push(`### [${insight.type.toUpperCase()}] ${insight.title}`);
+        lines.push("");
+        lines.push(insight.content);
+        if (insight.tags.length > 0) {
+          lines.push("");
+          lines.push(`**Tags:** ${insight.tags.join(", ")}`);
+        }
+        lines.push("");
+      }
+    }
+    lines.push("---");
+    lines.push(`*Discussion ID: ${discussion.id}*`);
+    return lines.join(`
+`);
+  }
+  ensureDir() {
+    if (!import_node_fs3.existsSync(this.discussionsDir)) {
+      import_node_fs3.mkdirSync(this.discussionsDir, { recursive: true });
+    }
+  }
+}
+var import_node_fs3, import_node_path5;
+var init_discussion_manager = __esm(() => {
+  init_config();
+  import_node_fs3 = require("node:fs");
+  import_node_path5 = require("node:path");
+});
+
 // src/core/prompt-builder.ts
 class PromptBuilder {
   projectPath;
@@ -1909,6 +2131,15 @@ ${knowledgeBase}
 These are accumulated lessons from past tasks. Follow them to avoid repeating mistakes:
 ${learnings}
 </learnings>
+`;
+    }
+    const discussionInsights = this.getDiscussionInsightsContent();
+    if (discussionInsights) {
+      sections += `
+<discussion_insights>
+These are key decisions and insights from product discussions. Follow them to maintain product coherence:
+${discussionInsights}
+</discussion_insights>
 `;
     }
     if (task.docs && task.docs.length > 0) {
@@ -1997,6 +2228,15 @@ ${knowledgeBase}
 These are accumulated lessons from past tasks. Follow them to avoid repeating mistakes:
 ${learnings}
 </learnings>
+`;
+    }
+    const discussionInsights = this.getDiscussionInsightsContent();
+    if (discussionInsights) {
+      sections += `
+<discussion_insights>
+These are key decisions and insights from product discussions. Follow them to maintain product coherence:
+${discussionInsights}
+</discussion_insights>
 `;
     }
     return `<direct_execution>
@@ -2011,9 +2251,9 @@ ${sections}
   }
   getProjectContext() {
     const contextPath = getLocusPath(this.projectPath, "contextFile");
-    if (import_node_fs3.existsSync(contextPath)) {
+    if (import_node_fs4.existsSync(contextPath)) {
       try {
-        const context = import_node_fs3.readFileSync(contextPath, "utf-8");
+        const context = import_node_fs4.readFileSync(contextPath, "utf-8");
         if (context.trim().length > 20) {
           return context;
         }
@@ -2024,10 +2264,10 @@ ${sections}
     return this.getFallbackContext() || null;
   }
   getFallbackContext() {
-    const readmePath = import_node_path5.join(this.projectPath, "README.md");
-    if (import_node_fs3.existsSync(readmePath)) {
+    const readmePath = import_node_path6.join(this.projectPath, "README.md");
+    if (import_node_fs4.existsSync(readmePath)) {
       try {
-        const content = import_node_fs3.readFileSync(readmePath, "utf-8");
+        const content = import_node_fs4.readFileSync(readmePath, "utf-8");
         const limit = 1000;
         return content.slice(0, limit) + (content.length > limit ? `
 ...(truncated)...` : "");
@@ -2041,15 +2281,16 @@ ${sections}
     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)
+- Discussions: \`.locus/discussions\` (product discussion insights and decisions)
 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)) {
+    if (!import_node_fs4.existsSync(learningsPath)) {
       return null;
     }
     try {
-      const content = import_node_fs3.readFileSync(learningsPath, "utf-8");
+      const content = import_node_fs4.readFileSync(learningsPath, "utf-8");
       const lines = content.split(`
 `).filter((l) => l.startsWith("- "));
       if (lines.length === 0) {
@@ -2061,6 +2302,53 @@ If you need more information about the project strategies, plans, or architectur
       return null;
     }
   }
+  getDiscussionInsightsContent() {
+    try {
+      const manager = new DiscussionManager(this.projectPath);
+      const insights = manager.getAllInsights();
+      if (insights.length === 0) {
+        return null;
+      }
+      const groups = {};
+      for (const insight of insights) {
+        const key = insight.type;
+        if (!groups[key]) {
+          groups[key] = [];
+        }
+        groups[key].push(insight);
+      }
+      const typeLabels = {
+        decision: "Decisions",
+        requirement: "Requirements",
+        idea: "Ideas",
+        concern: "Concerns",
+        learning: "Learnings"
+      };
+      let output = "";
+      for (const [type, label] of Object.entries(typeLabels)) {
+        const items = groups[type];
+        if (!items || items.length === 0)
+          continue;
+        output += `## ${label}
+`;
+        for (const item of items) {
+          output += `- [${item.title}]: ${item.content}
+`;
+        }
+        output += `
+`;
+      }
+      if (output.length === 0) {
+        return null;
+      }
+      if (output.length > 2000) {
+        output = `${output.slice(0, 1997)}...`;
+      }
+      return output.trimEnd();
+    } catch {
+      return null;
+    }
+  }
   roleToText(role) {
     if (!role) {
       return null;
@@ -2081,11 +2369,12 @@ If you need more information about the project strategies, plans, or architectur
     }
   }
 }
-var import_node_fs3, import_node_path5, import_shared2;
+var import_node_fs4, import_node_path6, import_shared2;
 var init_prompt_builder = __esm(() => {
+  init_discussion_manager();
   init_config();
-  import_node_fs3 = require("node:fs");
-  import_node_path5 = require("node:path");
+  import_node_fs4 = require("node:fs");
+  import_node_path6 = require("node:path");
   import_shared2 = require("@locusai/shared");
 });
 
@@ -2408,7 +2697,6 @@ Branch: \`${result.branch}\`` : "";
       this.log("All tasks done. Creating pull request...", "info");
       const prResult = this.gitWorkflow.createPullRequest(this.completedTaskList, this.taskSummaries);
       if (prResult.url) {
-        this.log(`PR created: ${prResult.url}`, "success");
         for (const task of this.completedTaskList) {
           try {
             await this.client.tasks.update(task.id, this.config.workspaceId, {
@@ -2467,6 +2755,8 @@ __export(exports_index_node, {
   detectRemoteProvider: () => detectRemoteProvider,
   createAiRunner: () => createAiRunner,
   c: () => c,
+  buildSummaryPrompt: () => buildSummaryPrompt,
+  buildFacilitatorPrompt: () => buildFacilitatorPrompt,
   WorkspacesModule: () => WorkspacesModule,
   TasksModule: () => TasksModule,
   TaskExecutor: () => TaskExecutor,
@@ -2494,6 +2784,11 @@ __export(exports_index_node, {
   ExecEventEmitter: () => ExecEventEmitter,
   DocumentFetcher: () => DocumentFetcher,
   DocsModule: () => DocsModule,
+  DiscussionSchema: () => DiscussionSchema,
+  DiscussionMessageSchema: () => DiscussionMessageSchema,
+  DiscussionManager: () => DiscussionManager,
+  DiscussionInsightSchema: () => DiscussionInsightSchema,
+  DiscussionFacilitator: () => DiscussionFacilitator,
   DEFAULT_MODEL: () => DEFAULT_MODEL,
   ContextTracker: () => ContextTracker,
   CodexRunner: () => CodexRunner,
@@ -2509,8 +2804,8 @@ module.exports = __toCommonJS(exports_index_node);
 
 // src/core/indexer.ts
 var import_node_crypto2 = require("node:crypto");
-var import_node_fs4 = require("node:fs");
-var import_node_path6 = require("node:path");
+var import_node_fs5 = require("node:fs");
+var import_node_path7 = require("node:path");
 var import_globby = require("globby");
 
 class CodebaseIndexer {
@@ -2519,7 +2814,7 @@ class CodebaseIndexer {
   fullReindexRatioThreshold = 0.2;
   constructor(projectPath) {
     this.projectPath = projectPath;
-    this.indexPath = import_node_path6.join(projectPath, ".locus", "codebase-index.json");
+    this.indexPath = import_node_path7.join(projectPath, ".locus", "codebase-index.json");
   }
   async index(onProgress, treeSummarizer, force = false) {
     if (!treeSummarizer) {
@@ -2575,11 +2870,11 @@ class CodebaseIndexer {
     }
   }
   async getFileTree() {
-    const gitmodulesPath = import_node_path6.join(this.projectPath, ".gitmodules");
+    const gitmodulesPath = import_node_path7.join(this.projectPath, ".gitmodules");
     const submoduleIgnores = [];
-    if (import_node_fs4.existsSync(gitmodulesPath)) {
+    if (import_node_fs5.existsSync(gitmodulesPath)) {
       try {
-        const content = import_node_fs4.readFileSync(gitmodulesPath, "utf-8");
+        const content = import_node_fs5.readFileSync(gitmodulesPath, "utf-8");
         const lines = content.split(`
 `);
         for (const line of lines) {
@@ -2635,9 +2930,9 @@ class CodebaseIndexer {
     });
   }
   loadIndex() {
-    if (import_node_fs4.existsSync(this.indexPath)) {
+    if (import_node_fs5.existsSync(this.indexPath)) {
       try {
-        return JSON.parse(import_node_fs4.readFileSync(this.indexPath, "utf-8"));
+        return JSON.parse(import_node_fs5.readFileSync(this.indexPath, "utf-8"));
       } catch {
         return null;
       }
@@ -2645,11 +2940,11 @@ class CodebaseIndexer {
     return null;
   }
   saveIndex(index) {
-    const dir = import_node_path6.dirname(this.indexPath);
-    if (!import_node_fs4.existsSync(dir)) {
-      import_node_fs4.mkdirSync(dir, { recursive: true });
+    const dir = import_node_path7.dirname(this.indexPath);
+    if (!import_node_fs5.existsSync(dir)) {
+      import_node_fs5.mkdirSync(dir, { recursive: true });
     }
-    import_node_fs4.writeFileSync(this.indexPath, JSON.stringify(index, null, 2));
+    import_node_fs5.writeFileSync(this.indexPath, JSON.stringify(index, null, 2));
   }
   cloneIndex(index) {
     return JSON.parse(JSON.stringify(index));
@@ -2665,7 +2960,7 @@ class CodebaseIndexer {
   }
   hashFile(filePath) {
     try {
-      const content = import_node_fs4.readFileSync(import_node_path6.join(this.projectPath, filePath), "utf-8");
+      const content = import_node_fs5.readFileSync(import_node_path7.join(this.projectPath, filePath), "utf-8");
       return import_node_crypto2.createHash("sha256").update(content).digest("hex").slice(0, 16);
     } catch {
       return null;
@@ -2820,8 +3115,8 @@ Return ONLY valid JSON (no code fences, no markdown):
 }
 // src/agent/document-fetcher.ts
 init_config();
-var import_node_fs5 = require("node:fs");
-var import_node_path7 = require("node:path");
+var import_node_fs6 = require("node:fs");
+var import_node_path8 = require("node:path");
 
 class DocumentFetcher {
   deps;
@@ -2830,8 +3125,8 @@ class DocumentFetcher {
   }
   async fetch() {
     const documentsDir = getLocusPath(this.deps.projectPath, "documentsDir");
-    if (!import_node_fs5.existsSync(documentsDir)) {
-      import_node_fs5.mkdirSync(documentsDir, { recursive: true });
+    if (!import_node_fs6.existsSync(documentsDir)) {
+      import_node_fs6.mkdirSync(documentsDir, { recursive: true });
     }
     try {
       const groups = await this.deps.client.docs.listGroups(this.deps.workspaceId);
@@ -2844,14 +3139,14 @@ class DocumentFetcher {
           continue;
         }
         const groupName = groupMap.get(doc.groupId || "") || "General";
-        const groupDir = import_node_path7.join(documentsDir, groupName);
-        if (!import_node_fs5.existsSync(groupDir)) {
-          import_node_fs5.mkdirSync(groupDir, { recursive: true });
+        const groupDir = import_node_path8.join(documentsDir, groupName);
+        if (!import_node_fs6.existsSync(groupDir)) {
+          import_node_fs6.mkdirSync(groupDir, { recursive: true });
         }
         const fileName = `${doc.title}.md`;
-        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 || "");
+        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 || "");
           fetchedCount++;
         }
       }
@@ -3385,6 +3680,341 @@ init_prompt_builder();
 // src/index-node.ts
 init_prompt_builder();
 
+// src/discussion/agents/facilitator-prompt.ts
+function buildFacilitatorPrompt(input) {
+  const {
+    topic,
+    projectContext,
+    learnings,
+    knowledgeBase,
+    previousMessages,
+    insights,
+    isFirstMessage
+  } = input;
+  let sections = "";
+  if (projectContext) {
+    sections += `
+<project_context>
+${projectContext}
+</project_context>
+`;
+  }
+  sections += `
+<knowledge_base>
+${knowledgeBase}
+</knowledge_base>
+`;
+  if (learnings) {
+    sections += `
+<learnings>
+These are accumulated lessons from past work on this project. Use them to ask more informed questions:
+${learnings}
+</learnings>
+`;
+  }
+  if (previousMessages.length > 0) {
+    let history = "";
+    for (const msg of previousMessages) {
+      const role = msg.role === "user" ? "User" : "Facilitator";
+      history += `[${role}]: ${msg.content}
+
+`;
+    }
+    sections += `
+<conversation_history>
+${history.trimEnd()}
+</conversation_history>
+`;
+  }
+  if (insights.length > 0) {
+    let insightsText = "";
+    for (const insight of insights) {
+      insightsText += `- [${insight.type.toUpperCase()}] ${insight.title}: ${insight.content}
+`;
+    }
+    sections += `
+<extracted_insights>
+Insights identified so far in this discussion:
+${insightsText.trimEnd()}
+</extracted_insights>
+`;
+  }
+  const firstMessageInstruction = isFirstMessage ? `This is the START of the discussion. Introduce yourself briefly, then ask your first probing question about the topic. Do NOT extract any insights yet — there is no user input to extract from.` : `Continue the discussion by responding to the user's latest message. Build on their answers to go deeper. After responding, extract any insights from their message.`;
+  return `<discussion_facilitator>
+You are a product strategy facilitator leading a structured discussion.
+
+<topic>
+${topic}
+</topic>
+${sections}
+<role>
+You are an expert product strategy facilitator. Your job is to:
+1. Ask probing, specific questions about the topic — never generic or surface-level
+2. Build on previous answers to progressively deepen the conversation
+3. Identify and extract key decisions, requirements, ideas, concerns, and learnings
+4. Reference existing project context and learnings to ask informed questions
+5. When the topic feels fully explored, suggest wrapping up with a summary
+</role>
+
+<rules>
+- ${firstMessageInstruction}
+- Ask ONE focused question at a time. Do not overwhelm with multiple questions.
+- Be conversational but purposeful — every question should drive toward actionable insights.
+- When you identify an insight from the user's response, include it as a structured XML block in your response.
+- Insight blocks use this format within your response text:
+
+<insight>
+{"type": "decision|requirement|idea|concern|learning", "title": "short title", "content": "detailed description", "tags": ["relevant", "tags"]}
+</insight>
+
+- You may include multiple <insight> blocks if the user's response contains several distinct insights.
+- The insight blocks will be parsed and removed from the displayed response, so write your conversational text as if they are not there.
+- Types explained:
+  - **decision**: A choice or direction that has been made or agreed upon
+  - **requirement**: A specific need, constraint, or must-have
+  - **idea**: A suggestion, proposal, or possibility to explore
+  - **concern**: A risk, worry, or potential problem identified
+  - **learning**: A realization, lesson, or important context discovered
+- Keep responses concise. Aim for 2-4 sentences of conversation plus any insight blocks.
+- If the user's responses indicate the topic is well-explored, suggest summarizing and wrapping up.
+</rules>
+</discussion_facilitator>`;
+}
+function buildSummaryPrompt(topic, messages, insights) {
+  let history = "";
+  for (const msg of messages) {
+    const role = msg.role === "user" ? "User" : "Facilitator";
+    history += `[${role}]: ${msg.content}
+
+`;
+  }
+  let insightsText = "";
+  if (insights.length > 0) {
+    for (const insight of insights) {
+      insightsText += `- [${insight.type.toUpperCase()}] **${insight.title}**: ${insight.content}`;
+      if (insight.tags.length > 0) {
+        insightsText += ` (tags: ${insight.tags.join(", ")})`;
+      }
+      insightsText += `
+`;
+    }
+  }
+  return `<discussion_summary>
+Create a final summary of this product discussion.
+
+<topic>
+${topic}
+</topic>
+
+<conversation>
+${history.trimEnd()}
+</conversation>
+
+${insightsText ? `<insights>
+${insightsText.trimEnd()}
+</insights>
+` : ""}
+<rules>
+- Write a clear, structured summary of the entire discussion.
+- Organize by: Key Decisions, Requirements, Ideas to Explore, Concerns & Risks, and Learnings.
+- Only include sections that have relevant content — skip empty categories.
+- For each item, provide a brief but actionable description.
+- End with a "Next Steps" section listing concrete action items that emerged.
+- Be concise — this summary should be scannable and useful as a reference.
+- Do NOT include any <insight> XML blocks in the summary.
+</rules>
+</discussion_summary>`;
+}
+// src/discussion/discussion-facilitator.ts
+init_config();
+var import_node_fs7 = require("node:fs");
+class DiscussionFacilitator {
+  projectPath;
+  aiRunner;
+  discussionManager;
+  log;
+  provider;
+  model;
+  constructor(config) {
+    this.projectPath = config.projectPath;
+    this.aiRunner = config.aiRunner;
+    this.discussionManager = config.discussionManager;
+    this.log = config.log ?? ((_msg) => {
+      return;
+    });
+    this.provider = config.provider;
+    this.model = config.model;
+  }
+  async startDiscussion(topic) {
+    this.log("Starting new discussion...", "info");
+    const discussion = this.discussionManager.create(topic, this.model, this.provider);
+    const { projectContext, learnings, knowledgeBase } = this.buildContext();
+    const prompt = buildFacilitatorPrompt({
+      topic,
+      projectContext,
+      learnings,
+      knowledgeBase,
+      previousMessages: [],
+      insights: [],
+      isFirstMessage: true
+    });
+    const response = await this.aiRunner.run(prompt);
+    const { cleanResponse } = this.parseInsights(response);
+    this.discussionManager.addMessage(discussion.id, "assistant", cleanResponse);
+    this.log("Discussion started", "success");
+    const saved = this.discussionManager.load(discussion.id);
+    if (!saved) {
+      throw new Error(`Failed to load discussion after creation: ${discussion.id}`);
+    }
+    return {
+      discussion: saved,
+      message: cleanResponse
+    };
+  }
+  async continueDiscussion(discussionId, userMessage) {
+    const discussion = this.discussionManager.load(discussionId);
+    if (!discussion) {
+      throw new Error(`Discussion not found: ${discussionId}`);
+    }
+    const updated = this.discussionManager.addMessage(discussionId, "user", userMessage);
+    const { projectContext, learnings, knowledgeBase } = this.buildContext();
+    const prompt = buildFacilitatorPrompt({
+      topic: updated.topic,
+      projectContext,
+      learnings,
+      knowledgeBase,
+      previousMessages: updated.messages,
+      insights: updated.insights,
+      isFirstMessage: false
+    });
+    const response = await this.aiRunner.run(prompt);
+    const { cleanResponse, insights } = this.parseInsights(response);
+    for (const insight of insights) {
+      this.discussionManager.addInsight(discussionId, insight);
+    }
+    this.discussionManager.addMessage(discussionId, "assistant", cleanResponse);
+    return { response: cleanResponse, insights };
+  }
+  async* continueDiscussionStream(discussionId, userMessage) {
+    const discussion = this.discussionManager.load(discussionId);
+    if (!discussion) {
+      throw new Error(`Discussion not found: ${discussionId}`);
+    }
+    const updated = this.discussionManager.addMessage(discussionId, "user", userMessage);
+    const { projectContext, learnings, knowledgeBase } = this.buildContext();
+    const prompt = buildFacilitatorPrompt({
+      topic: updated.topic,
+      projectContext,
+      learnings,
+      knowledgeBase,
+      previousMessages: updated.messages,
+      insights: updated.insights,
+      isFirstMessage: false
+    });
+    let fullResponse = "";
+    const stream = this.aiRunner.runStream(prompt);
+    for await (const chunk of stream) {
+      yield chunk;
+      if (chunk.type === "text_delta") {
+        fullResponse += chunk.content;
+      } else if (chunk.type === "result") {
+        fullResponse = chunk.content;
+      }
+    }
+    const { cleanResponse, insights } = this.parseInsights(fullResponse);
+    for (const insight of insights) {
+      this.discussionManager.addInsight(discussionId, insight);
+    }
+    this.discussionManager.addMessage(discussionId, "assistant", cleanResponse);
+    return { response: cleanResponse, insights };
+  }
+  async summarizeDiscussion(discussionId) {
+    const discussion = this.discussionManager.load(discussionId);
+    if (!discussion) {
+      throw new Error(`Discussion not found: ${discussionId}`);
+    }
+    this.log("Generating discussion summary...", "info");
+    const prompt = buildSummaryPrompt(discussion.topic, discussion.messages, discussion.insights);
+    const summary = await this.aiRunner.run(prompt);
+    this.discussionManager.addMessage(discussionId, "assistant", summary);
+    this.discussionManager.complete(discussionId);
+    this.log("Discussion summarized and completed", "success");
+    return summary;
+  }
+  parseInsights(response) {
+    const insights = [];
+    const insightRegex = /<insight>\s*([\s\S]*?)\s*<\/insight>/g;
+    let match = insightRegex.exec(response);
+    while (match !== null) {
+      try {
+        const parsed = JSON.parse(match[1]);
+        const id = `ins-${Date.now()}-${Math.random().toString(36).substring(2, 7)}`;
+        insights.push({
+          id,
+          type: parsed.type,
+          title: parsed.title,
+          content: parsed.content,
+          tags: parsed.tags ?? [],
+          createdAt: new Date().toISOString()
+        });
+      } catch {}
+      match = insightRegex.exec(response);
+    }
+    const cleanResponse = response.replace(/<insight>\s*[\s\S]*?\s*<\/insight>/g, "").replace(/\n{3,}/g, `
+
+`).trim();
+    return { cleanResponse, insights };
+  }
+  buildContext() {
+    return {
+      projectContext: this.getProjectContext(),
+      learnings: this.getLearningsContent(),
+      knowledgeBase: this.getKnowledgeBaseSection()
+    };
+  }
+  getProjectContext() {
+    const contextPath = getLocusPath(this.projectPath, "contextFile");
+    if (import_node_fs7.existsSync(contextPath)) {
+      try {
+        const context = import_node_fs7.readFileSync(contextPath, "utf-8");
+        if (context.trim().length > 20) {
+          return context;
+        }
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  getLearningsContent() {
+    const learningsPath = getLocusPath(this.projectPath, "learningsFile");
+    if (!import_node_fs7.existsSync(learningsPath)) {
+      return null;
+    }
+    try {
+      const content = import_node_fs7.readFileSync(learningsPath, "utf-8");
+      const lines = content.split(`
+`).filter((l) => l.startsWith("- "));
+      if (lines.length === 0) {
+        return null;
+      }
+      return lines.join(`
+`);
+    } catch {
+      return null;
+    }
+  }
+  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.`;
+  }
+}
+
+// src/discussion/index.ts
+init_discussion_manager();
+init_discussion_types();
 // src/exec/context-tracker.ts
 var REFERENCE_ALIASES = {
   plan: ["the plan", "sprint plan", "project plan", "implementation plan"],
@@ -3799,8 +4429,8 @@ class ExecEventEmitter {
 }
 // src/exec/history-manager.ts
 init_config();
-var import_node_fs6 = require("node:fs");
-var import_node_path8 = require("node:path");
+var import_node_fs8 = require("node:fs");
+var import_node_path9 = require("node:path");
 var DEFAULT_MAX_SESSIONS = 30;
 function generateSessionId2() {
   const timestamp = Date.now().toString(36);
@@ -3812,30 +4442,30 @@ class HistoryManager {
   historyDir;
   maxSessions;
   constructor(projectPath, options) {
-    this.historyDir = options?.historyDir ?? import_node_path8.join(projectPath, LOCUS_CONFIG.dir, LOCUS_CONFIG.sessionsDir);
+    this.historyDir = options?.historyDir ?? import_node_path9.join(projectPath, LOCUS_CONFIG.dir, LOCUS_CONFIG.sessionsDir);
     this.maxSessions = options?.maxSessions ?? DEFAULT_MAX_SESSIONS;
     this.ensureHistoryDir();
   }
   ensureHistoryDir() {
-    if (!import_node_fs6.existsSync(this.historyDir)) {
-      import_node_fs6.mkdirSync(this.historyDir, { recursive: true });
+    if (!import_node_fs8.existsSync(this.historyDir)) {
+      import_node_fs8.mkdirSync(this.historyDir, { recursive: true });
     }
   }
   getSessionPath(sessionId) {
-    return import_node_path8.join(this.historyDir, `${sessionId}.json`);
+    return import_node_path9.join(this.historyDir, `${sessionId}.json`);
   }
   saveSession(session) {
     const filePath = this.getSessionPath(session.id);
     session.updatedAt = Date.now();
-    import_node_fs6.writeFileSync(filePath, JSON.stringify(session, null, 2), "utf-8");
+    import_node_fs8.writeFileSync(filePath, JSON.stringify(session, null, 2), "utf-8");
   }
   loadSession(sessionId) {
     const filePath = this.getSessionPath(sessionId);
-    if (!import_node_fs6.existsSync(filePath)) {
+    if (!import_node_fs8.existsSync(filePath)) {
       return null;
     }
     try {
-      const content = import_node_fs6.readFileSync(filePath, "utf-8");
+      const content = import_node_fs8.readFileSync(filePath, "utf-8");
       return JSON.parse(content);
     } catch {
       return null;
@@ -3843,18 +4473,18 @@ class HistoryManager {
   }
   deleteSession(sessionId) {
     const filePath = this.getSessionPath(sessionId);
-    if (!import_node_fs6.existsSync(filePath)) {
+    if (!import_node_fs8.existsSync(filePath)) {
       return false;
     }
     try {
-      import_node_fs6.rmSync(filePath);
+      import_node_fs8.rmSync(filePath);
       return true;
     } catch {
       return false;
     }
   }
   listSessions(options) {
-    const files = import_node_fs6.readdirSync(this.historyDir);
+    const files = import_node_fs8.readdirSync(this.historyDir);
     let sessions = [];
     for (const file of files) {
       if (file.endsWith(".json")) {
@@ -3927,11 +4557,11 @@ class HistoryManager {
     return deleted;
   }
   getSessionCount() {
-    const files = import_node_fs6.readdirSync(this.historyDir);
+    const files = import_node_fs8.readdirSync(this.historyDir);
     return files.filter((f) => f.endsWith(".json")).length;
   }
   sessionExists(sessionId) {
-    return import_node_fs6.existsSync(this.getSessionPath(sessionId));
+    return import_node_fs8.existsSync(this.getSessionPath(sessionId));
   }
   findSessionByPartialId(partialId) {
     const sessions = this.listSessions();
@@ -3945,12 +4575,12 @@ class HistoryManager {
     return this.historyDir;
   }
   clearAllSessions() {
-    const files = import_node_fs6.readdirSync(this.historyDir);
+    const files = import_node_fs8.readdirSync(this.historyDir);
     let deleted = 0;
     for (const file of files) {
       if (file.endsWith(".json")) {
         try {
-          import_node_fs6.rmSync(import_node_path8.join(this.historyDir, file));
+          import_node_fs8.rmSync(import_node_path9.join(this.historyDir, file));
           deleted++;
         } catch {}
       }
@@ -4226,8 +4856,8 @@ init_src();
 init_colors();
 init_resolve_bin();
 var import_node_child_process7 = require("node:child_process");
-var import_node_fs7 = require("node:fs");
-var import_node_path9 = require("node:path");
+var import_node_fs9 = require("node:fs");
+var import_node_path10 = require("node:path");
 var import_node_url = require("node:url");
 var import_shared4 = require("@locusai/shared");
 var import_events4 = require("events");
@@ -4495,14 +5125,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_path9.dirname(currentModulePath);
+    const currentModuleDir = import_node_path10.dirname(currentModulePath);
     const potentialPaths = [
-      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")
+      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")
     ];
-    return potentialPaths.find((p) => import_node_fs7.existsSync(p));
+    return potentialPaths.find((p) => import_node_fs9.existsSync(p));
   }
 }
 function killProcessTree(proc) {
@@ -4521,12 +5151,12 @@ function sleep(ms) {
 }
 // src/planning/plan-manager.ts
 init_config();
-var import_node_fs8 = require("node:fs");
-var import_node_path10 = require("node:path");
+var import_node_fs10 = require("node:fs");
+var import_node_path11 = require("node:path");
 
 // src/planning/sprint-plan.ts
 var import_shared5 = require("@locusai/shared");
-var import_zod = require("zod");
+var import_zod2 = require("zod");
 
 // src/utils/structured-output.ts
 function parseJsonWithSchema(raw, schema) {
@@ -4551,26 +5181,26 @@ Parsed JSON preview: ${JSON.stringify(parsed).slice(0, 300)}`);
 }
 
 // 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 PlannedTaskSchema = import_zod2.z.object({
+  title: import_zod2.z.string().default("Untitled Task"),
+  description: import_zod2.z.string().default(""),
+  assigneeRole: import_zod2.z.enum(["BACKEND", "FRONTEND", "QA", "PM", "DESIGN"]).default("BACKEND"),
+  priority: import_zod2.z.enum(["CRITICAL", "HIGH", "MEDIUM", "LOW"]).default("MEDIUM"),
+  complexity: import_zod2.z.number().min(1).max(5).default(3),
+  acceptanceCriteria: import_zod2.z.array(import_zod2.z.string()).default([]),
+  labels: import_zod2.z.array(import_zod2.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 SprintPlanRiskSchema = import_zod2.z.object({
+  description: import_zod2.z.string().default(""),
+  mitigation: import_zod2.z.string().default(""),
+  severity: import_zod2.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 PlannerOutputSchema = import_zod2.z.object({
+  name: import_zod2.z.string().default("Unnamed Sprint"),
+  goal: import_zod2.z.string().default(""),
+  estimatedDays: import_zod2.z.number().default(1),
+  tasks: import_zod2.z.array(PlannedTaskSchema).default([]),
+  risks: import_zod2.z.array(SprintPlanRiskSchema).default([])
 });
 var SprintPlanAIOutputSchema = PlannerOutputSchema;
 function sprintPlanToMarkdown(plan) {
@@ -4687,19 +5317,19 @@ class PlanManager {
   save(plan) {
     this.ensurePlansDir();
     const slug = this.slugify(plan.name);
-    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");
+    const jsonPath = import_node_path11.join(this.plansDir, `${slug}.json`);
+    const mdPath = import_node_path11.join(this.plansDir, `sprint-${slug}.md`);
+    import_node_fs10.writeFileSync(jsonPath, JSON.stringify(plan, null, 2), "utf-8");
+    import_node_fs10.writeFileSync(mdPath, sprintPlanToMarkdown(plan), "utf-8");
     return plan.id;
   }
   load(idOrSlug) {
     this.ensurePlansDir();
-    const files = import_node_fs8.readdirSync(this.plansDir).filter((f) => f.endsWith(".json"));
+    const files = import_node_fs10.readdirSync(this.plansDir).filter((f) => f.endsWith(".json"));
     for (const file of files) {
-      const filePath = import_node_path10.join(this.plansDir, file);
+      const filePath = import_node_path11.join(this.plansDir, file);
       try {
-        const plan = JSON.parse(import_node_fs8.readFileSync(filePath, "utf-8"));
+        const plan = JSON.parse(import_node_fs10.readFileSync(filePath, "utf-8"));
         if (plan.id === idOrSlug || this.slugify(plan.name) === idOrSlug) {
           return plan;
         }
@@ -4709,11 +5339,11 @@ class PlanManager {
   }
   list(status) {
     this.ensurePlansDir();
-    const files = import_node_fs8.readdirSync(this.plansDir).filter((f) => f.endsWith(".json"));
+    const files = import_node_fs10.readdirSync(this.plansDir).filter((f) => f.endsWith(".json"));
     const plans = [];
     for (const file of files) {
       try {
-        const plan = JSON.parse(import_node_fs8.readFileSync(import_node_path10.join(this.plansDir, file), "utf-8"));
+        const plan = JSON.parse(import_node_fs10.readFileSync(import_node_path11.join(this.plansDir, file), "utf-8"));
         if (!status || plan.status === status) {
           plans.push(plan);
         }
@@ -4770,18 +5400,18 @@ class PlanManager {
   }
   delete(idOrSlug) {
     this.ensurePlansDir();
-    const files = import_node_fs8.readdirSync(this.plansDir);
+    const files = import_node_fs10.readdirSync(this.plansDir);
     for (const file of files) {
-      const filePath = import_node_path10.join(this.plansDir, file);
+      const filePath = import_node_path11.join(this.plansDir, file);
       if (!file.endsWith(".json"))
         continue;
       try {
-        const plan = JSON.parse(import_node_fs8.readFileSync(filePath, "utf-8"));
+        const plan = JSON.parse(import_node_fs10.readFileSync(filePath, "utf-8"));
         if (plan.id === idOrSlug || this.slugify(plan.name) === idOrSlug) {
-          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);
+          import_node_fs10.unlinkSync(filePath);
+          const mdPath = import_node_path11.join(this.plansDir, `sprint-${this.slugify(plan.name)}.md`);
+          if (import_node_fs10.existsSync(mdPath)) {
+            import_node_fs10.unlinkSync(mdPath);
           }
           return;
         }
@@ -4795,8 +5425,8 @@ class PlanManager {
     return sprintPlanToMarkdown(plan);
   }
   ensurePlansDir() {
-    if (!import_node_fs8.existsSync(this.plansDir)) {
-      import_node_fs8.mkdirSync(this.plansDir, { recursive: true });
+    if (!import_node_fs10.existsSync(this.plansDir)) {
+      import_node_fs10.mkdirSync(this.plansDir, { recursive: true });
     }
   }
   slugify(name) {
@@ -4805,8 +5435,8 @@ class PlanManager {
 }
 // src/planning/planning-meeting.ts
 init_config();
-var import_node_fs9 = require("node:fs");
-var import_node_path11 = require("node:path");
+var import_node_fs11 = require("node:fs");
+var import_node_path12 = require("node:path");
 
 // src/planning/agents/planner.ts
 function buildPlannerPrompt(input) {
@@ -4892,8 +5522,8 @@ class PlanningMeeting {
   async run(directive, feedback) {
     this.log("Planning sprint...", "info");
     const plansDir = getLocusPath(this.projectPath, "plansDir");
-    if (!import_node_fs9.existsSync(plansDir)) {
-      import_node_fs9.mkdirSync(plansDir, { recursive: true });
+    if (!import_node_fs11.existsSync(plansDir)) {
+      import_node_fs11.mkdirSync(plansDir, { recursive: true });
     }
     const ts = Date.now();
     const planId = `plan-${ts}`;
@@ -4907,11 +5537,11 @@ class PlanningMeeting {
     });
     const response = await this.aiRunner.run(prompt);
     this.log("Planning meeting complete.", "success");
-    const expectedPath = import_node_path11.join(plansDir, `${fileName}.json`);
+    const expectedPath = import_node_path12.join(plansDir, `${fileName}.json`);
     let plan = null;
-    if (import_node_fs9.existsSync(expectedPath)) {
+    if (import_node_fs11.existsSync(expectedPath)) {
       try {
-        plan = JSON.parse(import_node_fs9.readFileSync(expectedPath, "utf-8"));
+        plan = JSON.parse(import_node_fs11.readFileSync(expectedPath, "utf-8"));
       } catch {}
     }
     if (!plan) {