@yemi33/minions 0.1.2382 → 0.1.2384

package/engine/pr-action.js

@@ -184,19 +184,17 @@ function buildCreatePrFollowups({ project, branch, contextOnly = false, checkout
 
   let message;
   if (checkoutMode === 'worktree') {
-    // Worktree-mode projects: the server moves the live-checkout changes into an
-    // isolated worktree and restores the live checkout clean, so the commit /
-    // push / PR all happen OFF the operator's tree. CC never runs git in the
-    // live checkout — that is what kept leaking commits onto `main`.
+    // Worktree-mode projects: copy pre-existing operator changes into an
+    // isolated worktree without modifying their checkout.
     message =
-      `Create a PR from the local changes you just made in the ${proj} project. ` +
-      `This project uses isolated worktrees, so do NOT commit, branch, or push in its live checkout. ` +
-      `Steps: (1) call POST /api/pr-action/prepare-create-pr-worktree with {"project":"${proj}"} — the server moves your uncommitted changes into a fresh isolated worktree, restores the live checkout clean, and returns {worktreePath, branch, baseBranch}; ` +
+      `Create a PR from the pre-existing operator changes in the ${proj} project. ` +
+      `This project uses isolated worktrees, so do NOT edit, commit, branch, clean, reset, or push in its operator checkout. ` +
+      `Steps: (1) call POST /api/pr-action/prepare-create-pr-worktree with {"project":"${proj}"} — the server copies the uncommitted changes into a fresh isolated worktree, leaves the operator checkout unchanged, and returns {worktreePath, branch, baseBranch}; ` +
       `(2) run all git from inside worktreePath (use \`git -C <worktreePath> ...\`): stage and commit the changes on the returned branch with a clear conventional-commit message; ` +
       `(3) push that branch; (4) open a PR against baseBranch using the right CLI for the repo host (gh for GitHub, az repos for ADO); ` +
       `(5) link it by calling POST /api/pull-requests/link with ${linkBody} ${trackNote}; ` +
       `(6) finally call POST /api/pr-action/cleanup-create-pr-worktree with {"project":"${proj}","worktreePath":"<worktreePath>"} to remove the worktree. ` +
-      `Never git-commit/-push in the live checkout. Then show me the PR URL.`;
+      `Do not clean up the operator's original changes; report that they remain untouched. Then show me the PR URL.`;
   } else {
     // Live-checkout projects: operate in place, but ALWAYS build the PR on a
     // fresh branch off the up-to-date origin/<mainBranch> tip — never off

package/engine/process-utils.js

@@ -14,7 +14,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const { execSync: _execSync } = require('child_process');
+const { execSync: _execSync, execFile: _execFile } = require('child_process');
 
 // Shared.js-local PID liveness check, moved here unchanged. Avoids a circular
 // require on engine/cli.js (which has its own isPidAlive) and engine/timeout.js
@@ -24,7 +24,12 @@ const { execSync: _execSync } = require('child_process');
 function isPidAlive(pid) {
   if (!Number.isFinite(pid) || pid <= 0) return false;
   try { process.kill(pid, 0); return true; }
-  catch { return false; }
+  catch (err) {
+    // Signal 0 returning EPERM means the process exists but this caller cannot
+    // inspect it. Treating that as dead lets lock recovery delete a live
+    // holder's lock and breaks cross-process mutual exclusion.
+    return err && err.code === 'EPERM';
+  }
 }
 
 // ─── Cross-Platform Process Kill Helpers ─────────────────────────────────────
@@ -206,6 +211,7 @@ function _parseWmicCsv(text) {
   const ppidIdx = idx('ParentProcessId');
   const pidIdx = idx('ProcessId');
   const cmdIdx = idx('CommandLine');
+  const creationIdx = idx('CreationDate');
   if (nameIdx < 0 || ppidIdx < 0 || pidIdx < 0) return [];
   const out = [];
   for (let i = 1; i < lines.length; i++) {
@@ -218,28 +224,31 @@ function _parseWmicCsv(text) {
     const ppid = parseInt(cols[ppidIdx], 10);
     const name = cols[nameIdx] || '';
     const cmd = cmdIdx >= 0 ? cols.slice(cmdIdx).join(',') : '';
-    out.push({ pid, ppid: Number.isInteger(ppid) ? ppid : 0, name, cmd });
+    const created = creationIdx >= 0
+      ? String(cols[creationIdx] || '').match(/^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})\.(\d{3})\d{3}([+-]\d{3})$/)
+      : null;
+    const startedAt = created
+      ? Date.UTC(
+        Number(created[1]), Number(created[2]) - 1, Number(created[3]),
+        Number(created[4]), Number(created[5]), Number(created[6]), Number(created[7])
+      ) - Number(created[8]) * 60000
+      : 0;
+    out.push({ pid, ppid: Number.isInteger(ppid) ? ppid : 0, name, cmd, startedAt });
   }
   return out;
 }
 
+const PROCESS_LIST_PS_SCRIPT = "Get-CimInstance Win32_Process | ForEach-Object { [PSCustomObject]@{ Name = $_.Name; ParentProcessId = $_.ParentProcessId; ProcessId = $_.ProcessId; CommandLine = $_.CommandLine; StartedAt = if ($_.CreationDate) { [int64](([datetimeoffset]$_.CreationDate).ToUnixTimeMilliseconds()) } else { 0 } } } | ConvertTo-Json -Compress -Depth 2";
+
 // PowerShell Get-CimInstance is the modern path (wmic is removed on Win11
 // 24H2+). We try it first and fall back to wmic for older Windows hosts.
 function _psListProcesses() {
-  const script = "Get-CimInstance Win32_Process | Select-Object Name,ParentProcessId,ProcessId,CommandLine | ConvertTo-Json -Compress -Depth 2";
   try {
     const out = _execSync(
-      `powershell -NoProfile -NonInteractive -Command "${script}"`,
+      `powershell -NoProfile -NonInteractive -Command "${PROCESS_LIST_PS_SCRIPT}"`,
       { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 4000, windowsHide: true, maxBuffer: 4 * 1024 * 1024 }
     );
-    const parsed = JSON.parse(out);
-    const arr = Array.isArray(parsed) ? parsed : [parsed];
-    return arr.map(p => ({
-      pid: Number(p.ProcessId),
-      ppid: Number(p.ParentProcessId) || 0,
-      name: p.Name || '',
-      cmd: p.CommandLine || '',
-    })).filter(p => Number.isInteger(p.pid) && p.pid > 0);
+    return _parsePowerShellProcesses(out);
   } catch { return null; }
 }
 
@@ -261,11 +270,7 @@ function _unixListProcesses() {
       'ps -A -o pid=,ppid=,comm=',
       { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 5000 }
     );
-    return out.split(/\r?\n/).map(line => {
-      const m = line.trim().match(/^(\d+)\s+(\d+)\s+(.*)$/);
-      if (!m) return null;
-      return { pid: parseInt(m[1], 10), ppid: parseInt(m[2], 10), name: m[3], cmd: '' };
-    }).filter(Boolean);
+    return _parseUnixProcesses(out);
   } catch { return []; }
 }
 
