ultra-builder-pro-cli 0.25.1 → 0.26.1

package/orchestrator/daemon.cjs

@@ -1,264 +0,0 @@
-'use strict';
-
-// Phase 5.4 — Orchestrator daemon.
-//
-// Polls state.db for pending tasks, runs admission + routing, and spawns
-// session-runner children. This is *not* Phase 8B dispatch rules — just the
-// simplest "pick a runtime, spawn one session per pending task" loop. The
-// daemon never picks a task while admission says blocked_by_breaker; the
-// circuit breaker (5.2) is the only gate above routing.
-//
-// opt-in lives in bin/orchestrator.js which reads settings.json before
-// calling runDaemon — the runtime layer itself has no opt-in concept.
-
-const ops = require('../mcp-server/lib/state-ops.cjs');
-const runtimeState = require('../mcp-server/lib/runtime-state.cjs');
-const projector = require('../mcp-server/lib/projector.cjs');
-const workerPackets = require('../mcp-server/lib/worker-packet.cjs');
-const runner = require('./session-runner.cjs');
-const recovery = require('./recovery.cjs');
-const { evaluate, DEFAULT_RULES } = require('./dispatch-rules.cjs');
-
-// Phase 8B.1 — routeTask is now a thin wrapper over evaluate() so Phase 5.4
-// callers see identical behavior while the parallel orchestrator (8B.2) can
-// feed richer ctx (wave, deps_ready) to the same rule engine.
-function routeTask(task, availableRuntimes) {
-  const d = evaluate({
-    task: task || {},
-    deps_ready: true,
-    available_runtimes: Array.isArray(availableRuntimes) ? availableRuntimes : [],
-    breaker_state: 'ok',
-    wave: null,
-  }, DEFAULT_RULES);
-  return d.action === 'spawn_agent' ? d.runtime : null;
-}
-
-function taskDependenciesReady(db, task) {
-  return (task.deps || []).every((dependencyId) => {
-    const dependency = ops.readTask(db, dependencyId);
-    return Boolean(dependency && ['completed', 'expanded'].includes(dependency.status));
-  });
-}
-
-function hasActiveFileConflict(db, task) {
-  const declared = new Set(task.files_modified || []);
-  if (declared.size === 0) return false;
-  return ops.listActiveSessions(db).some((session) => {
-    if (!session.task_id || session.task_id === task.id) return false;
-    const activeTask = ops.readTask(db, session.task_id);
-    return Boolean(
-      activeTask
-      && (activeTask.files_modified || []).some((file) => declared.has(file)),
-    );
-  });
-}
-
-function maintainState({ db, repoRoot, project = projector.projectAll } = {}) {
-  if (!db) throw new Error('maintainState: db required');
-  if (!repoRoot) throw new Error('maintainState: repoRoot required');
-  const cursor = runtimeState.readConsumerCursor(db, 'spec-staleness');
-  const staleness = ops.consumeSpecChangedEvents(db, { since_id: cursor, limit: 500 });
-  runtimeState.writeConsumerCursor(db, 'spec-staleness', staleness.next_since_id);
-  const ensured = runtimeState.ensureProjectionJob(db, { tool_name: 'orchestrator.maintenance' });
-  const projections = runtimeState.processProjectionJobs(db, {
-    rootDir: repoRoot, project, limit: 500,
-  });
-  return { staleness, ensured, projections };
-}
-
-function runDaemon({
-  db,
-  repoRoot,
-  runtimes,
-  pollMs = 1000,
-  command = null,
-  commandArgs = [],
-  onError = null,
-  branchScoped = false,
-} = {}) {
-  if (!db) throw new Error('runDaemon: db required');
-  if (!repoRoot) throw new Error('runDaemon: repoRoot required');
-  if (!Array.isArray(runtimes) || runtimes.length === 0) {
-    throw new Error('runDaemon: runtimes array required');
-  }
-  if (typeof command !== 'string' || command.trim() === '') {
-    const error = new Error(
-      'runDaemon: an explicit executable command is required; refusing to reserve empty sessions',
-    );
-    error.code = 'ORCHESTRATOR_COMMAND_REQUIRED';
-    throw error;
-  }
-  if (!Array.isArray(commandArgs)) {
-    const error = new Error('runDaemon: commandArgs must be an array');
-    error.code = 'ORCHESTRATOR_COMMAND_INVALID';
-    throw error;
-  }
-
-  let stopped = false;
-  const children = [];
-  let bootRecovery;
-  try {
-    bootRecovery = recovery.recoverOnBoot(db, { repoRoot });
-  } catch (error) {
-    runtimeState.recordIncident(db, {
-      code: 'BOOT_RECOVERY_FAILED', severity: 'critical', retryable: true,
-      message: error.message, source_kind: 'orchestrator', source_id: 'boot',
-    });
-    if (onError) onError(error); else throw error;
-    bootRecovery = { recovered: [], count: 0, error: error.message };
-  }
-
-  function settleExecution(handle, task) {
-    let settled = false;
-    const stopHeartbeat = runner.attachHeartbeat(db, handle.sid);
-    const settle = (rawCode, signal, spawnError = null) => {
-      if (settled) return;
-      settled = true;
-      stopHeartbeat();
-      const code = rawCode === null ? -1 : rawCode;
-      const success = code === 0;
-      // A caller may intentionally close the DB while leaving child processes
-      // alive during shutdown. The next boot recovery owns those stale leases.
-      if (!db.open) return;
-      const liveSession = ops.readSession(db, handle.sid);
-      // Takeover or an explicit close already owns the terminal transition.
-      // The late child exit must not block the replacement task/session.
-      if (!liveSession || liveSession.status !== 'running') return;
-      try {
-        if (!success) {
-          try { ops.patchTask(db, task.id, { status: 'blocked' }); }
-          catch (error) {
-            runtimeState.recordIncident(db, {
-              code: 'ORCHESTRATOR_TASK_BLOCK_FAILED', severity: 'error', retryable: true,
-              message: error.message, source_kind: 'task', source_id: task.id,
-            });
-          }
-          ops.recordTaskFailure(db, task.id, {
-            reason: spawnError
-              ? `worker spawn or runtime error: ${spawnError.message}`
-              : `runtime process exited with code ${code}${signal ? ` (${signal})` : ''}`,
-            session_id: handle.sid,
-          });
-        }
-        runner.closeSession(
-          { db, repoRoot, sid: handle.sid },
-          { status: success ? 'completed' : 'crashed', remove_worktree: false },
-        );
-      } catch (error) {
-        if (onError) onError(error);
-        else process.stderr.write(`orchestrator settle error: ${error.message}\n`);
-      }
-    };
-    handle.process.once('exit', settle);
-    handle.process.once('error', (error) => settle(-1, null, error));
-    if (handle.process.exitCode !== null && handle.process.exitCode !== undefined) {
-      setImmediate(() => settle(handle.process.exitCode, handle.process.signalCode || null));
-    }
-  }
-
-  function tick() {
-    if (stopped) return;
-    try {
-      maintainState({ db, repoRoot });
-    } catch (error) {
-      runtimeState.recordIncident(db, {
-        code: 'RUNTIME_MAINTENANCE_FAILED', severity: 'error', retryable: true,
-        message: error.message, source_kind: 'orchestrator', source_id: 'maintenance',
-      });
-      if (onError) onError(error); else throw error;
-      return;
-    }
-    let pending;
-    try {
-      const filter = { status: 'pending' };
-      if (branchScoped) {
-        const tag = ops.deriveBranchTag(repoRoot);
-        if (tag) filter.tag = tag;
-      }
-      pending = ops.listTasks(db, filter);
-    } catch (err) {
-      if (onError) onError(err); else throw err;
-      return;
-    }
-    for (const task of pending) {
-      if (stopped) return;
-      if (task.stale) continue;
-      if (!taskDependenciesReady(db, task)) continue;
-      if (hasActiveFileConflict(db, task)) continue;
-      // v0.24 workers are always bound to an active Change and receive one
-      // immutable Worker Packet. Legacy unbound tasks remain readable but are
-      // never dispatched by the daemon.
-      if (!task.change_id) continue;
-      // admissionCheck catches both live-session conflicts and tripped breakers.
-      let verdict;
-      try { verdict = ops.admissionCheck(db, task.id); }
-      catch (err) { if (onError) onError(err); continue; }
-      if (!verdict.can_spawn) continue;
-
-      const runtime = routeTask(task, runtimes);
-      if (!runtime) continue;
-
-      let packet = null;
-      try {
-        packet = workerPackets.createWorkerPacket(db, {
-          role: 'implement',
-          task_id: task.id,
-          runtime,
-          output_path: `.ultra/changes/active/${task.change_id}/delivery/${task.id}-outcome.json`,
-          output_schema: {
-            type: 'object',
-            required: ['packet_digest'],
-            properties: {
-              packet_digest: { type: 'string', pattern: '^[0-9a-f]{64}$' },
-            },
-          },
-        }, { rootDir: repoRoot });
-        const handle = runner.spawnSession({
-          db, repoRoot,
-          task_id: task.id,
-          runtime,
-          command,
-          args: commandArgs,
-          mark_task_started: true,
-          kernel_mode: true,
-          packet_digest: packet.packet_digest,
-        });
-        handle.task_id = task.id;
-        handle.packet = packet;
-        workerPackets.markWorkerPacketAssigned(db, packet.id);
-        settleExecution(handle, task);
-        children.push(handle);
-      } catch (err) {
-        if (packet?.id) {
-          workerPackets.abandonWorkerPacket(db, packet.id, err.code || err.message);
-        }
-        if (!runner.isExpectedExecutionGate(err) && onError) onError(err);
-        // Don't throw — one bad task shouldn't stop the loop.
-      }
-    }
-  }
-
-  const timer = setInterval(tick, pollMs);
-  if (typeof timer.unref === 'function') timer.unref();
-  // Fire one tick immediately so tests don't need to wait pollMs.
-  setImmediate(tick);
-
-  return {
-    stop() {
-      if (stopped) return;
-      stopped = true;
-      clearInterval(timer);
-    },
-    get running() { return !stopped; },
-    get children() { return children.slice(); },
-    get bootRecovery() { return bootRecovery; },
-  };
-}
-
-module.exports = {
-  runDaemon,
-  routeTask,
-  maintainState,
-  taskDependenciesReady,
-  hasActiveFileConflict,
-};

