@contextgraph/agent 0.4.17 → 0.4.19

package/dist/index.js

@@ -4,11 +4,11 @@
 import { Command } from "commander";
 import { readFileSync as readFileSync2 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname2, join as join4 } from "path";
+import { dirname as dirname2, join as join6 } from "path";
 
 // src/callback-server.ts
 import http from "http";
-import { URL } from "url";
+import { URL as URL2 } from "url";
 var MIN_PORT = 3e3;
 var MAX_PORT = 3100;
 async function findFreePort() {
@@ -38,7 +38,7 @@ async function startCallbackServer() {
   let callbackResolve = null;
   const connections = /* @__PURE__ */ new Set();
   const server = http.createServer((req, res) => {
-    const url = new URL(req.url || "/", `http://localhost:${port}`);
+    const url = new URL2(req.url || "/", `http://localhost:${port}`);
     if (url.pathname === "/callback") {
       const token = url.searchParams.get("token");
       const userId = url.searchParams.get("userId");
@@ -859,6 +859,32 @@ async function executeClaude(options) {
         // Allow MCP tools to execute automatically
         maxTurns: 100,
         // Reasonable limit
+        // Enable skills: load from project .claude/skills/ and allow Skill tool
+        settingSources: ["project"],
+        allowedTools: [
+          // Core file operations
+          "Read",
+          "Write",
+          "Edit",
+          "MultiEdit",
+          // Search tools
+          "Grep",
+          "Glob",
+          // Execution
+          "Bash",
+          // Skills
+          "Skill",
+          // Agent orchestration
+          "Task",
+          // User interaction
+          "TodoWrite",
+          "AskUserQuestion",
+          // Web access
+          "WebFetch",
+          "WebSearch",
+          // MCP tools (pattern match for contextgraph MCP server)
+          "mcp__*"
+        ],
         env: {
           ...process.env,
           // Pass auth token through environment for MCP server
@@ -1310,208 +1336,219 @@ var HeartbeatManager = class {
   }
 };
 
-// src/workflows/prepare.ts
-var API_BASE_URL = "https://www.contextgraph.dev";
-async function runPrepare(actionId, options) {
-  const credentials = await loadCredentials();
-  if (!credentials) {
-    console.error("\u274C Not authenticated. Run authentication first.");
-    process.exit(1);
+// src/workspace-setup.ts
+import { mkdtemp as mkdtemp2, rm as rm2 } from "fs/promises";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join4 } from "path";
+
+// src/workspace-prep.ts
+import { spawn as spawn2 } from "child_process";
+import { mkdtemp, rm } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join3 } from "path";
+
+// src/skill-injection.ts
+import { mkdir as mkdir2, writeFile } from "fs/promises";
+import { join as join2 } from "path";
+async function injectSkills(workspacePath, skills) {
+  if (skills.length === 0) {
+    console.log("\u{1F4DA} No skills to inject");
+    return;
   }
-  if (isExpired(credentials) || isTokenExpired(credentials.clerkToken)) {
-    console.error("\u274C Token expired. Re-authenticate to continue.");
-    process.exit(1);
+  console.log(`\u{1F4DA} Injecting ${skills.length} skill(s) into workspace...`);
+  for (const skill of skills) {
+    try {
+      const skillDir = join2(workspacePath, ".claude", "skills", skill.name);
+      await mkdir2(skillDir, { recursive: true });
+      const triggerSection = skill.trigger ? `trigger: |
+${skill.trigger.split("\n").map((line) => `  ${line}`).join("\n")}
+` : "";
+      const skillContent = `---
+name: ${skill.name}
+description: ${skill.description}
+${triggerSection}---
+
+${skill.content}
+`;
+      const skillFilePath = join2(skillDir, "SKILL.md");
+      await writeFile(skillFilePath, skillContent, "utf-8");
+      console.log(`   \u2705 Injected skill: ${skill.name}`);
+    } catch (error) {
+      console.error(`   \u274C Failed to inject skill "${skill.name}":`, error);
+      throw error;
+    }
   }
-  const logTransport = new LogTransportService(API_BASE_URL, credentials.clerkToken);
-  let runId;
-  let heartbeatManager;
-  let logBuffer;
+  console.log(`\u2705 Skills injected successfully`);
+}
+
+// src/skills-library-fetch.ts
+var API_BASE_URL = "https://www.contextgraph.dev";
+async function fetchSkillsLibrary(options) {
+  const { authToken, runId } = options;
   try {
-    console.log("[Log Streaming] Creating run for prepare phase...");
-    runId = await logTransport.createRun(actionId, "prepare", {
-      startingCommit: options?.startingCommit
-    });
-    console.log(`[Log Streaming] Run created: ${runId}`);
-    console.log(`Fetching preparation instructions for action ${actionId}...
-`);
+    const url = new URL(`${API_BASE_URL}/api/skills/library`);
+    if (runId) {
+      url.searchParams.set("runId", runId);
+    }
     const response = await fetchWithRetry(
-      `${API_BASE_URL}/api/prompts/prepare`,
+      url.toString(),
       {
-        method: "POST",
         headers: {
-          "Authorization": `Bearer ${credentials.clerkToken}`,
+          "x-authorization": `Bearer ${authToken}`,
           "Content-Type": "application/json"
-        },
-        body: JSON.stringify({ actionId, runId })
+        }
+      },
+      {
+        maxRetries: 2,
+        baseDelayMs: 500
       }
     );
     if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(`Failed to fetch prepare prompt: ${response.statusText}
-${errorText}`);
-    }
-    const { prompt } = await response.json();
-    await logTransport.updateRunState("preparing");
-    heartbeatManager = new HeartbeatManager(API_BASE_URL, credentials.clerkToken, runId);
-    heartbeatManager.start();
-    console.log("[Log Streaming] Heartbeat started");
-    logBuffer = new LogBuffer(logTransport);
-    logBuffer.start();
-    console.log("Spawning Claude for preparation...\n");
-    const claudeResult = await executeClaude({
-      prompt,
-      cwd: options?.cwd || process.cwd(),
-      authToken: credentials.clerkToken,
-      model: options?.model || "claude-opus-4-5-20251101",
-      onLogEvent: (event) => {
-        logBuffer.push(event);
-      }
+      console.warn(`\u26A0\uFE0F  Skills library API returned ${response.status}: ${response.statusText}`);
+      return [];
+    }
+    const data = await response.json();
+    if (!data.success || !data.data?.skills) {
+      console.warn("\u26A0\uFE0F  Skills library API returned unexpected format");
+      return [];
+    }
+    const skills = data.data.skills.map((skill) => {
+      const name = skill.filename.replace(/\.md$/, "");
+      return {
+        name,
+        description: skill.description,
+        trigger: skill.trigger,
+        content: skill.content
+      };
     });
-    if (claudeResult.exitCode === 0) {
-      await logTransport.finishRun("success", {
-        exitCode: claudeResult.exitCode,
-        cost: claudeResult.cost,
-        usage: claudeResult.usage
-      });
-      console.log("\n\u2705 Preparation complete");
-    } else {
-      await logTransport.finishRun("error", {
-        exitCode: claudeResult.exitCode,
-        errorMessage: `Claude preparation failed with exit code ${claudeResult.exitCode}`
-      });
-      console.error(`
-\u274C Claude preparation failed with exit code ${claudeResult.exitCode}`);
-      process.exit(1);
-    }
+    return skills;
   } catch (error) {
-    if (runId) {
-      try {
-        await logTransport.finishRun("error", {
-          errorMessage: error instanceof Error ? error.message : String(error)
-        });
-      } catch (stateError) {
-        console.error("[Log Streaming] Failed to update run state:", stateError);
-      }
-    }
-    throw error;
-  } finally {
-    if (heartbeatManager) {
-      heartbeatManager.stop();
-      console.log("[Log Streaming] Heartbeat stopped");
-    }
-    if (logBuffer) {
-      await logBuffer.stop();
-      console.log("[Log Streaming] Logs flushed");
-    }
+    console.warn("\u26A0\uFE0F  Failed to fetch skills library:", error instanceof Error ? error.message : error);
+    return [];
   }
 }
 
-// src/workflows/execute.ts
+// src/workspace-prep.ts
 var API_BASE_URL2 = "https://www.contextgraph.dev";
-async function runExecute(actionId, options) {
-  const credentials = await loadCredentials();
-  if (!credentials) {
-    console.error("\u274C Not authenticated. Run authentication first.");
-    process.exit(1);
+async function fetchGitHubCredentials(authToken) {
+  const response = await fetchWithRetry(`${API_BASE_URL2}/api/cli/credentials`, {
+    headers: {
+      "x-authorization": `Bearer ${authToken}`,
+      "Content-Type": "application/json"
+    }
+  });
+  if (response.status === 401) {
+    throw new Error("Authentication failed. Please re-authenticate.");
   }
-  if (isExpired(credentials) || isTokenExpired(credentials.clerkToken)) {
-    console.error("\u274C Token expired. Re-authenticate to continue.");
-    process.exit(1);
+  if (response.status === 404) {
+    throw new Error(
+      "GitHub not connected. Please connect your GitHub account at https://contextgraph.dev/settings."
+    );
   }
-  const logTransport = new LogTransportService(API_BASE_URL2, credentials.clerkToken);
-  let runId;
-  let heartbeatManager;
-  let logBuffer;
-  try {
-    console.log("[Log Streaming] Creating run...");
-    runId = await logTransport.createRun(actionId, "execute", {
-      startingCommit: options?.startingCommit
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Failed to fetch GitHub credentials: ${response.statusText}
+${errorText}`);
+  }
+  return response.json();
+}
+function runGitCommand(args, cwd) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn2("git", args, { cwd });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
     });
-    console.log(`[Log Streaming] Run created: ${runId}`);
-    console.log(`Fetching execution instructions for action ${actionId}...
-`);
-    const response = await fetchWithRetry(
-      `${API_BASE_URL2}/api/prompts/execute`,
-      {
-        method: "POST",
-        headers: {
-          "Authorization": `Bearer ${credentials.clerkToken}`,
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({ actionId, runId })
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve({ stdout, stderr });
+      } else {
+        reject(new Error(`git ${args[0]} failed (exit ${code}): ${stderr || stdout}`));
       }
-    );
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(`Failed to fetch execute prompt: ${response.statusText}
-${errorText}`);
+    });
+    proc.on("error", (err) => {
+      reject(new Error(`Failed to spawn git: ${err.message}`));
+    });
+  });
+}
+function buildAuthenticatedUrl(repoUrl, token) {
+  if (repoUrl.startsWith("https://github.com/")) {
+    return repoUrl.replace("https://github.com/", `https://${token}@github.com/`);
+  }
+  if (repoUrl.startsWith("https://github.com")) {
+    return repoUrl.replace("https://github.com", `https://${token}@github.com`);
+  }
+  return repoUrl;
+}
+async function prepareWorkspace(repoUrl, options) {
+  const { branch, authToken, runId, skipSkills } = options;
+  const credentials = await fetchGitHubCredentials(authToken);
+  const workspacePath = await mkdtemp(join3(tmpdir(), "cg-workspace-"));
+  const cleanup = async () => {
+    try {
+      await rm(workspacePath, { recursive: true, force: true });
+    } catch (error) {
+      console.error(`Warning: Failed to cleanup workspace at ${workspacePath}:`, error);
     }
-    const { prompt } = await response.json();
-    await logTransport.updateRunState("executing");
-    heartbeatManager = new HeartbeatManager(API_BASE_URL2, credentials.clerkToken, runId);
-    heartbeatManager.start();
-    console.log("[Log Streaming] Heartbeat started");
-    logBuffer = new LogBuffer(logTransport);
-    logBuffer.start();
-    console.log("Spawning Claude for execution...\n");
-    const claudeResult = await executeClaude({
-      prompt,
-      cwd: options?.cwd || process.cwd(),
-      authToken: credentials.clerkToken,
-      ...options?.model ? { model: options.model } : {},
-      onLogEvent: (event) => {
-        logBuffer.push(event);
+  };
+  try {
+    const cloneUrl = buildAuthenticatedUrl(repoUrl, credentials.githubToken);
+    console.log(`\u{1F4C2} Cloning ${repoUrl}`);
+    console.log(`   \u2192 ${workspacePath}`);
+    await runGitCommand(["clone", cloneUrl, workspacePath]);
+    console.log(`\u2705 Repository cloned`);
+    if (credentials.githubUsername) {
+      await runGitCommand(["config", "user.name", credentials.githubUsername], workspacePath);
+    }
+    if (credentials.githubEmail) {
+      await runGitCommand(["config", "user.email", credentials.githubEmail], workspacePath);
+    }
+    if (branch) {
+      const { stdout } = await runGitCommand(
+        ["ls-remote", "--heads", "origin", branch],
+        workspacePath
+      );
+      const branchExists = stdout.trim().length > 0;
+      if (branchExists) {
+        console.log(`\u{1F33F} Checking out branch: ${branch}`);
+        await runGitCommand(["checkout", branch], workspacePath);
+      } else {
+        console.log(`\u{1F331} Creating new branch: ${branch}`);
+        await runGitCommand(["checkout", "-b", branch], workspacePath);
       }
-    });
-    if (claudeResult.exitCode === 0) {
-      await logTransport.finishRun("success", {
-        exitCode: claudeResult.exitCode,
-        cost: claudeResult.cost,
-        usage: claudeResult.usage
-      });
-      console.log("\n\u2705 Execution complete");
-    } else {
-      await logTransport.finishRun("error", {
-        exitCode: claudeResult.exitCode,
-        errorMessage: `Claude execution failed with exit code ${claudeResult.exitCode}`
-      });
-      throw new Error(`Claude execution failed with exit code ${claudeResult.exitCode}`);
     }
-  } catch (error) {
-    if (runId) {
+    const { stdout: commitHash } = await runGitCommand(["rev-parse", "HEAD"], workspacePath);
+    const startingCommit = commitHash.trim();
+    console.log("");
+    if (skipSkills) {
+      console.log("\u{1F4DA} Skipping skill injection (--no-skills flag)");
+    } else {
       try {
-        await logTransport.finishRun("error", {
-          errorMessage: error instanceof Error ? error.message : String(error)
-        });
-      } catch (stateError) {
-        console.error("[Log Streaming] Failed to update run state:", stateError);
+        const librarySkills = await fetchSkillsLibrary({ authToken, runId });
+        if (librarySkills.length > 0) {
+          await injectSkills(workspacePath, librarySkills);
+        } else {
+          console.log("\u{1F4DA} No skills to inject (empty library)");
+        }
+      } catch (skillError) {
+        console.warn("\u26A0\uFE0F  Skill injection failed (agent will continue):", skillError);
       }
     }
+    return { path: workspacePath, startingCommit, cleanup };
+  } catch (error) {
+    await cleanup();
     throw error;
-  } finally {
-    if (heartbeatManager) {
-      heartbeatManager.stop();
-      console.log("[Log Streaming] Heartbeat stopped");
-    }
-    if (logBuffer) {
-      await logBuffer.stop();
-      console.log("[Log Streaming] Logs flushed");
-    }
   }
 }
 
-// src/workflows/agent.ts
-import { randomUUID } from "crypto";
-import { readFileSync } from "fs";
-import { mkdtemp as mkdtemp2, rm as rm2 } from "fs/promises";
-import { tmpdir as tmpdir2 } from "os";
-import { fileURLToPath } from "url";
-import { dirname, join as join3 } from "path";
-
 // package.json
 var package_default = {
   name: "@contextgraph/agent",
-  version: "0.4.16",
+  version: "0.4.19",
   description: "Autonomous agent for contextgraph action execution",
   type: "module",
   bin: {
@@ -1619,164 +1656,336 @@ var ApiClient = class {
   async claimNextAction(workerId) {
     const token = await this.getAuthToken();
     const response = await fetchWithRetry(
-      `${this.baseUrl}/api/worker/next?token=${encodeURIComponent(token)}`,
+      `${this.baseUrl}/api/worker/next?token=${encodeURIComponent(token)}`,
+      {
+        method: "POST",
+        headers: {
+          "x-authorization": `Bearer ${token}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          worker_id: workerId,
+          agent_version: package_default.version
+        })
+      }
+    );
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`API error ${response.status}: ${errorText}`);
+    }
+    const result = await response.json();
+    if (!result.success) {
+      throw new Error(result.error || "API returned unsuccessful response");
+    }
+    return result.data;
+  }
+  async releaseClaim(params) {
+    const token = await this.getAuthToken();
+    const response = await fetchWithRetry(
+      `${this.baseUrl}/api/worker/release?token=${encodeURIComponent(token)}`,
+      {
+        method: "POST",
+        headers: {
+          "x-authorization": `Bearer ${token}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(params)
+      }
+    );
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`API error ${response.status}: ${errorText}`);
+    }
+    const result = await response.json();
+    if (!result.success) {
+      throw new Error(result.error || "API returned unsuccessful response");
+    }
+  }
+};
+
+// src/workspace-setup.ts
+var API_BASE_URL3 = "https://www.contextgraph.dev";
+async function setupWorkspaceForAction(actionId, options) {
+  const { authToken, phase, startingCommit: startingCommitOverride, skipSkills } = options;
+  let actionDetail = options.actionDetail;
+  if (!actionDetail) {
+    const apiClient2 = new ApiClient();
+    console.log(`Fetching action details for ${actionId}...`);
+    actionDetail = await apiClient2.getActionDetail(actionId);
+  }
+  const logTransport = new LogTransportService(API_BASE_URL3, authToken);
+  console.log(`[Log Streaming] Creating run for ${phase} phase...`);
+  const runId = await logTransport.createRun(actionId, phase, {
+    startingCommit: startingCommitOverride
+  });
+  console.log(`[Log Streaming] Run created: ${runId}`);
+  const repoUrl = actionDetail.resolved_repository_url || actionDetail.repository_url;
+  const branch = actionDetail.resolved_branch || actionDetail.branch;
+  let workspacePath;
+  let cleanup;
+  let startingCommit = startingCommitOverride;
+  if (repoUrl) {
+    const workspace = await prepareWorkspace(repoUrl, {
+      branch: branch || void 0,
+      authToken,
+      runId,
+      skipSkills
+    });
+    workspacePath = workspace.path;
+    cleanup = workspace.cleanup;
+    startingCommit = workspace.startingCommit;
+  } else {
+    console.log(`\u{1F4C2} No repository configured - creating blank workspace`);
+    workspacePath = await mkdtemp2(join4(tmpdir2(), "cg-workspace-"));
+    console.log(`   \u2192 ${workspacePath}`);
+    cleanup = async () => {
+      try {
+        await rm2(workspacePath, { recursive: true, force: true });
+      } catch (error) {
+        console.error(`Warning: Failed to cleanup workspace at ${workspacePath}:`, error);
+      }
+    };
+  }
+  return {
+    workspacePath,
+    cleanup,
+    startingCommit,
+    runId,
+    logTransport
+  };
+}
+
+// src/workflows/prepare.ts
+var API_BASE_URL4 = "https://www.contextgraph.dev";
+async function runPrepare(actionId, options) {
+  const credentials = await loadCredentials();
+  if (!credentials) {
+    console.error("\u274C Not authenticated. Run authentication first.");
+    process.exit(1);
+  }
+  if (isExpired(credentials) || isTokenExpired(credentials.clerkToken)) {
+    console.error("\u274C Token expired. Re-authenticate to continue.");
+    process.exit(1);
+  }
+  let runId = options?.runId;
+  let heartbeatManager;
+  let logBuffer;
+  let workspacePath;
+  let cleanup;
+  let logTransport;
+  try {
+    if (!runId) {
+      const setup = await setupWorkspaceForAction(actionId, {
+        authToken: credentials.clerkToken,
+        phase: "prepare",
+        startingCommit: options?.startingCommit,
+        skipSkills: options?.skipSkills
+      });
+      workspacePath = setup.workspacePath;
+      cleanup = setup.cleanup;
+      runId = setup.runId;
+      logTransport = setup.logTransport;
+    } else {
+      console.log(`[Log Streaming] Using pre-created run: ${runId}`);
+      workspacePath = options?.cwd || process.cwd();
+      logTransport = new LogTransportService(API_BASE_URL4, credentials.clerkToken, runId);
+    }
+    console.log(`Fetching preparation instructions for action ${actionId}...
+`);
+    const response = await fetchWithRetry(
+      `${API_BASE_URL4}/api/prompts/prepare`,
       {
         method: "POST",
         headers: {
-          "x-authorization": `Bearer ${token}`,
+          "Authorization": `Bearer ${credentials.clerkToken}`,
           "Content-Type": "application/json"
         },
-        body: JSON.stringify({
-          worker_id: workerId,
-          agent_version: package_default.version
-        })
+        body: JSON.stringify({ actionId, runId })
       }
     );
     if (!response.ok) {
       const errorText = await response.text();
-      throw new Error(`API error ${response.status}: ${errorText}`);
+      throw new Error(`Failed to fetch prepare prompt: ${response.statusText}
+${errorText}`);
     }
-    const result = await response.json();
-    if (!result.success) {
-      throw new Error(result.error || "API returned unsuccessful response");
+    const { prompt } = await response.json();
+    await logTransport.updateRunState("preparing");
+    heartbeatManager = new HeartbeatManager(API_BASE_URL4, credentials.clerkToken, runId);
+    heartbeatManager.start();
+    console.log("[Log Streaming] Heartbeat started");
+    logBuffer = new LogBuffer(logTransport);
+    logBuffer.start();
+    console.log("Spawning Claude for preparation...\n");
+    const claudeResult = await executeClaude({
+      prompt,
+      cwd: workspacePath,
+      authToken: credentials.clerkToken,
+      model: options?.model || "claude-opus-4-5-20251101",
+      onLogEvent: (event) => {
+        logBuffer.push(event);
+      }
+    });
+    if (claudeResult.exitCode === 0) {
+      await logTransport.finishRun("success", {
+        exitCode: claudeResult.exitCode,
+        cost: claudeResult.cost,
+        usage: claudeResult.usage
+      });
+      console.log("\n\u2705 Preparation complete");
+    } else {
+      await logTransport.finishRun("error", {
+        exitCode: claudeResult.exitCode,
+        errorMessage: `Claude preparation failed with exit code ${claudeResult.exitCode}`
+      });
+      console.error(`
+\u274C Claude preparation failed with exit code ${claudeResult.exitCode}`);
+      process.exit(1);
+    }
+  } catch (error) {
+    if (runId) {
+      try {
+        await logTransport.finishRun("error", {
+          errorMessage: error instanceof Error ? error.message : String(error)
+        });
+      } catch (stateError) {
+        console.error("[Log Streaming] Failed to update run state:", stateError);
+      }
+    }
+    throw error;
+  } finally {
+    if (heartbeatManager) {
+      heartbeatManager.stop();
+      console.log("[Log Streaming] Heartbeat stopped");
+    }
+    if (logBuffer) {
+      await logBuffer.stop();
+      console.log("[Log Streaming] Logs flushed");
+    }
+    if (cleanup) {
+      await cleanup();
     }
-    return result.data;
   }
-  async releaseClaim(params) {
-    const token = await this.getAuthToken();
+}
+
+// src/workflows/execute.ts
+var API_BASE_URL5 = "https://www.contextgraph.dev";
+async function runExecute(actionId, options) {
+  const credentials = await loadCredentials();
+  if (!credentials) {
+    console.error("\u274C Not authenticated. Run authentication first.");
+    process.exit(1);
+  }
+  if (isExpired(credentials) || isTokenExpired(credentials.clerkToken)) {
+    console.error("\u274C Token expired. Re-authenticate to continue.");
+    process.exit(1);
+  }
+  let runId = options?.runId;
+  let heartbeatManager;
+  let logBuffer;
+  let workspacePath;
+  let cleanup;
+  let logTransport;
+  try {
+    if (!runId) {
+      const setup = await setupWorkspaceForAction(actionId, {
+        authToken: credentials.clerkToken,
+        phase: "execute",
+        startingCommit: options?.startingCommit,
+        skipSkills: options?.skipSkills
+      });
+      workspacePath = setup.workspacePath;
+      cleanup = setup.cleanup;
+      runId = setup.runId;
+      logTransport = setup.logTransport;
+    } else {
+      console.log(`[Log Streaming] Using pre-created run: ${runId}`);
+      workspacePath = options?.cwd || process.cwd();
+      logTransport = new LogTransportService(API_BASE_URL5, credentials.clerkToken, runId);
+    }
+    console.log(`Fetching execution instructions for action ${actionId}...
+`);
     const response = await fetchWithRetry(
-      `${this.baseUrl}/api/worker/release?token=${encodeURIComponent(token)}`,
+      `${API_BASE_URL5}/api/prompts/execute`,
       {
         method: "POST",
         headers: {
-          "x-authorization": `Bearer ${token}`,
+          "Authorization": `Bearer ${credentials.clerkToken}`,
           "Content-Type": "application/json"
         },
-        body: JSON.stringify(params)
+        body: JSON.stringify({ actionId, runId })
       }
     );
     if (!response.ok) {
       const errorText = await response.text();
-      throw new Error(`API error ${response.status}: ${errorText}`);
-    }
-    const result = await response.json();
-    if (!result.success) {
-      throw new Error(result.error || "API returned unsuccessful response");
-    }
-  }
-};
-
-// src/workspace-prep.ts
-import { spawn as spawn2 } from "child_process";
-import { mkdtemp, rm } from "fs/promises";
-import { tmpdir } from "os";
-import { join as join2 } from "path";
-var API_BASE_URL3 = "https://www.contextgraph.dev";
-async function fetchGitHubCredentials(authToken) {
-  const response = await fetchWithRetry(`${API_BASE_URL3}/api/cli/credentials`, {
-    headers: {
-      "x-authorization": `Bearer ${authToken}`,
-      "Content-Type": "application/json"
-    }
-  });
-  if (response.status === 401) {
-    throw new Error("Authentication failed. Please re-authenticate.");
-  }
-  if (response.status === 404) {
-    throw new Error(
-      "GitHub not connected. Please connect your GitHub account at https://contextgraph.dev/settings."
-    );
-  }
-  if (!response.ok) {
-    const errorText = await response.text();
-    throw new Error(`Failed to fetch GitHub credentials: ${response.statusText}
+      throw new Error(`Failed to fetch execute prompt: ${response.statusText}
 ${errorText}`);
-  }
-  return response.json();
-}
-function runGitCommand(args, cwd) {
-  return new Promise((resolve, reject) => {
-    const proc = spawn2("git", args, { cwd });
-    let stdout = "";
-    let stderr = "";
-    proc.stdout.on("data", (data) => {
-      stdout += data.toString();
-    });
-    proc.stderr.on("data", (data) => {
-      stderr += data.toString();
-    });
-    proc.on("close", (code) => {
-      if (code === 0) {
-        resolve({ stdout, stderr });
-      } else {
-        reject(new Error(`git ${args[0]} failed (exit ${code}): ${stderr || stdout}`));
+    }
+    const { prompt } = await response.json();
+    await logTransport.updateRunState("executing");
+    heartbeatManager = new HeartbeatManager(API_BASE_URL5, credentials.clerkToken, runId);
+    heartbeatManager.start();
+    console.log("[Log Streaming] Heartbeat started");
+    logBuffer = new LogBuffer(logTransport);
+    logBuffer.start();
+    console.log("Spawning Claude for execution...\n");
+    const claudeResult = await executeClaude({
+      prompt,
+      cwd: workspacePath,
+      authToken: credentials.clerkToken,
+      ...options?.model ? { model: options.model } : {},
+      onLogEvent: (event) => {
+        logBuffer.push(event);
       }
     });
-    proc.on("error", (err) => {
-      reject(new Error(`Failed to spawn git: ${err.message}`));
-    });
-  });
-}
-function buildAuthenticatedUrl(repoUrl, token) {
-  if (repoUrl.startsWith("https://github.com/")) {
-    return repoUrl.replace("https://github.com/", `https://${token}@github.com/`);
-  }
-  if (repoUrl.startsWith("https://github.com")) {
-    return repoUrl.replace("https://github.com", `https://${token}@github.com`);
-  }
-  return repoUrl;
-}
-async function prepareWorkspace(repoUrl, options) {
-  const { branch, authToken } = options;
-  const credentials = await fetchGitHubCredentials(authToken);
-  const workspacePath = await mkdtemp(join2(tmpdir(), "cg-workspace-"));
-  const cleanup = async () => {
-    try {
-      await rm(workspacePath, { recursive: true, force: true });
-    } catch (error) {
-      console.error(`Warning: Failed to cleanup workspace at ${workspacePath}:`, error);
-    }
-  };
-  try {
-    const cloneUrl = buildAuthenticatedUrl(repoUrl, credentials.githubToken);
-    console.log(`\u{1F4C2} Cloning ${repoUrl}`);
-    console.log(`   \u2192 ${workspacePath}`);
-    await runGitCommand(["clone", cloneUrl, workspacePath]);
-    console.log(`\u2705 Repository cloned`);
-    if (credentials.githubUsername) {
-      await runGitCommand(["config", "user.name", credentials.githubUsername], workspacePath);
-    }
-    if (credentials.githubEmail) {
-      await runGitCommand(["config", "user.email", credentials.githubEmail], workspacePath);
+    if (claudeResult.exitCode === 0) {
+      await logTransport.finishRun("success", {
+        exitCode: claudeResult.exitCode,
+        cost: claudeResult.cost,
+        usage: claudeResult.usage
+      });
+      console.log("\n\u2705 Execution complete");
+    } else {
+      await logTransport.finishRun("error", {
+        exitCode: claudeResult.exitCode,
+        errorMessage: `Claude execution failed with exit code ${claudeResult.exitCode}`
+      });
+      throw new Error(`Claude execution failed with exit code ${claudeResult.exitCode}`);
     }
-    if (branch) {
-      const { stdout } = await runGitCommand(
-        ["ls-remote", "--heads", "origin", branch],
-        workspacePath
-      );
-      const branchExists = stdout.trim().length > 0;
-      if (branchExists) {
-        console.log(`\u{1F33F} Checking out branch: ${branch}`);
-        await runGitCommand(["checkout", branch], workspacePath);
-      } else {
-        console.log(`\u{1F331} Creating new branch: ${branch}`);
-        await runGitCommand(["checkout", "-b", branch], workspacePath);
+  } catch (error) {
+    if (runId) {
+      try {
+        await logTransport.finishRun("error", {
+          errorMessage: error instanceof Error ? error.message : String(error)
+        });
+      } catch (stateError) {
+        console.error("[Log Streaming] Failed to update run state:", stateError);
       }
     }
-    const { stdout: commitHash } = await runGitCommand(["rev-parse", "HEAD"], workspacePath);
-    const startingCommit = commitHash.trim();
-    return { path: workspacePath, startingCommit, cleanup };
-  } catch (error) {
-    await cleanup();
     throw error;
+  } finally {
+    if (heartbeatManager) {
+      heartbeatManager.stop();
+      console.log("[Log Streaming] Heartbeat stopped");
+    }
+    if (logBuffer) {
+      await logBuffer.stop();
+      console.log("[Log Streaming] Logs flushed");
+    }
+    if (cleanup) {
+      await cleanup();
+    }
   }
 }
 
 // src/workflows/agent.ts
+import { randomUUID } from "crypto";
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join as join5 } from "path";
 var __filename2 = fileURLToPath(import.meta.url);
 var __dirname2 = dirname(__filename2);
 var packageJson = JSON.parse(
-  readFileSync(join3(__dirname2, "../package.json"), "utf-8")
+  readFileSync(join5(__dirname2, "../package.json"), "utf-8")
 );
 var INITIAL_POLL_INTERVAL = parseInt(process.env.WORKER_INITIAL_POLL_INTERVAL || "2000", 10);
 var MAX_POLL_INTERVAL = parseInt(process.env.WORKER_MAX_POLL_INTERVAL || "5000", 10);
@@ -1946,35 +2155,24 @@ async function runLocalAgent(options) {
       continue;
     }
     console.log(`Working: ${actionDetail.title}`);
-    const repoUrl = actionDetail.resolved_repository_url || actionDetail.repository_url;
-    const branch = actionDetail.resolved_branch || actionDetail.branch;
     let workspacePath;
     let cleanup;
     let startingCommit;
-    const needsRepo = repoUrl;
+    let runId;
     try {
-      if (needsRepo) {
-        const workspace = await prepareWorkspace(repoUrl, {
-          branch: branch || void 0,
-          authToken: credentials.clerkToken
-        });
-        workspacePath = workspace.path;
-        cleanup = workspace.cleanup;
-        startingCommit = workspace.startingCommit;
-      } else {
-        console.log(`\u{1F4C2} No repository configured - creating blank workspace`);
-        workspacePath = await mkdtemp2(join3(tmpdir2(), "cg-workspace-"));
-        console.log(`   \u2192 ${workspacePath}`);
-        cleanup = async () => {
-          try {
-            await rm2(workspacePath, { recursive: true, force: true });
-          } catch (error) {
-            console.error(`Warning: Failed to cleanup workspace at ${workspacePath}:`, error);
-          }
-        };
-      }
+      const setup = await setupWorkspaceForAction(actionDetail.id, {
+        authToken: credentials.clerkToken,
+        phase,
+        actionDetail,
+        // Pass pre-fetched action detail to avoid redundant API call
+        skipSkills: options?.skipSkills
+      });
+      workspacePath = setup.workspacePath;
+      cleanup = setup.cleanup;
+      startingCommit = setup.startingCommit;
+      runId = setup.runId;
       if (phase === "prepare") {
-        await runPrepare(actionDetail.id, { cwd: workspacePath, startingCommit, model: options?.forceModel });
+        await runPrepare(actionDetail.id, { cwd: workspacePath, startingCommit, model: options?.forceModel, runId });
         stats.prepared++;
         if (currentClaim && apiClient) {
           try {
@@ -1991,7 +2189,7 @@ async function runLocalAgent(options) {
         continue;
       }
       try {
-        await runExecute(actionDetail.id, { cwd: workspacePath, startingCommit, model: options?.forceModel });
+        await runExecute(actionDetail.id, { cwd: workspacePath, startingCommit, model: options?.forceModel, runId });
         stats.executed++;
         console.log(`Completed: ${actionDetail.title}`);
       } catch (executeError) {
@@ -2040,14 +2238,15 @@ async function runLocalAgent(options) {
 var __filename3 = fileURLToPath2(import.meta.url);
 var __dirname3 = dirname2(__filename3);
 var packageJson2 = JSON.parse(
-  readFileSync2(join4(__dirname3, "../package.json"), "utf-8")
+  readFileSync2(join6(__dirname3, "../package.json"), "utf-8")
 );
 var program = new Command();
 program.name("contextgraph-agent").description("Autonomous agent for contextgraph action execution").version(packageJson2.version);
-program.command("run").description("Run continuous worker loop (claims and executes actions until Ctrl+C)").option("--force-haiku", "Force all workflows to use claude-haiku-4-5 instead of default models").action(async (options) => {
+program.command("run").description("Run continuous worker loop (claims and executes actions until Ctrl+C)").option("--force-haiku", "Force all workflows to use claude-haiku-4-5 instead of default models").option("--skip-skills", "Skip skill injection (for testing)").action(async (options) => {
   try {
     await runLocalAgent({
-      forceModel: options.forceHaiku ? "claude-haiku-4-5-20251001" : void 0
+      forceModel: options.forceHaiku ? "claude-haiku-4-5-20251001" : void 0,
+      skipSkills: options.skipSkills
     });
   } catch (error) {
     if (error instanceof Error) {
@@ -2070,17 +2269,17 @@ program.command("auth").description("Authenticate with contextgraph.dev").action
     process.exit(1);
   }
 });
-program.command("prepare").argument("<action-id>", "Action ID to prepare").description("Prepare a single action").action(async (actionId) => {
+program.command("prepare").argument("<action-id>", "Action ID to prepare").description("Prepare a single action").option("--skip-skills", "Skip skill injection (for testing)").action(async (actionId, options) => {
   try {
-    await runPrepare(actionId);
+    await runPrepare(actionId, { skipSkills: options.skipSkills });
   } catch (error) {
     console.error("Error preparing action:", error instanceof Error ? error.message : error);
     process.exit(1);
   }
 });
-program.command("execute").argument("<action-id>", "Action ID to execute").description("Execute a single action").action(async (actionId) => {
+program.command("execute").argument("<action-id>", "Action ID to execute").description("Execute a single action").option("--skip-skills", "Skip skill injection (for testing)").action(async (actionId, options) => {
   try {
-    await runExecute(actionId);
+    await runExecute(actionId, { skipSkills: options.skipSkills });
   } catch (error) {
     console.error("Error executing action:", error instanceof Error ? error.message : error);
     process.exit(1);