@mndrk/agx 1.4.64 → 2.0.0-next.0

package/lib/cli/v2TaskRouting.js

@@ -0,0 +1,82 @@
+'use strict';
+
+const LEGACY_STAGE_KEYS = new Set([
+  'intake',
+  'planning',
+  'plan',
+  'execute',
+  'execution',
+  'verify',
+  'verification',
+  'resume',
+]);
+
+const V2_STAGE_KEYS = new Set(['intake', 'progress']);
+const V2_MODES = new Set(['simple', 'project']);
+
+function normalizeStage(stage) {
+  return String(stage || '').trim().toLowerCase();
+}
+
+function normalizeMode(mode) {
+  return String(mode || '').trim().toLowerCase();
+}
+
+function hasGraphId(task) {
+  const graphId = task?.graph_id || task?.graphId;
+  return typeof graphId === 'string' && graphId.trim().length > 0;
+}
+
+function hasGraphPayload(task) {
+  if (task?.execution_graph && typeof task.execution_graph === 'object') return true;
+  if (task?.executionGraph && typeof task.executionGraph === 'object') return true;
+  if (task?.graph && typeof task.graph === 'object') return true;
+  return false;
+}
+
+function classifyTaskExecutionTrack(task) {
+  const stageKey = normalizeStage(task?.stage);
+  const modeKey = normalizeMode(task?.mode || task?.graph_mode || task?.graphMode);
+
+  if (hasGraphId(task)) {
+    return { track: 'v2', reason: 'graph_id_present', stageKey, modeKey };
+  }
+
+  if (hasGraphPayload(task)) {
+    return { track: 'v2', reason: 'graph_payload_present', stageKey, modeKey };
+  }
+
+  if (V2_MODES.has(modeKey)) {
+    return { track: 'v2', reason: `graph_mode_${modeKey}`, stageKey, modeKey };
+  }
+
+  if (V2_STAGE_KEYS.has(stageKey)) {
+    return { track: 'v2', reason: `stage_${stageKey}`, stageKey, modeKey };
+  }
+
+  if (LEGACY_STAGE_KEYS.has(stageKey) || !stageKey) {
+    return { track: 'legacy', reason: stageKey ? `stage_${stageKey}` : 'stage_unknown', stageKey, modeKey };
+  }
+
+  // Unknown stage keys are treated as legacy for backward compatibility.
+  return { track: 'legacy', reason: `stage_${stageKey}`, stageKey, modeKey };
+}
+
+function buildV2RoutingError(task, trackInfo) {
+  const taskId = String(task?.id || '').trim() || 'unknown-task';
+  const stage = String(task?.stage || '').trim() || 'unknown';
+  const mode = String(task?.mode || task?.graph_mode || task?.graphMode || '').trim() || 'unknown';
+  const graphId = String(task?.graph_id || task?.graphId || '').trim() || 'none';
+  const reason = trackInfo?.reason || 'v2_task_detected';
+
+  return (
+    `[v2-required] Task ${taskId} must run via the v2 execution graph runtime `
+    + `(reason=${reason}, stage=${stage}, mode=${mode}, graph_id=${graphId}). `
+    + 'Legacy execute/verify execution is disabled for v2 tasks.'
+  );
+}
+
+module.exports = {
+  classifyTaskExecutionTrack,
+  buildV2RoutingError,
+};

package/lib/cloud/status.js

