@mndrk/agx 1.4.64 → 2.0.0-next.0

package/lib/executor.js

@@ -11,6 +11,17 @@ const path = require('path');
 const os = require('os');
 const { commandExists } = require('./proc/commandExists');
 const { interpolate, DEFAULT_STAGE_PROMPT, PROJECT_CONTEXT, EXECUTOR_PROMPT } = require('./prompts/templates');
+const { createCheckpoint, checkpointsPath } = require('./storage/checkpoints');
+const { captureGitState } = require('./storage/git');
+const { createCloudSyncer } = require('./cloud-sync');
+const { runVerifyGate } = require('./verify-gate');
+
+let json5;
+try {
+  json5 = require('json5');
+} catch {
+  json5 = null;
+}
 
 // Engine configurations
 const ENGINES = {
@@ -99,8 +110,161 @@ async function executeTask(options) {
     onLog,
     onProgress,
     onStream,
+    projectSlug,
+    taskSlug,
+    iteration = 1,
+    objective,
+    constraints,
+    dontRepeat,
+    verifyFailures,
+    plan: initialPlan,
+    criteria: initialCriteria,
+    repoPath,
   } = options;
 
+  const iterationValue = (() => {
+    const parsed = Number(iteration);
+    if (Number.isFinite(parsed) && parsed >= 1) {
+      return parsed;
+    }
+    return 1;
+  })();
+
+  const gitCwd = typeof repoPath === 'string' && repoPath ? repoPath : process.cwd();
+
+  const executionState = {
+    plan: initialPlan || null,
+    criteria: initialCriteria || null,
+  };
+  const pendingPersistence = new Set();
+  const cloudSyncer = (() => {
+    if (!projectSlug || !taskSlug || !options.cloudTaskId) return null;
+    try {
+      return createCloudSyncer({
+        taskRoot: path.dirname(checkpointsPath(projectSlug, taskSlug)),
+        cloudTaskId: options.cloudTaskId,
+        onLog,
+      });
+    } catch (err) {
+      onLog?.(`[cloud-sync] init failed: ${err?.message || err}`);
+      return null;
+    }
+  })();
+
+  const ensureDefaultPlan = () => {
+    if (!executionState.plan && iterationValue === 1) {
+      executionState.plan = createDefaultPlan();
+    }
+  };
+
+  const captureGitStateSafe = () => {
+    try {
+      return captureGitState(gitCwd);
+    } catch (err) {
+      onLog?.(`[checkpoint] unable to record git state: ${err?.message || err}`);
+      return null;
+    }
+  };
+
+  const persistCheckpoint = async (label) => {
+    if (!projectSlug || !taskSlug) return;
+    const trimmedLabel = (label || '').toString().trim();
+    if (!trimmedLabel) return;
+
+    ensureDefaultPlan();
+    const checkpointPayload = {
+      label: trimmedLabel,
+      iteration: iterationValue,
+      objective,
+      plan: executionState.plan,
+      criteria: executionState.criteria,
+      constraints,
+      dontRepeat,
+      verifyFailures,
+      git: captureGitStateSafe(),
+    };
+
+    try {
+      const checkpoint = await createCheckpoint(projectSlug, taskSlug, checkpointPayload);
+      if (cloudSyncer && checkpoint) {
+        try {
+          await cloudSyncer.sync(checkpoint);
+        } catch (err) {
+          onLog?.(`[cloud-sync] sync failed: ${err?.message || err}`);
+        }
+      }
+    } catch (err) {
+      onLog?.(`[checkpoint] failed to persist: ${err?.message || err}`);
+    }
+  };
+
+  const trackPersistence = (promise) => {
+    if (!promise || typeof promise.then !== 'function') return;
+    pendingPersistence.add(promise);
+    promise.finally(() => pendingPersistence.delete(promise));
+  };
+
+  const flushPendingPersistence = async () => {
+    if (pendingPersistence.size === 0) return;
+    const pending = Array.from(pendingPersistence);
+    onLog?.(`[checkpoint] waiting for ${pending.length} pending persistence operation(s)`);
+    await Promise.allSettled(pending);
+  };
+
+  const handleCheckpoint = (label) => {
+    trackPersistence(persistCheckpoint(label));
+  };
+
+  const handlePlanJson = (plan) => {
+    if (plan && typeof plan === 'object') {
+      executionState.plan = plan;
+    }
+  };
+
+  const handleCriteriaJson = (criteria) => {
+    if (criteria && typeof criteria === 'object') {
+      executionState.criteria = criteria;
+    }
+  };
+
+  const handleBlocked = async (blockedInfo) => {
+    // Persist rich blocked state with current checkpoint data
+    const richBlockedState = {
+      ...blockedInfo,
+      iteration: iterationValue,
+      objective,
+      plan: executionState.plan,
+      criteria: executionState.criteria,
+      constraints,
+      dontRepeat,
+      verifyFailures,
+      git: captureGitStateSafe(),
+    };
+    
+    // Save blocked state as a special checkpoint
+    const persistBlockedPromise = (async () => {
+      try {
+        const checkpoint = await createCheckpoint(projectSlug, taskSlug, {
+          ...richBlockedState,
+          label: `blocked: ${blockedInfo.reason}`,
+          blockedAt: blockedInfo.timestamp,
+        });
+        onLog?.(`[blocked] State persisted for recovery`);
+        if (cloudSyncer && checkpoint) {
+          try {
+            await cloudSyncer.sync(checkpoint);
+          } catch (err) {
+            onLog?.(`[cloud-sync] sync failed: ${err?.message || err}`);
+          }
+        }
+      } catch (err) {
+        onLog?.(`[blocked] Failed to persist state: ${err?.message || err}`);
+      }
+    })();
+    trackPersistence(persistBlockedPromise);
+    await persistBlockedPromise;
+  };
+
   const stageConfig = resolveStageConfig(options);
   const engineConfig = ENGINES[engine] || ENGINES.claude;
 
@@ -150,7 +314,17 @@ async function executeTask(options) {
       onStream?.(chunk);
       
       // Parse output markers
-      parseMarkers(chunk, { onLog, onProgress, taskId });
+      parseMarkers(chunk, {
+        onLog,
+        onProgress,
+        taskId,
+        projectSlug,
+        taskSlug,
+        onCheckpoint: handleCheckpoint,
+        onPlanJson: handlePlanJson,
+        onCriteriaJson: handleCriteriaJson,
+        onBlocked: handleBlocked,
+      });
       
       // Increment progress as we get output
       lastProgress = Math.min(90, lastProgress + 5);
@@ -181,24 +355,76 @@ async function executeTask(options) {
       timeout = null;
     };
 
+    // Auto-checkpoint every 5 minutes
+    const AUTO_CHECKPOINT_INTERVAL_MS = 5 * 60 * 1000;
+    let autoCheckpointTimer = null;
+    let autoCheckpointCount = 0;
+    
+    const startAutoCheckpoint = () => {
+      if (autoCheckpointTimer) return;
+      autoCheckpointTimer = setInterval(async () => {
+        autoCheckpointCount++;
+        onLog?.(`[checkpoint] auto-checkpoint #${autoCheckpointCount}`);
+        await persistCheckpoint(`auto-5min-${autoCheckpointCount}`);
+      }, AUTO_CHECKPOINT_INTERVAL_MS);
+      autoCheckpointTimer.unref?.();
+    };
+    
+    const stopAutoCheckpoint = () => {
+      if (autoCheckpointTimer) {
+        clearInterval(autoCheckpointTimer);
+        autoCheckpointTimer = null;
+      }
+    };
+    
+    // Start auto-checkpoint timer
+    startAutoCheckpoint();
+
     proc.on('error', (err) => {
+      stopAutoCheckpoint();
       clearStageTimeout();
       require('./telemetry').track('executor_spawn_error', { engine, error: err.message });
       settle(reject)(new Error(`Failed to spawn ${engine}: ${err.message}`));
     });
 
-    proc.on('close', (code) => {
+    proc.on('close', async (code) => {
+      stopAutoCheckpoint();
       clearStageTimeout();
       onProgress?.(100);
+      await flushPendingPersistence();
       
       if (code === 0 || code === null) {
-        onLog?.(`[${engine}] Stage completed successfully`);
+        onLog?.(`[${engine}] Stage process finished`);
+        
+        let gateResult = null;
+        try {
+          onLog?.(`[verify-gate] Running verification...`);
+          gateResult = await runVerifyGate({
+            criteria: executionState.criteria || [],
+            cwd: gitCwd,
+            verifyFailures: verifyFailures || 0,
+            onLog
+          });
+          
+          if (gateResult.forceAction) {
+            onLog?.(`[verify-gate] Force action triggered: ${gateResult.reason}`);
+            // We resolve as success but pass the gate result so the loop can handle the force action
+          } else if (gateResult.passed) {
+            onLog?.(`[verify-gate] Passed all checks`);
+          } else {
+            onLog?.(`[verify-gate] Checks failed or need LLM`);
+          }
+        } catch (err) {
+           onLog?.(`[verify-gate] execution error: ${err.message}`);
+        }
+
         require('./telemetry').track('executor_completed', { engine, stage, duration_ms: Date.now() - execStart });
         settle(resolve)({
           success: true,
           output,
           workDir,
           exitCode: code,
+          gateResult,
         });
       } else {
         onLog?.(`[${engine}] Stage failed with exit code ${code}`);
@@ -232,14 +458,95 @@ function buildPrompt(title, content, stage, stageConfig) {
   });
 }
 
+function createDefaultPlan() {
+  return {
+    steps: [
+      { desc: 'Analyze', status: 'done' },
+      { desc: 'Implement', status: 'in_progress' },
+      { desc: 'Verify', status: 'todo' },
+    ],
+    current: 1,
+  };
+}
+
+function tryParseJsonCandidate(candidate) {
+  try {
+    return JSON.parse(candidate);
+  } catch (err) {
+    if (json5) {
+      try {
+        return json5.parse(candidate);
+      } catch (json5Err) {
+        return null;
+      }
+    }
+    return null;
+  }
+}
+
+function extractJsonObjects(text, markerName) {
+  if (!text || !markerName) return [];
+  const lowerText = text.toLowerCase();
+  const marker = `[${markerName.toLowerCase()}:`;
+  const results = [];
+  let cursor = 0;
+  while (cursor < lowerText.length) {
+    const markerIndex = lowerText.indexOf(marker, cursor);
+    if (markerIndex === -1) break;
+    const braceStart = text.indexOf('{', markerIndex + marker.length);
+    if (braceStart === -1) {
+      cursor = markerIndex + marker.length;
+      continue;
+    }
+    let depth = 0;
+    let sliceEnd = -1;
+    for (let i = braceStart; i < text.length; i += 1) {
+      const ch = text[i];
+      if (ch === '{') {
+        depth += 1;
+      } else if (ch === '}') {
+        depth -= 1;
+        if (depth === 0) {
+          sliceEnd = i;
+          break;
+        }
+      }
+    }
+    if (sliceEnd === -1) {
+      cursor = markerIndex + marker.length;
+      continue;
+    }
+    const candidate = text.slice(braceStart, sliceEnd + 1);
+    const parsed = tryParseJsonCandidate(candidate);
+    if (parsed !== null) {
+      results.push(parsed);
+      cursor = sliceEnd + 1;
+    } else {
+      cursor = braceStart + 1;
+    }
+  }
+  return results;
+}
+
 /**
  * Parse output markers from agent output
  */
-function parseMarkers(text, { onLog, onProgress, taskId }) {
-  // [checkpoint: message]
-  const checkpointMatch = text.match(/\[checkpoint:\s*([^\]]+)\]/i);
-  if (checkpointMatch) {
-    onLog?.(`[checkpoint] ${checkpointMatch[1]}`);
+function parseMarkers(text, {
+  onLog,
+  onProgress,
+  taskId,
+  projectSlug,
+  taskSlug,
+  onCheckpoint,
+  onPlanJson,
+  onCriteriaJson,
+  onBlocked,
+}) {
+  // [checkpoint: message] - capture all occurrences in chunk
+  const checkpointMatches = [...text.matchAll(/\[checkpoint:\s*([^\]]+)\]/gi)];
+  for (const match of checkpointMatches) {
+    onLog?.(`[checkpoint] ${match[1]}`);
+    onCheckpoint?.(match[1]);
   }
 
   // [learn: insight]
@@ -257,13 +564,31 @@ function parseMarkers(text, { onLog, onProgress, taskId }) {
   // [blocked: reason]
   const blockedMatch = text.match(/\[blocked:\s*([^\]]+)\]/i);
   if (blockedMatch) {
-    onLog?.(`[blocked] ${blockedMatch[1]}`);
+    const reason = blockedMatch[1];
+    onLog?.(`[blocked] ${reason}`);
+    onBlocked?.({
+      reason,
+      timestamp: new Date().toISOString(),
+      taskId,
+      projectSlug,
+      taskSlug,
+    });
   }
 
   // [done]
   if (/\[done\]/i.test(text)) {
     onLog?.(`[done] Stage marked complete`);
   }
+
+  const planObjects = extractJsonObjects(text, 'plan_json');
+  for (const plan of planObjects) {
+    onPlanJson?.(plan);
+  }
+
+  const criteriaObjects = extractJsonObjects(text, 'criteria_json');
+  for (const criteria of criteriaObjects) {
+    onCriteriaJson?.(criteria);
+  }
 }
 
 /**

package/lib/graph/constants.js

@@ -0,0 +1,25 @@
+const TERMINAL_NODE_STATUSES = ["done", "passed", "failed", "skipped"];
+const SUCCESS_NODE_STATUSES = ["done", "passed"];
+const FAILURE_NODE_STATUSES = ["failed"];
+const SOFT_DEP_SATISFIED_STATUSES = ["done", "passed", "failed", "skipped", "blocked"];
+const INCOMPLETE_FOR_DONE_STATUSES = ["pending", "running", "awaiting_human", "blocked"];
+const DEFAULT_EXECUTION_POLICY = {
+  replanBudgetRemaining: 3,
+  replanBudgetInitial: 3,
+  verifyBudgetRemaining: 5,
+  verifyBudgetInitial: 5,
+  maxConcurrentAutoChecks: 1,
+  immutableRequiredGates: true,
+  maxConcurrent: 3,
+  priorityMode: "fifo",
+  nodeTimeoutMs: 30 * 60 * 1e3,
+  graphTimeoutMs: 24 * 60 * 60 * 1e3
+};
+module.exports = {
+  TERMINAL_NODE_STATUSES,
+  SUCCESS_NODE_STATUSES,
+  FAILURE_NODE_STATUSES,
+  SOFT_DEP_SATISFIED_STATUSES,
+  INCOMPLETE_FOR_DONE_STATUSES,
+  DEFAULT_EXECUTION_POLICY
+};

package/lib/graph/scheduler.js

@@ -0,0 +1,137 @@
+const {
+  FAILURE_NODE_STATUSES,
+  INCOMPLETE_FOR_DONE_STATUSES,
+  SOFT_DEP_SATISFIED_STATUSES,
+  SUCCESS_NODE_STATUSES,
+  TERMINAL_NODE_STATUSES
+} = require("./types");
+function deepClone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function defaultNow() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function findDependencyEdge(graph, depId, nodeId) {
+  if (!graph || !Array.isArray(graph.edges)) {
+    return null;
+  }
+  return graph.edges.find((edge) => edge && edge.from === depId && edge.to === nodeId) || null;
+}
+function isDependencySatisfied(graph, depId, nodeId) {
+  const dep = graph.nodes[depId];
+  if (!dep) {
+    return false;
+  }
+  const edge = findDependencyEdge(graph, depId, nodeId) || {
+    type: "hard",
+    condition: "on_success"
+  };
+  const edgeCondition = edge.condition || "on_success";
+  if (edge.type === "soft") {
+    return SOFT_DEP_SATISFIED_STATUSES.includes(dep.status);
+  }
+  if (edgeCondition === "on_failure") {
+    return FAILURE_NODE_STATUSES.includes(dep.status);
+  }
+  if (edgeCondition === "always") {
+    return TERMINAL_NODE_STATUSES.includes(dep.status);
+  }
+  return SUCCESS_NODE_STATUSES.includes(dep.status);
+}
+function canRunNode(graph, nodeId) {
+  const node = graph.nodes[nodeId];
+  if (!node || !Array.isArray(node.deps)) {
+    return true;
+  }
+  return node.deps.every((depId) => isDependencySatisfied(graph, depId, nodeId));
+}
+function normalizeAllowedNodeIds(allowedNodeIds) {
+  if (!allowedNodeIds) return null;
+  const values = Array.isArray(allowedNodeIds) ? allowedNodeIds : [allowedNodeIds];
+  const ids = values.map((value) => String(value || "").trim()).filter(Boolean);
+  if (ids.length === 0) return null;
+  return new Set(ids);
+}
+function tick(graph, options = {}) {
+  const now = options.now || defaultNow();
+  const nextGraph = deepClone(graph);
+  const events = [];
+  const allowedNodeIds = normalizeAllowedNodeIds(options.allowedNodeIds);
+  const maxConcurrent = Number.isInteger(nextGraph.policy && nextGraph.policy.maxConcurrent) ? Math.max(1, nextGraph.policy.maxConcurrent) : 1;
+  const runningWorkNodeCount = Object.keys(nextGraph.nodes).filter((nodeId) => {
+    const node = nextGraph.nodes[nodeId];
+    return node && node.type === "work" && node.status === "running";
+  }).length;
+  const pendingRunnableGateNodeIds = [];
+  const pendingRunnableWorkNodeIds = [];
+  for (const nodeId of Object.keys(nextGraph.nodes)) {
+    const node = nextGraph.nodes[nodeId];
+    if (!node || node.status !== "pending") {
+      continue;
+    }
+    if (!INCOMPLETE_FOR_DONE_STATUSES.includes(node.status)) {
+      continue;
+    }
+    // Root/fork/join nodes auto-complete when deps are satisfied
+    if (node.type !== "work" && node.type !== "gate") {
+      if (canRunNode(nextGraph, nodeId)) {
+        const previous = node.status;
+        node.status = "done";
+        node.completedAt = node.completedAt || now;
+        events.push({
+          eventType: "node_status",
+          nodeId,
+          fromStatus: previous,
+          toStatus: node.status,
+          timestamp: now,
+          reason: "auto_complete"
+        });
+      }
+      continue;
+    }
+    if (!canRunNode(nextGraph, nodeId)) {
+      continue;
+    }
+    if (allowedNodeIds && !allowedNodeIds.has(nodeId)) {
+      continue;
+    }
+    if (node.type === "gate") {
+      pendingRunnableGateNodeIds.push(nodeId);
+    } else {
+      pendingRunnableWorkNodeIds.push(nodeId);
+    }
+  }
+  for (const nodeId of pendingRunnableGateNodeIds) {
+    const node = nextGraph.nodes[nodeId];
+    const previous = node.status;
+    node.status = "running";
+    node.startedAt = node.startedAt || now;
+    events.push({
+      eventType: "node_status",
+      nodeId,
+      fromStatus: previous,
+      toStatus: node.status,
+      timestamp: now,
+      reason: "deps_satisfied"
+    });
+  }
+  const availableWorkSlots = Math.max(0, maxConcurrent - runningWorkNodeCount);
+  for (const nodeId of pendingRunnableWorkNodeIds.slice(0, availableWorkSlots)) {
+    const node = nextGraph.nodes[nodeId];
+    const previous = node.status;
+    node.status = "running";
+    node.startedAt = node.startedAt || now;
+    events.push({
+      eventType: "node_status",
+      nodeId,
+      fromStatus: previous,
+      toStatus: node.status,
+      timestamp: now,
+      reason: "deps_satisfied"
+    });
+  }
+  return { graph: nextGraph, events };
+}
+module.exports = {
+  tick
+};

package/lib/graph/types.js

@@ -0,0 +1,24 @@
+const {
+  DEFAULT_EXECUTION_POLICY,
+  FAILURE_NODE_STATUSES,
+  INCOMPLETE_FOR_DONE_STATUSES,
+  SOFT_DEP_SATISFIED_STATUSES,
+  SUCCESS_NODE_STATUSES,
+  TERMINAL_NODE_STATUSES
+} = require("./constants");
+function isTerminalStatus(status) {
+  return TERMINAL_NODE_STATUSES.includes(status);
+}
+function isIncompleteStatus(status) {
+  return INCOMPLETE_FOR_DONE_STATUSES.includes(status);
+}
+module.exports = {
+  DEFAULT_EXECUTION_POLICY,
+  TERMINAL_NODE_STATUSES,
+  SUCCESS_NODE_STATUSES,
+  FAILURE_NODE_STATUSES,
+  SOFT_DEP_SATISFIED_STATUSES,
+  INCOMPLETE_FOR_DONE_STATUSES,
+  isTerminalStatus,
+  isIncompleteStatus
+};

package/lib/prompts/cloudTask.js

@@ -44,6 +44,12 @@ function sanitizeTaskContentForPrompt(content) {
   return collapseBlankLines(out);
 }
 
+function resolveTaskPromptBody(task) {
+  const description = String(task?.description || '').trim();
+  if (description) return description;
+  return sanitizeTaskContentForPrompt(task?.content);
+}
+
 function buildContinueCloudTaskPrompt({
   task,
   taskComments,
@@ -65,11 +71,11 @@ function buildContinueCloudTaskPrompt({
   let augmentedPrompt = hasTaskPrompt ? task.prompt.trim() : interpolate(CONTINUE_CLOUD_TASK, {
     id: task.id,
     title: task.title || 'Untitled',
-    stage: task.stage || 'ideation',
+    stage: task.stage || 'intake',
     stagePrompt,
     stageRequirement,
     taskTitle: task?.title,
-    taskContent: sanitizeTaskContentForPrompt(task?.content),
+    taskContent: resolveTaskPromptBody(task),
     taskComments: (taskComments || []).map(c => `${c.author}: ${c.content}`).join('\n'),
     goal: task.title || 'Untitled',
     plan: plan || '(none)',
@@ -111,7 +117,7 @@ function buildCloudTaskPromptFromContext(task) {
   const metaLines = [
     `Title: ${task.title || 'Untitled'}`,
     `Slug: ${task.slug || 'unspecified'}`,
-    `Stage: ${task.stage || 'ideation'}`,
+    `Stage: ${task.stage || 'intake'}`,
     `Project: ${task.project || 'none'}`,
     `Engine: ${task.engine || provider || 'unspecified'}`,
     `Provider: ${provider}`,
@@ -138,7 +144,7 @@ function buildCloudTaskPromptFromContext(task) {
 
   const sections = [
     stagePrompt ? `STAGE PROMPT\n${stagePrompt}` : null,
-    'EXECUTION RULES\n- Do not use AGX MCP tools or AGX MCP servers for this task.\n- Complete work using local edits, shell commands, and allowed HTTP APIs only.',
+    'WORK RULES\n- Do not use AGX MCP tools or AGX MCP servers for this task.\n- Complete work using local edits, shell commands, and allowed HTTP APIs only.',
     `TASK META\n${metaLines.join('\n')}`,
     `TASK\n${description || '(empty)'}`,
     `COMMENTS\n${formatList(commentLines, '(none)')}`,
@@ -165,7 +171,7 @@ function buildNewAutonomousCloudTaskPrompt({
     stagePrompt,
     stageRequirement,
     taskTitle: task?.title,
-    taskContent: sanitizeTaskContentForPrompt(task?.content),
+    taskContent: resolveTaskPromptBody(task),
     taskComments: (taskComments || []).map(c => `${c.author}: ${c.content}`).join('\n'),
     finalPrompt,
   });
@@ -184,7 +190,7 @@ function buildLegacyInstructionFooter({ runContext, finalPrompt } = {}) {
   const artifactsDir = typeof runContext?.artifactsDir === 'string' ? runContext.artifactsDir.trim() : '';
 
   const runPaths = (runRoot || planDir || artifactsDir)
-    ? `\nLocal run paths (scratch space):\n- Run root: ${runRoot || '(unset)'}\n- Plan dir: ${planDir || '(unset)'}\n- Artifacts dir: ${artifactsDir || '(unset)'}\n\nPrefer writing scratch planning docs under the run's Plan dir to avoid polluting the repo.\n`
+    ? `\nLocal run paths (scratch space):\n- Run root: ${runRoot || '(unset)'}\n- Plan dir: ${planDir || '(unset)'}\n- Artifacts dir: ${artifactsDir || '(unset)'}\n\nPrefer writing scratch notes under the run's Plan dir to avoid polluting the repo.\n`
     : '';
 
   return interpolate(LEGACY_INSTRUCTION_FOOTER, {