@@ -273,6 +278,103 @@ function listAllProcesses() {
   return process.platform === 'win32' ? _winListProcesses() : _unixListProcesses();
 }
 
+function _parsePowerShellProcesses(out) {
+  const parsed = JSON.parse(out);
+  const arr = Array.isArray(parsed) ? parsed : [parsed];
+  return arr.map(p => ({
+    pid: Number(p.ProcessId),
+    ppid: Number(p.ParentProcessId) || 0,
+    name: p.Name || '',
+    cmd: p.CommandLine || '',
+    startedAt: Number(p.StartedAt) || 0,
+  })).filter(p => Number.isInteger(p.pid) && p.pid > 0);
+}
+
+function _parseUnixProcesses(out) {
+  return out.split(/\r?\n/).map(line => {
+    const m = line.trim().match(/^(\d+)\s+(\d+)\s+(.*)$/);
+    if (!m) return null;
+    return { pid: parseInt(m[1], 10), ppid: parseInt(m[2], 10), name: m[3], cmd: '' };
+  }).filter(Boolean);
+}
+
+function _parseUnixProcessesWithStart(out) {
+  return out.split(/\r?\n/).map(line => {
+    const m = line.trim().match(/^(\d+)\s+(\d+)\s+(.{24})\s+(.*)$/);
+    if (!m) return null;
+    const startedAt = Date.parse(m[3].trim());
+    return {
+      pid: parseInt(m[1], 10),
+      ppid: parseInt(m[2], 10),
+      name: m[4],
+      cmd: '',
+      startedAt: Number.isNaN(startedAt) ? 0 : startedAt,
+    };
+  }).filter(Boolean);
+}
+
+async function _applyLinuxStartTicks(processes) {
+  if (process.platform !== 'linux') return processes;
+  await Promise.all(processes.map(async (entry) => {
+    try {
+      const stat = await fs.promises.readFile(`/proc/${entry.pid}/stat`, 'utf8');
+      const fields = stat.slice(stat.lastIndexOf(') ') + 2).trim().split(/\s+/);
+      const startTicks = Number(fields[19]);
+      entry.startedAt = Number.isFinite(startTicks) && startTicks > 0 ? startTicks : 0;
+    } catch {
+      entry.startedAt = 0;
+    }
+  }));
+  return processes;
+}
+
+function _execFileText(file, args, opts) {
+  return new Promise((resolve, reject) => {
+    _execFile(file, args, opts, (err, stdout) => {
+      if (err) reject(err);
+      else resolve(stdout);
+    });
+  });
+}
+
+async function listAllProcessesAsync() {
+  if (process.platform === 'win32') {
+    try {
+      const out = await _execFileText(
+        'powershell',
+        ['-NoProfile', '-NonInteractive', '-Command', PROCESS_LIST_PS_SCRIPT],
+        { encoding: 'utf8', windowsHide: true, timeout: 4000, maxBuffer: 4 * 1024 * 1024 }
+      );
+      const parsed = _parsePowerShellProcesses(out);
+      if (parsed.length > 0) return parsed;
+    } catch { /* fall through to wmic */ }
+    try {
+      const out = await _execFileText(
+        'wmic',
+        ['process', 'get', 'CreationDate,Name,ParentProcessId,ProcessId', '/format:csv'],
+        { encoding: 'utf8', windowsHide: true, timeout: 4000, maxBuffer: 4 * 1024 * 1024 }
+      );
+      return _parseWmicCsv(out);
+    } catch {
+      return [];
+    }
+  }
+  try {
+    const out = await _execFileText(
+      'ps',
+      ['-A', '-o', 'pid=,ppid=,lstart=,comm='],
+      {
+        encoding: 'utf8',
+        timeout: 5000,
+        env: { ...process.env, LC_ALL: 'C', LANG: 'C' },
+      }
+    );
+    return await _applyLinuxStartTicks(_parseUnixProcessesWithStart(out));
+  } catch {
+    return [];
+  }
+}
+
 // W-mq6f2fe0000557fa — orphan-worktree GC: identify OS processes whose cwd
 // is at or inside `dir`. Cross-platform with a fail-open contract: on any
 // error or timeout we return [] (the caller continues with its existing