@@ -15,11 +15,13 @@ function normalizeStage(raw) {
  * @param {object} params
  * @param {string} [params.decision] - daemon decision: done|blocked|failed|not_done
  * @param {string} [params.newStage] - board stage after /api/queue/complete
+ * @param {string} [params.previousStage] - task stage before /api/queue/complete
  * @param {string} [params.nowIso] - override for deterministic tests
  * @returns {object|null} patch body for PATCH /api/tasks/:id
  */
-function buildCloudTaskTerminalPatch({ decision, newStage, nowIso } = {}) {
+function buildCloudTaskTerminalPatch({ decision, newStage, previousStage, nowIso } = {}) {
   const stage = normalizeStage(newStage);
+  const prevStage = normalizeStage(previousStage);
   const d = normalizeDecision(decision);
   const now = nowIso || new Date().toISOString();
 
@@ -29,10 +31,15 @@ function buildCloudTaskTerminalPatch({ decision, newStage, nowIso } = {}) {
     return { status: 'completed', completed_at: now };
   }
 
-  // NOTE: decision "done" means the CURRENT STAGE is complete, not the entire task.
-  // Only mark task as completed when stage reaches "done" (handled above).
-  // Do NOT mark completed just because decision is "done" - that prematurely
-  // ends tasks stuck in ideation/planning/execution.
+  // V2 tasks use intake -> progress -> done. If queue completion returns/keeps
+  // stage "progress" after a terminal "done" decision (common when final
+  // handoff gate is approved), force the stage transition.
+  if (d === 'done' && (stage === 'progress' || (!stage && prevStage === 'progress'))) {
+    return { stage: 'done', status: 'completed', completed_at: now };
+  }
+
+  // NOTE: for legacy tasks, decision "done" means the CURRENT STAGE is complete,
+  // not necessarily the whole task.
   if (d === 'failed') return { status: 'failed', completed_at: now };
   if (d === 'blocked') return { status: 'blocked' };
 
@@ -42,4 +49,3 @@ function buildCloudTaskTerminalPatch({ decision, newStage, nowIso } = {}) {
 }
 
 module.exports = { buildCloudTaskTerminalPatch };
-

package/lib/cloud-sync.js

@@ -0,0 +1,267 @@
+/**
+ * Cloud Sync - Sync local checkpoints to agx cloud API.
+ *
+ * Local-first with cloud sync:
+ * - Checkpoints are always saved locally first
+ * - Cloud sync happens asynchronously (best-effort)
+ * - Failures don't block local operations
+ *
+ * Sync strategy:
+ * - On checkpoint create: queue for cloud sync
+ * - Background worker processes queue
+ * - Retry with exponential backoff
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const SYNC_QUEUE_FILE = 'sync-queue.json';
+const MAX_RETRY_ATTEMPTS = 3;
+const RETRY_DELAY_MS = 1000;
+
+/**
+ * Load cloud config from environment or config file.
+ * @returns {{ apiUrl: string, token: string, userId: string } | null}
+ */
+function loadCloudConfig() {
+  // Try environment first
+  if (process.env.AGX_CLOUD_URL) {
+    return {
+      apiUrl: process.env.AGX_CLOUD_URL,
+      token: process.env.AGX_CLOUD_TOKEN || '',
+      userId: process.env.AGX_CLOUD_USER_ID || '',
+    };
+  }
+  
+  // Try config file
+  try {
+    const configPath = path.join(process.env.HOME || '', '.agx', 'cloud-config.json');
+    if (fs.existsSync(configPath)) {
+      return JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    }
+  } catch {
+    // Ignore
+  }
+  
+  return null;
+}
+
+/**
+ * Sync a checkpoint to the cloud.
+ * @param {object} options
+ * @param {string} options.taskId - Cloud task ID
+ * @param {object} options.checkpoint - Checkpoint data
+ * @param {function} options.onLog - Logging callback
+ * @returns {Promise<{ success: boolean, error?: string }>}
+ */
+async function syncCheckpointToCloud({ taskId, checkpoint, onLog = () => {} }) {
+  const config = loadCloudConfig();
+  if (!config?.apiUrl) {
+    return { success: false, error: 'No cloud config' };
+  }
+  
+  if (!taskId) {
+    return { success: false, error: 'No task ID' };
+  }
+  
+  try {
+    const url = `${config.apiUrl}/api/tasks/${taskId}/checkpoints`;
+    
+    // Prepare checkpoint for cloud (remove large fields)
+    const cloudCheckpoint = {
+      id: checkpoint.id,
+      label: checkpoint.label,
+      createdAt: checkpoint.createdAt,
+      iteration: checkpoint.iteration,
+      objective: checkpoint.objective,
+      // Include plan summary, not full plan
+      planStepCount: checkpoint.plan?.steps?.length || 0,
+      currentStep: checkpoint.plan?.currentStep,
+      // Include criteria summary
+      criteriaCount: checkpoint.criteria?.length || 0,
+      criteriaPassed: checkpoint.criteria?.filter(c => c.passed)?.length || 0,
+      // Git info (no patch content)
+      gitSha: checkpoint.git?.sha,
+      gitBranch: checkpoint.git?.branch,
+      gitDirty: checkpoint.git?.dirty,
+      // Blocked info
+      blockedAt: checkpoint.blockedAt,
+      blockedReason: checkpoint.reason,
+    };
+    
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        ...(config.token ? { 'Authorization': `Bearer ${config.token}` } : {}),
+        ...(config.userId ? { 'x-user-id': config.userId } : {}),
+      },
+      body: JSON.stringify(cloudCheckpoint),
+    });
+    
+    if (!response.ok) {
+      const error = `HTTP ${response.status}`;
+      onLog(`[cloud-sync] Failed to sync checkpoint: ${error}`);
+      return { success: false, error };
+    }
+    
+    onLog(`[cloud-sync] Checkpoint ${checkpoint.id} synced`);
+    return { success: true };
+  } catch (err) {
+    const error = err?.message || String(err);
+    onLog(`[cloud-sync] Sync error: ${error}`);
+    return { success: false, error };
+  }
+}
+
+/**
+ * Queue a checkpoint for cloud sync.
+ * @param {string} taskRoot - Local task directory
+ * @param {object} checkpoint - Checkpoint data
+ * @param {string} cloudTaskId - Cloud task ID
+ */
+async function queueForSync(taskRoot, checkpoint, cloudTaskId) {
+  if (!taskRoot || !checkpoint || !cloudTaskId) return;
+  
+  try {
+    const queuePath = path.join(taskRoot, SYNC_QUEUE_FILE);
+    let queue = [];
+    
+    if (fs.existsSync(queuePath)) {
+      try {
+        queue = JSON.parse(fs.readFileSync(queuePath, 'utf8'));
+      } catch {
+        queue = [];
+      }
+    }
+    
+    queue.push({
+      checkpointId: checkpoint.id,
+      cloudTaskId,
+      checkpoint,
+      queuedAt: new Date().toISOString(),
+      attempts: 0,
+    });
+    
+    fs.writeFileSync(queuePath, JSON.stringify(queue, null, 2));
+  } catch {
+    // Ignore queue errors
+  }
+}
+
+/**
+ * Process the sync queue for a task.
+ * @param {string} taskRoot - Local task directory
+ * @param {function} onLog - Logging callback
+ * @returns {Promise<{ synced: number, failed: number }>}
+ */
+async function processSyncQueue(taskRoot, onLog = () => {}) {
+  const queuePath = path.join(taskRoot, SYNC_QUEUE_FILE);
+  if (!fs.existsSync(queuePath)) {
+    return { synced: 0, failed: 0 };
+  }
+  
+  let queue;
+  try {
+    queue = JSON.parse(fs.readFileSync(queuePath, 'utf8'));
+  } catch {
+    return { synced: 0, failed: 0 };
+  }
+  
+  if (!Array.isArray(queue) || queue.length === 0) {
+    return { synced: 0, failed: 0 };
+  }
+  
+  let synced = 0;
+  let failed = 0;
+  const remaining = [];
+  
+  for (const item of queue) {
+    const result = await syncCheckpointToCloud({
+      taskId: item.cloudTaskId,
+      checkpoint: item.checkpoint,
+      onLog,
+    });
+    
+    if (result.success) {
+      synced++;
+    } else {
+      item.attempts++;
+      item.lastError = result.error;
+      item.lastAttempt = new Date().toISOString();
+      
+      if (item.attempts < MAX_RETRY_ATTEMPTS) {
+        remaining.push(item);
+      } else {
+        failed++;
+        onLog(`[cloud-sync] Checkpoint ${item.checkpointId} failed after ${MAX_RETRY_ATTEMPTS} attempts`);
+      }
+    }
+  }
+  
+  // Update queue with remaining items
+  if (remaining.length > 0) {
+    fs.writeFileSync(queuePath, JSON.stringify(remaining, null, 2));
+  } else {
+    try {
+      fs.unlinkSync(queuePath);
+    } catch {
+      // Ignore
+    }
+  }
+  
+  return { synced, failed };
+}
+
+/**
+ * Create a cloud syncer that automatically syncs checkpoints.
+ * @param {object} options
+ * @param {string} options.taskRoot - Local task directory
+ * @param {string} options.cloudTaskId - Cloud task ID
+ * @param {function} options.onLog - Logging callback
+ * @returns {{ sync: function, processQueue: function }}
+ */
+function createCloudSyncer(options = {}) {
+  const { taskRoot, cloudTaskId, onLog = () => {} } = options;
+  
+  return {
+    /**
+     * Sync a checkpoint immediately (best-effort).
+     */
+    async sync(checkpoint) {
+      if (!cloudTaskId) {
+        // Queue for later if no cloud task ID yet
+        await queueForSync(taskRoot, checkpoint, cloudTaskId);
+        return { success: false, queued: true };
+      }
+      
+      const result = await syncCheckpointToCloud({
+        taskId: cloudTaskId,
+        checkpoint,
+        onLog,
+      });
+      
+      if (!result.success) {
+        // Queue for retry
+        await queueForSync(taskRoot, checkpoint, cloudTaskId);
+      }
+      
+      return result;
+    },
+    
+    /**
+     * Process queued checkpoints.
+     */
+    async processQueue() {
+      return processSyncQueue(taskRoot, onLog);
+    },
+  };
+}
+
+module.exports = {
+  loadCloudConfig,
+  syncCheckpointToCloud,
+  queueForSync,
+  processSyncQueue,
+  createCloudSyncer,
+};

