@locusai/sdk 0.7.1 → 0.7.4

package/dist/agent/worker.js

@@ -516,8 +516,8 @@ var PROVIDER = {
   CODEX: "codex"
 };
 var DEFAULT_MODEL = {
-  [PROVIDER.CLAUDE]: "sonnet",
-  [PROVIDER.CODEX]: "gpt-5.1-codex-mini"
+  [PROVIDER.CLAUDE]: "opus",
+  [PROVIDER.CODEX]: "gpt-5.2-codex"
 };
 var LOCUS_CONFIG = {
   dir: ".locus",
@@ -526,14 +526,26 @@ var LOCUS_CONFIG = {
   contextFile: "CLAUDE.md",
   artifactsDir: "artifacts",
   documentsDir: "documents",
-  agentSkillsDir: ".agent/skills"
+  agentSkillsDir: ".agent/skills",
+  sessionsDir: "sessions"
 };
+var LOCUS_GITIGNORE_PATTERNS = [
+  "# Locus AI - Session data (user-specific, can grow large)",
+  ".locus/sessions/",
+  "",
+  "# Locus AI - Artifacts (local-only, user-specific)",
+  ".locus/artifacts/"
+];
 function getLocusPath(projectPath, fileName) {
   if (fileName === "contextFile") {
     return import_node_path.join(projectPath, LOCUS_CONFIG.contextFile);
   }
   return import_node_path.join(projectPath, LOCUS_CONFIG.dir, LOCUS_CONFIG[fileName]);
 }
+function getAgentArtifactsPath(projectPath, agentId) {
+  const shortId = agentId.slice(-8);
+  return import_node_path.join(projectPath, LOCUS_CONFIG.dir, LOCUS_CONFIG.artifactsDir, shortId);
+}
 
 // src/ai/claude-runner.ts
 var import_node_child_process = require("node:child_process");
@@ -606,11 +618,17 @@ class ClaudeRunner {
   model;
   log;
   projectPath;
+  eventEmitter;
+  currentToolName;
+  activeTools = new Map;
   constructor(projectPath, model = DEFAULT_MODEL[PROVIDER.CLAUDE], log) {
     this.model = model;
     this.log = log;
     this.projectPath = import_node_path2.resolve(projectPath);
   }
+  setEventEmitter(emitter) {
+    this.eventEmitter = emitter;
+  }
   async run(prompt, _isPlanning = false) {
     const maxRetries = 3;
     let lastError = null;
@@ -630,6 +648,246 @@ class ClaudeRunner {
     }
     throw lastError || new Error("Claude CLI failed after multiple attempts");
   }
+  async* runStream(prompt) {
+    const args = [
+      "--dangerously-skip-permissions",
+      "--print",
+      "--verbose",
+      "--output-format",
+      "stream-json",
+      "--include-partial-messages",
+      "--model",
+      this.model
+    ];
+    const env = {
+      ...process.env,
+      FORCE_COLOR: "1",
+      TERM: "xterm-256color"
+    };
+    this.eventEmitter?.emitSessionStarted({
+      model: this.model,
+      provider: "claude"
+    });
+    this.eventEmitter?.emitPromptSubmitted(prompt, prompt.length > 500);
+    const claude = import_node_child_process.spawn("claude", args, {
+      cwd: this.projectPath,
+      stdio: ["pipe", "pipe", "pipe"],
+      env
+    });
+    let buffer = "";
+    let stderrBuffer = "";
+    let resolveChunk = null;
+    const chunkQueue = [];
+    let processEnded = false;
+    let errorMessage = "";
+    let finalContent = "";
+    let isThinking = false;
+    const enqueueChunk = (chunk) => {
+      this.emitEventForChunk(chunk, isThinking);
+      if (chunk.type === "thinking") {
+        isThinking = true;
+      } else if (chunk.type === "text_delta" || chunk.type === "tool_use") {
+        if (isThinking) {
+          this.eventEmitter?.emitThinkingStoped();
+          isThinking = false;
+        }
+      }
+      if (chunk.type === "text_delta") {
+        finalContent += chunk.content;
+      }
+      if (resolveChunk) {
+        const resolve2 = resolveChunk;
+        resolveChunk = null;
+        resolve2(chunk);
+      } else {
+        chunkQueue.push(chunk);
+      }
+    };
+    const signalEnd = () => {
+      processEnded = true;
+      if (resolveChunk) {
+        resolveChunk(null);
+        resolveChunk = null;
+      }
+    };
+    claude.stdout.on("data", (data) => {
+      buffer += data.toString();
+      const lines = buffer.split(`
+`);
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        const chunk = this.parseStreamLineToChunk(line);
+        if (chunk) {
+          enqueueChunk(chunk);
+        }
+      }
+    });
+    claude.stderr.on("data", (data) => {
+      const chunk = data.toString();
+      stderrBuffer += chunk;
+      const lines = stderrBuffer.split(`
+`);
+      stderrBuffer = lines.pop() || "";
+      for (const line of lines) {
+        if (!this.shouldSuppressLine(line)) {
+          process.stderr.write(`${line}
+`);
+        }
+      }
+    });
+    claude.on("error", (err) => {
+      errorMessage = `Failed to start Claude CLI: ${err.message}. Please ensure the 'claude' command is available in your PATH.`;
+      this.eventEmitter?.emitErrorOccurred(errorMessage, "SPAWN_ERROR");
+      signalEnd();
+    });
+    claude.on("close", (code) => {
+      if (stderrBuffer && !this.shouldSuppressLine(stderrBuffer)) {
+        process.stderr.write(`${stderrBuffer}
+`);
+      }
+      if (code !== 0 && !errorMessage) {
+        errorMessage = this.createExecutionError(code, stderrBuffer).message;
+        this.eventEmitter?.emitErrorOccurred(errorMessage, `EXIT_${code}`);
+      }
+      signalEnd();
+    });
+    claude.stdin.write(prompt);
+    claude.stdin.end();
+    while (true) {
+      if (chunkQueue.length > 0) {
+        const chunk = chunkQueue.shift();
+        if (chunk)
+          yield chunk;
+      } else if (processEnded) {
+        if (errorMessage) {
+          yield { type: "error", error: errorMessage };
+          this.eventEmitter?.emitSessionEnded(false);
+        } else {
+          if (finalContent) {
+            this.eventEmitter?.emitResponseCompleted(finalContent);
+          }
+          this.eventEmitter?.emitSessionEnded(true);
+        }
+        break;
+      } else {
+        const chunk = await new Promise((resolve2) => {
+          resolveChunk = resolve2;
+        });
+        if (chunk === null) {
+          if (errorMessage) {
+            yield { type: "error", error: errorMessage };
+            this.eventEmitter?.emitSessionEnded(false);
+          } else {
+            if (finalContent) {
+              this.eventEmitter?.emitResponseCompleted(finalContent);
+            }
+            this.eventEmitter?.emitSessionEnded(true);
+          }
+          break;
+        }
+        yield chunk;
+      }
+    }
+  }
+  emitEventForChunk(chunk, isThinking) {
+    if (!this.eventEmitter)
+      return;
+    switch (chunk.type) {
+      case "text_delta":
+        this.eventEmitter.emitTextDelta(chunk.content);
+        break;
+      case "tool_use":
+        if (this.currentToolName) {
+          this.eventEmitter.emitToolCompleted(this.currentToolName);
+        }
+        this.currentToolName = chunk.tool;
+        this.eventEmitter.emitToolStarted(chunk.tool, chunk.id);
+        break;
+      case "thinking":
+        if (!isThinking) {
+          this.eventEmitter.emitThinkingStarted(chunk.content);
+        }
+        break;
+      case "result":
+        if (this.currentToolName) {
+          this.eventEmitter.emitToolCompleted(this.currentToolName);
+          this.currentToolName = undefined;
+        }
+        break;
+      case "error":
+        this.eventEmitter.emitErrorOccurred(chunk.error);
+        break;
+    }
+  }
+  parseStreamLineToChunk(line) {
+    if (!line.trim())
+      return null;
+    try {
+      const item = JSON.parse(line);
+      return this.processStreamItemToChunk(item);
+    } catch {
+      return null;
+    }
+  }
+  processStreamItemToChunk(item) {
+    if (item.type === "result") {
+      return { type: "result", content: item.result || "" };
+    }
+    if (item.type === "stream_event" && item.event) {
+      return this.handleEventToChunk(item.event);
+    }
+    return null;
+  }
+  handleEventToChunk(event) {
+    const { type, delta, content_block, index } = event;
+    if (type === "content_block_delta" && delta?.type === "text_delta") {
+      return { type: "text_delta", content: delta.text || "" };
+    }
+    if (type === "content_block_delta" && delta?.type === "input_json_delta" && delta.partial_json !== undefined && index !== undefined) {
+      const activeTool = this.activeTools.get(index);
+      if (activeTool) {
+        activeTool.parameterJson += delta.partial_json;
+      }
+      return null;
+    }
+    if (type === "content_block_start" && content_block) {
+      if (content_block.type === "tool_use" && content_block.name) {
+        if (index !== undefined) {
+          this.activeTools.set(index, {
+            name: content_block.name,
+            id: content_block.id,
+            index,
+            parameterJson: "",
+            startTime: Date.now()
+          });
+        }
+        return {
+          type: "tool_use",
+          tool: content_block.name,
+          id: content_block.id
+        };
+      }
+      if (content_block.type === "thinking") {
+        return { type: "thinking" };
+      }
+    }
+    if (type === "content_block_stop" && index !== undefined) {
+      const activeTool = this.activeTools.get(index);
+      if (activeTool?.parameterJson) {
+        try {
+          const parameters = JSON.parse(activeTool.parameterJson);
+          return {
+            type: "tool_parameters",
+            tool: activeTool.name,
+            id: activeTool.id,
+            parameters
+          };
+        } catch {}
+      }
+      return null;
+    }
+    return null;
+  }
   executeRun(prompt) {
     return new Promise((resolve2, reject) => {
       const args = [
@@ -725,7 +983,6 @@ class ClaudeRunner {
     if (type === "content_block_start" && content_block) {
       if (content_block.type === "tool_use" && content_block.name) {
         this.log?.(`
-
 ${c.primary("[Claude]")} ${c.bold(`Running ${content_block.name}...`)}
 `, "info");
       }
@@ -774,6 +1031,99 @@ class CodexRunner {
     }
     throw lastError || new Error("Codex CLI failed after multiple attempts");
   }
+  async* runStream(prompt) {
+    const outputPath = import_node_path3.join(import_node_os.tmpdir(), `locus-codex-${import_node_crypto.randomUUID()}.txt`);
+    const args = this.buildArgs(outputPath);
+    const codex = import_node_child_process2.spawn("codex", args, {
+      cwd: this.projectPath,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: process.env,
+      shell: false
+    });
+    let resolveChunk = null;
+    const chunkQueue = [];
+    let processEnded = false;
+    let errorMessage = "";
+    let finalOutput = "";
+    const enqueueChunk = (chunk) => {
+      if (resolveChunk) {
+        const resolve2 = resolveChunk;
+        resolveChunk = null;
+        resolve2(chunk);
+      } else {
+        chunkQueue.push(chunk);
+      }
+    };
+    const signalEnd = () => {
+      processEnded = true;
+      if (resolveChunk) {
+        resolveChunk(null);
+        resolveChunk = null;
+      }
+    };
+    const processOutput = (data) => {
+      const msg = data.toString();
+      finalOutput += msg;
+      for (const rawLine of msg.split(`
+`)) {
+        const line = rawLine.trim();
+        if (!line)
+          continue;
+        if (/^thinking\b/i.test(line)) {
+          enqueueChunk({ type: "thinking", content: line });
+        } else if (/^[→•✓]/.test(line) || /^Plan update\b/.test(line)) {
+          enqueueChunk({
+            type: "tool_use",
+            tool: line.replace(/^[→•✓]\s*/, "")
+          });
+        } else if (this.shouldDisplay(line)) {
+          enqueueChunk({ type: "text_delta", content: `${line}
+` });
+        }
+      }
+    };
+    codex.stdout.on("data", processOutput);
+    codex.stderr.on("data", processOutput);
+    codex.on("error", (err) => {
+      errorMessage = `Failed to start Codex CLI: ${err.message}. Ensure 'codex' is installed and available in PATH.`;
+      signalEnd();
+    });
+    codex.on("close", (code) => {
+      this.cleanupTempFile(outputPath);
+      if (code === 0) {
+        const result = this.readOutput(outputPath, finalOutput);
+        enqueueChunk({ type: "result", content: result });
+      } else if (!errorMessage) {
+        errorMessage = this.createErrorFromOutput(code, finalOutput).message;
+      }
+      signalEnd();
+    });
+    codex.stdin.write(prompt);
+    codex.stdin.end();
+    while (true) {
+      if (chunkQueue.length > 0) {
+        const chunk = chunkQueue.shift();
+        if (chunk)
+          yield chunk;
+      } else if (processEnded) {
+        if (errorMessage) {
+          yield { type: "error", error: errorMessage };
+        }
+        break;
+      } else {
+        const chunk = await new Promise((resolve2) => {
+          resolveChunk = resolve2;
+        });
+        if (chunk === null) {
+          if (errorMessage) {
+            yield { type: "error", error: errorMessage };
+          }
+          break;
+        }
+        yield chunk;
+      }
+    }
+  }
   executeRun(prompt) {
     return new Promise((resolve2, reject) => {
       const outputPath = import_node_path3.join(import_node_os.tmpdir(), `locus-codex-${import_node_crypto.randomUUID()}.txt`);
@@ -882,105 +1232,10 @@ function createAiRunner(provider, config) {
   }
 }
 
-// src/agent/artifact-syncer.ts
-var import_node_fs2 = require("node:fs");
-var import_node_path4 = require("node:path");
-var import_shared2 = require("@locusai/shared");
-class ArtifactSyncer {
-  deps;
-  constructor(deps) {
-    this.deps = deps;
-  }
-  async getOrCreateArtifactsGroup() {
-    try {
-      const groups = await this.deps.client.docs.listGroups(this.deps.workspaceId);
-      const artifactsGroup = groups.find((g) => g.name === "Artifacts");
-      if (artifactsGroup) {
-        return artifactsGroup.id;
-      }
-      const newGroup = await this.deps.client.docs.createGroup(this.deps.workspaceId, {
-        name: "Artifacts",
-        order: 999
-      });
-      this.deps.log("Created 'Artifacts' group for agent-generated docs", "info");
-      return newGroup.id;
-    } catch (error) {
-      this.deps.log(`Failed to get/create Artifacts group: ${error}`, "error");
-      throw error;
-    }
-  }
-  async sync() {
-    const artifactsDir = getLocusPath(this.deps.projectPath, "artifactsDir");
-    if (!import_node_fs2.existsSync(artifactsDir)) {
-      import_node_fs2.mkdirSync(artifactsDir, { recursive: true });
-      return;
-    }
-    try {
-      const files = import_node_fs2.readdirSync(artifactsDir);
-      this.deps.log(`Syncing ${files.length} artifacts to server...`, "info");
-      const groups = await this.deps.client.docs.listGroups(this.deps.workspaceId);
-      const groupMap = new Map(groups.map((g) => [g.id, g.name]));
-      let artifactsGroupId = groups.find((g) => g.name === "Artifacts")?.id;
-      if (!artifactsGroupId) {
-        artifactsGroupId = await this.getOrCreateArtifactsGroup();
-      }
-      const existingDocs = await this.deps.client.docs.list(this.deps.workspaceId);
-      for (const file of files) {
-        const filePath = import_node_path4.join(artifactsDir, file);
-        if (import_node_fs2.statSync(filePath).isFile()) {
-          const content = import_node_fs2.readFileSync(filePath, "utf-8");
-          const title = file.replace(/\.md$/, "").trim();
-          if (!title)
-            continue;
-          const existing = existingDocs.find((d) => d.title === title);
-          if (existing) {
-            if (existing.content !== content || existing.groupId !== artifactsGroupId) {
-              await this.deps.client.docs.update(existing.id, this.deps.workspaceId, { content, groupId: artifactsGroupId });
-              this.deps.log(`Updated artifact: ${file}`, "success");
-            }
-          } else {
-            await this.deps.client.docs.create(this.deps.workspaceId, {
-              title,
-              content,
-              groupId: artifactsGroupId,
-              type: import_shared2.DocType.GENERAL
-            });
-            this.deps.log(`Created artifact: ${file}`, "success");
-          }
-        }
-      }
-      for (const doc of existingDocs) {
-        if (doc.groupId === artifactsGroupId) {
-          const fileName = `${doc.title}.md`;
-          const filePath = import_node_path4.join(artifactsDir, fileName);
-          if (!import_node_fs2.existsSync(filePath)) {
-            import_node_fs2.writeFileSync(filePath, doc.content || "");
-            this.deps.log(`Fetched artifact: ${fileName}`, "success");
-          }
-        } else {
-          const documentsDir = getLocusPath(this.deps.projectPath, "documentsDir");
-          const groupName = groupMap.get(doc.groupId || "") || "General";
-          const groupDir = import_node_path4.join(documentsDir, groupName);
-          if (!import_node_fs2.existsSync(groupDir)) {
-            import_node_fs2.mkdirSync(groupDir, { recursive: true });
-          }
-          const fileName = `${doc.title}.md`;
-          const filePath = import_node_path4.join(groupDir, fileName);
-          if (!import_node_fs2.existsSync(filePath) || import_node_fs2.readFileSync(filePath, "utf-8") !== doc.content) {
-            import_node_fs2.writeFileSync(filePath, doc.content || "");
-          }
-        }
-      }
-    } catch (error) {
-      this.deps.log(`Failed to sync artifacts: ${error}`, "error");
-    }
-  }
-}
-
 // src/core/indexer.ts
 var import_node_crypto2 = require("node:crypto");
-var import_node_fs3 = require("node:fs");
-var import_node_path5 = require("node:path");
+var import_node_fs2 = require("node:fs");
+var import_node_path4 = require("node:path");
 var import_globby = require("globby");
 
 class CodebaseIndexer {
@@ -989,7 +1244,7 @@ class CodebaseIndexer {
   fullReindexRatioThreshold = 0.2;
   constructor(projectPath) {
     this.projectPath = projectPath;
-    this.indexPath = import_node_path5.join(projectPath, ".locus", "codebase-index.json");
+    this.indexPath = import_node_path4.join(projectPath, ".locus", "codebase-index.json");
   }
   async index(onProgress, treeSummarizer, force = false) {
     if (!treeSummarizer) {
@@ -1045,11 +1300,11 @@ class CodebaseIndexer {
     }
   }
   async getFileTree() {
-    const gitmodulesPath = import_node_path5.join(this.projectPath, ".gitmodules");
+    const gitmodulesPath = import_node_path4.join(this.projectPath, ".gitmodules");
     const submoduleIgnores = [];
-    if (import_node_fs3.existsSync(gitmodulesPath)) {
+    if (import_node_fs2.existsSync(gitmodulesPath)) {
       try {
-        const content = import_node_fs3.readFileSync(gitmodulesPath, "utf-8");
+        const content = import_node_fs2.readFileSync(gitmodulesPath, "utf-8");
         const lines = content.split(`
 `);
         for (const line of lines) {
@@ -1105,9 +1360,9 @@ class CodebaseIndexer {
     });
   }
   loadIndex() {
-    if (import_node_fs3.existsSync(this.indexPath)) {
+    if (import_node_fs2.existsSync(this.indexPath)) {
       try {
-        return JSON.parse(import_node_fs3.readFileSync(this.indexPath, "utf-8"));
+        return JSON.parse(import_node_fs2.readFileSync(this.indexPath, "utf-8"));
       } catch {
         return null;
       }
@@ -1115,11 +1370,11 @@ class CodebaseIndexer {
     return null;
   }
   saveIndex(index) {
-    const dir = import_node_path5.dirname(this.indexPath);
-    if (!import_node_fs3.existsSync(dir)) {
-      import_node_fs3.mkdirSync(dir, { recursive: true });
+    const dir = import_node_path4.dirname(this.indexPath);
+    if (!import_node_fs2.existsSync(dir)) {
+      import_node_fs2.mkdirSync(dir, { recursive: true });
     }
-    import_node_fs3.writeFileSync(this.indexPath, JSON.stringify(index, null, 2));
+    import_node_fs2.writeFileSync(this.indexPath, JSON.stringify(index, null, 2));
   }
   cloneIndex(index) {
     return JSON.parse(JSON.stringify(index));
@@ -1135,7 +1390,7 @@ class CodebaseIndexer {
   }
   hashFile(filePath) {
     try {
-      const content = import_node_fs3.readFileSync(import_node_path5.join(this.projectPath, filePath), "utf-8");
+      const content = import_node_fs2.readFileSync(import_node_path4.join(this.projectPath, filePath), "utf-8");
       return import_node_crypto2.createHash("sha256").update(content).digest("hex").slice(0, 16);
     } catch {
       return null;
@@ -1239,11 +1494,55 @@ Return ONLY valid JSON, no markdown formatting.`;
   }
 }
 
+// src/agent/document-fetcher.ts
+var import_node_fs3 = require("node:fs");
+var import_node_path5 = require("node:path");
+class DocumentFetcher {
+  deps;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  async fetch() {
+    const documentsDir = getLocusPath(this.deps.projectPath, "documentsDir");
+    if (!import_node_fs3.existsSync(documentsDir)) {
+      import_node_fs3.mkdirSync(documentsDir, { recursive: true });
+    }
+    try {
+      const groups = await this.deps.client.docs.listGroups(this.deps.workspaceId);
+      const groupMap = new Map(groups.map((g) => [g.id, g.name]));
+      const docs2 = await this.deps.client.docs.list(this.deps.workspaceId);
+      const artifactsGroupId = groups.find((g) => g.name === "Artifacts")?.id;
+      let fetchedCount = 0;
+      for (const doc of docs2) {
+        if (doc.groupId === artifactsGroupId) {
+          continue;
+        }
+        const groupName = groupMap.get(doc.groupId || "") || "General";
+        const groupDir = import_node_path5.join(documentsDir, groupName);
+        if (!import_node_fs3.existsSync(groupDir)) {
+          import_node_fs3.mkdirSync(groupDir, { recursive: true });
+        }
+        const fileName = `${doc.title}.md`;
+        const filePath = import_node_path5.join(groupDir, fileName);
+        if (!import_node_fs3.existsSync(filePath) || import_node_fs3.readFileSync(filePath, "utf-8") !== doc.content) {
+          import_node_fs3.writeFileSync(filePath, doc.content || "");
+          fetchedCount++;
+        }
+      }
+      if (fetchedCount > 0) {
+        this.deps.log(`Fetched ${fetchedCount} document(s) from server`, "info");
+      }
+    } catch (error) {
+      this.deps.log(`Failed to fetch documents: ${error}`, "error");
+    }
+  }
+}
+
 // src/core/prompt-builder.ts
 var import_node_fs4 = require("node:fs");
 var import_node_os2 = require("node:os");
 var import_node_path6 = require("node:path");
-var import_shared3 = require("@locusai/shared");
+var import_shared2 = require("@locusai/shared");
 class PromptBuilder {
   projectPath;
   constructor(projectPath) {
@@ -1332,7 +1631,7 @@ ${serverContext.context}
 `;
     prompt += `You have access to the following documentation directories for context:
 `;
-    prompt += `- Artifacts: \`.locus/artifacts\`
+    prompt += `- Artifacts: \`.locus/artifacts\`)
 `;
     prompt += `- Documents: \`.locus/documents\`
 `;
@@ -1394,6 +1693,76 @@ ${comment.text}
 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. When finished successfully, output: <promise>COMPLETE</promise>
+`;
+    return prompt;
+  }
+  async buildGenericPrompt(query) {
+    let prompt = `# Direct Execution
+
+`;
+    prompt += `## Prompt
+${query}
+
+`;
+    const projectConfig = this.getProjectConfig();
+    if (projectConfig) {
+      prompt += `## Project Metadata
+`;
+      prompt += `- Version: ${projectConfig.version || "Unknown"}
+`;
+      prompt += `- Created At: ${projectConfig.createdAt || "Unknown"}
+
+`;
+    }
+    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)
+${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}
+
+`;
+      }
+    }
+    prompt += this.getProjectStructure();
+    prompt += this.getSkillsInfo();
+    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.
+
+`;
+    const indexPath = getLocusPath(this.projectPath, "indexFile");
+    if (import_node_fs4.existsSync(indexPath)) {
+      prompt += `## Codebase Overview
+There is an index file in the .locus/codebase-index.json and if you need you can check it.
+
+`;
+    }
+    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. When finished successfully, output: <promise>COMPLETE</promise>
 `;
     return prompt;
   }
@@ -1504,15 +1873,15 @@ ${comment.text}
       return null;
     }
     switch (role) {
-      case import_shared3.AssigneeRole.BACKEND:
+      case import_shared2.AssigneeRole.BACKEND:
         return "Backend Engineer";
-      case import_shared3.AssigneeRole.FRONTEND:
+      case import_shared2.AssigneeRole.FRONTEND:
         return "Frontend Engineer";
-      case import_shared3.AssigneeRole.PM:
+      case import_shared2.AssigneeRole.PM:
         return "Product Manager";
-      case import_shared3.AssigneeRole.QA:
+      case import_shared2.AssigneeRole.QA:
         return "QA Engineer";
-      case import_shared3.AssigneeRole.DESIGN:
+      case import_shared2.AssigneeRole.DESIGN:
         return "Product Designer";
       default:
         return "engineer";
@@ -1588,7 +1957,7 @@ class AgentWorker {
   client;
   aiRunner;
   indexerService;
-  artifactSyncer;
+  documentFetcher;
   taskExecutor;
   consecutiveEmpty = 0;
   maxEmpty = 60;
@@ -1620,7 +1989,7 @@ class AgentWorker {
       projectPath,
       log
     });
-    this.artifactSyncer = new ArtifactSyncer({
+    this.documentFetcher = new DocumentFetcher({
       client: this.client,
       workspaceId: config.workspaceId,
       projectPath,
@@ -1706,9 +2075,9 @@ class AgentWorker {
       this.log(`Claimed: ${task.title}`, "success");
       const result = await this.executeTask(task);
       try {
-        await this.artifactSyncer.sync();
+        await this.documentFetcher.fetch();
       } catch (err) {
-        this.log(`Artifact sync failed: ${err}`, "error");
+        this.log(`Document fetch failed: ${err}`, "error");
       }
       if (result.success) {
         this.log(`Completed: ${task.title}`, "success");