@@ -315,6 +417,7 @@ function findProcessesWithCwdInside(dir, opts = {}) {
     if (process.platform === 'win32') {
       return _findWindowsProcessesWithCwdInside(resolved, timeoutMs, now);
     }
+
     if (process.platform === 'linux') {
       return _findLinuxProcessesWithCwdInside(resolved, timeoutMs, now);
     }
@@ -322,6 +425,37 @@ function findProcessesWithCwdInside(dir, opts = {}) {
   } catch { return []; }
 }
 
+async function findProcessesWithCwdInsideAsync(dir, opts = {}) {
+  const timeoutMs = Number(opts.timeoutMs) > 0 ? Number(opts.timeoutMs) : 5000;
+  const script = [
+    'const utils = require(process.argv[1]);',
+    '(async () => {',
+    'const timeoutMs = Number(process.argv[3]);',
+    "const rows = process.platform === 'win32'",
+    '? utils.findProcessCwdHolders(process.argv[2], { timeoutMs })',
+    ': utils.findProcessesWithCwdInside(process.argv[2], { timeoutMs });',
+    'const processes = await utils.listAllProcessesAsync();',
+    'const byPid = new Map(processes.map((entry) => [Number(entry.pid), entry]));',
+    'const enriched = rows.map((entry) => ({',
+    '...entry, startedAt: Number(byPid.get(Number(entry.pid))?.startedAt) || 0,',
+    '})).filter((entry) => entry.startedAt > 0);',
+    'process.stdout.write(JSON.stringify(enriched));',
+    '})().catch((err) => { console.error(err.message); process.exitCode = 1; });',
+  ].join('');
+  const out = await _execFileText(
+    process.execPath,
+    ['-e', script, __filename, String(dir || ''), String(timeoutMs)],
+    {
+      encoding: 'utf8',
+      timeout: timeoutMs + 2000,
+      windowsHide: true,
+      maxBuffer: 4 * 1024 * 1024,
+    }
+  );
+  const parsed = JSON.parse(out || '[]');
+  return Array.isArray(parsed) ? parsed : [];
+}
+
 function _findWindowsProcessesWithCwdInside(resolved, timeoutMs, now) {
   // Win32_Process exposes CommandLine but not the cwd. Match by basename of
   // the worktree dir (the dispatch id like W-mq1k8z6o003acd89) appearing in
@@ -695,7 +829,9 @@ module.exports = {
   _winListProcesses,
   _unixListProcesses,
   listAllProcesses,
+  listAllProcessesAsync,
   findProcessesWithCwdInside,
+  findProcessesWithCwdInsideAsync,
   _findWindowsProcessesWithCwdInside,
   _findLinuxProcessesWithCwdInside,
   _findMacProcessesWithCwdInside,

package/engine/runtimes/claude.js

@@ -6,23 +6,9 @@
  * everything Claude-CLI-specific: binary resolution, arg construction, prompt
  * preparation, output parsing, and error normalization.
  *
- * Adapter contract (all runtimes must implement):
- *   - name: string
- *   - capabilities: { ... } feature flags consumed by engine code
- *   - resolveBinary() → { bin, native, leadingArgs }
- *   - capsFile: absolute path of the binary-resolution cache for this runtime
- *   - listModels() → Promise<{id,name,provider}[] | null>
- *   - modelsCache: absolute path of the model-list cache for this runtime
- *   - spawnScript: absolute path of the spawn wrapper (or null if direct-only)
- *   - buildArgs(opts) → string[] — CLI args excluding the binary
- *   - buildPrompt(promptText, sysPromptText) → string — final prompt delivered
- *   - getUserAssetDirs(opts) → string[] — runtime-native global asset roots
- *   - getSkillRoots(opts) → {scope,dir,projectName?}[] — skill discovery roots
- *   - getSkillWriteTargets(opts) → {personal,project} — extraction targets
- *   - resolveModel(input) → string|undefined — shorthand expansion / passthrough
- *   - parseOutput(raw) → { text, usage, sessionId, model }
- *   - parseStreamChunk(line) → parsed event object or null
- *   - parseError(rawOutput) → { message, code, retriable }
+ * The versioned adapter contract and compatibility defaults live in
+ * engine/runtimes/contract.js. Keep harness-specific argv, prompt, parser,
+ * workspace, and persistent-worker behavior in this module.
  */
 
 const fs = require('fs');
@@ -36,6 +22,8 @@ const MINIONS_DIR = path.resolve(ENGINE_DIR, '..');
 const _CACHE_DIR = resolveEngineCacheDir(ENGINE_DIR);
 
 const isWin = process.platform === 'win32';
+const RUNTIME_NAME = 'claude';
+const SPAWN_STARTUP_SUBTYPES = new Set(['init', 'hook_started', 'hook_response']);
 
 // ── Binary Resolution ────────────────────────────────────────────────────────
 // Mirrors engine/spawn-agent.js:26-91. Cached at engine/claude-caps.json so the
@@ -253,7 +241,7 @@ function buildArgs(opts = {}) {
 }
 
 function buildSpawnFlags(opts = {}) {
-  const flags = ['--runtime', 'claude'];
+  const flags = ['--runtime', RUNTIME_NAME];
   if (opts.maxTurns != null) flags.push('--max-turns', String(opts.maxTurns));
   if (opts.model) flags.push('--model', String(opts.model));
   if (opts.allowedTools) flags.push('--allowedTools', String(opts.allowedTools));
@@ -268,12 +256,13 @@ function buildSpawnFlags(opts = {}) {
   return flags;
 }
 
-// Stamped into every session.json this adapter writes so the pre-spawn resume
-// path can detect "session was produced by a different runtime" — Claude
-// rejects Copilot session IDs (and vice versa) with "No conversation found",
-// which would otherwise burn a retry slot before the post-failure cleanup at
-// engine.js:1195 fires. See W-mot9fwya000d09cb.
-const RUNTIME_NAME = 'claude';
+function resolveInvocationOptions({ options = {}, engineConfig = {} } = {}) {
+  const resolved = { ...options };
+  if (resolved.fallbackModel == null && engineConfig.claudeFallbackModel) {
+    resolved.fallbackModel = engineConfig.claudeFallbackModel;
+  }
+  return resolved;
+}
 
 /**
  * Compute the directory Claude CLI uses to persist a project's conversation
@@ -934,6 +923,81 @@ function getMcpConfigPaths({ homeDir = os.homedir(), project = null } = {}) {
   return paths;
 }
 
+function prepareWorkspace({
+  worktreePath,
+  homeDir,
+  engineConfig,
+  mutateJsonFileLocked,
+  existsSync = fs.existsSync,
+  readFileSync = fs.readFileSync,
+} = {}) {
+  if (engineConfig && engineConfig.claudePreApproveWorkspaceMcps === false) {
+    return { wrote: false, reason: 'flag-off', servers: [] };
+  }
+  if (!worktreePath || typeof worktreePath !== 'string') {
+    return { wrote: false, reason: 'no-worktree', servers: [] };
+  }
+  const workspaceMcpPath = path.join(worktreePath, '.mcp.json');
+  if (!existsSync(workspaceMcpPath)) {
+    return { wrote: false, reason: 'no-workspace-mcp', servers: [] };
+  }
+  let workspaceMcp;
+  try {
+    workspaceMcp = JSON.parse(readFileSync(workspaceMcpPath, 'utf8'));
+  } catch {
+    return { wrote: false, reason: 'invalid-workspace-mcp', servers: [] };
+  }
+  const serversObj = workspaceMcp && typeof workspaceMcp === 'object' ? workspaceMcp.mcpServers : null;
+  const servers = serversObj && typeof serversObj === 'object' && !Array.isArray(serversObj)
+    ? Object.keys(serversObj).filter(name => typeof name === 'string' && name.length > 0)
+    : [];
+  if (servers.length === 0) {
+    return { wrote: false, reason: 'no-servers', servers: [] };
+  }
+  if (!homeDir || typeof mutateJsonFileLocked !== 'function') {
+    return { wrote: false, reason: 'no-home-or-mutator', servers };
+  }
+
+  const claudeJsonPath = path.join(homeDir, '.claude.json');
+  let didWrite = false;
+  mutateJsonFileLocked(claudeJsonPath, (data) => {
+    const root = data && typeof data === 'object' ? data : {};
+    if (!root.projects || typeof root.projects !== 'object') root.projects = {};
+    const projectState = root.projects[worktreePath] && typeof root.projects[worktreePath] === 'object'
+      ? root.projects[worktreePath]
+      : {};
+    const enabled = Array.isArray(projectState.enabledMcpjsonServers)
+      ? projectState.enabledMcpjsonServers.slice()
+      : [];
+    const disabled = Array.isArray(projectState.disabledMcpjsonServers)
+      ? projectState.disabledMcpjsonServers.slice()
+      : [];
+    const enabledSet = new Set(enabled.filter(name => typeof name === 'string'));
+    let mutated = false;
+    for (const name of servers) {
+      if (!enabledSet.has(name)) {
+        enabledSet.add(name);
+        mutated = true;
+      }
+    }
+    const nextDisabled = disabled.filter(name => typeof name === 'string' && !servers.includes(name));
+    if (nextDisabled.length !== disabled.length) mutated = true;
+    if (!mutated) return data;
+    projectState.enabledMcpjsonServers = [...enabledSet];
+    projectState.disabledMcpjsonServers = nextDisabled;
+    root.projects[worktreePath] = projectState;
+    didWrite = true;
+    return root;
+  }, { defaultValue: {}, skipWriteIfUnchanged: true });
+
+  return { wrote: didWrite, reason: 'ok', servers, target: claudeJsonPath };
+}
+
+function isSpawnStartupEvent(event) {
+  if (!event || event.type !== 'system') return false;
+  return SPAWN_STARTUP_SUBTYPES.has(typeof event.subtype === 'string' ? event.subtype : '');
+}
+
 // Heuristic: does `model` look like a Claude model identifier? Powers the
 // preflight "stale model after CLI switch" warning in cli.js. Returning false
 // means "this looks wrong for Claude" — gpt-5.4 / o3-* / codex etc. Keep this
@@ -948,7 +1012,8 @@ function modelLooksFamiliar(model) {
 }
 
 module.exports = {
-  name: 'claude',
+  apiVersion: 1,
+  name: RUNTIME_NAME,
   capabilities,
   resolveBinary,
   capsFile: CAPS_FILE,
@@ -956,6 +1021,7 @@ module.exports = {
   modelsCache: MODELS_CACHE,
   spawnScript: path.join(ENGINE_DIR, 'spawn-agent.js'),
   installHint: INSTALL_HINT,
+  resolveInvocationOptions,
   buildSpawnFlags,
   buildArgs,
   buildPrompt,
@@ -964,6 +1030,8 @@ module.exports = {
   getSkillWriteTargets,
   getCommandRoots,
   getMcpConfigPaths,
+  prepareWorkspace,
+  isSpawnStartupEvent,
   getResumeSessionId,
   saveSession,
   detectPermissionGate,
@@ -981,4 +1049,5 @@ module.exports = {
   _CLAUDE_SHORTHANDS,
   _extractInvalidModelName,
   THINKING_BLOCK_TYPES,
+  SPAWN_STARTUP_SUBTYPES,
 };

package/engine/runtimes/codex.js

@@ -929,6 +929,7 @@ const INSTALL_HINT = 'install Codex CLI with `npm install -g @openai/codex` or `
 const PERMISSION_BYPASS_FLAGS = ['--sandbox'];
 
 module.exports = {
+  apiVersion: 1,
   name: RUNTIME_NAME,
   capabilities,
   resolveBinary,