package/lib/commands/chat.js

@@ -0,0 +1,95 @@
+'use strict';
+
+const { c } = require('../ui/colors');
+const { loadConfig } = require('../cli/configStore');
+const { detectProviders } = require('../cli/providers');
+const { startChat } = require('../cli/chat');
+
+const PROVIDER_ALIASES = {
+  'c': 'claude', 'cl': 'claude', 'claude': 'claude',
+  'x': 'codex', 'codex': 'codex',
+  'g': 'gemini', 'gem': 'gemini', 'gemini': 'gemini',
+  'o': 'ollama', 'ol': 'ollama', 'ollama': 'ollama'
+};
+
+async function maybeHandleChatCommand({ cmd, args }) {
+  if (cmd !== 'chat') return false;
+
+  const config = loadConfig() || {};
+  const providers = detectProviders();
+
+  // agx chat [provider]
+  let providerArg = args[1];
+  let provider = null;
+  let model = null;
+  let taskId = null;
+
+  // Simple arg parsing
+  for (let i = 1; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--model' || arg === '-m') {
+      model = args[++i];
+      continue;
+    }
+    if (arg === '--task' || arg === '-t') {
+      taskId = args[++i];
+      continue;
+    }
+    if (arg === '--resume' || arg === '-r') {
+      // Resume last chat? Not implemented yet, but we can support --task
+      continue;
+    }
+    if (!arg.startsWith('-')) {
+      if (!provider) {
+        const alias = PROVIDER_ALIASES[arg.toLowerCase()];
+        if (alias) {
+          provider = alias;
+        } else {
+           // Maybe it's a model or something else?
+           // For now, assume unknown arg is provider if it looks like one
+           if (['claude', 'gemini', 'ollama', 'codex'].includes(arg)) {
+             provider = arg;
+           }
+        }
+      }
+    }
+  }
+
+  if (!provider) {
+    // Check config or pick one
+    provider = config.defaultProvider;
+    if (!provider) {
+      if (providers.claude) provider = 'claude';
+      else if (providers.gemini) provider = 'gemini';
+      else if (providers.codex) provider = 'codex';
+      else if (providers.ollama) provider = 'ollama';
+    }
+  }
+
+  if (!provider) {
+    console.log(`${c.yellow}No AI provider found or configured.${c.reset}`);
+    console.log(`Run ${c.cyan}agx init${c.reset} or install a provider.`);
+    return true;
+  }
+
+  // If the provider CLI is missing, startChat might fail or we should warn.
+  // startChat handles detection too, but let's be safe.
+  if (!providers[provider] && provider !== 'codex') { // codex might be via npx?
+      // warning handled in startChat
+  }
+
+  try {
+    await startChat({
+      provider,
+      model,
+      taskId,
+      configDir: config.configDir // Optional
+    });
+  } catch (err) {
+    console.log(`${c.red}Chat session failed:${c.reset} ${err.message}`);
+  }
+
+  return true;
+}
+
+module.exports = { maybeHandleChatCommand };

