@locusai/sdk 0.14.4 → 0.15.0

package/dist/index-node.js

@@ -225,6 +225,29 @@ var init_invitations = __esm(() => {
   };
 });
 
+// src/modules/jobs.ts
+var JobsModule;
+var init_jobs = __esm(() => {
+  JobsModule = class JobsModule extends BaseModule {
+    async create(workspaceId, data) {
+      const { data: res } = await this.api.post(`/workspaces/${workspaceId}/job-runs`, data);
+      return res.jobRun;
+    }
+    async list(workspaceId, params) {
+      const { data } = await this.api.get(`/workspaces/${workspaceId}/job-runs`, { params });
+      return data.jobRuns;
+    }
+    async get(workspaceId, id) {
+      const { data } = await this.api.get(`/workspaces/${workspaceId}/job-runs/${id}`);
+      return data.jobRun;
+    }
+    async update(workspaceId, id, data) {
+      const { data: res } = await this.api.patch(`/workspaces/${workspaceId}/job-runs/${id}`, data);
+      return res.jobRun;
+    }
+  };
+});
+
 // src/modules/organizations.ts
 var OrganizationsModule;
 var init_organizations = __esm(() => {
@@ -307,6 +330,29 @@ var init_sprints = __esm(() => {
   };
 });
 
+// src/modules/suggestions.ts
+var SuggestionsModule;
+var init_suggestions = __esm(() => {
+  SuggestionsModule = class SuggestionsModule extends BaseModule {
+    async create(workspaceId, data) {
+      const { data: res } = await this.api.post(`/workspaces/${workspaceId}/suggestions`, data);
+      return res.suggestion;
+    }
+    async list(workspaceId, params) {
+      const { data } = await this.api.get(`/workspaces/${workspaceId}/suggestions`, { params });
+      return data.suggestions;
+    }
+    async get(workspaceId, id) {
+      const { data } = await this.api.get(`/workspaces/${workspaceId}/suggestions/${id}`);
+      return data.suggestion;
+    }
+    async updateStatus(workspaceId, id, status) {
+      const { data } = await this.api.patch(`/workspaces/${workspaceId}/suggestions/${id}/status`, status);
+      return data.suggestion;
+    }
+  };
+});
+
 // src/modules/tasks.ts
 var import_shared, TasksModule;
 var init_tasks = __esm(() => {
@@ -483,11 +529,13 @@ var exports_src = {};
 __export(exports_src, {
   WorkspacesModule: () => WorkspacesModule,
   TasksModule: () => TasksModule,
+  SuggestionsModule: () => SuggestionsModule,
   SprintsModule: () => SprintsModule,
   OrganizationsModule: () => OrganizationsModule,
   LocusEvent: () => LocusEvent,
   LocusEmitter: () => LocusEmitter,
   LocusClient: () => LocusClient,
+  JobsModule: () => JobsModule,
   InvitationsModule: () => InvitationsModule,
   InstancesModule: () => InstancesModule,
   DocsModule: () => DocsModule,
@@ -511,6 +559,8 @@ class LocusClient {
   docs;
   ci;
   instances;
+  jobs;
+  suggestions;
   constructor(config) {
     this.emitter = new LocusEmitter;
     this.api = import_axios.default.create({
@@ -531,6 +581,8 @@ class LocusClient {
     this.docs = new DocsModule(this.api, this.emitter);
     this.ci = new CiModule(this.api, this.emitter);
     this.instances = new InstancesModule(this.api, this.emitter);
+    this.jobs = new JobsModule(this.api, this.emitter);
+    this.suggestions = new SuggestionsModule(this.api, this.emitter);
     if (config.retryOptions) {
       this.setupRetryInterceptor(config.retryOptions);
     }
@@ -598,8 +650,10 @@ var init_src = __esm(() => {
   init_docs();
   init_instances();
   init_invitations();
+  init_jobs();
   init_organizations();
   init_sprints();
+  init_suggestions();
   init_tasks();
   init_workspaces();
   init_discussion_types();
@@ -610,8 +664,10 @@ var init_src = __esm(() => {
   init_docs();
   init_instances();
   init_invitations();
+  init_jobs();
   init_organizations();
   init_sprints();
+  init_suggestions();
   init_tasks();
   init_workspaces();
 });
@@ -883,6 +939,7 @@ class ClaudeRunner {
   currentToolName;
   activeTools = new Map;
   activeProcess = null;
+  aborted = false;
   timeoutMs;
   constructor(projectPath, model = DEFAULT_MODEL[PROVIDER.CLAUDE], log, timeoutMs) {
     this.model = model;
@@ -895,6 +952,7 @@ class ClaudeRunner {
   }
   abort() {
     if (this.activeProcess && !this.activeProcess.killed) {
+      this.aborted = true;
       this.activeProcess.kill("SIGTERM");
       this.activeProcess = null;
     }
@@ -953,6 +1011,7 @@ class ClaudeRunner {
     return args;
   }
   async* runStream(prompt) {
+    this.aborted = false;
     const args = this.buildCliArgs();
     const env = getAugmentedEnv({
       FORCE_COLOR: "1",
@@ -1047,7 +1106,7 @@ class ClaudeRunner {
         process.stderr.write(`${stderrBuffer}
 `);
       }
-      if (code !== 0 && !errorMessage) {
+      if (code !== 0 && !errorMessage && !this.aborted) {
         const detail = stderrFull.trim() || lastResultContent.trim();
         errorMessage = this.createExecutionError(code, detail).message;
         this.eventEmitter?.emitErrorOccurred(errorMessage, `EXIT_${code}`);
@@ -1192,6 +1251,7 @@ class ClaudeRunner {
     return null;
   }
   executeRun(prompt) {
+    this.aborted = false;
     return new Promise((resolve2, reject) => {
       const args = this.buildCliArgs();
       const env = getAugmentedEnv({
@@ -1244,7 +1304,7 @@ class ClaudeRunner {
         }
         process.stdout.write(`
 `);
-        if (code === 0) {
+        if (code === 0 || this.aborted) {
           resolve2(finalResult);
         } else {
           const detail = errorOutput.trim() || finalResult.trim();
@@ -1311,6 +1371,7 @@ class CodexRunner {
   log;
   reasoningEffort;
   activeProcess = null;
+  aborted = false;
   eventEmitter;
   currentToolName;
   timeoutMs;
@@ -1326,11 +1387,13 @@ class CodexRunner {
   }
   abort() {
     if (this.activeProcess && !this.activeProcess.killed) {
+      this.aborted = true;
       this.activeProcess.kill("SIGTERM");
       this.activeProcess = null;
     }
   }
   async run(prompt) {
+    this.aborted = false;
     const maxRetries = 3;
     let lastError = null;
     for (let attempt = 1;attempt <= maxRetries; attempt++) {
@@ -1446,7 +1509,7 @@ class CodexRunner {
     });
     codex.on("close", (code) => {
       this.activeProcess = null;
-      if (code === 0) {
+      if (code === 0 || this.aborted) {
         const result = this.readOutput(outputPath, finalOutput);
         this.cleanupTempFile(outputPath);
         if (result && finalContent.trim().length === 0) {
@@ -1559,7 +1622,7 @@ class CodexRunner {
       });
       codex.on("close", (code) => {
         this.activeProcess = null;
-        if (code === 0) {
+        if (code === 0 || this.aborted) {
           const result = this.readOutput(outputPath, output);
           this.cleanupTempFile(outputPath);
           resolve2(result);
@@ -2844,16 +2907,22 @@ __export(exports_index_node, {
   getAgentArtifactsPath: () => getAgentArtifactsPath,
   extractJsonFromLLMOutput: () => extractJsonFromLLMOutput,
   detectRemoteProvider: () => detectRemoteProvider,
+  createDefaultRegistry: () => createDefaultRegistry,
   createAiRunner: () => createAiRunner,
   c: () => c,
   buildSummaryPrompt: () => buildSummaryPrompt,
   buildFacilitatorPrompt: () => buildFacilitatorPrompt,
   WorkspacesModule: () => WorkspacesModule,
+  TodoScanJob: () => TodoScanJob,
+  TestScanJob: () => TestScanJob,
   TasksModule: () => TasksModule,
   TaskExecutor: () => TaskExecutor,
+  SuggestionsModule: () => SuggestionsModule,
   SprintsModule: () => SprintsModule,
+  SchedulerEvent: () => SchedulerEvent,
   ReviewerWorker: () => ReviewerWorker,
   ReviewService: () => ReviewService,
+  ProposalEngine: () => ProposalEngine,
   PromptBuilder: () => PromptBuilder,
   PrService: () => PrService,
   PlanningMeeting: () => PlanningMeeting,
@@ -2864,10 +2933,16 @@ __export(exports_index_node, {
   LocusEvent: () => LocusEvent,
   LocusEmitter: () => LocusEmitter,
   LocusClient: () => LocusClient,
+  LintScanJob: () => LintScanJob,
   LOCUS_SCHEMA_BASE_URL: () => LOCUS_SCHEMA_BASE_URL,
   LOCUS_SCHEMAS: () => LOCUS_SCHEMAS,
   LOCUS_GITIGNORE_PATTERNS: () => LOCUS_GITIGNORE_PATTERNS,
   LOCUS_CONFIG: () => LOCUS_CONFIG,
+  JobsModule: () => JobsModule,
+  JobScheduler: () => JobScheduler,
+  JobRunner: () => JobRunner,
+  JobRegistry: () => JobRegistry,
+  JobEvent: () => JobEvent,
   InvitationsModule: () => InvitationsModule,
   InstancesModule: () => InstancesModule,
   HistoryManager: () => HistoryManager,
@@ -2882,8 +2957,10 @@ __export(exports_index_node, {
   DiscussionManager: () => DiscussionManager,
   DiscussionInsightSchema: () => DiscussionInsightSchema,
   DiscussionFacilitator: () => DiscussionFacilitator,
+  DependencyScanJob: () => DependencyScanJob,
   DEFAULT_MODEL: () => DEFAULT_MODEL,
   ContextTracker: () => ContextTracker,
+  ContextGatherer: () => ContextGatherer,
   CodexRunner: () => CodexRunner,
   CodebaseIndexerService: () => CodebaseIndexerService,
   CodebaseIndexer: () => CodebaseIndexer,
@@ -2891,6 +2968,7 @@ __export(exports_index_node, {
   CiModule: () => CiModule,
   CODEX_MODELS: () => CODEX_MODELS,
   CLAUDE_MODELS: () => CLAUDE_MODELS,
+  BaseJob: () => BaseJob,
   AuthModule: () => AuthModule,
   AgentWorker: () => AgentWorker,
   AgentOrchestrator: () => AgentOrchestrator
@@ -4945,206 +5023,2054 @@ init_git_utils();
 // src/index-node.ts
 init_src();
 
-// src/orchestrator/index.ts
+// src/jobs/base-job.ts
+class BaseJob {
+  shouldAutoExecute(category, rules) {
+    const rule = rules.find((r) => r.category === category);
+    return rule ? rule.autoExecute : false;
+  }
+}
+// src/jobs/job-registry.ts
+class JobRegistry {
+  jobs = new Map;
+  register(job) {
+    this.jobs.set(job.type, job);
+  }
+  get(type) {
+    return this.jobs.get(type);
+  }
+  getAll() {
+    return Array.from(this.jobs.values());
+  }
+  has(type) {
+    return this.jobs.has(type);
+  }
+}
+
+// src/jobs/scans/dependency-scan.ts
 init_git_utils();
-init_src();
-init_colors();
-init_resolve_bin();
 var import_node_child_process7 = require("node:child_process");
 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");
-
-class AgentOrchestrator extends import_events4.EventEmitter {
-  client;
-  config;
-  isRunning = false;
-  processedTasks = new Set;
-  resolvedSprintId = null;
-  agentState = null;
-  heartbeatInterval = null;
-  constructor(config) {
-    super();
-    this.config = config;
-    this.client = new LocusClient({
-      baseUrl: config.apiBase,
-      token: config.apiKey
-    });
-  }
-  async resolveSprintId() {
-    if (this.config.sprintId) {
-      return this.config.sprintId;
+class DependencyScanJob extends BaseJob {
+  type = import_shared4.JobType.DEPENDENCY_CHECK;
+  name = "Dependency Check";
+  async run(context) {
+    const { projectPath, autonomyRules } = context;
+    const pm = this.detectPackageManager(projectPath);
+    if (!pm) {
+      return {
+        summary: "No package manager lock file detected",
+        suggestions: [],
+        filesChanged: 0
+      };
     }
+    let outdated;
     try {
-      const sprint = await this.client.sprints.getActive(this.config.workspaceId);
-      if (sprint?.id) {
-        console.log(c.info(`\uD83D\uDCCB Using active sprint: ${sprint.name}`));
-        return sprint.id;
-      }
-    } catch {}
-    console.log(c.dim("ℹ  No sprint specified, working with all workspace tasks"));
-    return "";
-  }
-  async start() {
-    if (this.isRunning) {
-      throw new Error("Orchestrator is already running");
+      outdated = this.getOutdatedPackages(pm, projectPath);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        summary: `Dependency check failed (outdated): ${message}`,
+        suggestions: [],
+        filesChanged: 0,
+        errors: [message]
+      };
     }
-    this.isRunning = true;
-    this.processedTasks.clear();
+    let vulnerabilities;
     try {
-      await this.orchestrationLoop();
-    } catch (error) {
-      this.emit("error", error);
-      throw error;
-    } finally {
-      await this.cleanup();
+      vulnerabilities = this.runSecurityAudit(pm, projectPath);
+    } catch {
+      vulnerabilities = [];
+    }
+    const patch = outdated.filter((p) => p.risk === "patch");
+    const minor = outdated.filter((p) => p.risk === "minor");
+    const major = outdated.filter((p) => p.risk === "major");
+    const canAutoExecute = this.shouldAutoExecute(import_shared4.ChangeCategory.DEPENDENCY, autonomyRules);
+    let filesChanged = 0;
+    let prUrl;
+    if (canAutoExecute && (patch.length > 0 || minor.length > 0) && major.length === 0) {
+      const autoResult = this.autoUpdate(pm, patch, minor, projectPath);
+      filesChanged = autoResult.filesChanged;
+      prUrl = autoResult.prUrl ?? undefined;
+    }
+    const suggestions2 = this.buildSuggestions(patch, minor, major, pm);
+    const summaryParts = [];
+    if (outdated.length > 0) {
+      summaryParts.push(`${outdated.length} outdated (${patch.length} patch, ${minor.length} minor, ${major.length} major)`);
+    } else {
+      summaryParts.push("all dependencies up to date");
     }
-  }
-  async orchestrationLoop() {
-    this.resolvedSprintId = await this.resolveSprintId();
-    this.emit("started", {
-      timestamp: new Date,
-      config: this.config,
-      sprintId: this.resolvedSprintId
-    });
-    this.printBanner();
-    const tasks2 = await this.getAvailableTasks();
-    if (tasks2.length === 0) {
-      console.log(c.dim("ℹ  No available tasks found in the backlog."));
-      return;
+    if (vulnerabilities.length > 0) {
+      summaryParts.push(`${vulnerabilities.length} vulnerability(ies)`);
     }
-    if (!this.preflightChecks())
-      return;
-    this.startHeartbeatMonitor();
-    await this.spawnAgent();
-    await this.waitForAgent();
-    console.log(`
-${c.success("✅ Orchestrator finished")}`);
-  }
-  printBanner() {
-    console.log(`
-${c.primary("\uD83E\uDD16 Locus Agent Orchestrator")}`);
-    console.log(c.dim("----------------------------------------------"));
-    console.log(`${c.bold("Workspace:")} ${this.config.workspaceId}`);
-    if (this.resolvedSprintId) {
-      console.log(`${c.bold("Sprint:")} ${this.resolvedSprintId}`);
+    if (filesChanged > 0) {
+      summaryParts.push(`auto-updated ${patch.length + minor.length} safe package(s)`);
     }
-    console.log(`${c.bold("API Base:")} ${this.config.apiBase}`);
-    console.log(c.dim(`----------------------------------------------
-`));
+    const summary = `Dependency check: ${summaryParts.join(", ")} (${pm})`;
+    return {
+      summary,
+      suggestions: suggestions2,
+      filesChanged,
+      prUrl
+    };
   }
-  preflightChecks() {
-    if (!isGitAvailable()) {
-      console.log(c.error("git is not installed. Install from https://git-scm.com/"));
-      return false;
-    }
-    if (!isGhAvailable(this.config.projectPath)) {
-      console.log(c.warning("GitHub CLI (gh) not available or not authenticated. Branch push can continue, but automatic PR creation may fail until gh is configured. Install from https://cli.github.com/"));
-    }
-    return true;
+  detectPackageManager(projectPath) {
+    if (import_node_fs9.existsSync(import_node_path10.join(projectPath, "bun.lock")))
+      return "bun";
+    if (import_node_fs9.existsSync(import_node_path10.join(projectPath, "pnpm-lock.yaml")))
+      return "pnpm";
+    if (import_node_fs9.existsSync(import_node_path10.join(projectPath, "yarn.lock")))
+      return "yarn";
+    if (import_node_fs9.existsSync(import_node_path10.join(projectPath, "package-lock.json")))
+      return "npm";
+    return null;
   }
-  async getAvailableTasks() {
-    try {
-      const tasks2 = await this.client.tasks.getAvailable(this.config.workspaceId, this.resolvedSprintId || undefined);
-      return tasks2.filter((task) => !this.processedTasks.has(task.id));
-    } catch (error) {
-      this.emit("error", error);
-      return [];
+  getOutdatedPackages(pm, projectPath) {
+    const output = this.runOutdatedCommand(pm, projectPath);
+    if (pm === "bun") {
+      return this.parseBunOutdated(output.stdout);
     }
+    return this.parseJsonOutdated(pm, output.stdout);
   }
-  async spawnAgent() {
-    const agentId = `agent-0-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
-    this.agentState = {
-      id: agentId,
-      status: "IDLE",
-      currentTaskId: null,
-      tasksCompleted: 0,
-      tasksFailed: 0,
-      lastHeartbeat: new Date
+  runOutdatedCommand(pm, projectPath) {
+    const commands = {
+      bun: ["bun", "outdated"],
+      npm: ["npm", "outdated", "--json"],
+      pnpm: ["pnpm", "outdated", "--format", "json"],
+      yarn: ["yarn", "outdated", "--json"]
     };
-    console.log(`${c.primary("\uD83D\uDE80 Agent started:")} ${c.bold(agentId)}
+    const [bin, ...args] = commands[pm];
+    return this.exec(bin, args, projectPath);
+  }
+  parseBunOutdated(stdout) {
+    const packages = [];
+    const lines = stdout.split(`
 `);
-    const workerPath = this.resolveWorkerPath();
-    if (!workerPath) {
-      throw new Error("Worker file not found. Make sure the SDK is properly built and installed.");
+    for (const line of lines) {
+      const match = line.match(/^\s*\|\s*(\S+)\s*\|\s*(\S+)\s*\|\s*(\S+)\s*\|\s*(\S+)\s*\|?\s*$/);
+      if (!match)
+        continue;
+      const [, name, current, , latest] = match;
+      if (!name || !current || !latest || name === "Package")
+        continue;
+      packages.push({
+        name,
+        current,
+        wanted: latest,
+        latest,
+        risk: this.classifyRisk(current, latest)
+      });
     }
-    const workerArgs = this.buildWorkerArgs(agentId);
-    const agentProcess = import_node_child_process7.spawn(process.execPath, [workerPath, ...workerArgs], {
-      stdio: ["pipe", "pipe", "pipe"],
-      detached: true,
-      env: getAugmentedEnv({
-        FORCE_COLOR: "1",
-        TERM: "xterm-256color",
-        LOCUS_WORKER: agentId,
-        LOCUS_WORKSPACE: this.config.workspaceId
-      })
-    });
-    this.agentState.process = agentProcess;
-    this.attachProcessHandlers(agentId, this.agentState, agentProcess);
-    this.emit("agent:spawned", { agentId });
+    return packages;
   }
-  async waitForAgent() {
-    while (this.agentState && this.isRunning) {
-      await sleep(2000);
+  parseJsonOutdated(pm, stdout) {
+    const packages = [];
+    if (!stdout.trim())
+      return packages;
+    if (pm === "yarn") {
+      return this.parseYarnOutdated(stdout);
     }
+    let data;
+    try {
+      data = JSON.parse(stdout);
+    } catch {
+      return packages;
+    }
+    for (const [name, info] of Object.entries(data)) {
+      const current = info.current ?? "0.0.0";
+      const wanted = info.wanted ?? current;
+      const latest = info.latest ?? wanted;
+      packages.push({
+        name,
+        current,
+        wanted,
+        latest,
+        risk: this.classifyRisk(current, latest)
+      });
+    }
+    return packages;
   }
-  startHeartbeatMonitor() {
-    this.heartbeatInterval = setInterval(() => {
-      if (!this.agentState)
-        return;
-      const now = Date.now();
-      if (this.agentState.status === "WORKING" && now - this.agentState.lastHeartbeat.getTime() > import_shared4.STALE_AGENT_TIMEOUT_MS) {
-        console.log(c.error(`Agent ${this.agentState.id} is stale (no heartbeat for 10 minutes). Killing.`));
-        if (this.agentState.process && !this.agentState.process.killed) {
-          killProcessTree(this.agentState.process);
+  parseYarnOutdated(stdout) {
+    const packages = [];
+    for (const line of stdout.split(`
+`)) {
+      if (!line.trim())
+        continue;
+      try {
+        const obj = JSON.parse(line);
+        if (obj.type === "table" && Array.isArray(obj.data?.body)) {
+          for (const row of obj.data.body) {
+            if (!Array.isArray(row) || row.length < 4)
+              continue;
+            const [name, current, wanted, latest] = row;
+            packages.push({
+              name,
+              current,
+              wanted,
+              latest,
+              risk: this.classifyRisk(current, latest)
+            });
+          }
         }
-        this.emit("agent:stale", { agentId: this.agentState.id });
+      } catch {}
+    }
+    return packages;
+  }
+  runSecurityAudit(pm, projectPath) {
+    const commands = {
+      bun: ["bun", "audit"],
+      npm: ["npm", "audit", "--json"],
+      pnpm: ["pnpm", "audit", "--json"],
+      yarn: ["yarn", "audit", "--json"]
+    };
+    const [bin, ...args] = commands[pm];
+    const output = this.exec(bin, args, projectPath);
+    if (pm === "npm" || pm === "pnpm") {
+      return this.parseNpmAudit(output.stdout);
+    }
+    return this.parseGenericAudit(output.stdout);
+  }
+  parseNpmAudit(stdout) {
+    const vulnerabilities = [];
+    if (!stdout.trim())
+      return vulnerabilities;
+    try {
+      const data = JSON.parse(stdout);
+      const vulns = data.vulnerabilities ?? data.advisories ?? {};
+      for (const [name, info] of Object.entries(vulns)) {
+        const v = info;
+        vulnerabilities.push({
+          name,
+          severity: v.severity ?? "unknown",
+          title: v.title ?? v.overview ?? name,
+          url: v.url ?? undefined
+        });
       }
-    }, 60000);
+    } catch {}
+    return vulnerabilities;
   }
-  async stop() {
-    this.isRunning = false;
-    await this.cleanup();
-    this.emit("stopped", { timestamp: new Date });
+  parseGenericAudit(stdout) {
+    const vulnerabilities = [];
+    for (const line of stdout.split(`
+`)) {
+      if (!line.trim())
+        continue;
+      try {
+        const obj = JSON.parse(line);
+        if (obj.type === "auditAdvisory" && obj.data?.advisory) {
+          const adv = obj.data.advisory;
+          vulnerabilities.push({
+            name: adv.module_name ?? "unknown",
+            severity: adv.severity ?? "unknown",
+            title: adv.title ?? "Unknown vulnerability",
+            url: adv.url
+          });
+        }
+      } catch {}
+    }
+    return vulnerabilities;
   }
-  stopAgent(agentId) {
-    if (!this.agentState || this.agentState.id !== agentId)
-      return false;
-    if (this.agentState.process && !this.agentState.process.killed) {
-      killProcessTree(this.agentState.process);
+  autoUpdate(pm, patch, minor, projectPath) {
+    const safePackages = [...patch, ...minor];
+    try {
+      this.runUpdateCommand(pm, safePackages, projectPath);
+      this.runInstallCommand(pm, projectPath);
+    } catch {
+      return { filesChanged: 0, prUrl: null };
     }
-    return true;
+    let changedFiles;
+    try {
+      const diffOutput = import_node_child_process7.execFileSync("git", ["diff", "--name-only"], {
+        cwd: projectPath,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      changedFiles = diffOutput ? diffOutput.split(`
+`) : [];
+    } catch {
+      changedFiles = [];
+    }
+    if (changedFiles.length === 0) {
+      return { filesChanged: 0, prUrl: null };
+    }
+    const prUrl = this.commitAndPush(projectPath, changedFiles, safePackages, pm);
+    return { filesChanged: changedFiles.length, prUrl };
   }
-  async cleanup() {
-    if (this.heartbeatInterval) {
-      clearInterval(this.heartbeatInterval);
-      this.heartbeatInterval = null;
+  runUpdateCommand(pm, packages, projectPath) {
+    const pkgSpecs = packages.map((p) => `${p.name}@${p.latest}`);
+    switch (pm) {
+      case "bun":
+        this.exec("bun", ["add", ...pkgSpecs], projectPath);
+        break;
+      case "npm":
+        this.exec("npm", ["install", ...pkgSpecs], projectPath);
+        break;
+      case "pnpm":
+        this.exec("pnpm", ["add", ...pkgSpecs], projectPath);
+        break;
+      case "yarn":
+        this.exec("yarn", ["add", ...pkgSpecs], projectPath);
+        break;
     }
-    if (this.agentState?.process && !this.agentState.process.killed) {
-      console.log(`Killing agent: ${this.agentState.id}`);
-      killProcessTree(this.agentState.process);
+  }
+  runInstallCommand(pm, projectPath) {
+    const commands = {
+      bun: ["bun", "install"],
+      npm: ["npm", "install"],
+      pnpm: ["pnpm", "install"],
+      yarn: ["yarn", "install"]
+    };
+    const [bin, ...args] = commands[pm];
+    this.exec(bin, args, projectPath);
+  }
+  commitAndPush(projectPath, changedFiles, packages, pm) {
+    try {
+      const defaultBranch = getDefaultBranch(projectPath);
+      const branchName = `locus/dep-update-${Date.now().toString(36)}`;
+      this.gitExec(["checkout", "-b", branchName], projectPath);
+      this.gitExec(["add", ...changedFiles], projectPath);
+      const packageList = packages.map((p) => `${p.name}@${p.latest}`).join(", ");
+      const commitMessage = `fix(deps): update ${packages.length} safe dependencies
+
+Updated: ${packageList}
+Package manager: ${pm}
+Agent: locus-dependency-check
+Co-authored-by: LocusAI <agent@locusai.team>`;
+      this.gitExec(["commit", "-m", commitMessage], projectPath);
+      this.gitExec(["push", "-u", "origin", branchName], projectPath);
+      let prUrl = null;
+      if (detectRemoteProvider(projectPath) === "github" && isGhAvailable(projectPath)) {
+        try {
+          const title = `[Locus] Update ${packages.length} safe dependencies`;
+          const body = [
+            "## Summary",
+            "",
+            `Automated dependency updates applied by Locus using \`${pm}\`.`,
+            "",
+            "### Updated packages",
+            "",
+            ...packages.map((p) => `- \`${p.name}\`: ${p.current} → ${p.latest} (${p.risk})`),
+            "",
+            `- **Files changed**: ${changedFiles.length}`,
+            "",
+            "---",
+            "*Created by Locus Agent (dependency-check)*"
+          ].join(`
+`);
+          prUrl = import_node_child_process7.execFileSync("gh", [
+            "pr",
+            "create",
+            "--title",
+            title,
+            "--body",
+            body,
+            "--base",
+            defaultBranch,
+            "--head",
+            branchName
+          ], {
+            cwd: projectPath,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"]
+          }).trim();
+        } catch {}
+      }
+      try {
+        this.gitExec(["checkout", defaultBranch], projectPath);
+      } catch {}
+      return prUrl;
+    } catch {
+      return null;
     }
   }
-  getStats() {
+  buildSuggestions(patch, minor, major, pm) {
+    const suggestions2 = [];
+    if (patch.length > 0) {
+      suggestions2.push({
+        type: import_shared4.SuggestionType.DEPENDENCY_UPDATE,
+        title: `${patch.length} patch update(s) available`,
+        description: `Safe patch updates: ${patch.map((p) => `${p.name} ${p.current} → ${p.latest}`).join(", ")}. Run \`${this.getUpdateHint(pm, patch)}\` to apply.`,
+        metadata: {
+          risk: "patch",
+          packages: patch.map((p) => ({
+            name: p.name,
+            current: p.current,
+            latest: p.latest
+          }))
+        }
+      });
+    }
+    if (minor.length > 0) {
+      suggestions2.push({
+        type: import_shared4.SuggestionType.DEPENDENCY_UPDATE,
+        title: `${minor.length} minor update(s) available`,
+        description: `Minor updates: ${minor.map((p) => `${p.name} ${p.current} → ${p.latest}`).join(", ")}. Generally safe but review changelogs.`,
+        metadata: {
+          risk: "minor",
+          packages: minor.map((p) => ({
+            name: p.name,
+            current: p.current,
+            latest: p.latest
+          }))
+        }
+      });
+    }
+    if (major.length > 0) {
+      suggestions2.push({
+        type: import_shared4.SuggestionType.DEPENDENCY_UPDATE,
+        title: `${major.length} major update(s) require review`,
+        description: `Breaking changes possible: ${major.map((p) => `${p.name} ${p.current} → ${p.latest}`).join(", ")}. Review migration guides before upgrading.`,
+        metadata: {
+          risk: "major",
+          packages: major.map((p) => ({
+            name: p.name,
+            current: p.current,
+            latest: p.latest
+          }))
+        }
+      });
+    }
+    return suggestions2;
+  }
+  classifyRisk(current, latest) {
+    const currentParts = this.parseSemver(current);
+    const latestParts = this.parseSemver(latest);
+    if (!currentParts || !latestParts)
+      return "major";
+    if (latestParts.major !== currentParts.major)
+      return "major";
+    if (latestParts.minor !== currentParts.minor)
+      return "minor";
+    return "patch";
+  }
+  parseSemver(version) {
+    const match = version.match(/^(\d+)\.(\d+)\.(\d+)/);
+    if (!match)
+      return null;
     return {
-      activeAgents: this.agentState ? 1 : 0,
-      totalTasksCompleted: this.agentState?.tasksCompleted ?? 0,
-      totalTasksFailed: this.agentState?.tasksFailed ?? 0,
-      processedTasks: this.processedTasks.size
+      major: parseInt(match[1], 10),
+      minor: parseInt(match[2], 10),
+      patch: parseInt(match[3], 10)
     };
   }
-  getAgentStates() {
-    return this.agentState ? [this.agentState] : [];
+  getUpdateHint(pm, packages) {
+    const specs = packages.map((p) => `${p.name}@${p.latest}`).join(" ");
+    switch (pm) {
+      case "bun":
+        return `bun add ${specs}`;
+      case "npm":
+        return `npm install ${specs}`;
+      case "pnpm":
+        return `pnpm add ${specs}`;
+      case "yarn":
+        return `yarn add ${specs}`;
+    }
   }
-  buildWorkerArgs(agentId) {
-    const args = [
-      "--agent-id",
-      agentId,
-      "--workspace-id",
-      this.config.workspaceId,
-      "--api-url",
+  exec(bin, args, cwd) {
+    try {
+      const stdout = import_node_child_process7.execFileSync(bin, args, {
+        cwd,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 120000
+      });
+      return { stdout, stderr: "", exitCode: 0 };
+    } catch (err) {
+      if (isExecError(err)) {
+        return {
+          stdout: err.stdout ?? "",
+          stderr: err.stderr ?? "",
+          exitCode: err.status ?? 1
+        };
+      }
+      throw err;
+    }
+  }
+  gitExec(args, cwd) {
+    return import_node_child_process7.execFileSync("git", args, {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  }
+}
+function isExecError(err) {
+  return typeof err === "object" && err !== null && "status" in err && "stdout" in err;
+}
+// src/jobs/scans/lint-scan.ts
+init_git_utils();
+var import_node_child_process8 = require("node:child_process");
+var import_node_fs10 = require("node:fs");
+var import_node_path11 = require("node:path");
+var import_shared5 = require("@locusai/shared");
+class LintScanJob extends BaseJob {
+  type = import_shared5.JobType.LINT_SCAN;
+  name = "Linting Scan";
+  async run(context) {
+    const { projectPath, autonomyRules } = context;
+    const linter = this.detectLinter(projectPath);
+    if (!linter) {
+      return {
+        summary: "No linter configuration detected",
+        suggestions: [],
+        filesChanged: 0
+      };
+    }
+    let lintOutput;
+    try {
+      lintOutput = this.runLinter(linter.checkCommand, projectPath);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        summary: `Linting scan failed: ${message}`,
+        suggestions: [],
+        filesChanged: 0,
+        errors: [message]
+      };
+    }
+    const parsed = this.parseLintOutput(linter.kind, lintOutput);
+    if (parsed.errors === 0 && parsed.warnings === 0) {
+      return {
+        summary: `Linting scan passed — no issues found (${linter.kind})`,
+        suggestions: [],
+        filesChanged: 0
+      };
+    }
+    const canAutoFix = this.shouldAutoExecute(import_shared5.ChangeCategory.STYLE, autonomyRules);
+    if (canAutoFix) {
+      return this.autoFix(linter, parsed, context);
+    }
+    return this.buildSuggestionResult(linter, parsed);
+  }
+  detectLinter(projectPath) {
+    if (import_node_fs10.existsSync(import_node_path11.join(projectPath, "biome.json")) || import_node_fs10.existsSync(import_node_path11.join(projectPath, "biome.jsonc"))) {
+      return {
+        kind: "biome",
+        checkCommand: ["bunx", "biome", "check", "."],
+        fixCommand: ["bunx", "biome", "check", "--fix", "."]
+      };
+    }
+    const eslintConfigPatterns = [
+      ".eslintrc",
+      ".eslintrc.js",
+      ".eslintrc.cjs",
+      ".eslintrc.json",
+      ".eslintrc.yml",
+      ".eslintrc.yaml"
+    ];
+    for (const config of eslintConfigPatterns) {
+      if (import_node_fs10.existsSync(import_node_path11.join(projectPath, config))) {
+        return {
+          kind: "eslint",
+          checkCommand: ["npx", "eslint", "."],
+          fixCommand: ["npx", "eslint", "--fix", "."]
+        };
+      }
+    }
+    try {
+      const files = import_node_fs10.readdirSync(projectPath);
+      const hasFlatConfig = files.some((f) => f.startsWith("eslint.config.") && /\.(js|cjs|mjs|ts|cts|mts)$/.test(f));
+      if (hasFlatConfig) {
+        return {
+          kind: "eslint",
+          checkCommand: ["npx", "eslint", "."],
+          fixCommand: ["npx", "eslint", "--fix", "."]
+        };
+      }
+    } catch {}
+    return null;
+  }
+  runLinter(command, projectPath) {
+    const [bin, ...args] = command;
+    try {
+      const stdout = import_node_child_process8.execFileSync(bin, args, {
+        cwd: projectPath,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 120000
+      });
+      return { stdout, stderr: "", exitCode: 0 };
+    } catch (err) {
+      if (isExecError2(err)) {
+        return {
+          stdout: err.stdout ?? "",
+          stderr: err.stderr ?? "",
+          exitCode: err.status ?? 1
+        };
+      }
+      throw err;
+    }
+  }
+  parseLintOutput(kind, output) {
+    const combined = `${output.stdout}
+${output.stderr}`;
+    if (kind === "biome") {
+      return this.parseBiomeOutput(combined);
+    }
+    return this.parseEslintOutput(combined);
+  }
+  parseBiomeOutput(raw) {
+    let errors = 0;
+    let warnings = 0;
+    const errorMatch = raw.match(/Found (\d+) error/i);
+    if (errorMatch) {
+      errors = parseInt(errorMatch[1], 10);
+    }
+    const warningMatch = raw.match(/Found (\d+) warning/i);
+    if (warningMatch) {
+      warnings = parseInt(warningMatch[1], 10);
+    }
+    if (errors === 0 && warnings === 0) {
+      const diagnosticLines = raw.split(`
+`).filter((line) => /\s+(error|warning)\[/.test(line));
+      errors = diagnosticLines.filter((l) => /\serror\[/.test(l)).length;
+      warnings = diagnosticLines.filter((l) => /\swarning\[/.test(l)).length;
+    }
+    return { errors, warnings, raw };
+  }
+  parseEslintOutput(raw) {
+    let errors = 0;
+    let warnings = 0;
+    const summaryMatch = raw.match(/(\d+) problems?\s*\((\d+) errors?,\s*(\d+) warnings?\)/);
+    if (summaryMatch) {
+      errors = parseInt(summaryMatch[2], 10);
+      warnings = parseInt(summaryMatch[3], 10);
+    } else {
+      const issueLines = raw.split(`
+`).filter((line) => /^\s+\d+:\d+\s+(error|warning)\s/.test(line));
+      errors = issueLines.filter((l) => /\serror\s/.test(l)).length;
+      warnings = issueLines.filter((l) => /\swarning\s/.test(l)).length;
+    }
+    return { errors, warnings, raw };
+  }
+  autoFix(linter, parsed, context) {
+    const { projectPath } = context;
+    try {
+      this.runLinter(linter.fixCommand, projectPath);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        summary: `Lint auto-fix failed: ${message}`,
+        suggestions: [],
+        filesChanged: 0,
+        errors: [message]
+      };
+    }
+    let changedFiles;
+    try {
+      const diffOutput = import_node_child_process8.execFileSync("git", ["diff", "--name-only"], {
+        cwd: projectPath,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+      changedFiles = diffOutput ? diffOutput.split(`
+`) : [];
+    } catch {
+      changedFiles = [];
+    }
+    if (changedFiles.length === 0) {
+      return {
+        summary: `Linting scan found ${this.issueCountSummary(parsed)} but auto-fix made no changes (${linter.kind})`,
+        suggestions: this.buildIssueSuggestions(linter, parsed),
+        filesChanged: 0
+      };
+    }
+    const prUrl = this.commitAndPush(projectPath, changedFiles, linter, parsed);
+    const summary = prUrl ? `Auto-fixed ${this.issueCountSummary(parsed)} across ${changedFiles.length} file(s) — PR created (${linter.kind})` : `Auto-fixed ${this.issueCountSummary(parsed)} across ${changedFiles.length} file(s) (${linter.kind})`;
+    return {
+      summary,
+      suggestions: [],
+      filesChanged: changedFiles.length,
+      prUrl: prUrl ?? undefined
+    };
+  }
+  commitAndPush(projectPath, changedFiles, linter, parsed) {
+    try {
+      const defaultBranch = getDefaultBranch(projectPath);
+      const branchName = `locus/lint-fix-${Date.now().toString(36)}`;
+      this.gitExec(["checkout", "-b", branchName], projectPath);
+      this.gitExec(["add", ...changedFiles], projectPath);
+      const commitMessage = `fix(lint): auto-fix ${this.issueCountSummary(parsed)} via ${linter.kind}
+
+Agent: locus-lint-scan
+Co-authored-by: LocusAI <agent@locusai.team>`;
+      this.gitExec(["commit", "-m", commitMessage], projectPath);
+      this.gitExec(["push", "-u", "origin", branchName], projectPath);
+      let prUrl = null;
+      if (detectRemoteProvider(projectPath) === "github" && isGhAvailable(projectPath)) {
+        try {
+          const title = `[Locus] Auto-fix lint issues (${this.issueCountSummary(parsed)})`;
+          const body = [
+            "## Summary",
+            "",
+            `Automated lint fixes applied by Locus using \`${linter.kind}\`.`,
+            "",
+            `- **Issues found**: ${parsed.errors} error(s), ${parsed.warnings} warning(s)`,
+            `- **Files changed**: ${changedFiles.length}`,
+            "",
+            "### Changed files",
+            "",
+            ...changedFiles.map((f) => `- \`${f}\``),
+            "",
+            "---",
+            "*Created by Locus Agent (lint-scan)*"
+          ].join(`
+`);
+          prUrl = import_node_child_process8.execFileSync("gh", [
+            "pr",
+            "create",
+            "--title",
+            title,
+            "--body",
+            body,
+            "--base",
+            defaultBranch,
+            "--head",
+            branchName
+          ], {
+            cwd: projectPath,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"]
+          }).trim();
+        } catch {}
+      }
+      try {
+        this.gitExec(["checkout", defaultBranch], projectPath);
+      } catch {}
+      return prUrl;
+    } catch {
+      return null;
+    }
+  }
+  buildSuggestionResult(linter, parsed) {
+    return {
+      summary: `Linting scan found ${this.issueCountSummary(parsed)} (${linter.kind})`,
+      suggestions: this.buildIssueSuggestions(linter, parsed),
+      filesChanged: 0
+    };
+  }
+  buildIssueSuggestions(linter, parsed) {
+    const suggestions2 = [];
+    if (parsed.errors > 0) {
+      suggestions2.push({
+        type: import_shared5.SuggestionType.CODE_FIX,
+        title: `Fix ${parsed.errors} lint error(s)`,
+        description: `The ${linter.kind} linter found ${parsed.errors} error(s). Run \`${linter.fixCommand.join(" ")}\` to auto-fix, or review the issues manually.`,
+        metadata: { linter: linter.kind, errors: parsed.errors }
+      });
+    }
+    if (parsed.warnings > 0) {
+      suggestions2.push({
+        type: import_shared5.SuggestionType.CODE_FIX,
+        title: `Resolve ${parsed.warnings} lint warning(s)`,
+        description: `The ${linter.kind} linter found ${parsed.warnings} warning(s). Run \`${linter.fixCommand.join(" ")}\` to auto-fix, or review the issues manually.`,
+        metadata: { linter: linter.kind, warnings: parsed.warnings }
+      });
+    }
+    return suggestions2;
+  }
+  issueCountSummary(parsed) {
+    const parts = [];
+    if (parsed.errors > 0)
+      parts.push(`${parsed.errors} error(s)`);
+    if (parsed.warnings > 0)
+      parts.push(`${parsed.warnings} warning(s)`);
+    return parts.join(", ") || "0 issues";
+  }
+  gitExec(args, cwd) {
+    return import_node_child_process8.execFileSync("git", args, {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  }
+}
+function isExecError2(err) {
+  return typeof err === "object" && err !== null && "status" in err && "stdout" in err;
+}
+// src/jobs/scans/test-scan.ts
+var import_node_child_process9 = require("node:child_process");
+var import_node_fs11 = require("node:fs");
+var import_node_path12 = require("node:path");
+var import_shared6 = require("@locusai/shared");
+class TestScanJob extends BaseJob {
+  type = import_shared6.JobType.FLAKY_TEST_DETECTION;
+  name = "Flaky Test Detection";
+  async run(context) {
+    const { projectPath } = context;
+    const retryCount = context.config.options?.retryCount ?? 2;
+    const runner = this.detectTestRunner(projectPath);
+    if (!runner) {
+      return {
+        summary: "No test runner detected — skipping flaky test detection",
+        suggestions: [],
+        filesChanged: 0
+      };
+    }
+    let firstRun;
+    try {
+      firstRun = this.runTests(runner, projectPath);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        summary: `Test scan failed: ${message}`,
+        suggestions: [],
+        filesChanged: 0,
+        errors: [message]
+      };
+    }
+    if (firstRun.total === 0) {
+      return {
+        summary: "No tests found in project",
+        suggestions: [],
+        filesChanged: 0
+      };
+    }
+    if (firstRun.failed === 0) {
+      return {
+        summary: `All ${firstRun.total} test(s) passed (${runner.kind}) — no flaky tests detected`,
+        suggestions: [],
+        filesChanged: 0
+      };
+    }
+    const allRuns = [
+      { runIndex: 0, results: this.indexByKey(firstRun.tests) }
+    ];
+    for (let i = 1;i <= retryCount; i++) {
+      try {
+        const rerun = this.runTests(runner, projectPath);
+        allRuns.push({ runIndex: i, results: this.indexByKey(rerun.tests) });
+      } catch {}
+    }
+    const { flaky, broken } = this.classifyTests(allRuns, firstRun.tests);
+    const suggestions2 = [];
+    for (const test of flaky) {
+      suggestions2.push({
+        type: import_shared6.SuggestionType.TEST_FIX,
+        title: `Flaky test: ${test.testName}`,
+        description: [
+          `**File:** \`${test.testFile}\``,
+          `**Test:** ${test.testName}`,
+          `**Pass rate:** ${test.passRate}/${allRuns.length} runs`,
+          `**Failure messages:**`,
+          ...test.failureMessages.map((m) => `> ${m}`)
+        ].join(`
+`),
+        metadata: {
+          testFile: test.testFile,
+          testName: test.testName,
+          passRate: `${test.passRate}/${allRuns.length}`,
+          failureMessages: test.failureMessages,
+          category: "flaky"
+        }
+      });
+    }
+    for (const test of broken) {
+      suggestions2.push({
+        type: import_shared6.SuggestionType.TEST_FIX,
+        title: `Broken test: ${test.testName}`,
+        description: [
+          `**File:** \`${test.testFile}\``,
+          `**Test:** ${test.testName}`,
+          `**Status:** Failed in all ${allRuns.length} run(s)`,
+          `**Failure messages:**`,
+          ...test.failureMessages.map((m) => `> ${m}`)
+        ].join(`
+`),
+        metadata: {
+          testFile: test.testFile,
+          testName: test.testName,
+          passRate: `0/${allRuns.length}`,
+          failureMessages: test.failureMessages,
+          category: "broken"
+        }
+      });
+    }
+    const summary = [
+      `Test health (${runner.kind}):`,
+      `${firstRun.total} total,`,
+      `${firstRun.passed} passing,`,
+      `${firstRun.failed} failing,`,
+      `${flaky.length} flaky,`,
+      `${broken.length} broken`
+    ].join(" ");
+    return {
+      summary,
+      suggestions: suggestions2,
+      filesChanged: 0
+    };
+  }
+  detectTestRunner(projectPath) {
+    try {
+      const files = import_node_fs11.readdirSync(projectPath);
+      if (files.some((f) => f.startsWith("jest.config."))) {
+        return {
+          kind: "jest",
+          command: ["npx", "jest", "--json", "--no-coverage"]
+        };
+      }
+    } catch {}
+    try {
+      const files = import_node_fs11.readdirSync(projectPath);
+      if (files.some((f) => f.startsWith("vitest.config."))) {
+        return {
+          kind: "vitest",
+          command: ["npx", "vitest", "run", "--reporter=json"]
+        };
+      }
+    } catch {}
+    const pkgJsonPath = import_node_path12.join(projectPath, "package.json");
+    if (import_node_fs11.existsSync(pkgJsonPath)) {
+      try {
+        const pkgJson = JSON.parse(import_node_fs11.readFileSync(pkgJsonPath, "utf-8"));
+        if (pkgJson.jest || pkgJson.devDependencies?.jest || pkgJson.dependencies?.jest) {
+          return {
+            kind: "jest",
+            command: ["npx", "jest", "--json", "--no-coverage"]
+          };
+        }
+        if (pkgJson.devDependencies?.vitest || pkgJson.dependencies?.vitest) {
+          return {
+            kind: "vitest",
+            command: ["npx", "vitest", "run", "--reporter=json"]
+          };
+        }
+        if (pkgJson.devDependencies?.mocha || pkgJson.dependencies?.mocha) {
+          return {
+            kind: "mocha",
+            command: ["npx", "mocha", "--reporter=json"]
+          };
+        }
+        if (pkgJson.scripts?.test && pkgJson.scripts.test !== 'echo "Error: no test specified" && exit 1') {
+          return {
+            kind: "fallback",
+            command: ["npm", "test", "--", "--no-coverage"]
+          };
+        }
+      } catch {}
+    }
+    if (import_node_fs11.existsSync(import_node_path12.join(projectPath, "bun.lock")) || import_node_fs11.existsSync(import_node_path12.join(projectPath, "bunfig.toml"))) {
+      return { kind: "fallback", command: ["bun", "test"] };
+    }
+    return null;
+  }
+  runTests(runner, projectPath) {
+    const output = this.exec(runner.command, projectPath);
+    switch (runner.kind) {
+      case "jest":
+        return this.parseJestOutput(output);
+      case "vitest":
+        return this.parseVitestOutput(output);
+      case "mocha":
+        return this.parseMochaOutput(output);
+      default:
+        return this.parseFallbackOutput(output);
+    }
+  }
+  parseJestOutput(output) {
+    const combined = `${output.stdout}
+${output.stderr}`;
+    const tests = [];
+    let total = 0;
+    let passed = 0;
+    let failed = 0;
+    let skipped = 0;
+    const jsonData = this.extractJson(combined);
+    if (jsonData) {
+      total = jsonData.numTotalTests ?? 0;
+      passed = jsonData.numPassedTests ?? 0;
+      failed = jsonData.numFailedTests ?? 0;
+      skipped = jsonData.numPendingTests ?? 0;
+      const testResults = jsonData.testResults ?? [];
+      for (const suite of testResults) {
+        const filePath = suite.testFilePath ?? suite.name ?? "unknown";
+        const assertionResults = suite.assertionResults ?? suite.testResults ?? [];
+        for (const test of assertionResults) {
+          const ancestors = Array.isArray(test.ancestorTitles) ? test.ancestorTitles.join(" > ") : "";
+          const testName = ancestors ? `${ancestors} > ${test.title ?? test.fullName ?? "unknown"}` : test.title ?? test.fullName ?? "unknown";
+          tests.push({
+            testFile: filePath,
+            testName,
+            status: test.status === "passed" ? "passed" : test.status === "pending" ? "skipped" : "failed",
+            failureMessages: Array.isArray(test.failureMessages) ? test.failureMessages.map(String) : []
+          });
+        }
+      }
+    }
+    return { total, passed, failed, skipped, tests };
+  }
+  parseVitestOutput(output) {
+    return this.parseJestOutput(output);
+  }
+  parseMochaOutput(output) {
+    const combined = `${output.stdout}
+${output.stderr}`;
+    const tests = [];
+    let total = 0;
+    let passed = 0;
+    let failed = 0;
+    let skipped = 0;
+    const jsonData = this.extractJson(combined);
+    if (jsonData?.stats) {
+      total = jsonData.stats.tests ?? 0;
+      passed = jsonData.stats.passes ?? 0;
+      failed = jsonData.stats.failures ?? 0;
+      skipped = jsonData.stats.pending ?? 0;
+      if (Array.isArray(jsonData.passes)) {
+        for (const t of jsonData.passes) {
+          tests.push({
+            testFile: t.file ?? "unknown",
+            testName: t.fullTitle ?? t.title ?? "unknown",
+            status: "passed",
+            failureMessages: []
+          });
+        }
+      }
+      if (Array.isArray(jsonData.failures)) {
+        for (const t of jsonData.failures) {
+          tests.push({
+            testFile: t.file ?? "unknown",
+            testName: t.fullTitle ?? t.title ?? "unknown",
+            status: "failed",
+            failureMessages: t.err?.message ? [t.err.message] : []
+          });
+        }
+      }
+      if (Array.isArray(jsonData.pending)) {
+        for (const t of jsonData.pending) {
+          tests.push({
+            testFile: t.file ?? "unknown",
+            testName: t.fullTitle ?? t.title ?? "unknown",
+            status: "skipped",
+            failureMessages: []
+          });
+        }
+      }
+    }
+    return { total, passed, failed, skipped, tests };
+  }
+  parseFallbackOutput(output) {
+    const combined = `${output.stdout}
+${output.stderr}`;
+    let total = 0;
+    let passed = 0;
+    let failed = 0;
+    let skipped = 0;
+    const jestSummary = combined.match(/Tests:\s*(?:(\d+)\s+failed,\s*)?(?:(\d+)\s+skipped,\s*)?(?:(\d+)\s+passed,\s*)?(\d+)\s+total/i);
+    if (jestSummary) {
+      failed = parseInt(jestSummary[1] ?? "0", 10);
+      skipped = parseInt(jestSummary[2] ?? "0", 10);
+      passed = parseInt(jestSummary[3] ?? "0", 10);
+      total = parseInt(jestSummary[4], 10);
+    }
+    if (total === 0) {
+      const vitestSummary = combined.match(/(\d+)\s+passed.*?(\d+)\s+failed.*?(\d+)\s+total/i);
+      if (vitestSummary) {
+        passed = parseInt(vitestSummary[1], 10);
+        failed = parseInt(vitestSummary[2], 10);
+        total = parseInt(vitestSummary[3], 10);
+      }
+    }
+    if (total === 0) {
+      const lines = combined.split(`
+`);
+      for (const line of lines) {
+        if (/\bpass(ed|ing)?\b/i.test(line))
+          passed++;
+        if (/\bfail(ed|ing|ure)?\b/i.test(line))
+          failed++;
+        if (/\bskip(ped)?\b/i.test(line))
+          skipped++;
+      }
+      total = passed + failed + skipped;
+    }
+    return { total, passed, failed, skipped, tests: [] };
+  }
+  classifyTests(allRuns, _firstRunTests) {
+    const flaky = [];
+    const broken = [];
+    const failedKeys = new Set;
+    for (const run of allRuns) {
+      for (const [key, result] of run.results) {
+        if (result.status === "failed") {
+          failedKeys.add(key);
+        }
+      }
+    }
+    for (const key of failedKeys) {
+      let passCount = 0;
+      let failCount = 0;
+      const failureMessages = [];
+      let testFile = "unknown";
+      let testName = key;
+      for (const run of allRuns) {
+        const result = run.results.get(key);
+        if (!result)
+          continue;
+        testFile = result.testFile;
+        testName = result.testName;
+        if (result.status === "passed") {
+          passCount++;
+        } else if (result.status === "failed") {
+          failCount++;
+          for (const msg of result.failureMessages) {
+            if (msg && !failureMessages.includes(msg)) {
+              failureMessages.push(msg);
+            }
+          }
+        }
+      }
+      const truncatedMessages = failureMessages.map((m) => m.length > 500 ? `${m.slice(0, 500)}...` : m);
+      if (passCount > 0 && failCount > 0) {
+        flaky.push({
+          testFile,
+          testName,
+          passRate: passCount,
+          failureMessages: truncatedMessages
+        });
+      } else if (failCount > 0 && passCount === 0) {
+        broken.push({
+          testFile,
+          testName,
+          passRate: 0,
+          failureMessages: truncatedMessages
+        });
+      }
+    }
+    return { flaky, broken };
+  }
+  testKey(test) {
+    return `${test.testFile}::${test.testName}`;
+  }
+  indexByKey(tests) {
+    const map = new Map;
+    for (const test of tests) {
+      map.set(this.testKey(test), test);
+    }
+    return map;
+  }
+  extractJson(text) {
+    const firstBrace = text.indexOf("{");
+    if (firstBrace === -1)
+      return null;
+    let depth = 0;
+    let lastBrace = -1;
+    for (let i = firstBrace;i < text.length; i++) {
+      if (text[i] === "{")
+        depth++;
+      else if (text[i] === "}") {
+        depth--;
+        if (depth === 0) {
+          lastBrace = i;
+          break;
+        }
+      }
+    }
+    if (lastBrace === -1)
+      return null;
+    try {
+      return JSON.parse(text.slice(firstBrace, lastBrace + 1));
+    } catch {
+      return null;
+    }
+  }
+  exec(command, projectPath) {
+    const [bin, ...args] = command;
+    try {
+      const stdout = import_node_child_process9.execFileSync(bin, args, {
+        cwd: projectPath,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 300000
+      });
+      return { stdout, stderr: "", exitCode: 0 };
+    } catch (err) {
+      if (isExecError3(err)) {
+        return {
+          stdout: err.stdout ?? "",
+          stderr: err.stderr ?? "",
+          exitCode: err.status ?? 1
+        };
+      }
+      throw err;
+    }
+  }
+}
+function isExecError3(err) {
+  return typeof err === "object" && err !== null && "status" in err && "stdout" in err;
+}
+// src/jobs/scans/todo-scan.ts
+var import_node_child_process10 = require("node:child_process");
+var import_node_path13 = require("node:path");
+var import_shared7 = require("@locusai/shared");
+class TodoScanJob extends BaseJob {
+  type = import_shared7.JobType.TODO_CLEANUP;
+  name = "TODO Cleanup";
+  async run(context) {
+    const { projectPath } = context;
+    let output;
+    try {
+      output = this.scanForTodos(projectPath);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        summary: `TODO scan failed: ${message}`,
+        suggestions: [],
+        filesChanged: 0,
+        errors: [message]
+      };
+    }
+    const items = this.parseGrepOutput(output.stdout, projectPath);
+    if (items.length === 0) {
+      return {
+        summary: "TODO scan passed — no TODO/FIXME/HACK/XXX comments found",
+        suggestions: [],
+        filesChanged: 0
+      };
+    }
+    const grouped = this.groupByType(items);
+    const suggestions2 = this.buildSuggestions(items);
+    const summary = this.buildSummary(grouped, items, context);
+    return {
+      summary,
+      suggestions: suggestions2,
+      filesChanged: 0
+    };
+  }
+  scanForTodos(projectPath) {
+    const args = [
+      "-rn",
+      "--include=*.ts",
+      "--include=*.tsx",
+      "--include=*.js",
+      "--include=*.jsx",
+      "--exclude-dir=node_modules",
+      "--exclude-dir=.git",
+      "--exclude-dir=dist",
+      "--exclude-dir=build",
+      "--exclude-dir=.locus",
+      "-E",
+      "(TODO|FIXME|HACK|XXX):?",
+      projectPath
+    ];
+    return this.exec("grep", args, projectPath);
+  }
+  parseGrepOutput(stdout, projectPath) {
+    const items = [];
+    const lines = stdout.split(`
+`);
+    for (const line of lines) {
+      if (!line.trim())
+        continue;
+      const match = line.match(/^(.+?):(\d+):(.+)$/);
+      if (!match)
+        continue;
+      const [, filePath, lineNum, content] = match;
+      const typeMatch = content.match(/\b(TODO|FIXME|HACK|XXX):?\s*(.*)/);
+      if (!typeMatch)
+        continue;
+      const todoType = typeMatch[1];
+      const text = typeMatch[2].trim() || content.trim();
+      const relFile = import_node_path13.relative(projectPath, filePath);
+      items.push({
+        file: relFile,
+        line: parseInt(lineNum, 10),
+        type: todoType,
+        text
+      });
+    }
+    return items;
+  }
+  groupByType(items) {
+    const grouped = {
+      TODO: [],
+      FIXME: [],
+      HACK: [],
+      XXX: []
+    };
+    for (const item of items) {
+      grouped[item.type].push(item);
+    }
+    return grouped;
+  }
+  buildSuggestions(items) {
+    return items.map((item) => ({
+      type: import_shared7.SuggestionType.CODE_FIX,
+      title: `${item.type} in ${item.file}:${item.line}`,
+      description: `${item.type} comment found: ${item.text}`,
+      metadata: {
+        file: item.file,
+        line: item.line,
+        todoType: item.type,
+        text: item.text
+      }
+    }));
+  }
+  buildSummary(grouped, items, context) {
+    const uniqueFiles = new Set(items.map((i) => i.file)).size;
+    const counts = [];
+    if (grouped.TODO.length > 0)
+      counts.push(`${grouped.TODO.length} TODOs`);
+    if (grouped.FIXME.length > 0)
+      counts.push(`${grouped.FIXME.length} FIXMEs`);
+    if (grouped.HACK.length > 0)
+      counts.push(`${grouped.HACK.length} HACKs`);
+    if (grouped.XXX.length > 0)
+      counts.push(`${grouped.XXX.length} XXXs`);
+    let summary = `Found ${counts.join(", ")} across ${uniqueFiles} file(s)`;
+    const previousCount = context.config.options?.previousTodoCount;
+    if (typeof previousCount === "number") {
+      const diff = previousCount - items.length;
+      if (diff > 0) {
+        summary += ` (${diff} resolved since last run)`;
+      } else if (diff < 0) {
+        summary += ` (${Math.abs(diff)} new since last run)`;
+      }
+    }
+    return summary;
+  }
+  exec(bin, args, cwd) {
+    try {
+      const stdout = import_node_child_process10.execFileSync(bin, args, {
+        cwd,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 120000
+      });
+      return { stdout, stderr: "", exitCode: 0 };
+    } catch (err) {
+      if (isExecError4(err)) {
+        return {
+          stdout: err.stdout ?? "",
+          stderr: err.stderr ?? "",
+          exitCode: err.status ?? 1
+        };
+      }
+      throw err;
+    }
+  }
+}
+function isExecError4(err) {
+  return typeof err === "object" && err !== null && "status" in err && "stdout" in err;
+}
+// src/jobs/default-registry.ts
+function createDefaultRegistry() {
+  const registry = new JobRegistry;
+  registry.register(new LintScanJob);
+  registry.register(new DependencyScanJob);
+  registry.register(new TodoScanJob);
+  registry.register(new TestScanJob);
+  return registry;
+}
+// src/jobs/job-runner.ts
+var import_shared8 = require("@locusai/shared");
+var JobEvent;
+((JobEvent2) => {
+  JobEvent2["JOB_STARTED"] = "JOB_STARTED";
+  JobEvent2["JOB_COMPLETED"] = "JOB_COMPLETED";
+  JobEvent2["JOB_FAILED"] = "JOB_FAILED";
+})(JobEvent ||= {});
+
+class JobRunner {
+  registry;
+  client;
+  projectPath;
+  workspaceId;
+  constructor(registry, client, projectPath, workspaceId) {
+    this.registry = registry;
+    this.client = client;
+    this.projectPath = projectPath;
+    this.workspaceId = workspaceId;
+  }
+  async runJob(jobType, config, autonomyRules) {
+    const job = this.registry.get(jobType);
+    if (!job) {
+      throw new Error(`No job handler registered for type: ${jobType}`);
+    }
+    const jobRun = await this.client.jobs.create(this.workspaceId, {
+      jobType,
+      status: import_shared8.JobStatus.RUNNING,
+      startedAt: new Date().toISOString()
+    });
+    this.client.emitter.emit("JOB_STARTED" /* JOB_STARTED */, {
+      jobType,
+      jobRunId: jobRun.id
+    });
+    const context = {
+      workspaceId: this.workspaceId,
+      projectPath: this.projectPath,
+      config,
+      autonomyRules,
+      client: this.client
+    };
+    try {
+      const result = await job.run(context);
+      await this.client.jobs.update(this.workspaceId, jobRun.id, {
+        status: import_shared8.JobStatus.COMPLETED,
+        completedAt: new Date().toISOString(),
+        result: {
+          summary: result.summary,
+          filesChanged: result.filesChanged,
+          prUrl: result.prUrl,
+          errors: result.errors
+        }
+      });
+      for (const suggestion of result.suggestions) {
+        await this.client.suggestions.create(this.workspaceId, {
+          type: suggestion.type,
+          title: suggestion.title,
+          description: suggestion.description,
+          jobRunId: jobRun.id,
+          metadata: suggestion.metadata
+        });
+      }
+      this.client.emitter.emit("JOB_COMPLETED" /* JOB_COMPLETED */, {
+        jobType,
+        jobRunId: jobRun.id,
+        result
+      });
+      return result;
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      await this.client.jobs.update(this.workspaceId, jobRun.id, {
+        status: import_shared8.JobStatus.FAILED,
+        completedAt: new Date().toISOString(),
+        error: errorMessage
+      }).catch(() => {});
+      this.client.emitter.emit("JOB_FAILED" /* JOB_FAILED */, {
+        jobType,
+        jobRunId: jobRun.id,
+        error: errorMessage
+      });
+      throw err;
+    }
+  }
+  async runAllEnabled(configs, autonomyRules) {
+    const results = new Map;
+    const enabledConfigs = configs.filter((c2) => c2.enabled && this.registry.has(c2.type));
+    for (const config of enabledConfigs) {
+      try {
+        const result = await this.runJob(config.type, config, autonomyRules);
+        results.set(config.type, result);
+      } catch {}
+    }
+    return results;
+  }
+}
+// src/jobs/proposals/context-gatherer.ts
+var import_node_child_process11 = require("node:child_process");
+var import_node_fs12 = require("node:fs");
+var import_node_path14 = require("node:path");
+
+class ContextGatherer {
+  async gather(projectPath, client, workspaceId) {
+    const [jobRuns, activeSprint, allTasks, skippedSuggestions] = await Promise.all([
+      this.fetchJobRuns(client, workspaceId),
+      this.fetchActiveSprint(client, workspaceId),
+      this.fetchTasks(client, workspaceId),
+      this.fetchSkippedSuggestions(client, workspaceId)
+    ]);
+    const sprintTasks = activeSprint ? allTasks.filter((t) => t.sprintId === activeSprint.id) : [];
+    const backlogTasks = allTasks.filter((t) => !t.sprintId);
+    const gitLog = this.readGitLog(projectPath);
+    const artifactContents = this.readArtifacts(projectPath);
+    const locusInstructions = this.readLocusInstructions(projectPath);
+    return {
+      jobRuns,
+      activeSprint,
+      sprintTasks,
+      backlogTasks,
+      gitLog,
+      artifactContents,
+      locusInstructions,
+      skippedSuggestions
+    };
+  }
+  async fetchJobRuns(client, workspaceId) {
+    try {
+      return await client.jobs.list(workspaceId, { limit: 10 });
+    } catch {
+      return [];
+    }
+  }
+  async fetchActiveSprint(client, workspaceId) {
+    try {
+      return await client.sprints.getActive(workspaceId);
+    } catch {
+      return null;
+    }
+  }
+  async fetchTasks(client, workspaceId) {
+    try {
+      return await client.tasks.list(workspaceId);
+    } catch {
+      return [];
+    }
+  }
+  async fetchSkippedSuggestions(client, workspaceId) {
+    try {
+      return await client.suggestions.list(workspaceId, { status: "SKIPPED" });
+    } catch {
+      return [];
+    }
+  }
+  readGitLog(projectPath) {
+    try {
+      return import_node_child_process11.execFileSync("git", ["log", "--oneline", "--no-decorate", "-n", "20"], {
+        cwd: projectPath,
+        encoding: "utf-8",
+        timeout: 1e4,
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trim();
+    } catch {
+      return "";
+    }
+  }
+  readArtifacts(projectPath) {
+    const artifactsDir = import_node_path14.join(projectPath, ".locus", "artifacts");
+    if (!import_node_fs12.existsSync(artifactsDir))
+      return [];
+    try {
+      const files = import_node_fs12.readdirSync(artifactsDir).filter((f) => f.endsWith(".md"));
+      return files.slice(0, 10).map((name) => ({
+        name,
+        content: import_node_fs12.readFileSync(import_node_path14.join(artifactsDir, name), "utf-8").slice(0, 2000)
+      }));
+    } catch {
+      return [];
+    }
+  }
+  readLocusInstructions(projectPath) {
+    const locusPath = import_node_path14.join(projectPath, ".locus", "LOCUS.md");
+    if (!import_node_fs12.existsSync(locusPath))
+      return null;
+    try {
+      return import_node_fs12.readFileSync(locusPath, "utf-8").slice(0, 3000);
+    } catch {
+      return null;
+    }
+  }
+}
+// src/jobs/proposals/proposal-engine.ts
+init_factory();
+var import_shared9 = require("@locusai/shared");
+class ProposalEngine {
+  contextGatherer;
+  constructor(contextGatherer) {
+    this.contextGatherer = contextGatherer ?? new ContextGatherer;
+  }
+  async runProposalCycle(projectPath, client, workspaceId) {
+    const context = await this.contextGatherer.gather(projectPath, client, workspaceId);
+    return this.generateProposals(context, projectPath, client, workspaceId);
+  }
+  async generateProposals(context, projectPath, client, workspaceId) {
+    const prompt = this.buildPrompt(context);
+    const runner = createAiRunner(undefined, {
+      projectPath,
+      timeoutMs: 5 * 60 * 1000,
+      maxTurns: 1
+    });
+    let aiResponse;
+    try {
+      aiResponse = await runner.run(prompt);
+    } catch {
+      return [];
+    }
+    const proposals = this.parseResponse(aiResponse);
+    const created = [];
+    for (const proposal of proposals) {
+      if (this.isDuplicate(proposal.title, context.skippedSuggestions)) {
+        continue;
+      }
+      try {
+        const suggestion = await client.suggestions.create(workspaceId, {
+          type: import_shared9.SuggestionType.NEXT_STEP,
+          title: proposal.title,
+          description: proposal.description,
+          metadata: {
+            complexity: proposal.complexity,
+            relatedBacklogItem: proposal.relatedBacklogItem,
+            source: "proposal-engine"
+          }
+        });
+        created.push(suggestion);
+      } catch {}
+    }
+    return created;
+  }
+  buildPrompt(context) {
+    const sections = [];
+    sections.push("You are a proactive software engineering advisor. Based on the project context below, propose 1-3 high-value next steps the team should take. Focus on actionable, impactful work.");
+    if (context.jobRuns.length > 0) {
+      const jobSummaries = context.jobRuns.filter((j) => j.result).map((j) => `- [${j.jobType}] ${j.status}: ${j.result?.summary ?? "No summary"} (${j.result?.filesChanged ?? 0} files changed)`).join(`
+`);
+      if (jobSummaries) {
+        sections.push(`## Recent Job Results
+${jobSummaries}`);
+      }
+    }
+    if (context.activeSprint) {
+      const sprintInfo = `Sprint: ${context.activeSprint.name} (${context.activeSprint.status})`;
+      const tasksByStatus = this.groupTasksByStatus(context.sprintTasks);
+      sections.push(`## Current Sprint
+${sprintInfo}
+${tasksByStatus}`);
+    }
+    if (context.backlogTasks.length > 0) {
+      const backlogList = context.backlogTasks.slice(0, 15).map((t) => `- [${t.priority}] ${t.title}${t.description ? `: ${t.description.slice(0, 100)}` : ""}`).join(`
+`);
+      sections.push(`## Backlog Items
+${backlogList}`);
+    }
+    if (context.gitLog) {
+      sections.push(`## Recent Commits (last 20)
+${context.gitLog}`);
+    }
+    if (context.artifactContents.length > 0) {
+      const artifacts = context.artifactContents.map((a) => `### ${a.name}
+${a.content}`).join(`
+
+`);
+      sections.push(`## Product Context
+${artifacts}`);
+    }
+    if (context.locusInstructions) {
+      sections.push(`## Project Instructions
+${context.locusInstructions}`);
+    }
+    if (context.skippedSuggestions.length > 0) {
+      const skipped = context.skippedSuggestions.map((s) => `- ${s.title}`).join(`
+`);
+      sections.push(`## Previously Skipped Proposals (do NOT re-propose these)
+${skipped}`);
+    }
+    sections.push(`## Instructions
+Propose 1-3 high-value next steps. For each, respond with exactly this format:
+
+PROPOSAL_START
+Title: <clear, concise title>
+Description: <what to do and why, 2-4 sentences>
+Complexity: <low|medium|high>
+Related Backlog: <title of related backlog item, or "none">
+PROPOSAL_END
+
+Rules:
+- Focus on what would deliver the most value right now
+- Consider what the recent job results revealed (bugs, tech debt, missing tests)
+- Align with the current sprint goals when possible
+- Don't propose things that are already in progress
+- Don't re-propose previously skipped suggestions
+- Keep proposals specific and actionable`);
+    return sections.join(`
+
+`);
+  }
+  parseResponse(response) {
+    const proposals = [];
+    const blocks = response.split("PROPOSAL_START");
+    for (const block of blocks) {
+      const endIdx = block.indexOf("PROPOSAL_END");
+      if (endIdx === -1)
+        continue;
+      const content = block.slice(0, endIdx).trim();
+      const title = this.extractField(content, "Title");
+      const description = this.extractField(content, "Description");
+      const complexity = this.extractField(content, "Complexity") ?? "medium";
+      const relatedRaw = this.extractField(content, "Related Backlog");
+      const relatedBacklogItem = relatedRaw && relatedRaw.toLowerCase() !== "none" ? relatedRaw : null;
+      if (title && description) {
+        proposals.push({
+          title: title.slice(0, 200),
+          description: description.slice(0, 2000),
+          complexity: complexity.toLowerCase(),
+          relatedBacklogItem
+        });
+      }
+    }
+    return proposals.slice(0, 3);
+  }
+  extractField(content, field) {
+    const regex = new RegExp(`^${field}:\\s*(.+)`, "im");
+    const match = content.match(regex);
+    return match ? match[1].trim() : null;
+  }
+  isDuplicate(title, skipped) {
+    const normalized = title.toLowerCase().trim();
+    return skipped.some((s) => {
+      const skippedNorm = s.title.toLowerCase().trim();
+      return skippedNorm === normalized || skippedNorm.includes(normalized) || normalized.includes(skippedNorm);
+    });
+  }
+  groupTasksByStatus(tasks2) {
+    const groups = {};
+    for (const t of tasks2) {
+      groups[t.status] = (groups[t.status] ?? 0) + 1;
+    }
+    return Object.entries(groups).map(([status, count]) => `- ${status}: ${count} task(s)`).join(`
+`);
+  }
+}
+// src/jobs/scheduler.ts
+var import_node_cron = __toESM(require("node-cron"));
+var SchedulerEvent;
+((SchedulerEvent2) => {
+  SchedulerEvent2["SCHEDULER_STARTED"] = "SCHEDULER_STARTED";
+  SchedulerEvent2["SCHEDULER_STOPPED"] = "SCHEDULER_STOPPED";
+  SchedulerEvent2["JOB_SCHEDULED"] = "JOB_SCHEDULED";
+  SchedulerEvent2["JOB_TRIGGERED"] = "JOB_TRIGGERED";
+  SchedulerEvent2["JOB_SKIPPED"] = "JOB_SKIPPED";
+  SchedulerEvent2["CONFIG_RELOADED"] = "CONFIG_RELOADED";
+  SchedulerEvent2["PROPOSALS_GENERATED"] = "PROPOSALS_GENERATED";
+})(SchedulerEvent ||= {});
+
+class JobScheduler {
+  runner;
+  configLoader;
+  emitter;
+  proposalConfig;
+  tasks = new Map;
+  runningJobs = new Set;
+  currentConfigs = [];
+  currentAutonomyRules = [];
+  proposalRunning = false;
+  proposalDebounceTimer = null;
+  constructor(runner, configLoader, emitter, proposalConfig) {
+    this.runner = runner;
+    this.configLoader = configLoader;
+    this.emitter = emitter;
+    this.proposalConfig = proposalConfig;
+  }
+  start() {
+    const { jobConfigs, autonomyRules } = this.configLoader();
+    this.currentConfigs = jobConfigs;
+    this.currentAutonomyRules = autonomyRules;
+    const enabledConfigs = jobConfigs.filter((c2) => c2.enabled && c2.schedule.enabled);
+    for (const config of enabledConfigs) {
+      this.scheduleJob(config);
+    }
+    this.emitter.emit("SCHEDULER_STARTED" /* SCHEDULER_STARTED */, {
+      jobCount: enabledConfigs.length,
+      jobs: enabledConfigs.map((c2) => ({
+        type: c2.type,
+        cronExpression: c2.schedule.cronExpression
+      }))
+    });
+  }
+  stop() {
+    if (this.proposalDebounceTimer) {
+      clearTimeout(this.proposalDebounceTimer);
+      this.proposalDebounceTimer = null;
+    }
+    for (const [, task] of this.tasks) {
+      task.stop();
+    }
+    this.tasks.clear();
+    this.runningJobs.clear();
+    this.emitter.emit("SCHEDULER_STOPPED" /* SCHEDULER_STOPPED */);
+  }
+  reload() {
+    const previousJobCount = this.tasks.size;
+    for (const [, task] of this.tasks) {
+      task.stop();
+    }
+    this.tasks.clear();
+    const { jobConfigs, autonomyRules } = this.configLoader();
+    this.currentConfigs = jobConfigs;
+    this.currentAutonomyRules = autonomyRules;
+    const enabledConfigs = jobConfigs.filter((c2) => c2.enabled && c2.schedule.enabled);
+    for (const config of enabledConfigs) {
+      this.scheduleJob(config);
+    }
+    this.emitter.emit("CONFIG_RELOADED" /* CONFIG_RELOADED */, {
+      previousJobCount,
+      newJobCount: enabledConfigs.length
+    });
+  }
+  getScheduledJobs() {
+    const result = [];
+    for (const config of this.currentConfigs) {
+      if (this.tasks.has(config.type)) {
+        result.push({
+          type: config.type,
+          cronExpression: config.schedule.cronExpression
+        });
+      }
+    }
+    return result;
+  }
+  isRunning(jobType) {
+    return this.runningJobs.has(jobType);
+  }
+  scheduleJob(config) {
+    const { type, schedule } = config;
+    const { cronExpression } = schedule;
+    if (!import_node_cron.default.validate(cronExpression)) {
+      console.error(`Invalid cron expression for job ${type}: "${cronExpression}" — skipping`);
+      return;
+    }
+    const task = import_node_cron.default.schedule(cronExpression, () => {
+      this.triggerJob(type);
+    });
+    this.tasks.set(type, task);
+    this.emitter.emit("JOB_SCHEDULED" /* JOB_SCHEDULED */, {
+      jobType: type,
+      cronExpression
+    });
+  }
+  triggerJob(jobType) {
+    if (this.runningJobs.has(jobType)) {
+      this.emitter.emit("JOB_SKIPPED" /* JOB_SKIPPED */, {
+        jobType,
+        reason: "Previous run still in progress"
+      });
+      return;
+    }
+    const config = this.currentConfigs.find((c2) => c2.type === jobType);
+    if (!config)
+      return;
+    this.emitter.emit("JOB_TRIGGERED" /* JOB_TRIGGERED */, {
+      jobType
+    });
+    this.runningJobs.add(jobType);
+    this.runner.runJob(jobType, config, this.currentAutonomyRules).catch(() => {}).finally(() => {
+      this.runningJobs.delete(jobType);
+      this.scheduleProposalCycle();
+    });
+  }
+  scheduleProposalCycle() {
+    if (!this.proposalConfig)
+      return;
+    if (this.proposalDebounceTimer) {
+      clearTimeout(this.proposalDebounceTimer);
+    }
+    this.proposalDebounceTimer = setTimeout(() => {
+      this.proposalDebounceTimer = null;
+      if (this.runningJobs.size === 0) {
+        this.runProposalCycle();
+      }
+    }, 30000);
+  }
+  async runProposalCycle() {
+    if (!this.proposalConfig || this.proposalRunning)
+      return;
+    this.proposalRunning = true;
+    const { engine, projectPath, client, workspaceId } = this.proposalConfig;
+    try {
+      const suggestions2 = await engine.runProposalCycle(projectPath, client, workspaceId);
+      if (suggestions2.length > 0) {
+        this.emitter.emit("PROPOSALS_GENERATED" /* PROPOSALS_GENERATED */, {
+          suggestions: suggestions2
+        });
+      }
+    } catch (err) {
+      console.error("[scheduler] Proposal cycle failed:", err);
+    } finally {
+      this.proposalRunning = false;
+    }
+  }
+}
+// src/orchestrator/index.ts
+init_git_utils();
+init_src();
+init_colors();
+init_resolve_bin();
+var import_node_child_process12 = require("node:child_process");
+var import_node_fs13 = require("node:fs");
+var import_node_path15 = require("node:path");
+var import_node_url = require("node:url");
+var import_shared10 = require("@locusai/shared");
+var import_events4 = require("events");
+
+class AgentOrchestrator extends import_events4.EventEmitter {
+  client;
+  config;
+  isRunning = false;
+  processedTasks = new Set;
+  resolvedSprintId = null;
+  agentState = null;
+  heartbeatInterval = null;
+  constructor(config) {
+    super();
+    this.config = config;
+    this.client = new LocusClient({
+      baseUrl: config.apiBase,
+      token: config.apiKey
+    });
+  }
+  async resolveSprintId() {
+    if (this.config.sprintId) {
+      return this.config.sprintId;
+    }
+    try {
+      const sprint = await this.client.sprints.getActive(this.config.workspaceId);
+      if (sprint?.id) {
+        console.log(c.info(`\uD83D\uDCCB Using active sprint: ${sprint.name}`));
+        return sprint.id;
+      }
+    } catch {}
+    console.log(c.dim("ℹ  No sprint specified, working with all workspace tasks"));
+    return "";
+  }
+  async start() {
+    if (this.isRunning) {
+      throw new Error("Orchestrator is already running");
+    }
+    this.isRunning = true;
+    this.processedTasks.clear();
+    try {
+      await this.orchestrationLoop();
+    } catch (error) {
+      this.emit("error", error);
+      throw error;
+    } finally {
+      await this.cleanup();
+    }
+  }
+  async orchestrationLoop() {
+    this.resolvedSprintId = await this.resolveSprintId();
+    this.emit("started", {
+      timestamp: new Date,
+      config: this.config,
+      sprintId: this.resolvedSprintId
+    });
+    this.printBanner();
+    const tasks2 = await this.getAvailableTasks();
+    if (tasks2.length === 0) {
+      console.log(c.dim("ℹ  No available tasks found in the backlog."));
+      return;
+    }
+    if (!this.preflightChecks())
+      return;
+    this.startHeartbeatMonitor();
+    await this.spawnAgent();
+    await this.waitForAgent();
+    console.log(`
+${c.success("✅ Orchestrator finished")}`);
+  }
+  printBanner() {
+    console.log(`
+${c.primary("\uD83E\uDD16 Locus Agent Orchestrator")}`);
+    console.log(c.dim("----------------------------------------------"));
+    console.log(`${c.bold("Workspace:")} ${this.config.workspaceId}`);
+    if (this.resolvedSprintId) {
+      console.log(`${c.bold("Sprint:")} ${this.resolvedSprintId}`);
+    }
+    console.log(`${c.bold("API Base:")} ${this.config.apiBase}`);
+    console.log(c.dim(`----------------------------------------------
+`));
+  }
+  preflightChecks() {
+    if (!isGitAvailable()) {
+      console.log(c.error("git is not installed. Install from https://git-scm.com/"));
+      return false;
+    }
+    if (!isGhAvailable(this.config.projectPath)) {
+      console.log(c.warning("GitHub CLI (gh) not available or not authenticated. Branch push can continue, but automatic PR creation may fail until gh is configured. Install from https://cli.github.com/"));
+    }
+    return true;
+  }
+  async getAvailableTasks() {
+    try {
+      const tasks2 = await this.client.tasks.getAvailable(this.config.workspaceId, this.resolvedSprintId || undefined);
+      return tasks2.filter((task) => !this.processedTasks.has(task.id));
+    } catch (error) {
+      this.emit("error", error);
+      return [];
+    }
+  }
+  async spawnAgent() {
+    const agentId = `agent-0-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+    this.agentState = {
+      id: agentId,
+      status: "IDLE",
+      currentTaskId: null,
+      tasksCompleted: 0,
+      tasksFailed: 0,
+      lastHeartbeat: new Date
+    };
+    console.log(`${c.primary("\uD83D\uDE80 Agent started:")} ${c.bold(agentId)}
+`);
+    const workerPath = this.resolveWorkerPath();
+    if (!workerPath) {
+      throw new Error("Worker file not found. Make sure the SDK is properly built and installed.");
+    }
+    const workerArgs = this.buildWorkerArgs(agentId);
+    const agentProcess = import_node_child_process12.spawn(process.execPath, [workerPath, ...workerArgs], {
+      stdio: ["pipe", "pipe", "pipe"],
+      detached: true,
+      env: getAugmentedEnv({
+        FORCE_COLOR: "1",
+        TERM: "xterm-256color",
+        LOCUS_WORKER: agentId,
+        LOCUS_WORKSPACE: this.config.workspaceId
+      })
+    });
+    this.agentState.process = agentProcess;
+    this.attachProcessHandlers(agentId, this.agentState, agentProcess);
+    this.emit("agent:spawned", { agentId });
+  }
+  async waitForAgent() {
+    while (this.agentState && this.isRunning) {
+      await sleep(2000);
+    }
+  }
+  startHeartbeatMonitor() {
+    this.heartbeatInterval = setInterval(() => {
+      if (!this.agentState)
+        return;
+      const now = Date.now();
+      if (this.agentState.status === "WORKING" && now - this.agentState.lastHeartbeat.getTime() > import_shared10.STALE_AGENT_TIMEOUT_MS) {
+        console.log(c.error(`Agent ${this.agentState.id} is stale (no heartbeat for 10 minutes). Killing.`));
+        if (this.agentState.process && !this.agentState.process.killed) {
+          killProcessTree(this.agentState.process);
+        }
+        this.emit("agent:stale", { agentId: this.agentState.id });
+      }
+    }, 60000);
+  }
+  async stop() {
+    this.isRunning = false;
+    await this.cleanup();
+    this.emit("stopped", { timestamp: new Date });
+  }
+  stopAgent(agentId) {
+    if (!this.agentState || this.agentState.id !== agentId)
+      return false;
+    if (this.agentState.process && !this.agentState.process.killed) {
+      killProcessTree(this.agentState.process);
+    }
+    return true;
+  }
+  async cleanup() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+    if (this.agentState?.process && !this.agentState.process.killed) {
+      console.log(`Killing agent: ${this.agentState.id}`);
+      killProcessTree(this.agentState.process);
+    }
+  }
+  getStats() {
+    return {
+      activeAgents: this.agentState ? 1 : 0,
+      totalTasksCompleted: this.agentState?.tasksCompleted ?? 0,
+      totalTasksFailed: this.agentState?.tasksFailed ?? 0,
+      processedTasks: this.processedTasks.size
+    };
+  }
+  getAgentStates() {
+    return this.agentState ? [this.agentState] : [];
+  }
+  buildWorkerArgs(agentId) {
+    const args = [
+      "--agent-id",
+      agentId,
+      "--workspace-id",
+      this.config.workspaceId,
+      "--api-url",
       this.config.apiBase,
       "--api-key",
       this.config.apiKey,
@@ -5220,14 +7146,14 @@ ${agentId} finished (exit code: ${code})`);
   }
   resolveWorkerPath() {
     const currentModulePath = import_node_url.fileURLToPath("file:///home/runner/work/locusai/locusai/packages/sdk/src/orchestrator/index.ts");
-    const currentModuleDir = import_node_path10.dirname(currentModulePath);
+    const currentModuleDir = import_node_path15.dirname(currentModulePath);
     const potentialPaths = [
-      import_node_path10.join(currentModuleDir, "..", "agent", "worker.js"),
-      import_node_path10.join(currentModuleDir, "agent", "worker.js"),
-      import_node_path10.join(currentModuleDir, "worker.js"),
-      import_node_path10.join(currentModuleDir, "..", "agent", "worker.ts")
+      import_node_path15.join(currentModuleDir, "..", "agent", "worker.js"),
+      import_node_path15.join(currentModuleDir, "agent", "worker.js"),
+      import_node_path15.join(currentModuleDir, "worker.js"),
+      import_node_path15.join(currentModuleDir, "..", "agent", "worker.ts")
     ];
-    return potentialPaths.find((p) => import_node_fs9.existsSync(p));
+    return potentialPaths.find((p) => import_node_fs13.existsSync(p));
   }
 }
 function killProcessTree(proc) {
@@ -5246,11 +7172,11 @@ function sleep(ms) {
 }
 // src/planning/plan-manager.ts
 init_config();
-var import_node_fs10 = require("node:fs");
-var import_node_path11 = require("node:path");
+var import_node_fs14 = require("node:fs");
+var import_node_path16 = require("node:path");
 
 // src/planning/sprint-plan.ts
-var import_shared5 = require("@locusai/shared");
+var import_shared11 = require("@locusai/shared");
 var import_zod2 = require("zod");
 
 // src/utils/structured-output.ts
@@ -5358,7 +7284,7 @@ function plannedTasksToCreatePayloads(plan, sprintId) {
   return plan.tasks.map((task) => ({
     title: task.title,
     description: task.description,
-    status: import_shared5.TaskStatus.BACKLOG,
+    status: import_shared11.TaskStatus.BACKLOG,
     assigneeRole: task.assigneeRole,
     priority: task.priority,
     labels: task.labels,
@@ -5412,19 +7338,19 @@ class PlanManager {
   save(plan) {
     this.ensurePlansDir();
     const slug = this.slugify(plan.name);
-    const jsonPath = import_node_path11.join(this.plansDir, `${slug}.json`);
-    const mdPath = import_node_path11.join(this.plansDir, `sprint-${slug}.md`);
-    import_node_fs10.writeFileSync(jsonPath, JSON.stringify(plan, null, 2), "utf-8");
-    import_node_fs10.writeFileSync(mdPath, sprintPlanToMarkdown(plan), "utf-8");
+    const jsonPath = import_node_path16.join(this.plansDir, `${slug}.json`);
+    const mdPath = import_node_path16.join(this.plansDir, `sprint-${slug}.md`);
+    import_node_fs14.writeFileSync(jsonPath, JSON.stringify(plan, null, 2), "utf-8");
+    import_node_fs14.writeFileSync(mdPath, sprintPlanToMarkdown(plan), "utf-8");
     return plan.id;
   }
   load(idOrSlug) {
     this.ensurePlansDir();
-    const files = import_node_fs10.readdirSync(this.plansDir).filter((f) => f.endsWith(".json"));
+    const files = import_node_fs14.readdirSync(this.plansDir).filter((f) => f.endsWith(".json"));
     for (const file of files) {
-      const filePath = import_node_path11.join(this.plansDir, file);
+      const filePath = import_node_path16.join(this.plansDir, file);
       try {
-        const plan = JSON.parse(import_node_fs10.readFileSync(filePath, "utf-8"));
+        const plan = JSON.parse(import_node_fs14.readFileSync(filePath, "utf-8"));
         if (plan.id === idOrSlug || this.slugify(plan.name) === idOrSlug) {
           return plan;
         }
@@ -5434,11 +7360,11 @@ class PlanManager {
   }
   list(status) {
     this.ensurePlansDir();
-    const files = import_node_fs10.readdirSync(this.plansDir).filter((f) => f.endsWith(".json"));
+    const files = import_node_fs14.readdirSync(this.plansDir).filter((f) => f.endsWith(".json"));
     const plans = [];
     for (const file of files) {
       try {
-        const plan = JSON.parse(import_node_fs10.readFileSync(import_node_path11.join(this.plansDir, file), "utf-8"));
+        const plan = JSON.parse(import_node_fs14.readFileSync(import_node_path16.join(this.plansDir, file), "utf-8"));
         if (!status || plan.status === status) {
           plans.push(plan);
         }
@@ -5495,18 +7421,18 @@ class PlanManager {
   }
   delete(idOrSlug) {
     this.ensurePlansDir();
-    const files = import_node_fs10.readdirSync(this.plansDir);
+    const files = import_node_fs14.readdirSync(this.plansDir);
     for (const file of files) {
-      const filePath = import_node_path11.join(this.plansDir, file);
+      const filePath = import_node_path16.join(this.plansDir, file);
       if (!file.endsWith(".json"))
         continue;
       try {
-        const plan = JSON.parse(import_node_fs10.readFileSync(filePath, "utf-8"));
+        const plan = JSON.parse(import_node_fs14.readFileSync(filePath, "utf-8"));
         if (plan.id === idOrSlug || this.slugify(plan.name) === idOrSlug) {
-          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);
+          import_node_fs14.unlinkSync(filePath);
+          const mdPath = import_node_path16.join(this.plansDir, `sprint-${this.slugify(plan.name)}.md`);
+          if (import_node_fs14.existsSync(mdPath)) {
+            import_node_fs14.unlinkSync(mdPath);
           }
           return;
         }
@@ -5520,8 +7446,8 @@ class PlanManager {
     return sprintPlanToMarkdown(plan);
   }
   ensurePlansDir() {
-    if (!import_node_fs10.existsSync(this.plansDir)) {
-      import_node_fs10.mkdirSync(this.plansDir, { recursive: true });
+    if (!import_node_fs14.existsSync(this.plansDir)) {
+      import_node_fs14.mkdirSync(this.plansDir, { recursive: true });
     }
   }
   slugify(name) {
@@ -5530,8 +7456,8 @@ class PlanManager {
 }
 // src/planning/planning-meeting.ts
 init_config();
-var import_node_fs11 = require("node:fs");
-var import_node_path12 = require("node:path");
+var import_node_fs15 = require("node:fs");
+var import_node_path17 = require("node:path");
 
 // src/planning/agents/planner.ts
 function buildPlannerPrompt(input) {
@@ -5617,8 +7543,8 @@ class PlanningMeeting {
   async run(directive, feedback) {
     this.log("Planning sprint...", "info");
     const plansDir = getLocusPath(this.projectPath, "plansDir");
-    if (!import_node_fs11.existsSync(plansDir)) {
-      import_node_fs11.mkdirSync(plansDir, { recursive: true });
+    if (!import_node_fs15.existsSync(plansDir)) {
+      import_node_fs15.mkdirSync(plansDir, { recursive: true });
     }
     const ts = Date.now();
     const planId = `plan-${ts}`;
@@ -5632,11 +7558,11 @@ class PlanningMeeting {
     });
     const response = await this.aiRunner.run(prompt);
     this.log("Planning meeting complete.", "success");
-    const expectedPath = import_node_path12.join(plansDir, `${fileName}.json`);
+    const expectedPath = import_node_path17.join(plansDir, `${fileName}.json`);
     let plan = null;
-    if (import_node_fs11.existsSync(expectedPath)) {
+    if (import_node_fs15.existsSync(expectedPath)) {
       try {
-        plan = JSON.parse(import_node_fs11.readFileSync(expectedPath, "utf-8"));
+        plan = JSON.parse(import_node_fs15.readFileSync(expectedPath, "utf-8"));
       } catch {}
     }
     if (!plan) {