ultra-builder-pro-cli 0.25.1 → 0.26.1

package/orchestrator/planner/plan-builder.cjs

@@ -1,125 +0,0 @@
-'use strict';
-
-// Phase 8A.4a — Execution plan builder (Functional Core, no IO).
-//
-// buildPlan(tasks) → { waves, ownership_forecast, conflict_surface,
-// estimated_cost_usd, estimated_duration_min, cycles }.
-// Composes topo.computeWaves + pricing.computeCost with a file-overlap
-// conflict detector. Downstream 8A.4b writes this object to
-// the owning Change's deterministic plan.json and plan.md artifacts.
-
-const { computeWaves } = require('../../mcp-server/lib/topo.cjs');
-const { computeCost } = require('../../mcp-server/lib/pricing.cjs');
-
-const DEFAULT_COMPLEXITY = 3;
-const TOKENS_PER_COMPLEXITY = Object.freeze({ input: 5000, output: 2000 });
-const DURATION_MIN_PER_COMPLEXITY = 5;
-
-function buildPlan(tasks, { runtime = null, model = null, changeId = null } = {}) {
-  if (!Array.isArray(tasks)) {
-    throw new TypeError('buildPlan: tasks must be an array');
-  }
-
-  // Plan artifacts are durable and compared by digest. Keep their ordering
-  // independent from SQLite insertion order or caller enumeration order.
-  const orderedTasks = [...tasks].sort((left, right) => String(left.id).localeCompare(String(right.id)));
-
-  const graph = orderedTasks.map((t) => ({
-    id: t.id,
-    deps: Array.isArray(t.deps) ? t.deps : [],
-  }));
-  const { waves, cycles } = computeWaves(graph);
-
-  const byId = new Map(orderedTasks.map((t) => [t.id, t]));
-
-  const conflict_surface = [];
-  const wavePayload = waves.map((waveTasks, idx) => {
-    const pairs = listWaveConflicts(waveTasks, byId);
-    for (const p of pairs) {
-      conflict_surface.push({
-        files: p.files,
-        tasks: p.tasks,
-        recommend: 'sequentialize',
-      });
-    }
-    const hasConflict = pairs.length > 0;
-    const entry = {
-      id: idx + 1,
-      tasks: waveTasks,
-      parallel: !hasConflict && waveTasks.length > 1,
-    };
-    if (hasConflict) {
-      const sharedFiles = [...new Set(pairs.flatMap((p) => p.files))];
-      entry.reason = `shared files: ${sharedFiles.join(', ')}`;
-    }
-    return entry;
-  });
-
-  const ownership_forecast = {};
-  for (const t of orderedTasks) {
-    ownership_forecast[t.id] = Array.isArray(t.files_modified) ? t.files_modified : [];
-  }
-
-  const taskCosts = orderedTasks.map((t) => {
-    const complexity = Number(t.complexity || DEFAULT_COMPLEXITY);
-    const ti = complexity * TOKENS_PER_COMPLEXITY.input;
-    const to = complexity * TOKENS_PER_COMPLEXITY.output;
-    return computeCost(runtime, model, ti, to);
-  });
-  const estimated_cost_usd = orderedTasks.length === 0
-    ? 0
-    : (taskCosts.some((cost) => cost === null)
-      ? null
-      : round4(taskCosts.reduce((sum, cost) => sum + cost, 0)));
-
-  const estimated_duration_min = wavePayload.reduce((acc, wv) => {
-    const complexities = wv.tasks.map(
-      (id) => Number(byId.get(id)?.complexity || DEFAULT_COMPLEXITY),
-    );
-    if (wv.parallel) {
-      return acc + Math.max(0, ...complexities) * DURATION_MIN_PER_COMPLEXITY;
-    }
-    return acc + complexities.reduce((a, b) => a + b, 0) * DURATION_MIN_PER_COMPLEXITY;
-  }, 0);
-
-  return {
-    schema_version: '1.0',
-    change_id: changeId,
-    waves: wavePayload,
-    ownership_forecast,
-    conflict_surface,
-    estimated_cost_usd,
-    estimated_duration_min,
-    cycles,
-  };
-}
-
-function listWaveConflicts(waveTasks, byId) {
-  const conflicts = [];
-  for (let i = 0; i < waveTasks.length; i++) {
-    for (let j = i + 1; j < waveTasks.length; j++) {
-      const a = waveTasks[i];
-      const b = waveTasks[j];
-      const aFiles = new Set(byId.get(a)?.files_modified || []);
-      const bFiles = new Set(byId.get(b)?.files_modified || []);
-      const overlap = [];
-      for (const f of aFiles) if (bFiles.has(f)) overlap.push(f);
-      if (overlap.length > 0) {
-        conflicts.push({ files: overlap, tasks: [a, b] });
-      }
-    }
-  }
-  return conflicts;
-}
-
-function round4(n) {
-  return Math.round(n * 10000) / 10000;
-}
-
-module.exports = {
-  buildPlan,
-  listWaveConflicts,
-  DEFAULT_COMPLEXITY,
-  TOKENS_PER_COMPLEXITY,
-  DURATION_MIN_PER_COMPLEXITY,
-};

