@yattalo/task-system 0.1.0

package/dist/generators/agent-ops-scripts.js

@@ -0,0 +1,843 @@
+// ============================================================
+// Generator: Layer 4 — Agent-Ops Scripts
+// Generates scripts/agent-ops/*.ts
+// ============================================================
+import { writeFileSync } from "node:fs";
+import { join } from "node:path";
+export function generateAgentOpsScripts(ctx) {
+    const results = [];
+    const base = join(ctx.targetDir, "scripts", "agent-ops");
+    results.push(generateTypes(ctx, base));
+    results.push(generateConfig(ctx, base));
+    results.push(generateScheduler(ctx, base));
+    results.push(generateLaneQueue(ctx, base));
+    results.push(generateGitIsolation(ctx, base));
+    results.push(generateAgentLauncher(ctx, base));
+    results.push(generateLogStreamer(ctx, base));
+    results.push(generatePrCreator(ctx, base));
+    results.push(generateCleanup(ctx, base));
+    results.push(generateRunner(ctx, base));
+    return results;
+}
+function writeIfNotDry(path, content, dryRun) {
+    const lineCount = content.split("\n").length;
+    if (!dryRun)
+        writeFileSync(path, content, "utf-8");
+    return lineCount;
+}
+// ── types.ts ──
+function generateTypes(ctx, base) {
+    const content = `// Agent-Ops shared types — generated by @yattalo/task-system
+
+export interface AgentOpsConfig {
+  convexUrl: string;
+  pollInterval: number;
+  maxConcurrentRuns: number;
+  maxRunsPerDay: number;
+  defaultTimeoutMinutes: number;
+  protectedBranches: string[];
+  agentCommands: Record<string, string>;
+  projectRoot: string;
+  worktreeBase: string;
+}
+
+export interface JobSnapshot {
+  jobId: string;
+  name: string;
+  agent: string;
+  prompt: string;
+  executionMode: string;
+  createPR: boolean;
+  prBaseBranch?: string;
+  maxDurationMinutes?: number;
+  laneId?: string;
+}
+
+export interface RunContext {
+  runId: string;
+  jobId: string;
+  agent: string;
+  prompt: string;
+  executionMode: string;
+  worktreePath: string;
+  branchName: string;
+  baseBranch: string;
+  startedAt: number;
+}
+
+export interface LogEntry {
+  timestamp: number;
+  level: "info" | "warn" | "error" | "debug";
+  message: string;
+}
+`;
+    const lines = writeIfNotDry(join(base, "types.ts"), content, ctx.dryRun);
+    return { file: "scripts/agent-ops/types.ts", lines };
+}
+// ── config.ts ──
+function generateConfig(ctx, base) {
+    const agentOps = ctx.config.agentOps ?? {};
+    const agentCmds = agentOps.agentCommands ?? {};
+    const cmdsStr = Object.entries(agentCmds)
+        .map(([k, v]) => `    ${k}: "${v}"`)
+        .join(",\n");
+    const content = `// Agent-Ops config loader — generated by @yattalo/task-system
+import { resolve } from "node:path";
+import { existsSync } from "node:fs";
+import type { AgentOpsConfig } from "./types.js";
+
+const DEFAULT_CONFIG: AgentOpsConfig = {
+  convexUrl: process.env.CONVEX_URL ?? "",
+  pollInterval: ${agentOps.pollInterval ?? 30000},
+  maxConcurrentRuns: ${agentOps.maxConcurrentRuns ?? 3},
+  maxRunsPerDay: ${agentOps.maxRunsPerDay ?? 100},
+  defaultTimeoutMinutes: ${agentOps.defaultTimeoutMinutes ?? 30},
+  protectedBranches: ${JSON.stringify(agentOps.protectedBranches ?? ["main", "master"])},
+  agentCommands: {
+${cmdsStr}
+  },
+  projectRoot: process.cwd(),
+  worktreeBase: resolve(process.env.HOME ?? "~", ".agent-ops", "worktrees"),
+};
+
+export function loadConfig(): AgentOpsConfig {
+  // Try to load from task-system.config.ts at project root
+  const configPath = resolve(process.cwd(), "task-system.config.ts");
+  if (existsSync(configPath)) {
+    // Config is TypeScript — in production this would use tsx or similar
+    // For now, use defaults + env overrides
+  }
+
+  return {
+    ...DEFAULT_CONFIG,
+    convexUrl: process.env.CONVEX_URL ?? DEFAULT_CONFIG.convexUrl,
+    pollInterval: parseInt(process.env.AGENT_OPS_POLL_INTERVAL ?? String(DEFAULT_CONFIG.pollInterval), 10),
+    maxConcurrentRuns: parseInt(process.env.AGENT_OPS_MAX_CONCURRENT ?? String(DEFAULT_CONFIG.maxConcurrentRuns), 10),
+  };
+}
+`;
+    const lines = writeIfNotDry(join(base, "config.ts"), content, ctx.dryRun);
+    return { file: "scripts/agent-ops/config.ts", lines };
+}
+// ── scheduler.ts ──
+function generateScheduler(ctx, base) {
+    const content = `// Agent-Ops cron scheduler — generated by @yattalo/task-system
+//
+// Minimal cron parser for Agent-Ops scheduling.
+// Supports standard 5-field cron expressions: minute hour day month weekday
+
+export function parseCron(expression: string): { minute: number[]; hour: number[]; day: number[]; month: number[]; weekday: number[] } {
+  const parts = expression.trim().split(/\\s+/);
+  if (parts.length !== 5) throw new Error(\`Invalid cron: \${expression}\`);
+
+  return {
+    minute: parseField(parts[0], 0, 59),
+    hour: parseField(parts[1], 0, 23),
+    day: parseField(parts[2], 1, 31),
+    month: parseField(parts[3], 1, 12),
+    weekday: parseField(parts[4], 0, 6),
+  };
+}
+
+function parseField(field: string, min: number, max: number): number[] {
+  if (field === "*") return range(min, max);
+
+  const values = new Set<number>();
+  for (const part of field.split(",")) {
+    if (part.includes("/")) {
+      const [rangeStr, stepStr] = part.split("/");
+      const step = parseInt(stepStr, 10);
+      const [start, end] = rangeStr === "*" ? [min, max] : rangeStr.split("-").map(Number);
+      for (let i = start; i <= (end ?? max); i += step) values.add(i);
+    } else if (part.includes("-")) {
+      const [start, end] = part.split("-").map(Number);
+      for (let i = start; i <= end; i++) values.add(i);
+    } else {
+      values.add(parseInt(part, 10));
+    }
+  }
+  return [...values].sort((a, b) => a - b);
+}
+
+function range(min: number, max: number): number[] {
+  return Array.from({ length: max - min + 1 }, (_, i) => min + i);
+}
+
+export function getNextRun(expression: string, after: Date = new Date()): Date {
+  const cron = parseCron(expression);
+  const next = new Date(after.getTime() + 60000); // start from next minute
+  next.setSeconds(0, 0);
+
+  for (let attempts = 0; attempts < 525960; attempts++) { // max ~1 year of minutes
+    if (
+      cron.month.includes(next.getMonth() + 1) &&
+      cron.day.includes(next.getDate()) &&
+      cron.weekday.includes(next.getDay()) &&
+      cron.hour.includes(next.getHours()) &&
+      cron.minute.includes(next.getMinutes())
+    ) {
+      return next;
+    }
+    next.setTime(next.getTime() + 60000);
+  }
+
+  throw new Error(\`No next run found for: \${expression}\`);
+}
+
+export function shouldRunNow(expression: string, lastRunAt?: number): boolean {
+  const now = new Date();
+  const cron = parseCron(expression);
+
+  const matches =
+    cron.month.includes(now.getMonth() + 1) &&
+    cron.day.includes(now.getDate()) &&
+    cron.weekday.includes(now.getDay()) &&
+    cron.hour.includes(now.getHours()) &&
+    cron.minute.includes(now.getMinutes());
+
+  if (!matches) return false;
+  if (!lastRunAt) return true;
+
+  // Don't run again if already ran this minute
+  const lastRun = new Date(lastRunAt);
+  return (
+    lastRun.getMinutes() !== now.getMinutes() ||
+    lastRun.getHours() !== now.getHours() ||
+    lastRun.getDate() !== now.getDate()
+  );
+}
+`;
+    const lines = writeIfNotDry(join(base, "scheduler.ts"), content, ctx.dryRun);
+    return { file: "scripts/agent-ops/scheduler.ts", lines };
+}
+// ── lane-queue.ts ──
+function generateLaneQueue(ctx, base) {
+    const content = `// Agent-Ops lane queue — generated by @yattalo/task-system
+//
+// Prevents concurrent runs on the same lane.
+// A lane is a logical grouping (e.g., "frontend", "backend") to prevent conflicts.
+
+const activeLanes = new Map<string, string>(); // laneId -> runId
+
+export function acquireLane(laneId: string, runId: string): boolean {
+  if (activeLanes.has(laneId)) {
+    return false; // lane is busy
+  }
+  activeLanes.set(laneId, runId);
+  return true;
+}
+
+export function releaseLane(laneId: string, runId: string): void {
+  if (activeLanes.get(laneId) === runId) {
+    activeLanes.delete(laneId);
+  }
+}
+
+export function isLaneBusy(laneId: string): boolean {
+  return activeLanes.has(laneId);
+}
+
+export function getActiveLanes(): Map<string, string> {
+  return new Map(activeLanes);
+}
+`;
+    const lines = writeIfNotDry(join(base, "lane-queue.ts"), content, ctx.dryRun);
+    return { file: "scripts/agent-ops/lane-queue.ts", lines };
+}
+// ── git-isolation.ts ──
+function generateGitIsolation(ctx, base) {
+    const protectedBranches = JSON.stringify(ctx.config.agentOps?.protectedBranches ?? ["main", "master"]);
+    const content = `// Agent-Ops git isolation — generated by @yattalo/task-system
+//
+// Creates and manages git worktrees for isolated agent execution.
+// Each run gets its own worktree to prevent conflicts.
+
+import { execSync } from "node:child_process";
+import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { join, resolve } from "node:path";
+import type { AgentOpsConfig } from "./types.js";
+
+const PROTECTED_BRANCHES = ${protectedBranches};
+
+export interface WorktreeInfo {
+  path: string;
+  branch: string;
+  baseBranch: string;
+}
+
+export function createWorktree(
+  config: AgentOpsConfig,
+  runId: string,
+  baseBranch: string = "main",
+): WorktreeInfo {
+  const worktreeBase = config.worktreeBase;
+  mkdirSync(worktreeBase, { recursive: true });
+
+  const branchName = \`agent-ops/\${runId}\`;
+  const worktreePath = join(worktreeBase, runId);
+
+  if (existsSync(worktreePath)) {
+    throw new Error(\`Worktree already exists: \${worktreePath}\`);
+  }
+
+  // Validate base branch exists
+  try {
+    execSync(\`git rev-parse --verify \${baseBranch}\`, {
+      cwd: config.projectRoot,
+      stdio: "pipe",
+    });
+  } catch {
+    throw new Error(\`Base branch does not exist: \${baseBranch}\`);
+  }
+
+  // Validate not targeting protected branch directly
+  if (PROTECTED_BRANCHES.includes(branchName)) {
+    throw new Error(\`Cannot create worktree on protected branch: \${branchName}\`);
+  }
+
+  // Create worktree with new branch
+  execSync(
+    \`git worktree add -b "\${branchName}" "\${worktreePath}" "\${baseBranch}"\`,
+    { cwd: config.projectRoot, stdio: "pipe" },
+  );
+
+  return { path: worktreePath, branch: branchName, baseBranch };
+}
+
+export function removeWorktree(config: AgentOpsConfig, runId: string): void {
+  const worktreePath = join(config.worktreeBase, runId);
+
+  if (!existsSync(worktreePath)) return;
+
+  try {
+    execSync(\`git worktree remove "\${worktreePath}" --force\`, {
+      cwd: config.projectRoot,
+      stdio: "pipe",
+    });
+  } catch {
+    // Fallback: manual cleanup
+    rmSync(worktreePath, { recursive: true, force: true });
+    try {
+      execSync("git worktree prune", { cwd: config.projectRoot, stdio: "pipe" });
+    } catch {}
+  }
+
+  // Clean up branch
+  const branchName = \`agent-ops/\${runId}\`;
+  try {
+    execSync(\`git branch -D "\${branchName}"\`, {
+      cwd: config.projectRoot,
+      stdio: "pipe",
+    });
+  } catch {}
+}
+
+export function getWorktreeGitStats(
+  worktreePath: string,
+  baseBranch: string,
+): { commitCount: number; filesChanged: number; linesAdded: number; linesRemoved: number } {
+  try {
+    const commitCount = parseInt(
+      execSync(\`git rev-list --count \${baseBranch}..HEAD\`, {
+        cwd: worktreePath,
+        encoding: "utf-8",
+      }).trim(),
+      10,
+    );
+
+    const diffStat = execSync(\`git diff --shortstat \${baseBranch}..HEAD\`, {
+      cwd: worktreePath,
+      encoding: "utf-8",
+    }).trim();
+
+    let filesChanged = 0, linesAdded = 0, linesRemoved = 0;
+    const filesMatch = diffStat.match(/(\\d+) files? changed/);
+    const addMatch = diffStat.match(/(\\d+) insertions?/);
+    const delMatch = diffStat.match(/(\\d+) deletions?/);
+
+    if (filesMatch) filesChanged = parseInt(filesMatch[1], 10);
+    if (addMatch) linesAdded = parseInt(addMatch[1], 10);
+    if (delMatch) linesRemoved = parseInt(delMatch[1], 10);
+
+    return { commitCount, filesChanged, linesAdded, linesRemoved };
+  } catch {
+    return { commitCount: 0, filesChanged: 0, linesAdded: 0, linesRemoved: 0 };
+  }
+}
+
+export function listStaleWorktrees(config: AgentOpsConfig, maxAgeMs: number = 24 * 60 * 60 * 1000): string[] {
+  const worktreeBase = config.worktreeBase;
+  if (!existsSync(worktreeBase)) return [];
+
+  const { readdirSync, statSync } = require("node:fs");
+  const now = Date.now();
+  const stale: string[] = [];
+
+  for (const entry of readdirSync(worktreeBase)) {
+    const entryPath = join(worktreeBase, entry);
+    try {
+      const stat = statSync(entryPath);
+      if (now - stat.mtimeMs > maxAgeMs) {
+        stale.push(entry);
+      }
+    } catch {}
+  }
+
+  return stale;
+}
+`;
+    const lines = writeIfNotDry(join(base, "git-isolation.ts"), content, ctx.dryRun);
+    return { file: "scripts/agent-ops/git-isolation.ts", lines };
+}
+// ── agent-launcher.ts ──
+function generateAgentLauncher(ctx, base) {
+    const content = `// Agent-Ops agent launcher — generated by @yattalo/task-system
+//
+// Spawns agent CLI processes (claude, gemini, codex) with proper environment.
+
+import { spawn, ChildProcess } from "node:child_process";
+import type { AgentOpsConfig, RunContext, LogEntry } from "./types.js";
+
+export interface LaunchResult {
+  process: ChildProcess;
+  exitCode: Promise<number>;
+}
+
+export function launchAgent(
+  config: AgentOpsConfig,
+  run: RunContext,
+  onLog: (entry: LogEntry) => void,
+): LaunchResult {
+  const agentCmd = config.agentCommands[run.agent];
+  if (!agentCmd) {
+    throw new Error(\`No command configured for agent: \${run.agent}\`);
+  }
+
+  const timeoutMs = (config.defaultTimeoutMinutes ?? 30) * 60 * 1000;
+
+  // Build agent-specific args
+  const args = buildAgentArgs(run);
+
+  onLog({
+    timestamp: Date.now(),
+    level: "info",
+    message: \`Launching \${run.agent}: \${agentCmd} \${args.join(" ")}\`,
+  });
+
+  const proc = spawn(agentCmd, args, {
+    cwd: run.worktreePath,
+    env: {
+      ...process.env,
+      AGENT_OPS_RUN_ID: run.runId,
+      AGENT_OPS_JOB_ID: run.jobId,
+    },
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+
+  // Stream stdout/stderr to log callback
+  proc.stdout?.on("data", (data: Buffer) => {
+    const text = data.toString().trim();
+    if (text) {
+      onLog({ timestamp: Date.now(), level: "info", message: text.slice(0, 500) });
+    }
+  });
+
+  proc.stderr?.on("data", (data: Buffer) => {
+    const text = data.toString().trim();
+    if (text) {
+      onLog({ timestamp: Date.now(), level: "warn", message: text.slice(0, 500) });
+    }
+  });
+
+  // Timeout handling
+  const timeoutId = setTimeout(() => {
+    onLog({ timestamp: Date.now(), level: "error", message: \`Timeout after \${config.defaultTimeoutMinutes}min\` });
+    proc.kill("SIGTERM");
+    setTimeout(() => proc.kill("SIGKILL"), 5000);
+  }, timeoutMs);
+
+  const exitCode = new Promise<number>((resolve) => {
+    proc.on("close", (code) => {
+      clearTimeout(timeoutId);
+      resolve(code ?? 1);
+    });
+    proc.on("error", (err) => {
+      clearTimeout(timeoutId);
+      onLog({ timestamp: Date.now(), level: "error", message: \`Process error: \${err.message}\` });
+      resolve(1);
+    });
+  });
+
+  return { process: proc, exitCode };
+}
+
+function buildAgentArgs(run: RunContext): string[] {
+  switch (run.agent) {
+    case "claude":
+      return ["--print", "--dangerously-skip-permissions", "-p", run.prompt];
+    case "gemini":
+      return ["--prompt", run.prompt];
+    case "codex":
+      return ["--prompt", run.prompt, "--approval-mode", "full-auto"];
+    default:
+      return [run.prompt];
+  }
+}
+`;
+    const lines = writeIfNotDry(join(base, "agent-launcher.ts"), content, ctx.dryRun);
+    return { file: "scripts/agent-ops/agent-launcher.ts", lines };
+}
+// ── log-streamer.ts ──
+function generateLogStreamer(ctx, base) {
+    const content = `// Agent-Ops log streamer — generated by @yattalo/task-system
+//
+// Batches log entries and uploads them to Convex periodically.
+
+import { execSync } from "node:child_process";
+import type { LogEntry } from "./types.js";
+
+export class LogStreamer {
+  private buffer: LogEntry[] = [];
+  private intervalId: ReturnType<typeof setInterval> | null = null;
+  private readonly maxBatchSize = 20;
+  private readonly flushIntervalMs = 5000;
+
+  constructor(
+    private readonly runId: string,
+    private readonly projectRoot: string,
+  ) {}
+
+  start(): void {
+    this.intervalId = setInterval(() => this.flush(), this.flushIntervalMs);
+  }
+
+  stop(): void {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    this.flush(); // Final flush
+  }
+
+  push(entry: LogEntry): void {
+    this.buffer.push(entry);
+    if (this.buffer.length >= this.maxBatchSize) {
+      this.flush();
+    }
+  }
+
+  private flush(): void {
+    if (this.buffer.length === 0) return;
+
+    const entries = this.buffer.splice(0, this.maxBatchSize);
+
+    try {
+      execSync(
+        \`npx convex run taskSystem/agentOps:appendRunLog '\${JSON.stringify({
+          runId: this.runId,
+          entries,
+        })}'\`,
+        { cwd: this.projectRoot, stdio: "pipe", timeout: 10000 },
+      );
+    } catch (err) {
+      // Re-add failed entries for next attempt
+      this.buffer.unshift(...entries);
+      console.error(\`[log-streamer] Failed to flush logs: \${(err as Error).message}\`);
+    }
+  }
+}
+`;
+    const lines = writeIfNotDry(join(base, "log-streamer.ts"), content, ctx.dryRun);
+    return { file: "scripts/agent-ops/log-streamer.ts", lines };
+}
+// ── pr-creator.ts ──
+function generatePrCreator(ctx, base) {
+    const content = `// Agent-Ops PR creator — generated by @yattalo/task-system
+//
+// Creates GitHub PRs from agent run branches using gh CLI.
+
+import { execSync } from "node:child_process";
+import type { RunContext } from "./types.js";
+
+export interface PRResult {
+  url: string;
+  number: number;
+}
+
+export function createPR(run: RunContext, summary?: string): PRResult | null {
+  try {
+    // Check if there are commits to push
+    const commitCount = execSync(
+      \`git rev-list --count \${run.baseBranch}..HEAD\`,
+      { cwd: run.worktreePath, encoding: "utf-8" },
+    ).trim();
+
+    if (commitCount === "0") {
+      console.log("[pr-creator] No commits to create PR for");
+      return null;
+    }
+
+    // Push branch
+    execSync(\`git push -u origin \${run.branchName}\`, {
+      cwd: run.worktreePath,
+      stdio: "pipe",
+    });
+
+    // Create PR
+    const title = \`[Agent-Ops] \${run.agent}/\${run.jobId}: \${summary?.slice(0, 60) ?? "Automated changes"}\`;
+    const body = [
+      "## Agent-Ops Automated PR",
+      "",
+      \`- **Job**: \${run.jobId}\`,
+      \`- **Run**: \${run.runId}\`,
+      \`- **Agent**: \${run.agent}\`,
+      \`- **Commits**: \${commitCount}\`,
+      "",
+      summary ? \`## Summary\\n\${summary}\` : "",
+      "",
+      "---",
+      "Generated by @yattalo/task-system Agent-Ops",
+    ].join("\\n");
+
+    const prUrl = execSync(
+      \`gh pr create --title "\${title.replace(/"/g, '\\\\"')}" --body "\${body.replace(/"/g, '\\\\"')}" --base \${run.baseBranch}\`,
+      { cwd: run.worktreePath, encoding: "utf-8" },
+    ).trim();
+
+    // Extract PR number from URL
+    const match = prUrl.match(/\\/(\\d+)$/);
+    const prNumber = match ? parseInt(match[1], 10) : 0;
+
+    return { url: prUrl, number: prNumber };
+  } catch (err) {
+    console.error(\`[pr-creator] Failed: \${(err as Error).message}\`);
+    return null;
+  }
+}
+`;
+    const lines = writeIfNotDry(join(base, "pr-creator.ts"), content, ctx.dryRun);
+    return { file: "scripts/agent-ops/pr-creator.ts", lines };
+}
+// ── cleanup.ts ──
+function generateCleanup(ctx, base) {
+    const content = `// Agent-Ops cleanup — generated by @yattalo/task-system
+//
+// Garbage collects stale worktrees older than 24h.
+
+import { listStaleWorktrees, removeWorktree } from "./git-isolation.js";
+import type { AgentOpsConfig } from "./types.js";
+
+export function cleanupStaleWorktrees(config: AgentOpsConfig, maxAgeMs?: number): number {
+  const stale = listStaleWorktrees(config, maxAgeMs);
+
+  let cleaned = 0;
+  for (const runId of stale) {
+    try {
+      removeWorktree(config, runId);
+      console.log(\`[cleanup] Removed stale worktree: \${runId}\`);
+      cleaned++;
+    } catch (err) {
+      console.error(\`[cleanup] Failed to remove \${runId}: \${(err as Error).message}\`);
+    }
+  }
+
+  return cleaned;
+}
+`;
+    const lines = writeIfNotDry(join(base, "cleanup.ts"), content, ctx.dryRun);
+    return { file: "scripts/agent-ops/cleanup.ts", lines };
+}
+// ── runner.ts (main loop) ──
+function generateRunner(ctx, base) {
+    const content = `#!/usr/bin/env npx tsx
+// ============================================================
+// Agent-Ops Runner — Main polling loop
+// Generated by @yattalo/task-system for ${ctx.config.projectName}
+// ============================================================
+//
+// Usage: npx tsx scripts/agent-ops/runner.ts
+//
+// This is the main Agent-Ops daemon. It:
+// 1. Polls Convex for pending runs every N seconds
+// 2. Evaluates scheduled jobs for due runs
+// 3. Creates git worktrees for isolation
+// 4. Launches agent CLI processes
+// 5. Streams logs back to Convex
+// 6. Cleans up on completion
+
+import { execSync } from "node:child_process";
+import { loadConfig } from "./config.js";
+import { shouldRunNow, getNextRun } from "./scheduler.js";
+import { acquireLane, releaseLane } from "./lane-queue.js";
+import { createWorktree, removeWorktree, getWorktreeGitStats } from "./git-isolation.js";
+import { launchAgent } from "./agent-launcher.js";
+import { LogStreamer } from "./log-streamer.js";
+import { createPR } from "./pr-creator.js";
+import { cleanupStaleWorktrees } from "./cleanup.js";
+import type { AgentOpsConfig, RunContext, LogEntry } from "./types.js";
+
+const config = loadConfig();
+let activeRuns = 0;
+let totalRunsToday = 0;
+let lastCleanup = 0;
+
+function convexRun(fn: string, args?: Record<string, unknown>): string {
+  const argsStr = args ? \` '\${JSON.stringify(args)}'\` : "";
+  return execSync(\`npx convex run taskSystem/agentOps:\${fn}\${argsStr}\`, {
+    cwd: config.projectRoot,
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"],
+  }).trim();
+}
+
+async function pollOnce(): Promise<void> {
+  // 1. Check for pending runs
+  try {
+    const pendingRaw = convexRun("getPendingRuns");
+    const pendingRuns = JSON.parse(pendingRaw);
+
+    for (const run of pendingRuns) {
+      if (activeRuns >= config.maxConcurrentRuns) break;
+      if (totalRunsToday >= config.maxRunsPerDay) {
+        console.log("[runner] Daily run limit reached");
+        break;
+      }
+
+      // Check lane availability
+      if (run.laneId && !acquireLane(run.laneId, run.runId)) {
+        console.log(\`[runner] Lane \${run.laneId} busy, skipping \${run.runId}\`);
+        continue;
+      }
+
+      executeRun(run).catch((err) => {
+        console.error(\`[runner] Run \${run.runId} failed: \${err.message}\`);
+      });
+    }
+  } catch (err) {
+    console.error(\`[runner] Poll error: \${(err as Error).message}\`);
+  }
+
+  // 2. Evaluate scheduled jobs
+  try {
+    const jobsRaw = convexRun("listJobs", { enabled: true });
+    const jobs = JSON.parse(jobsRaw);
+
+    for (const job of jobs) {
+      if (job.scheduleType === "cron" && job.cronExpression) {
+        if (shouldRunNow(job.cronExpression, job.lastRunAt)) {
+          console.log(\`[runner] Scheduling job \${job.jobId}\`);
+          convexRun("triggerManualRun", { jobId: job.jobId });
+        }
+      }
+    }
+  } catch (err) {
+    console.error(\`[runner] Schedule check error: \${(err as Error).message}\`);
+  }
+
+  // 3. Periodic cleanup (every hour)
+  if (Date.now() - lastCleanup > 3600000) {
+    cleanupStaleWorktrees(config);
+    lastCleanup = Date.now();
+  }
+}
+
+async function executeRun(run: any): Promise<void> {
+  activeRuns++;
+  totalRunsToday++;
+  const logStreamer = new LogStreamer(run.runId, config.projectRoot);
+
+  try {
+    // Update status to provisioning
+    convexRun("updateRunStatus", { runId: run.runId, status: "provisioning" });
+
+    // Create worktree
+    const baseBranch = run.baseBranch ?? "main";
+    const worktree = createWorktree(config, run.runId, baseBranch);
+    convexRun("updateRunGitInfo", {
+      runId: run.runId,
+      worktreePath: worktree.path,
+      branchName: worktree.branch,
+    });
+
+    // Update status to running
+    convexRun("updateRunStatus", { runId: run.runId, status: "running" });
+
+    // Start log streaming
+    logStreamer.start();
+
+    const runCtx: RunContext = {
+      runId: run.runId,
+      jobId: run.jobId,
+      agent: run.agent,
+      prompt: run.prompt,
+      executionMode: run.executionMode,
+      worktreePath: worktree.path,
+      branchName: worktree.branch,
+      baseBranch,
+      startedAt: Date.now(),
+    };
+
+    // Launch agent
+    const { exitCode } = launchAgent(config, runCtx, (entry) => logStreamer.push(entry));
+    const code = await exitCode;
+
+    // Collect git stats
+    const stats = getWorktreeGitStats(worktree.path, baseBranch);
+    convexRun("updateRunGitInfo", { runId: run.runId, ...stats });
+
+    // Create PR if configured
+    let prUrl: string | undefined;
+    let prNumber: number | undefined;
+
+    // Get job config for PR creation
+    try {
+      const jobRaw = convexRun("getJob", { jobId: run.jobId });
+      const job = JSON.parse(jobRaw);
+      if (job.createPR && stats.commitCount > 0) {
+        const pr = createPR(runCtx, \`Job \${run.jobId} completed\`);
+        if (pr) {
+          prUrl = pr.url;
+          prNumber = pr.number;
+        }
+      }
+    } catch {}
+
+    // Complete run
+    const status = code === 0 ? "success" : "failed";
+    convexRun("completeRun", {
+      runId: run.runId,
+      status,
+      exitCode: code,
+      summary: \`Agent \${run.agent} exited with code \${code}. \${stats.commitCount} commits, \${stats.filesChanged} files changed.\`,
+      ...(prUrl ? { prUrl, prNumber } : {}),
+    });
+
+    // Cleanup worktree (keep if PR was created)
+    if (!prUrl) {
+      removeWorktree(config, run.runId);
+    }
+  } catch (err) {
+    convexRun("completeRun", {
+      runId: run.runId,
+      status: "failed",
+      error: (err as Error).message,
+    });
+  } finally {
+    logStreamer.stop();
+    activeRuns--;
+    if (run.laneId) releaseLane(run.laneId, run.runId);
+  }
+}
+
+// Main loop
+console.log("[agent-ops] Starting runner...");
+console.log(\`[agent-ops] Poll interval: \${config.pollInterval}ms\`);
+console.log(\`[agent-ops] Max concurrent: \${config.maxConcurrentRuns}\`);
+
+setInterval(pollOnce, config.pollInterval);
+pollOnce(); // Run immediately
+`;
+    const lines = writeIfNotDry(join(base, "runner.ts"), content, ctx.dryRun);
+    return { file: "scripts/agent-ops/runner.ts", lines };
+}
+//# sourceMappingURL=agent-ops-scripts.js.map