package/orchestrator/dispatch-rules.cjs

@@ -1,78 +0,0 @@
-'use strict';
-
-// Declarative dispatch rules for deterministic priority matching.
-//
-// evaluate(ctx, rules) walks a priority-sorted rule array and returns the
-// first matching { rule_id, action, runtime }. Actions:
-//   • spawn_agent — orchestrator should spawn a session with `runtime`
-//   • defer       — leave task pending, revisit next tick (deps/wave wait)
-//   • block       — terminal: don't spawn (breaker, no runtimes, etc.)
-//
-// Runtime order is caller-owned. The orchestrator does not infer model quality,
-// price, or capability from a host name because every host can be configured
-// with different models. The parallel orchestrator supplies richer dimensions:
-// wave state, dependency readiness, and explicit custom rules.
-
-const { isSupportedRuntime } = require('../adapters/_shared/runtime-assets.cjs');
-
-const DEFAULT_RULES = Object.freeze([
-  {
-    id: 'breaker-blocked',
-    priority: 100,
-    when: (ctx) => ctx.breaker_state === 'tripped',
-    action: 'block',
-  },
-  {
-    id: 'deps-not-ready',
-    priority: 90,
-    when: (ctx) => ctx.deps_ready === false,
-    action: 'defer',
-  },
-  {
-    id: 'no-runtimes',
-    priority: 80,
-    when: (ctx) => !Array.isArray(ctx.available_runtimes) || ctx.available_runtimes.length === 0,
-    action: 'block',
-  },
-  {
-    id: 'wave-conflict',
-    priority: 70,
-    when: (ctx) => !!(ctx.wave && ctx.wave.parallel === false && (ctx.wave.running_count || 0) > 0),
-    action: 'defer',
-  },
-  {
-    id: 'first-authorized-runtime',
-    priority: 0,
-    when: () => true,
-    action: 'spawn_agent',
-    resolve: (ctx) => ctx.available_runtimes[0],
-  },
-]);
-
-function evaluate(ctx, rules = DEFAULT_RULES) {
-  const normalizedCtx = {
-    ...ctx,
-    available_runtimes: Array.isArray(ctx && ctx.available_runtimes)
-      ? [...new Set(ctx.available_runtimes.filter(isSupportedRuntime))]
-      : [],
-  };
-  const sorted = [...rules].sort((a, b) => (b.priority || 0) - (a.priority || 0));
-  for (const rule of sorted) {
-    if (rule.when(normalizedCtx)) {
-      let runtime = null;
-      if (rule.action === 'spawn_agent') {
-        runtime = rule.resolve ? rule.resolve(normalizedCtx) : (rule.runtime || null);
-        if (!isSupportedRuntime(runtime)) {
-          return { rule_id: rule.id, action: 'block', runtime: null };
-        }
-      }
-      return { rule_id: rule.id, action: rule.action, runtime };
-    }
-  }
-  return { rule_id: null, action: 'block', runtime: null };
-}
-
-module.exports = {
-  evaluate,
-  DEFAULT_RULES,
-};