package/orchestrator/recovery.cjs

@@ -1,188 +0,0 @@
-'use strict';
-
-// Phase 5.1 — Recovery decision layer.
-//
-// Phase 4.5's reapOrphanSessions marks running sessions whose lease or
-// heartbeat has expired as `orphan`. Orphan is a safe waypoint — we don't yet
-// know whether the child is dead, deadlocked, or just slow.
-//
-// recoverOnBoot upgrades orphans whose pid is demonstrably dead to `crashed`,
-// records a task_failure event, and leaves orphans with live pids alone so
-// they can recover on their own heartbeat.
-//
-// The circuit breaker (Phase 5.2) consumes task_failure events to decide
-// whether the task should be tripped.
-
-const ops = require('../mcp-server/lib/state-ops.cjs');
-const fs = require('node:fs');
-const path = require('node:path');
-const closeJournal = require('./session-close-journal.cjs');
-const runner = require('./session-runner.cjs');
-
-function isPidAlive(pid) {
-  if (!pid || pid <= 0) return false;
-  try {
-    // Signal 0 performs error checking without actually sending a signal.
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    // ESRCH = no such process; EPERM = process exists but owned by another user
-    // (still counts as alive for our purposes).
-    if (err && err.code === 'EPERM') return true;
-    return false;
-  }
-}
-
-function listOrphanSessions(db) {
-  return db.prepare("SELECT * FROM sessions WHERE status = 'orphan'").all();
-}
-
-function reconcileCloseWorktree(repoRoot, intent) {
-  runner._internal.assertManagedWorktreePath(
-    repoRoot,
-    intent.worktree_path,
-    { sid: intent.sid, validateRuntimeTree: false },
-  );
-  if (fs.existsSync(intent.worktree_path)) {
-    const blocker = runner._internal.worktreeRemovalBlocker(
-      repoRoot,
-      intent.worktree_path,
-    );
-    if (blocker) throw new Error(blocker);
-  }
-  runner._internal.reconcileRemovedWorktree(
-    repoRoot,
-    intent.worktree_path,
-    { sid: intent.sid },
-  );
-}
-
-function closeIntentMatchesSession(intent, session) {
-  return Boolean(
-    intent
-      && session
-      && intent.sid === session.sid
-      && intent.task_id === session.task_id
-      && typeof intent.worktree_path === 'string'
-      && typeof session.worktree_path === 'string'
-      && path.resolve(intent.worktree_path) === path.resolve(session.worktree_path),
-  );
-}
-
-function recoverCloseIntents(db, repoRoot) {
-  if (!repoRoot) return { recovered: [], pending: [] };
-  const recovered = [];
-  const pending = [];
-  for (const intent of closeJournal.list(repoRoot)) {
-    const session = ops.readSession(db, intent.sid);
-    if (!session) {
-      pending.push({ sid: intent.sid, reason: 'session_missing' });
-      continue;
-    }
-    if (!closeIntentMatchesSession(intent, session)) {
-      pending.push({ sid: intent.sid, reason: 'journal_identity_mismatch' });
-      continue;
-    }
-    if (session.status === intent.requested_status) {
-      try {
-        reconcileCloseWorktree(repoRoot, intent);
-        closeJournal.discard(repoRoot, intent.sid);
-        recovered.push({
-          sid: intent.sid,
-          status: session.status,
-          reconciled: 'already_terminal',
-        });
-      } catch (error) {
-        closeJournal.update(repoRoot, intent.sid, {
-          phase: 'recovery_failed',
-          error: error.message,
-        });
-        pending.push({ sid: intent.sid, reason: error.message });
-      }
-      continue;
-    }
-    if (['completed', 'crashed'].includes(session.status)) {
-      pending.push({
-        sid: intent.sid,
-        reason: `terminal_status_conflict:${session.status}`,
-      });
-      continue;
-    }
-    if (isPidAlive(session.pid)) {
-      pending.push({ sid: intent.sid, reason: 'worker_still_alive' });
-      continue;
-    }
-    try {
-      reconcileCloseWorktree(repoRoot, intent);
-      closeJournal.update(repoRoot, intent.sid, {
-        phase: 'worktree_removed',
-        error: null,
-      });
-      ops.updateSession(db, intent.sid, { status: intent.requested_status });
-      closeJournal.discard(repoRoot, intent.sid);
-      recovered.push({
-        sid: intent.sid,
-        status: intent.requested_status,
-        reconciled: 'close_intent',
-      });
-    } catch (error) {
-      closeJournal.update(repoRoot, intent.sid, {
-        phase: 'recovery_failed',
-        error: error.message,
-      });
-      pending.push({ sid: intent.sid, reason: error.message });
-    }
-  }
-  return { recovered, pending };
-}
-
-function recoverOnBoot(db, { graceSeconds = 300, repoRoot = null } = {}) {
-  if (!db) throw new Error('recoverOnBoot: db handle required');
-
-  const closeRecovery = recoverCloseIntents(db, repoRoot);
-
-  // Step 1 — promote stale running sessions to orphan (Phase 4.5 logic).
-  ops.reapOrphanSessions(db, {
-    graceSeconds,
-    exclude_session_ids: closeRecovery.pending.map((entry) => entry.sid),
-  });
-
-  // Step 2 — for every orphan, decide crashed vs. keep-watching.
-  const orphans = listOrphanSessions(db);
-  const recovered = [];
-  for (const s of orphans) {
-    const alive = isPidAlive(s.pid);
-    if (alive) continue;
-
-    const resolution = ops.crashOrphanSession(db, s.sid, {
-      reason: 'session_crashed_on_boot',
-    });
-    if (!resolution.changed) continue;
-    recovered.push({
-      sid: s.sid,
-      task_id: s.task_id,
-      pid: s.pid,
-      pid_alive: false,
-      reason: 'session_crashed_on_boot',
-    });
-  }
-
-  return {
-    recovered,
-    count: recovered.length,
-    closed: closeRecovery.recovered,
-    close_pending: closeRecovery.pending,
-  };
-}
-
-module.exports = {
-  recoverOnBoot,
-  // exposed for tests
-  _internal: {
-    isPidAlive,
-    listOrphanSessions,
-    closeIntentMatchesSession,
-    reconcileCloseWorktree,
-    recoverCloseIntents,
-  },
-};

package/orchestrator/session-close-journal-worker.cjs

@@ -1,5 +0,0 @@
-'use strict';
-
-const journal = require('./session-close-journal.cjs');
-
-journal._internal.helperMain();