@locusai/sdk 0.15.0 → 0.15.2

package/dist/index-node.js

@@ -225,29 +225,6 @@ 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(() => {
@@ -535,7 +512,6 @@ __export(exports_src, {
   LocusEvent: () => LocusEvent,
   LocusEmitter: () => LocusEmitter,
   LocusClient: () => LocusClient,
-  JobsModule: () => JobsModule,
   InvitationsModule: () => InvitationsModule,
   InstancesModule: () => InstancesModule,
   DocsModule: () => DocsModule,
@@ -559,7 +535,6 @@ class LocusClient {
   docs;
   ci;
   instances;
-  jobs;
   suggestions;
   constructor(config) {
     this.emitter = new LocusEmitter;
@@ -581,7 +556,6 @@ 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);
@@ -650,7 +624,6 @@ var init_src = __esm(() => {
   init_docs();
   init_instances();
   init_invitations();
-  init_jobs();
   init_organizations();
   init_sprints();
   init_suggestions();
@@ -664,7 +637,6 @@ var init_src = __esm(() => {
   init_docs();
   init_instances();
   init_invitations();
-  init_jobs();
   init_organizations();
   init_sprints();
   init_suggestions();
@@ -2907,19 +2879,15 @@ __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,
@@ -2933,16 +2901,10 @@ __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,
@@ -2957,7 +2919,6 @@ __export(exports_index_node, {
   DiscussionManager: () => DiscussionManager,
   DiscussionInsightSchema: () => DiscussionInsightSchema,
   DiscussionFacilitator: () => DiscussionFacilitator,
-  DependencyScanJob: () => DependencyScanJob,
   DEFAULT_MODEL: () => DEFAULT_MODEL,
   ContextTracker: () => ContextTracker,
   ContextGatherer: () => ContextGatherer,
@@ -2968,7 +2929,6 @@ __export(exports_index_node, {
   CiModule: () => CiModule,
   CODEX_MODELS: () => CODEX_MODELS,
   CLAUDE_MODELS: () => CLAUDE_MODELS,
-  BaseJob: () => BaseJob,
   AuthModule: () => AuthModule,
   AgentWorker: () => AgentWorker,
   AgentOrchestrator: () => AgentOrchestrator
@@ -5023,2046 +4983,198 @@ init_git_utils();
 // src/index-node.ts
 init_src();
 
-// 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
+// src/orchestrator/index.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");
-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
-      };
+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;
     }
-    let outdated;
     try {
-      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]
-      };
+      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");
     }
-    let vulnerabilities;
+    this.isRunning = true;
+    this.processedTasks.clear();
     try {
-      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");
-    }
-    if (vulnerabilities.length > 0) {
-      summaryParts.push(`${vulnerabilities.length} vulnerability(ies)`);
-    }
-    if (filesChanged > 0) {
-      summaryParts.push(`auto-updated ${patch.length + minor.length} safe package(s)`);
+      await this.orchestrationLoop();
+    } catch (error) {
+      this.emit("error", error);
+      throw error;
+    } finally {
+      await this.cleanup();
     }
-    const summary = `Dependency check: ${summaryParts.join(", ")} (${pm})`;
-    return {
-      summary,
-      suggestions: suggestions2,
-      filesChanged,
-      prUrl
-    };
-  }
-  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;
   }
-  getOutdatedPackages(pm, projectPath) {
-    const output = this.runOutdatedCommand(pm, projectPath);
-    if (pm === "bun") {
-      return this.parseBunOutdated(output.stdout);
+  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;
     }
-    return this.parseJsonOutdated(pm, output.stdout);
-  }
-  runOutdatedCommand(pm, projectPath) {
-    const commands = {
-      bun: ["bun", "outdated"],
-      npm: ["npm", "outdated", "--json"],
-      pnpm: ["pnpm", "outdated", "--format", "json"],
-      yarn: ["yarn", "outdated", "--json"]
-    };
-    const [bin, ...args] = commands[pm];
-    return this.exec(bin, args, projectPath);
+    if (!this.preflightChecks())
+      return;
+    this.startHeartbeatMonitor();
+    await this.spawnAgent();
+    await this.waitForAgent();
+    console.log(`
+${c.success("✅ Orchestrator finished")}`);
   }
-  parseBunOutdated(stdout) {
-    const packages = [];
-    const lines = stdout.split(`
-`);
-    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)
-      });
+  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}`);
     }
-    return packages;
+    console.log(`${c.bold("API Base:")} ${this.config.apiBase}`);
+    console.log(c.dim(`----------------------------------------------
+`));
   }
-  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;
+  preflightChecks() {
+    if (!isGitAvailable()) {
+      console.log(c.error("git is not installed. Install from https://git-scm.com/"));
+      return false;
     }
-    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)
-      });
+    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 packages;
+    return true;
   }
-  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)
-            });
-          }
-        }
-      } catch {}
+  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 [];
     }
-    return packages;
   }
-  runSecurityAudit(pm, projectPath) {
-    const commands = {
-      bun: ["bun", "audit"],
-      npm: ["npm", "audit", "--json"],
-      pnpm: ["pnpm", "audit", "--json"],
-      yarn: ["yarn", "audit", "--json"]
+  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
     };
-    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
-        });
-      }
-    } catch {}
-    return vulnerabilities;
-  }
-  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 {}
+    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.");
     }
-    return vulnerabilities;
+    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 });
   }
-  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 };
-    }
-    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 };
+  async waitForAgent() {
+    while (this.agentState && this.isRunning) {
+      await sleep(2000);
     }
-    const prUrl = this.commitAndPush(projectPath, changedFiles, safePackages, pm);
-    return { filesChanged: changedFiles.length, prUrl };
   }
-  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;
-    }
+  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);
+        }
+        this.emit("agent:stale", { agentId: this.agentState.id });
+      }
+    }, 60000);
   }
-  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);
+  async stop() {
+    this.isRunning = false;
+    await this.cleanup();
+    this.emit("stopped", { timestamp: new Date });
   }
-  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;
+  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;
   }
-  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
-          }))
-        }
-      });
+  async cleanup() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
     }
-    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
-          }))
-        }
-      });
+    if (this.agentState?.process && !this.agentState.process.killed) {
+      console.log(`Killing agent: ${this.agentState.id}`);
+      killProcessTree(this.agentState.process);
     }
-    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;
+  }
+  getStats() {
     return {
-      major: parseInt(match[1], 10),
-      minor: parseInt(match[2], 10),
-      patch: parseInt(match[3], 10)
+      activeAgents: this.agentState ? 1 : 0,
+      totalTasksCompleted: this.agentState?.tasksCompleted ?? 0,
+      totalTasksFailed: this.agentState?.tasksFailed ?? 0,
+      processedTasks: this.processedTasks.size
     };
   }
-  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}`;
-    }
-  }
-  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] : [];
+  getAgentStates() {
+    return this.agentState ? [this.agentState] : [];
   }
   buildWorkerArgs(agentId) {
     const args = [
@@ -7146,14 +5258,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_path15.dirname(currentModulePath);
+    const currentModuleDir = import_node_path10.dirname(currentModulePath);
     const potentialPaths = [
-      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")
+      import_node_path10.join(currentModuleDir, "..", "agent", "worker.js"),
+      import_node_path10.join(currentModuleDir, "agent", "worker.js"),
+      import_node_path10.join(currentModuleDir, "worker.js"),
+      import_node_path10.join(currentModuleDir, "..", "agent", "worker.ts")
     ];
-    return potentialPaths.find((p) => import_node_fs13.existsSync(p));
+    return potentialPaths.find((p) => import_node_fs9.existsSync(p));
   }
 }
 function killProcessTree(proc) {
@@ -7172,11 +5284,11 @@ function sleep(ms) {
 }
 // src/planning/plan-manager.ts
 init_config();
-var import_node_fs14 = require("node:fs");
-var import_node_path16 = require("node:path");
+var import_node_fs10 = require("node:fs");
+var import_node_path11 = require("node:path");
 
 // src/planning/sprint-plan.ts
-var import_shared11 = require("@locusai/shared");
+var import_shared5 = require("@locusai/shared");
 var import_zod2 = require("zod");
 
 // src/utils/structured-output.ts
@@ -7284,7 +5396,7 @@ function plannedTasksToCreatePayloads(plan, sprintId) {
   return plan.tasks.map((task) => ({
     title: task.title,
     description: task.description,
-    status: import_shared11.TaskStatus.BACKLOG,
+    status: import_shared5.TaskStatus.BACKLOG,
     assigneeRole: task.assigneeRole,
     priority: task.priority,
     labels: task.labels,
@@ -7338,19 +5450,19 @@ class PlanManager {
   save(plan) {
     this.ensurePlansDir();
     const slug = this.slugify(plan.name);
-    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");
+    const jsonPath = import_node_path11.join(this.plansDir, `${slug}.json`);
+    const mdPath = import_node_path11.join(this.plansDir, `sprint-${slug}.md`);
+    import_node_fs10.writeFileSync(jsonPath, JSON.stringify(plan, null, 2), "utf-8");
+    import_node_fs10.writeFileSync(mdPath, sprintPlanToMarkdown(plan), "utf-8");
     return plan.id;
   }
   load(idOrSlug) {
     this.ensurePlansDir();
-    const files = import_node_fs14.readdirSync(this.plansDir).filter((f) => f.endsWith(".json"));
+    const files = import_node_fs10.readdirSync(this.plansDir).filter((f) => f.endsWith(".json"));
     for (const file of files) {
-      const filePath = import_node_path16.join(this.plansDir, file);
+      const filePath = import_node_path11.join(this.plansDir, file);
       try {
-        const plan = JSON.parse(import_node_fs14.readFileSync(filePath, "utf-8"));
+        const plan = JSON.parse(import_node_fs10.readFileSync(filePath, "utf-8"));
         if (plan.id === idOrSlug || this.slugify(plan.name) === idOrSlug) {
           return plan;
         }
@@ -7360,11 +5472,11 @@ class PlanManager {
   }
   list(status) {
     this.ensurePlansDir();
-    const files = import_node_fs14.readdirSync(this.plansDir).filter((f) => f.endsWith(".json"));
+    const files = import_node_fs10.readdirSync(this.plansDir).filter((f) => f.endsWith(".json"));
     const plans = [];
     for (const file of files) {
       try {
-        const plan = JSON.parse(import_node_fs14.readFileSync(import_node_path16.join(this.plansDir, file), "utf-8"));
+        const plan = JSON.parse(import_node_fs10.readFileSync(import_node_path11.join(this.plansDir, file), "utf-8"));
         if (!status || plan.status === status) {
           plans.push(plan);
         }
@@ -7421,18 +5533,18 @@ class PlanManager {
   }
   delete(idOrSlug) {
     this.ensurePlansDir();
-    const files = import_node_fs14.readdirSync(this.plansDir);
+    const files = import_node_fs10.readdirSync(this.plansDir);
     for (const file of files) {
-      const filePath = import_node_path16.join(this.plansDir, file);
+      const filePath = import_node_path11.join(this.plansDir, file);
       if (!file.endsWith(".json"))
         continue;
       try {
-        const plan = JSON.parse(import_node_fs14.readFileSync(filePath, "utf-8"));
+        const plan = JSON.parse(import_node_fs10.readFileSync(filePath, "utf-8"));
         if (plan.id === idOrSlug || this.slugify(plan.name) === idOrSlug) {
-          import_node_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);
+          import_node_fs10.unlinkSync(filePath);
+          const mdPath = import_node_path11.join(this.plansDir, `sprint-${this.slugify(plan.name)}.md`);
+          if (import_node_fs10.existsSync(mdPath)) {
+            import_node_fs10.unlinkSync(mdPath);
           }
           return;
         }
@@ -7446,8 +5558,8 @@ class PlanManager {
     return sprintPlanToMarkdown(plan);
   }
   ensurePlansDir() {
-    if (!import_node_fs14.existsSync(this.plansDir)) {
-      import_node_fs14.mkdirSync(this.plansDir, { recursive: true });
+    if (!import_node_fs10.existsSync(this.plansDir)) {
+      import_node_fs10.mkdirSync(this.plansDir, { recursive: true });
     }
   }
   slugify(name) {
@@ -7456,8 +5568,8 @@ class PlanManager {
 }
 // src/planning/planning-meeting.ts
 init_config();
-var import_node_fs15 = require("node:fs");
-var import_node_path17 = require("node:path");
+var import_node_fs11 = require("node:fs");
+var import_node_path12 = require("node:path");
 
 // src/planning/agents/planner.ts
 function buildPlannerPrompt(input) {
@@ -7543,8 +5655,8 @@ class PlanningMeeting {
   async run(directive, feedback) {
     this.log("Planning sprint...", "info");
     const plansDir = getLocusPath(this.projectPath, "plansDir");
-    if (!import_node_fs15.existsSync(plansDir)) {
-      import_node_fs15.mkdirSync(plansDir, { recursive: true });
+    if (!import_node_fs11.existsSync(plansDir)) {
+      import_node_fs11.mkdirSync(plansDir, { recursive: true });
     }
     const ts = Date.now();
     const planId = `plan-${ts}`;
@@ -7558,11 +5670,11 @@ class PlanningMeeting {
     });
     const response = await this.aiRunner.run(prompt);
     this.log("Planning meeting complete.", "success");
-    const expectedPath = import_node_path17.join(plansDir, `${fileName}.json`);
+    const expectedPath = import_node_path12.join(plansDir, `${fileName}.json`);
     let plan = null;
-    if (import_node_fs15.existsSync(expectedPath)) {
+    if (import_node_fs11.existsSync(expectedPath)) {
       try {
-        plan = JSON.parse(import_node_fs15.readFileSync(expectedPath, "utf-8"));
+        plan = JSON.parse(import_node_fs11.readFileSync(expectedPath, "utf-8"));
       } catch {}
     }
     if (!plan) {
@@ -7577,5 +5689,240 @@ class PlanningMeeting {
     };
   }
 }
+// src/proposals/context-gatherer.ts
+var import_node_child_process8 = require("node:child_process");
+var import_node_fs12 = require("node:fs");
+var import_node_path13 = require("node:path");
+
+class ContextGatherer {
+  async gather(projectPath, client, workspaceId) {
+    const [activeSprint, allTasks, skippedSuggestions] = await Promise.all([
+      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 {
+      activeSprint,
+      sprintTasks,
+      backlogTasks,
+      gitLog,
+      artifactContents,
+      locusInstructions,
+      skippedSuggestions
+    };
+  }
+  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_process8.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_path13.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_path13.join(artifactsDir, name), "utf-8").slice(0, 2000)
+      }));
+    } catch {
+      return [];
+    }
+  }
+  readLocusInstructions(projectPath) {
+    const locusPath = import_node_path13.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/proposals/proposal-engine.ts
+init_factory();
+var import_shared6 = 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_shared6.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.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
+- 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/index-node.ts
 init_colors();