ultra-builder-pro-cli 0.16.0 → 0.17.1

package/mcp-server/server.cjs

@@ -38,6 +38,7 @@ const {
   readProjectBreadcrumb,
   renderProjectBreadcrumb,
 } = require('./lib/project-breadcrumb.cjs');
+const sessionRunner = require('../orchestrator/session-runner.cjs');
 
 const REPO_ROOT = process.env.UBP_RUNTIME_ROOT
   ? path.resolve(process.env.UBP_RUNTIME_ROOT)
@@ -153,11 +154,6 @@ function buildAjv() {
   return ajv;
 }
 
-function mintSessionId() {
-  const { randomUUID } = require('node:crypto');
-  return `sess-${randomUUID().slice(0, 8)}`;
-}
-
 async function dispatchTool(name, input, db, ctx = {}) {
   switch (name) {
     case 'task.create': {
@@ -207,40 +203,51 @@ async function dispatchTool(name, input, db, ctx = {}) {
       return ops.subscribeEventsSince(db, input || {});
     }
     case 'session.spawn': {
-      // admission + takeover logic; actual git worktree + child process is
-      // delegated to orchestrator/session-runner (Phase 4.5.1). This tool
-      // records intent in state.db and returns the paths the runner should use.
-      const rootDir = ctx.rootDir || process.cwd();
-      const verdict = ops.admissionCheck(db, input.task_id);
-      if (!verdict.can_spawn && !input.takeover) {
-        const err = new Error(`active session exists for task ${input.task_id}; pass takeover=true or choose resume/abandon`);
-        err.code = 'ADMISSION_DENIED';
-        throw err;
-      }
-      if (!verdict.can_spawn && input.takeover && verdict.conflict) {
-        ops.updateSession(db, verdict.conflict.sid, { status: 'crashed' });
+      if (ctx.sessionId) {
+        const error = new Error(
+          `worker session ${ctx.sessionId} already owns an isolated worktree; `
+            + 'resume that session instead of recursively spawning another one',
+        );
+        error.code = 'NESTED_SESSION_FORBIDDEN';
+        throw error;
       }
-      const sid = mintSessionId();
-      const worktreeBase = input.worktree_base || path.join(rootDir, '.ultra', 'worktrees');
-      const worktree_path = path.join(worktreeBase, sid);
-      const artifact_dir = path.join(rootDir, '.ultra', 'sessions', sid);
-      const session = ops.createSession(db, {
-        sid,
+      const rootDir = ctx.rootDir || process.cwd();
+      const handle = sessionRunner.spawnSession({
+        db,
+        repoRoot: rootDir,
         task_id: input.task_id,
         runtime: input.runtime,
-        worktree_path,
-        artifact_dir,
+        takeover: Boolean(input.takeover),
+        worktree_base: input.worktree_base,
       });
       return {
-        sid,
-        worktree_path,
-        artifact_dir,
-        lease_expires_at: session.lease_expires_at,
+        sid: handle.sid,
+        worktree_path: handle.worktree_path,
+        artifact_dir: handle.artifact_dir,
+        lease_expires_at: handle.lease_expires_at,
+        worktree_created: true,
       };
     }
     case 'session.close': {
-      ops.updateSession(db, input.sid, { status: input.status });
-      return { ok: true };
+      if (ctx.sessionId) {
+        const error = new Error(
+          ctx.sessionId === input.sid
+            ? `worker session ${ctx.sessionId} is supervised by its parent; save evidence and exit so the parent can settle the lease`
+            : `worker session ${ctx.sessionId} cannot close unrelated session ${input.sid}`,
+        );
+        error.code = ctx.sessionId === input.sid
+          ? 'WORKER_SESSION_PARENT_OWNED'
+          : 'SESSION_SCOPE_VIOLATION';
+        throw error;
+      }
+      const closed = sessionRunner.closeSession(
+        { db, repoRoot: ctx.rootDir || process.cwd(), sid: input.sid },
+        { status: input.status, remove_worktree: input.remove_worktree === true },
+      );
+      return {
+        ok: true,
+        worktree_preserved: closed.worktree_preserved,
+      };
     }
     case 'session.get': {
       const session = ops.readSession(db, input.sid);
@@ -252,6 +259,11 @@ async function dispatchTool(name, input, db, ctx = {}) {
       return { session };
     }
     case 'session.admission_check': {
+      sessionRunner.assertSessionTaskReady(
+        db,
+        ctx.rootDir || process.cwd(),
+        input.task_id,
+      );
       return ops.admissionCheck(db, input.task_id);
     }
     case 'session.list': {
@@ -633,7 +645,13 @@ function errorResponse(code, message, retriable = false, details = undefined) {
   };
 }
 
-function startServer({ dbPath, rootDir, projectOnWrite = true, project = projector.projectAll }) {
+function startServer({
+  dbPath,
+  rootDir,
+  sessionId = null,
+  projectOnWrite = true,
+  project = projector.projectAll,
+}) {
   let db = null;
   const getDb = () => {
     if (!db) db = initStateDb(dbPath).db;
@@ -703,7 +721,12 @@ function startServer({ dbPath, rootDir, projectOnWrite = true, project = project
     try {
       toolDb = STATELESS_TOOLS.has(name) ? null : getDb();
       if (toolDb) assertStateAuthority(toolDb, rootDir);
-      result = await dispatchTool(name, args, toolDb, { rootDir, projector: project });
+      result = await dispatchTool(
+        name,
+        args,
+        toolDb,
+        { rootDir, sessionId, projector: project },
+      );
     } catch (err) {
       const code = err.code || (err instanceof ops.StateOpsError ? err.code : 'STATE_DB_ERROR');
       toolError = code;
@@ -768,7 +791,8 @@ async function main() {
   const rootDir = process.env.UBP_ROOT_DIR
     ? path.resolve(process.env.UBP_ROOT_DIR)
     : path.resolve('.');
-  const handle = startServer({ dbPath, rootDir });
+  const sessionId = process.env.UBP_SESSION_ID || null;
+  const handle = startServer({ dbPath, rootDir, sessionId });
   const transport = new StdioServerTransport();
   await handle.server.connect(transport);
   const cleanup = () => handle.close().finally(() => process.exit(0));

package/orchestrator/auto-merge.cjs

@@ -40,6 +40,25 @@ function autoMerge({ repoRoot, worktreePath, baseBranch = 'main', sid, task_id =
   if (!repoRoot) throw new Error('autoMerge: repoRoot required');
   if (!worktreePath) throw new Error('autoMerge: worktreePath required');
 
+  try {
+    const status = runGit(['status', '--porcelain=v1'], { cwd: worktreePath });
+    if (status) {
+      return {
+        merged: false,
+        reason: 'uncommitted_changes',
+        session_sha: null,
+        base_sha: null,
+      };
+    }
+  } catch (err) {
+    return {
+      merged: false,
+      reason: 'worktree_status_failed',
+      session_sha: null,
+      base_sha: null,
+    };
+  }
+
   let sessionSha;
   let baseSha;
   try {

package/orchestrator/daemon.cjs

@@ -32,6 +32,26 @@ function routeTask(task, availableRuntimes) {
   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');
@@ -60,6 +80,18 @@ function runDaemon({
   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 = [];
@@ -75,6 +107,54 @@ function runDaemon({
     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 {
@@ -101,6 +181,17 @@ function runDaemon({
     }
     for (const task of pending) {
       if (stopped) return;
+      if (task.stale) continue;
+      if (!taskDependenciesReady(db, task)) continue;
+      if (hasActiveFileConflict(db, task)) continue;
+      try {
+        runner.assertSessionTaskReady(db, repoRoot, task.id);
+      } catch (error) {
+        // A normal workflow gate is a durable pending state, not a daemon
+        // failure and not an error to repeat on every poll.
+        if (!runner.isExpectedExecutionGate(error) && onError) onError(error);
+        continue;
+      }
       // admissionCheck catches both live-session conflicts and tripped breakers.
       let verdict;
       try { verdict = ops.admissionCheck(db, task.id); }
@@ -118,6 +209,17 @@ function runDaemon({
           command,
           args: commandArgs,
         });
+        handle.task_id = task.id;
+        try {
+          ops.patchTask(db, task.id, { status: 'in_progress' });
+        } catch (error) {
+          runner.closeSession(
+            { db, repoRoot, sid: handle.sid },
+            { status: 'crashed', remove_worktree: false },
+          );
+          throw error;
+        }
+        settleExecution(handle, task);
         children.push(handle);
       } catch (err) {
         if (onError) onError(err);
@@ -147,4 +249,6 @@ module.exports = {
   runDaemon,
   routeTask,
   maintainState,
+  taskDependenciesReady,
+  hasActiveFileConflict,
 };