@mndrk/agx 2.0.33 → 2.0.34

package/cloud-runtime/standalone/src/graph/llm-review.ts

@@ -8,6 +8,12 @@ export type ReviewDispatcher = (
   graph: ExecutionGraph,
 ) => Promise<WorkDispatchResult>;
 
+export interface ReviewerProfile {
+  name?: string;
+  voice?: string;
+  seed?: string;
+}
+
 /**
  * Fetches the git diff for the current working directory.
  */
@@ -46,6 +52,7 @@ export function buildReviewWorkNode(
   root: RootNode,
   diff: string,
   gateId: string,
+  reviewer?: ReviewerProfile,
 ): WorkNode {
   const criteriaSection = root.criteria?.length
     ? `\n\nAcceptance Criteria:\n${root.criteria.map((c, i) => `${i + 1}. ${c}`).join('\n')}`
@@ -55,13 +62,22 @@ export function buildReviewWorkNode(
     ? diff.slice(0, 30_000) + '\n\n... (diff truncated)'
     : diff;
 
+  const reviewerContext = [
+    reviewer?.name?.trim() ? `Reviewer: ${reviewer.name.trim()}` : null,
+    reviewer?.voice?.trim() ? `Voice: ${reviewer.voice.trim()}` : null,
+    reviewer?.seed?.trim() ? `Core orientation: ${reviewer.seed.trim()}` : null,
+  ].filter(Boolean);
+
   return {
     type: 'work',
     status: 'pending',
     workType: 'spike',
     title: `Quality gate review: ${root.title}`,
     description: [
-      'You are a code reviewer. Evaluate whether the code changes satisfy the task objective.',
+      'You are reviewing this change against the task objective.',
+      reviewerContext.length > 0
+        ? `Preserve the reviewer\'s distinct perspective instead of flattening into generic review language.\n${reviewerContext.join('\n')}`
+        : 'Preserve your configured reviewer voice and perspective. Do not flatten into generic review language.',
       '',
       `## Task Objective`,
       root.objective,
@@ -96,6 +112,7 @@ export async function dispatchLlmReview(
   gateId: string,
   dispatcher: ReviewDispatcher,
   cwd?: string,
+  reviewer?: ReviewerProfile,
 ): Promise<ExecutedCheckResult> {
   const root = findRootNode(graph);
   if (!root) {
@@ -107,7 +124,7 @@ export async function dispatchLlmReview(
     return makeSkipResult('LLM review skipped: no changes detected');
   }
 
-  const reviewNode = buildReviewWorkNode(root, diff, gateId);
+  const reviewNode = buildReviewWorkNode(root, diff, gateId, reviewer);
   const result = await dispatcher(reviewNode, graph);
 
   if (result.status === 'success') {

package/cloud-runtime/standalone/src/prompt-scheduler/cron.ts

@@ -0,0 +1,46 @@
+import { toCronExpr } from '../graph/nl-schedule';
+import { CronExpressionParser } from 'cron-parser';
+
+export interface ParsedCadence {
+  cronExpr: string;
+  cadence: string;
+}
+
+export function parseCadence(input: string): ParsedCadence | null {
+  const trimmed = input.trim();
+  if (!trimmed) return null;
+
+  const nlResult = toCronExpr(trimmed);
+  if (nlResult) {
+    return { cronExpr: nlResult.cronExpr, cadence: nlResult.cadence };
+  }
+
+  // Try parsing as raw cron (5 fields)
+  if (isValidCron(trimmed)) {
+    return { cronExpr: trimmed, cadence: trimmed };
+  }
+
+  return null;
+}
+
+export function computeNextRun(cronExpr: string, fromMs?: number): number | null {
+  try {
+    const expr = CronExpressionParser.parse(cronExpr, {
+      currentDate: fromMs ? new Date(fromMs) : new Date(),
+    });
+    return expr.next().toDate().getTime();
+  } catch {
+    return null;
+  }
+}
+
+function isValidCron(expr: string): boolean {
+  const parts = expr.split(/\s+/);
+  if (parts.length !== 5) return false;
+  try {
+    CronExpressionParser.parse(expr);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/cloud-runtime/standalone/src/prompt-scheduler/engine.ts

@@ -0,0 +1,87 @@
+import type { PromptJob, PromptRun } from './types';
+import type { PromptJobStore } from './store';
+import { computeNextRun } from './cron';
+
+export interface PollResult {
+  queued: PromptRun[];
+  skipped: Array<{ jobId: string; reason: string }>;
+}
+
+export function pollDueJobs(store: PromptJobStore, now: number = Date.now()): PollResult {
+  // Heal active jobs with null nextRunAt
+  const allJobs = store.listJobs({ state: 'active' as any });
+  for (const job of allJobs) {
+    if (job.nextRunAt === null && job.cronExpr) {
+      const nextRunAt = computeNextRunAt(job, now);
+      if (nextRunAt) store.updateJob(job.id, { nextRunAt });
+    }
+  }
+
+  const dueJobs = store.getDueJobs(now);
+  const queued: PromptRun[] = [];
+  const skipped: Array<{ jobId: string; reason: string }> = [];
+
+  for (const job of dueJobs) {
+    if (job.overlapPolicy === 'skip' && store.hasRunningRun(job.id)) {
+      skipped.push({ jobId: job.id, reason: 'overlap_skip' });
+      const nextRunAt = computeNextRunAt(job, now);
+      store.updateJob(job.id, { nextRunAt });
+      continue;
+    }
+
+    // Handle catch-up policy for missed runs
+    const missedCount = countMissedOccurrences(job, now);
+
+    if (job.catchUpPolicy === 'skip' && missedCount > 1) {
+      // Skip all missed, just advance to next future tick
+      skipped.push({ jobId: job.id, reason: `catch_up_skip (${missedCount} missed)` });
+      const nextRunAt = computeNextRunAt(job, now);
+      store.updateJob(job.id, { nextRunAt, lastRunAt: now });
+      continue;
+    }
+
+    if (job.catchUpPolicy === 'replay_all' && missedCount > 1) {
+      // Queue one run per missed occurrence
+      for (let i = 0; i < missedCount; i++) {
+        const run = store.createRun(job.id);
+        queued.push(run);
+      }
+    } else {
+      // fire_once (default): just run once regardless of how many were missed
+      const run = store.createRun(job.id);
+      queued.push(run);
+    }
+
+    const nextRunAt = computeNextRunAt(job, now);
+    store.updateJob(job.id, { nextRunAt, lastRunAt: now });
+  }
+
+  return { queued, skipped };
+}
+
+/** Compute next run based on trigger type */
+function computeNextRunAt(job: { triggerType: string; checkEveryMs: number; cronExpr: string }, now: number): number | null {
+  if (job.triggerType === 'condition') {
+    return now + job.checkEveryMs;
+  }
+  return computeNextRun(job.cronExpr, now);
+}
+
+/** Count how many cron occurrences were missed between lastRunAt/nextRunAt and now */
+function countMissedOccurrences(job: PromptJob, now: number): number {
+  if (job.triggerType === 'condition') return 1;
+  if (!job.nextRunAt) return 1;
+
+  let count = 0;
+  let cursor = job.nextRunAt;
+  const maxCount = 100; // safety cap
+
+  while (cursor <= now && count < maxCount) {
+    count++;
+    const next = computeNextRun(job.cronExpr, cursor);
+    if (!next || next <= cursor) break;
+    cursor = next;
+  }
+
+  return Math.max(1, count);
+}

package/cloud-runtime/standalone/src/prompt-scheduler/get-store.ts

@@ -0,0 +1,36 @@
+import { PromptJobStore } from './store';
+import { readFileSync } from 'fs';
+import path from 'path';
+import { getSQLiteDb } from '@/lib/sqlite-query-adapter';
+
+let _store: PromptJobStore | null = null;
+
+export function getPromptJobStore(): PromptJobStore {
+  if (!_store) {
+    const db = getSQLiteDb();
+    const tableExists = db
+      .prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='prompt_jobs'")
+      .get();
+    if (!tableExists) {
+      const migration = readFileSync(
+        path.join(process.cwd(), 'db/sqlite/002_prompt_scheduler_schema.sql'),
+        'utf-8',
+      );
+      db.exec(migration);
+    } else {
+      // Run v2 migration if provider column doesn't exist yet
+      const hasProvider = db
+        .prepare("SELECT 1 FROM pragma_table_info('prompt_jobs') WHERE name='catch_up_policy'")
+        .get();
+      if (!hasProvider) {
+        const v2Migration = readFileSync(
+          path.join(process.cwd(), 'db/sqlite/003_prompt_scheduler_v2.sql'),
+          'utf-8',
+        );
+        db.exec(v2Migration);
+      }
+    }
+    _store = new PromptJobStore(db);
+  }
+  return _store;
+}

package/cloud-runtime/standalone/src/prompt-scheduler/runner.ts

@@ -0,0 +1,144 @@
+import { spawn } from 'child_process';
+
+export interface RunResult {
+  status: 'success' | 'failed' | 'cancelled';
+  output: string;
+  error: string;
+  durationMs: number;
+}
+
+export interface ExecuteRunOptions {
+  provider: string;
+  model: string;
+  cliArgs: string;
+  prompt: string;
+  cancelCheckSec: number;
+  isCancelled: () => Promise<boolean>;
+  onStart: () => void;
+  onComplete: (result: RunResult) => void;
+}
+
+interface CliCommand {
+  cmd: string;
+  args: string[];
+}
+
+const KNOWN_PROVIDERS: Record<string, { cmd: string; promptFlag: string; modelFlag?: string }> = {
+  claude: { cmd: 'claude', promptFlag: '-p', modelFlag: '--model' },
+  codex: { cmd: 'codex', promptFlag: '-p' },
+  gemini: { cmd: 'gemini', promptFlag: '-p', modelFlag: '--model' },
+};
+
+export function buildCliCommand(provider: string, prompt: string, model?: string, cliArgs?: string): CliCommand {
+  const known = KNOWN_PROVIDERS[provider];
+  if (known) {
+    const args: string[] = [];
+    if (model && known.modelFlag) {
+      args.push(known.modelFlag, model);
+    }
+    if (cliArgs) {
+      args.push(...cliArgs.split(/\s+/).filter(Boolean));
+    }
+    args.push(known.promptFlag, prompt);
+    return { cmd: known.cmd, args };
+  }
+
+  // Custom provider: treat as raw command
+  const parts = provider.split(' ');
+  const cmd = parts[0];
+  const baseArgs = parts.slice(1);
+
+  if (cliArgs) {
+    baseArgs.push(...cliArgs.split(/\s+/).filter(Boolean));
+  }
+
+  if (provider.includes('{prompt}')) {
+    const args = baseArgs.map((part) => part.replace('{prompt}', prompt));
+    return { cmd, args };
+  }
+
+  return { cmd, args: [...baseArgs, prompt] };
+}
+
+export function executeRun(opts: ExecuteRunOptions): void {
+  const { provider, model, cliArgs, prompt, cancelCheckSec, isCancelled, onStart, onComplete } = opts;
+
+  const { cmd, args } = buildCliCommand(provider, prompt, model, cliArgs);
+  const startMs = Date.now();
+
+  onStart();
+
+  let stdout = '';
+  let stderr = '';
+  let done = false;
+  let cancelInterval: ReturnType<typeof setInterval> | null = null;
+
+  const child = spawn(cmd, args, {
+    stdio: ['ignore', 'pipe', 'pipe'],
+    shell: false,
+  });
+
+  child.stdout.on('data', (chunk: Buffer) => {
+    stdout += chunk.toString();
+  });
+
+  child.stderr.on('data', (chunk: Buffer) => {
+    stderr += chunk.toString();
+  });
+
+  const finish = (result: RunResult) => {
+    if (done) return;
+    done = true;
+    if (cancelInterval !== null) {
+      clearInterval(cancelInterval);
+      cancelInterval = null;
+    }
+    onComplete(result);
+  };
+
+  child.on('error', (err: Error) => {
+    finish({
+      status: 'failed',
+      output: stdout,
+      error: err.message,
+      durationMs: Date.now() - startMs,
+    });
+  });
+
+  child.on('close', (code: number | null) => {
+    if (done) return;
+    const status = code === 0 ? 'success' : 'failed';
+    finish({
+      status,
+      output: stdout,
+      error: stderr,
+      durationMs: Date.now() - startMs,
+    });
+  });
+
+  // Set up cancel checking interval
+  const intervalMs = cancelCheckSec * 1000;
+  cancelInterval = setInterval(async () => {
+    if (done) {
+      if (cancelInterval !== null) {
+        clearInterval(cancelInterval);
+        cancelInterval = null;
+      }
+      return;
+    }
+    try {
+      const cancelled = await isCancelled();
+      if (cancelled && !done) {
+        child.kill('SIGTERM');
+        finish({
+          status: 'cancelled',
+          output: stdout,
+          error: stderr,
+          durationMs: Date.now() - startMs,
+        });
+      }
+    } catch {
+      // ignore cancel check errors
+    }
+  }, intervalMs);
+}

package/cloud-runtime/standalone/src/prompt-scheduler/store.ts

@@ -0,0 +1,327 @@
+import { randomUUID } from 'crypto';
+import type Database from 'better-sqlite3';
+import { computeNextTickFromCron } from '../graph/scheduler';
+import type {
+  PromptJob,
+  PromptRun,
+  PromptJobState,
+  RunStatus,
+  CreatePromptJobInput,
+  UpdatePromptJobInput,
+} from './types';
+
+// ── Row shapes from SQLite ────────────────────────────────────────────────────
+
+interface PromptJobRow {
+  id: string;
+  name: string;
+  prompt: string;
+  cli: string;
+  agent_id: string | null;
+  project_id: string | null;
+  provider: string;
+  model: string;
+  cli_args: string;
+  cron_expr: string;
+  cadence: string;
+  state: string;
+  overlap_policy: string;
+  catch_up_policy: string;
+  cancel_check_sec: number;
+  trigger_type: string;
+  condition: string;
+  check_every_ms: number;
+  next_run_at: number | null;
+  last_run_at: number | null;
+  last_outcome: string | null;
+  created_at: string;
+  updated_at: string;
+}
+
+interface PromptRunRow {
+  id: string;
+  job_id: string;
+  status: string;
+  output: string | null;
+  error: string | null;
+  duration_ms: number | null;
+  started_at: string | null;
+  finished_at: string | null;
+  cancelled_at: string | null;
+  created_at: string;
+}
+
+// ── Field mappers ─────────────────────────────────────────────────────────────
+
+function rowToJob(row: PromptJobRow): PromptJob {
+  return {
+    id: row.id,
+    name: row.name,
+    prompt: row.prompt,
+    agentId: row.agent_id || '',
+    projectId: row.project_id || '',
+    provider: row.provider || row.cli || 'claude',
+    model: row.model || '',
+    cliArgs: row.cli_args || '',
+    cronExpr: row.cron_expr,
+    cadence: row.cadence,
+    state: row.state as PromptJobState,
+    overlapPolicy: row.overlap_policy as PromptJob['overlapPolicy'],
+    catchUpPolicy: (row.catch_up_policy || 'fire_once') as PromptJob['catchUpPolicy'],
+    cancelCheckSec: row.cancel_check_sec,
+    triggerType: (row.trigger_type || 'scheduled') as PromptJob['triggerType'],
+    condition: row.condition || '',
+    checkEveryMs: row.check_every_ms || 300000,
+    nextRunAt: row.next_run_at,
+    lastRunAt: row.last_run_at,
+    lastOutcome: row.last_outcome as RunStatus | null,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+  };
+}
+
+function rowToRun(row: PromptRunRow): PromptRun {
+  return {
+    id: row.id,
+    jobId: row.job_id,
+    status: row.status as RunStatus,
+    output: row.output,
+    error: row.error,
+    durationMs: row.duration_ms,
+    startedAt: row.started_at,
+    finishedAt: row.finished_at,
+    cancelledAt: row.cancelled_at,
+    createdAt: row.created_at,
+  };
+}
+
+// ── Store ─────────────────────────────────────────────────────────────────────
+
+export class PromptJobStore {
+  constructor(private readonly db: Database.Database) {}
+
+  // ── Job operations ──────────────────────────────────────────────────────────
+
+  createJob(input: CreatePromptJobInput): PromptJob {
+    const id = randomUUID();
+    const cadence = input.cadence;
+    const cronExpr = input.cronExpr || cadence;
+    const triggerType = input.triggerType ?? 'scheduled';
+    const provider = input.provider ?? 'claude';
+
+    // For condition triggers, nextRunAt is based on checkEveryMs from now
+    // For scheduled triggers, nextRunAt is the next cron tick
+    let nextRunAt: number | null;
+    if (triggerType === 'condition') {
+      nextRunAt = Date.now() + (input.checkEveryMs ?? 300000);
+    } else {
+      nextRunAt = computeNextTickFromCron(cronExpr) ?? null;
+    }
+
+    this.db
+      .prepare(
+        `INSERT INTO prompt_jobs (id, name, prompt, cli, agent_id, project_id, provider, model, cli_args, cron_expr, cadence, overlap_policy, catch_up_policy, cancel_check_sec, trigger_type, condition, check_every_ms, next_run_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      )
+      .run(
+        id,
+        input.name,
+        input.prompt,
+        provider,
+        input.agentId || null,
+        input.projectId || null,
+        provider,
+        input.model ?? '',
+        input.cliArgs ?? '',
+        cronExpr,
+        cadence,
+        input.overlapPolicy ?? 'skip',
+        input.catchUpPolicy ?? 'fire_once',
+        input.cancelCheckSec ?? 5,
+        triggerType,
+        input.condition ?? '',
+        input.checkEveryMs ?? 300000,
+        nextRunAt,
+      );
+
+    return this.getJob(id) as PromptJob;
+  }
+
+  getJob(id: string): PromptJob | null {
+    const row = this.db
+      .prepare('SELECT * FROM prompt_jobs WHERE id = ?')
+      .get(id) as PromptJobRow | undefined;
+    return row ? rowToJob(row) : null;
+  }
+
+  listJobs(filter?: { state?: PromptJobState; projectId?: string }): PromptJob[] {
+    let sql = 'SELECT * FROM prompt_jobs';
+    const conditions: string[] = [];
+    const params: string[] = [];
+    if (filter?.state) {
+      conditions.push('state = ?');
+      params.push(filter.state);
+    }
+    if (filter?.projectId) {
+      conditions.push('project_id = ?');
+      params.push(filter.projectId);
+    }
+    if (conditions.length > 0) sql += ' WHERE ' + conditions.join(' AND ');
+    sql += ' ORDER BY created_at DESC';
+    const rows = this.db.prepare(sql).all(...params) as PromptJobRow[];
+    return rows.map(rowToJob);
+  }
+
+  updateJob(id: string, updates: UpdatePromptJobInput): PromptJob | null {
+    const fieldMap: Record<string, string> = {
+      name: 'name',
+      prompt: 'prompt',
+      cli: 'cli',
+      agentId: 'agent_id',
+      projectId: 'project_id',
+      provider: 'provider',
+      cronExpr: 'cron_expr',
+      model: 'model',
+      cliArgs: 'cli_args',
+      cadence: 'cadence',
+      state: 'state',
+      overlapPolicy: 'overlap_policy',
+      catchUpPolicy: 'catch_up_policy',
+      cancelCheckSec: 'cancel_check_sec',
+      triggerType: 'trigger_type',
+      condition: 'condition',
+      checkEveryMs: 'check_every_ms',
+      nextRunAt: 'next_run_at',
+      lastRunAt: 'last_run_at',
+      lastOutcome: 'last_outcome',
+    };
+
+    const setClauses: string[] = [];
+    const values: unknown[] = [];
+
+    for (const [key, value] of Object.entries(updates)) {
+      const col = fieldMap[key];
+      if (!col || value === undefined) continue;
+      setClauses.push(`${col} = ?`);
+      values.push(value);
+
+      // If cadence changed, also recompute cron_expr and next_run_at
+      if (key === 'cadence' && typeof value === 'string') {
+        setClauses.push('cron_expr = ?');
+        values.push(value);
+        const nextRunAt = computeNextTickFromCron(value) ?? null;
+        setClauses.push('next_run_at = ?');
+        values.push(nextRunAt);
+      }
+    }
+
+    if (setClauses.length === 0) {
+      return this.getJob(id);
+    }
+
+    setClauses.push("updated_at = datetime('now')");
+    values.push(id);
+
+    this.db
+      .prepare(`UPDATE prompt_jobs SET ${setClauses.join(', ')} WHERE id = ?`)
+      .run(...values);
+
+    return this.getJob(id);
+  }
+
+  deleteJob(id: string): void {
+    this.db.prepare('DELETE FROM prompt_jobs WHERE id = ?').run(id);
+  }
+
+  getDueJobs(now: number = Date.now()): PromptJob[] {
+    const nowSec = Math.floor(now / 1000);
+    // next_run_at is stored as epoch ms; compare directly
+    const rows = this.db
+      .prepare(
+        `SELECT * FROM prompt_jobs
+         WHERE state = 'active'
+           AND next_run_at IS NOT NULL
+           AND next_run_at <= ?
+         ORDER BY next_run_at ASC`,
+      )
+      .all(now) as PromptJobRow[];
+    return rows.map(rowToJob);
+  }
+
+  // ── Run operations ──────────────────────────────────────────────────────────
+
+  createRun(jobId: string): PromptRun {
+    const id = randomUUID();
+    this.db
+      .prepare(
+        `INSERT INTO prompt_runs (id, job_id) VALUES (?, ?)`,
+      )
+      .run(id, jobId);
+    return this.getRun(id) as PromptRun;
+  }
+
+  getRun(id: string): PromptRun | null {
+    const row = this.db
+      .prepare('SELECT * FROM prompt_runs WHERE id = ?')
+      .get(id) as PromptRunRow | undefined;
+    return row ? rowToRun(row) : null;
+  }
+
+  listRuns(jobId: string, limit = 50): PromptRun[] {
+    const rows = this.db
+      .prepare(
+        `SELECT * FROM prompt_runs WHERE job_id = ? ORDER BY created_at DESC LIMIT ?`,
+      )
+      .all(jobId, limit) as PromptRunRow[];
+    return rows.map(rowToRun);
+  }
+
+  updateRun(id: string, updates: Partial<Omit<PromptRun, 'id' | 'jobId' | 'createdAt'>>): PromptRun | null {
+    const fieldMap: Record<string, string> = {
+      status: 'status',
+      output: 'output',
+      error: 'error',
+      durationMs: 'duration_ms',
+      startedAt: 'started_at',
+      finishedAt: 'finished_at',
+      cancelledAt: 'cancelled_at',
+    };
+
+    const setClauses: string[] = [];
+    const values: unknown[] = [];
+
+    for (const [key, value] of Object.entries(updates)) {
+      const col = fieldMap[key];
+      if (!col) continue;
+      setClauses.push(`${col} = ?`);
+      values.push(value ?? null);
+    }
+
+    if (setClauses.length === 0) {
+      return this.getRun(id);
+    }
+
+    values.push(id);
+    this.db
+      .prepare(`UPDATE prompt_runs SET ${setClauses.join(', ')} WHERE id = ?`)
+      .run(...values);
+
+    return this.getRun(id);
+  }
+
+  hasRunningRun(jobId: string): boolean {
+    const row = this.db
+      .prepare(
+        `SELECT id FROM prompt_runs WHERE job_id = ? AND status IN ('queued', 'running') LIMIT 1`,
+      )
+      .get(jobId);
+    return row !== undefined;
+  }
+
+  isRunCancelled(runId: string): boolean {
+    const row = this.db
+      .prepare(`SELECT status FROM prompt_runs WHERE id = ?`)
+      .get(runId) as { status: string } | undefined;
+    return row?.status === 'cancelled';
+  }
+}