@mndrk/agx 1.4.65 → 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/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();

package/lib/executor.js

@@ -136,6 +136,7 @@ async function executeTask(options) {
     plan: initialPlan || null,
     criteria: initialCriteria || null,
   };
+  const pendingPersistence = new Set();
   const cloudSyncer = (() => {
     if (!projectSlug || !taskSlug || !options.cloudTaskId) return null;
     try {
@@ -197,8 +198,21 @@ async function executeTask(options) {
     }
   };
 
+  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) => {
-    void persistCheckpoint(label);
+    trackPersistence(persistCheckpoint(label));
   };
 
   const handlePlanJson = (plan) => {
@@ -228,23 +242,27 @@ async function executeTask(options) {
     };
     
     // Save blocked state as a special checkpoint
-    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}`);
+    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}`);
       }
-    } catch (err) {
-      onLog?.(`[blocked] Failed to persist state: ${err?.message || err}`);
-    }
+    })();
+    trackPersistence(persistBlockedPromise);
+    await persistBlockedPromise;
   };
 
   const stageConfig = resolveStageConfig(options);
@@ -373,6 +391,7 @@ async function executeTask(options) {
       stopAutoCheckpoint();
       clearStageTimeout();
       onProgress?.(100);
+      await flushPendingPersistence();
       
       if (code === 0 || code === null) {
         onLog?.(`[${engine}] Stage process finished`);

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
+};