@locusai/cli 0.7.3 → 0.7.6

package/bin/agent/worker.js

@@ -14880,11 +14880,11 @@ var require_out = __commonJS((exports) => {
     async.read(path, getSettings(optionsOrSettingsOrCallback), callback);
   }
   exports.stat = stat;
-  function statSync2(path, optionsOrSettings) {
+  function statSync(path, optionsOrSettings) {
     const settings = getSettings(optionsOrSettings);
     return sync.read(path, settings);
   }
-  exports.statSync = statSync2;
+  exports.statSync = statSync;
   function getSettings(settingsOrOptions = {}) {
     if (settingsOrOptions instanceof settings_1.default) {
       return settingsOrOptions;
@@ -17018,8 +17018,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",
@@ -17028,7 +17028,8 @@ var LOCUS_CONFIG = {
   contextFile: "CLAUDE.md",
   artifactsDir: "artifacts",
   documentsDir: "documents",
-  agentSkillsDir: ".agent/skills"
+  agentSkillsDir: ".agent/skills",
+  sessionsDir: "sessions"
 };
 function getLocusPath(projectPath, fileName) {
   if (fileName === "contextFile") {
@@ -17108,11 +17109,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 = resolve(projectPath);
   }
+  setEventEmitter(emitter) {
+    this.eventEmitter = emitter;
+  }
   async run(prompt, _isPlanning = false) {
     const maxRetries = 3;
     let lastError = null;
@@ -17132,6 +17139,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 = 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 = [
@@ -17275,6 +17522,99 @@ class CodexRunner {
     }
     throw lastError || new Error("Codex CLI failed after multiple attempts");
   }
+  async* runStream(prompt) {
+    const outputPath = join2(tmpdir(), `locus-codex-${randomUUID()}.txt`);
+    const args = this.buildArgs(outputPath);
+    const codex = spawn2("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 = join2(tmpdir(), `locus-codex-${randomUUID()}.txt`);
@@ -35504,111 +35844,10 @@ class LocusClient {
   }
 }
 
-// ../sdk/src/agent/artifact-syncer.ts
-import {
-  existsSync as existsSync2,
-  mkdirSync,
-  readdirSync,
-  readFileSync as readFileSync2,
-  statSync,
-  writeFileSync
-} from "node:fs";
-import { join as join3 } from "node:path";
-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 (error48) {
-      this.deps.log(`Failed to get/create Artifacts group: ${error48}`, "error");
-      throw error48;
-    }
-  }
-  async sync() {
-    const artifactsDir = getLocusPath(this.deps.projectPath, "artifactsDir");
-    if (!existsSync2(artifactsDir)) {
-      mkdirSync(artifactsDir, { recursive: true });
-      return;
-    }
-    try {
-      const files = 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 file2 of files) {
-        const filePath = join3(artifactsDir, file2);
-        if (statSync(filePath).isFile()) {
-          const content = readFileSync2(filePath, "utf-8");
-          const title = file2.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: ${file2}`, "success");
-            }
-          } else {
-            await this.deps.client.docs.create(this.deps.workspaceId, {
-              title,
-              content,
-              groupId: artifactsGroupId,
-              type: "GENERAL" /* GENERAL */
-            });
-            this.deps.log(`Created artifact: ${file2}`, "success");
-          }
-        }
-      }
-      for (const doc3 of existingDocs) {
-        if (doc3.groupId === artifactsGroupId) {
-          const fileName = `${doc3.title}.md`;
-          const filePath = join3(artifactsDir, fileName);
-          if (!existsSync2(filePath)) {
-            writeFileSync(filePath, doc3.content || "");
-            this.deps.log(`Fetched artifact: ${fileName}`, "success");
-          }
-        } else {
-          const documentsDir = getLocusPath(this.deps.projectPath, "documentsDir");
-          const groupName = groupMap.get(doc3.groupId || "") || "General";
-          const groupDir = join3(documentsDir, groupName);
-          if (!existsSync2(groupDir)) {
-            mkdirSync(groupDir, { recursive: true });
-          }
-          const fileName = `${doc3.title}.md`;
-          const filePath = join3(groupDir, fileName);
-          if (!existsSync2(filePath) || readFileSync2(filePath, "utf-8") !== doc3.content) {
-            writeFileSync(filePath, doc3.content || "");
-          }
-        }
-      }
-    } catch (error48) {
-      this.deps.log(`Failed to sync artifacts: ${error48}`, "error");
-    }
-  }
-}
-
 // ../sdk/src/core/indexer.ts
 import { createHash } from "node:crypto";
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname, join as join4 } from "node:path";
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { dirname, join as join3 } from "node:path";
 
 // ../../node_modules/globby/index.js
 import process4 from "node:process";
@@ -36121,7 +36360,7 @@ class CodebaseIndexer {
   fullReindexRatioThreshold = 0.2;
   constructor(projectPath) {
     this.projectPath = projectPath;
-    this.indexPath = join4(projectPath, ".locus", "codebase-index.json");
+    this.indexPath = join3(projectPath, ".locus", "codebase-index.json");
   }
   async index(onProgress, treeSummarizer, force = false) {
     if (!treeSummarizer) {
@@ -36177,11 +36416,11 @@ class CodebaseIndexer {
     }
   }
   async getFileTree() {
-    const gitmodulesPath = join4(this.projectPath, ".gitmodules");
+    const gitmodulesPath = join3(this.projectPath, ".gitmodules");
     const submoduleIgnores = [];
-    if (existsSync3(gitmodulesPath)) {
+    if (existsSync2(gitmodulesPath)) {
       try {
-        const content = readFileSync3(gitmodulesPath, "utf-8");
+        const content = readFileSync2(gitmodulesPath, "utf-8");
         const lines = content.split(`
 `);
         for (const line of lines) {
@@ -36237,9 +36476,9 @@ class CodebaseIndexer {
     });
   }
   loadIndex() {
-    if (existsSync3(this.indexPath)) {
+    if (existsSync2(this.indexPath)) {
       try {
-        return JSON.parse(readFileSync3(this.indexPath, "utf-8"));
+        return JSON.parse(readFileSync2(this.indexPath, "utf-8"));
       } catch {
         return null;
       }
@@ -36248,10 +36487,10 @@ class CodebaseIndexer {
   }
   saveIndex(index) {
     const dir = dirname(this.indexPath);
-    if (!existsSync3(dir)) {
-      mkdirSync2(dir, { recursive: true });
+    if (!existsSync2(dir)) {
+      mkdirSync(dir, { recursive: true });
     }
-    writeFileSync2(this.indexPath, JSON.stringify(index, null, 2));
+    writeFileSync(this.indexPath, JSON.stringify(index, null, 2));
   }
   cloneIndex(index) {
     return JSON.parse(JSON.stringify(index));
@@ -36267,7 +36506,7 @@ class CodebaseIndexer {
   }
   hashFile(filePath) {
     try {
-      const content = readFileSync3(join4(this.projectPath, filePath), "utf-8");
+      const content = readFileSync2(join3(this.projectPath, filePath), "utf-8");
       return createHash("sha256").update(content).digest("hex").slice(0, 16);
     } catch {
       return null;
@@ -36371,8 +36610,52 @@ Return ONLY valid JSON, no markdown formatting.`;
   }
 }
 
+// ../sdk/src/agent/document-fetcher.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join4 } from "node:path";
+class DocumentFetcher {
+  deps;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  async fetch() {
+    const documentsDir = getLocusPath(this.deps.projectPath, "documentsDir");
+    if (!existsSync3(documentsDir)) {
+      mkdirSync2(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 doc3 of docs2) {
+        if (doc3.groupId === artifactsGroupId) {
+          continue;
+        }
+        const groupName = groupMap.get(doc3.groupId || "") || "General";
+        const groupDir = join4(documentsDir, groupName);
+        if (!existsSync3(groupDir)) {
+          mkdirSync2(groupDir, { recursive: true });
+        }
+        const fileName = `${doc3.title}.md`;
+        const filePath = join4(groupDir, fileName);
+        if (!existsSync3(filePath) || readFileSync3(filePath, "utf-8") !== doc3.content) {
+          writeFileSync2(filePath, doc3.content || "");
+          fetchedCount++;
+        }
+      }
+      if (fetchedCount > 0) {
+        this.deps.log(`Fetched ${fetchedCount} document(s) from server`, "info");
+      }
+    } catch (error48) {
+      this.deps.log(`Failed to fetch documents: ${error48}`, "error");
+    }
+  }
+}
+
 // ../sdk/src/core/prompt-builder.ts
-import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync as statSync2 } from "node:fs";
+import { existsSync as existsSync4, readdirSync, readFileSync as readFileSync4, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { join as join5 } from "node:path";
 class PromptBuilder {
@@ -36463,7 +36746,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\`
 `;
@@ -36577,9 +36860,9 @@ ${fallback}
 `;
     prompt += `You have access to the following documentation directories for context:
 `;
-    prompt += `- Artifacts: \`.locus/artifacts\`
+    prompt += `- Artifacts: \`.locus/artifacts\` (local-only, not synced to cloud)
 `;
-    prompt += `- Documents: \`.locus/documents\`
+    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.
 
@@ -36625,12 +36908,12 @@ There is an index file in the .locus/codebase-index.json and if you need you can
   }
   getProjectStructure() {
     try {
-      const entries = readdirSync2(this.projectPath);
+      const entries = readdirSync(this.projectPath);
       const folders = entries.filter((e) => {
         if (e.startsWith(".") || e === "node_modules")
           return false;
         try {
-          return statSync2(join5(this.projectPath, e)).isDirectory();
+          return statSync(join5(this.projectPath, e)).isDirectory();
         } catch {
           return false;
         }
@@ -36688,9 +36971,9 @@ There is an index file in the .locus/codebase-index.json and if you need you can
     if (!existsSync4(dirPath))
       return;
     try {
-      const entries = readdirSync2(dirPath).filter((name) => {
+      const entries = readdirSync(dirPath).filter((name) => {
         try {
-          return statSync2(join5(dirPath, name)).isDirectory();
+          return statSync(join5(dirPath, name)).isDirectory();
         } catch {
           return false;
         }
@@ -36789,7 +37072,7 @@ class AgentWorker {
   client;
   aiRunner;
   indexerService;
-  artifactSyncer;
+  documentFetcher;
   taskExecutor;
   consecutiveEmpty = 0;
   maxEmpty = 60;
@@ -36821,7 +37104,7 @@ class AgentWorker {
       projectPath,
       log
     });
-    this.artifactSyncer = new ArtifactSyncer({
+    this.documentFetcher = new DocumentFetcher({
       client: this.client,
       workspaceId: config2.workspaceId,
       projectPath,
@@ -36907,9 +37190,9 @@ class AgentWorker {
       this.log(`Claimed: ${task2.title}`, "success");
       const result = await this.executeTask(task2);
       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: ${task2.title}`, "success");