package/lib/commands/daemonBoard.js

@@ -44,6 +44,7 @@ async function maybeHandleDaemonBoardCommand({ cmd, args, ctx }) {
   const {
     c,
     loadCloudConfig,
+    cloudRequest,
     runCloudDaemonLoop,
     startDaemon,
     stopDaemon,
@@ -69,6 +70,7 @@ async function maybeHandleDaemonBoardCommand({ cmd, args, ctx }) {
     const daemonArgs = args.slice(1);
     const subcmd = daemonArgs[0] && !daemonArgs[0].startsWith('-') ? daemonArgs[0] : undefined;
     const wantsHelp = args.includes('--help') || args.includes('-h') || subcmd === 'help';
+    const wantsDryPick = args.includes('--dry-pick');
     const workersFlagIdx = args.findIndex((arg) => arg === '-w' || arg === '--workers' || arg === '--max-workers');
     let maxWorkers;
     if (workersFlagIdx !== -1) {
@@ -82,6 +84,8 @@ async function maybeHandleDaemonBoardCommand({ cmd, args, ctx }) {
       maxWorkers = parsed;
     }
 
+    const wantsTail = args.includes('-t') || args.includes('--tail');
+
     const daemonOptions = {
       maxWorkers,
     };
@@ -90,11 +94,116 @@ async function maybeHandleDaemonBoardCommand({ cmd, args, ctx }) {
       console.log(`${c.bold}agx daemon${c.reset} - Local cloud worker\n`);
       console.log(`  agx daemon            Run local daemon loop in foreground`);
       console.log(`  agx daemon start      Start local daemon loop in background`);
+      console.log(`  agx daemon restart    Stop + start daemon`);
       console.log(`  agx daemon stop       Stop background worker`);
       console.log(`  agx daemon status     Check if running`);
       console.log(`  agx daemon logs       Show recent logs`);
       console.log(`  agx daemon tail       Live tail daemon logs`);
+      console.log(`  agx daemon pick       Preview next task candidate (no claim)`);
+      console.log(`  agx daemon --dry-pick Preview next task candidate (no claim)`);
       console.log(`  agx daemon -w, --workers <n>  Execution worker count (default: 1)`);
+      console.log(`  agx daemon start -t   Start and tail logs`);
+      console.log(`  agx daemon restart -t Restart and tail logs`);
+      process.exit(0);
+    }
+
+    if (subcmd === 'pick' || wantsDryPick) {
+      const cloudConfig = loadCloudConfig();
+      if (!cloudConfig?.apiUrl) {
+        console.log(`${c.red}Cloud API URL not configured.${c.reset} Set AGX_CLOUD_URL (default is http://localhost:41741)`);
+        process.exit(1);
+      }
+      if (typeof cloudRequest !== 'function') {
+        console.log(`${c.red}Cloud client unavailable for dry pick.${c.reset}`);
+        process.exit(1);
+      }
+
+      const toPriorityRank = (task) => {
+        const raw = task?.priority;
+        const n = Number(raw);
+        return Number.isFinite(n) ? n : Number.POSITIVE_INFINITY;
+      };
+
+      const toCreatedMs = (task) => {
+        const ms = Date.parse(String(task?.created_at || ''));
+        return Number.isFinite(ms) ? ms : Number.POSITIVE_INFINITY;
+      };
+
+      const formatTaskLabel = (task) => task?.title || task?.slug || task?.id || 'Untitled';
+      const toDependencySummary = (deps = []) => {
+        const unresolved = deps.filter((dep) => String(dep?.status || '') !== 'completed');
+        if (!unresolved.length) return null;
+        const shown = unresolved.slice(0, 3).map((dep) => {
+          const label = dep?.title || dep?.slug || dep?.id || '(unknown)';
+          const suffix = dep?.status ? ` (${dep.status})` : '';
+          return `${label}${suffix}`;
+        });
+        const extra = unresolved.length > 3 ? ` +${unresolved.length - 3} more` : '';
+        return `Waiting on dependencies: ${shown.join(', ')}${extra}`;
+      };
+
+      let queuedTasks = [];
+      try {
+        const response = await cloudRequest('GET', '/api/tasks?status=queued');
+        queuedTasks = Array.isArray(response?.tasks) ? response.tasks : [];
+      } catch (err) {
+        console.log(`${c.red}Failed to fetch queued tasks:${c.reset} ${err?.message || err}`);
+        process.exit(1);
+      }
+
+      const candidates = queuedTasks
+        .filter((task) => String(task?.stage || '').toLowerCase() !== 'done')
+        .sort((a, b) => {
+          const prio = toPriorityRank(a) - toPriorityRank(b);
+          if (prio !== 0) return prio;
+          return toCreatedMs(a) - toCreatedMs(b);
+        })
+        .slice(0, 25);
+
+      if (!candidates.length) {
+        console.log(`${c.dim}No queued tasks available for pickup.${c.reset}`);
+        process.exit(0);
+      }
+
+      let selected = null;
+      const skipped = [];
+      for (const candidate of candidates) {
+        let dependsOnTasks = [];
+        try {
+          const depResponse = await cloudRequest('GET', `/api/tasks/${encodeURIComponent(candidate.id)}/dependencies`);
+          dependsOnTasks = Array.isArray(depResponse?.depends_on_tasks) ? depResponse.depends_on_tasks : [];
+        } catch {
+          dependsOnTasks = [];
+        }
+
+        const blockedReason = toDependencySummary(dependsOnTasks);
+        if (blockedReason) {
+          skipped.push({ task: candidate, reason: blockedReason });
+          continue;
+        }
+        selected = candidate;
+        break;
+      }
+
+      if (!selected) {
+        console.log(`${c.yellow}No runnable queued tasks right now.${c.reset}`);
+        if (skipped.length) {
+          const first = skipped[0];
+          console.log(`${c.dim}Top blocked candidate:${c.reset} ${formatTaskLabel(first.task)} (${first.task.id})`);
+          console.log(`${c.dim}${first.reason}${c.reset}`);
+        }
+        process.exit(0);
+      }
+
+      console.log(`${c.green}Next daemon pick (dry):${c.reset} ${formatTaskLabel(selected)}`);
+      console.log(`  ID: ${selected.id}`);
+      console.log(`  Stage: ${selected.stage || 'unknown'}`);
+      console.log(`  Status: ${selected.status || 'queued'}`);
+      console.log(`  Priority: ${selected.priority ?? 'none'}`);
+      console.log(`  Created: ${selected.created_at || 'unknown'}`);
+      if (skipped.length) {
+        console.log(`${c.dim}Skipped ${skipped.length} blocked queued task(s) before this candidate.${c.reset}`);
+      }
       process.exit(0);
     }
 
@@ -117,6 +226,29 @@ async function maybeHandleDaemonBoardCommand({ cmd, args, ctx }) {
 
     if (subcmd === 'start') {
       startDaemon(daemonOptions);
+      if (wantsTail) {
+        // Give daemon a moment to create log file
+        await new Promise(r => setTimeout(r, 500));
+        if (fs.existsSync(DAEMON_LOG_FILE)) {
+          console.log(`${c.dim}Tailing ${DAEMON_LOG_FILE}... (Ctrl+C to stop)${c.reset}\n`);
+          const tail = execa('tail', ['-f', DAEMON_LOG_FILE], { stdio: 'inherit', reject: false });
+          tail.on('close', () => process.exit(0));
+          return true;
+        }
+      }
+      process.exit(0);
+    } else if (subcmd === 'restart') {
+      await stopDaemon();
+      startDaemon(daemonOptions);
+      if (wantsTail) {
+        await new Promise(r => setTimeout(r, 500));
+        if (fs.existsSync(DAEMON_LOG_FILE)) {
+          console.log(`${c.dim}Tailing ${DAEMON_LOG_FILE}... (Ctrl+C to stop)${c.reset}\n`);
+          const tail = execa('tail', ['-f', DAEMON_LOG_FILE], { stdio: 'inherit', reject: false });
+          tail.on('close', () => process.exit(0));
+          return true;
+        }
+      }
       process.exit(0);
     } else if (subcmd === 'stop') {
       await stopDaemon();