@yemi33/minions 0.1.2448 → 0.1.2449

package/engine/{ado-status.js → ado/status.js}

@@ -1,16 +1,14 @@
 #!/usr/bin/env node
 /**
- * engine/ado-status.js — CLI shim for querying PR and build status.
+ * engine/ado/status.js — CLI implementation for querying PR and build status.
  *
  * Agents steered to "check on the builds" or "is CI green for PR #123" should
  * use this instead of raw curl + ad-hoc auth calls. All ADO auth and retry
  * logic is handled by ado.js internally.
  *
  * Usage:
- *   node engine/ado-status.js <prNumber>
- *   node engine/ado-status.js <prNumber> --live
- *   node engine/ado-status.js <prNumber> --project MyProject
- *   node engine/ado-status.js <prNumber> --live --project MyProject
+ *   node engine/ado/status.js <prNumber>
+ *   node engine/ado/status.js <prNumber> --live
  *
  * Output: JSON to stdout. Exit 0 on success, 1 on error/not-found.
  *
@@ -22,7 +20,7 @@
 'use strict';
 
 const path = require('path');
-const shared = require('./shared');
+const shared = require('../core/shared');
 const { safeJson, readPullRequests, getProjects, MINIONS_DIR } = shared;
 
 // ── Arg parsing ──────────────────────────────────────────────────────────────
@@ -35,7 +33,7 @@ const projectName = projectIdx >= 0 ? args[projectIdx + 1] : null;
 
 if (!prNumberArg) {
   console.error([
-    'Usage: node engine/ado-status.js <prNumber> [--live] [--project <name>]',
+    'Usage: node engine/ado/status.js <prNumber> [--live] [--project <name>]',
     '',
     '  <prNumber>          PR number to look up (required)',
     '  --live              Make a fresh ADO API call instead of reading cached state',
@@ -110,7 +108,7 @@ async function main() {
   }
 
   // Live path: query all projects in parallel, return first match
-  const ado = require('./ado');
+  const ado = require('./index');
   const settled = await Promise.allSettled(
     projects.map(p => ado.fetchSinglePrBuildStatus(p, prNumber))
   );

package/engine/{ado-token.js → ado/token.js}

@@ -1,5 +1,5 @@
 /**
- * Shared Azure DevOps token acquisition.
+ * engine/ado/token.js — Shared Azure DevOps token acquisition.
  *
  * Prefer Azure CLI because it is the most common authenticated tool in agent
  * environments; keep azureauth as the non-interactive fallback for corp setups.

package/engine/{acp-transport.js → agents/acp-transport.js}

@@ -1,6 +1,6 @@
 /**
- * engine/acp-transport.js — Shared ACP (Agent Client Protocol) transport layer
- * (P-4c6e8a72, extracted from engine/cc-worker-pool.js).
+ * engine/agents/acp-transport.js — Shared ACP (Agent Client Protocol) transport layer
+ * (P-4c6e8a72, extracted from engine/agents/cc-worker-pool.js).
  *
  * ACP-capable harnesses expose a long-lived JSON-RPC server over stdin/stdout.
  * This module owns protocol plumbing that is identical regardless of which
@@ -15,8 +15,8 @@
  *     `mapAcpToolCallToToolUse`) and the `session/new` params builder
  *     (`buildSessionNewParams`).
  *
- * Consumers (engine/cc-worker-pool.js — one persistent worker per CC/doc-chat
- * tab, permanent ownership; engine/agent-worker-pool.js — a fixed-size pool of
+ * Consumers (engine/agents/cc-worker-pool.js — one persistent worker per CC/doc-chat
+ * tab, permanent ownership; engine/agents/agent-worker-pool.js — a fixed-size pool of
  * workers leased/released per fleet agent dispatch) own their OWN pooling
  * policy (eviction rules, idle reaping, FIFO acquire queues, mcpServersHash
  * matching strategy) on top of this shared transport. Neither consumer
@@ -45,12 +45,13 @@
 
 const { spawn } = require('child_process');
 const crypto = require('crypto');
-const { normalizeExecutionModel } = require('./execution-model');
+const processUtils = require('../processes/process-utils');
+const { normalizeExecutionModel } = require('../core/execution-model');
 const {
   resolveRuntime,
   resolveRuntimeByCapability,
   buildWorkerArgs,
-} = require('./runtimes');
+} = require('../runtimes');
 
 // W-mpmwxni2000c25c7-c — typed error codes the transport emits through every
 // failure exit so a consumer (CC streaming handler / doc-chat pool wrapper /
@@ -93,11 +94,47 @@ function typedError(message, code, retriable = true) {
 // consumers that pre-warm (like cc-worker-pool.js's warmTab) can share the
 // same knob instead of hardcoding their own copy.
 const WARM_MAX_CONCURRENT = 3;
-const ACP_HANDSHAKE_TIMEOUT_MS = 60000;
+// Budget for the cold ACP handshake — `initialize` plus the follow-up
+// `session/new` / `session/load`. Issue #1105 raised the default from 60s to
+// 180s: a cold `copilot --acp` start that loads the user's MCP configuration
+// routinely needs ~96s, and the old ceiling surfaced as "Command Center
+// returned no output / handshake timed out after 60000ms". This is the
+// module-level fallback only — consumers override it per Worker via
+// `internals.handshakeTimeoutMs` (pushed in from
+// `engine.acpHandshakeTimeoutMs` through each pool's setHandshakeTimeoutMs()).
+const ACP_HANDSHAKE_TIMEOUT_MS = 180000;
 const SESSION_LOAD_RETRY_ATTEMPTS = 10;
 const SESSION_LOAD_RETRY_DELAY_MS = 100;
 const SESSION_ROTATION_CANCEL_WAIT_MS = 1000;
 
+/**
+ * Issue #1105 — shared accessor pair for the cold-handshake budget a pool
+ * publishes on its own `_internals` seam. Both ACP pools (engine/cc-worker-pool
+ * and engine/agent-worker-pool) keep isolated `_internals` objects so their test
+ * stubs cannot collide, but the knob semantics are identical, so they share this
+ * factory rather than forking two copies.
+ *
+ * `_internals` is what `Worker` is constructed with, so every worker a pool owns
+ * — warm ones included — re-reads the current value on each handshake and a
+ * Settings change takes effect without recreating workers. Non-finite and
+ * non-positive values are ignored so a config typo can neither make the
+ * handshake un-cancellable nor fire before a cold start can finish.
+ */
+function createHandshakeTimeoutControls(internals) {
+  internals.handshakeTimeoutMs = ACP_HANDSHAKE_TIMEOUT_MS;
+  return {
+    setHandshakeTimeoutMs(ms) {
+      const n = Number(ms);
+      if (!Number.isFinite(n) || n <= 0) return internals.handshakeTimeoutMs;
+      internals.handshakeTimeoutMs = n;
+      return internals.handshakeTimeoutMs;
+    },
+    getHandshakeTimeoutMs() {
+      return internals.handshakeTimeoutMs;
+    },
+  };
+}
+
 function resolveWorkerRuntime(runtime) {
   const adapter = typeof runtime === 'string'
     ? resolveRuntime(runtime)
@@ -124,7 +161,7 @@ function spawnAcp({ runtime, cwd, env, workerOptions } = {}) {
     ...leadingArgs,
     ...buildWorkerArgs(adapter, { ...(workerOptions || {}), cwd, env: workerEnv }),
   ];
-  // Mirror engine/spawn-agent.js: native binaries run directly; a non-native
+  // Mirror engine/agents/spawn-agent.js: native binaries run directly; a non-native
   // (JS entry / npm shim) runs under process.execPath as `node <bin> ...`.
   const execBin = native ? bin : process.execPath;
   const execArgs = native ? acpArgs : [bin, ...acpArgs];
@@ -140,18 +177,13 @@ function spawnAcp({ runtime, cwd, env, workerOptions } = {}) {
 }
 
 // Real kill implementation — lazy require so a caller that stubs its own
-// _internals for tests doesn't need engine/shared loaded.
+// _internals for tests doesn't need engine/core/shared loaded.
 function killImmediate(proc) {
-  try {
-    const shared = require('./shared');
-    shared.killImmediate(proc);
-  } catch {
-    try { proc.kill('SIGKILL'); } catch { /* already dead */ }
-  }
+  return processUtils.terminateProcess('engine.acp-worker-close', proc);
 }
 
 function killRoot(proc) {
-  try { proc.kill('SIGKILL'); } catch { /* already dead */ }
+  return processUtils.terminateProcess('engine.acp-worker-root-close', proc);
 }
 
 function hashMcpServers(mcpServers) {
@@ -337,6 +369,16 @@ class Worker {
     this.initPromise = null;
   }
 
+  // Resolve the configured handshake budget at call time (not construction
+  // time) so a Settings change pushed into the pool's `_internals` between
+  // acquisitions takes effect without recreating warm workers (issue #1105).
+  _handshakeTimeoutMs() {
+    const configured = Number(this._internals.handshakeTimeoutMs);
+    return Number.isFinite(configured) && configured > 0
+      ? configured
+      : ACP_HANDSHAKE_TIMEOUT_MS;
+  }
+
   // ── Spawn + initialize handshake ────────────────────────────────────────
   async _spawnAndInit() {
     let proc;
@@ -398,10 +440,7 @@ class Worker {
     };
     proc.on('error', errorHandler);
 
-    const configuredHandshakeTimeout = Number(this._internals.handshakeTimeoutMs);
-    const handshakeTimeoutMs = Number.isFinite(configuredHandshakeTimeout) && configuredHandshakeTimeout > 0
-      ? configuredHandshakeTimeout
-      : ACP_HANDSHAKE_TIMEOUT_MS;
+    const handshakeTimeoutMs = this._handshakeTimeoutMs();
     let handshakeTimer;
     const handshakeTimeoutPromise = new Promise((_, reject) => {
       handshakeTimer = setTimeout(() => {
@@ -600,7 +639,7 @@ class Worker {
     let lastError;
     for (let attempt = 0; attempt < SESSION_LOAD_RETRY_ATTEMPTS; attempt++) {
       try {
-        return await this._call('session/load', params, ACP_HANDSHAKE_TIMEOUT_MS);
+        return await this._call('session/load', params, this._handshakeTimeoutMs());
       } catch (err) {
         lastError = err;
         if (!/already loaded/i.test(String(err && err.message))) throw err;
@@ -758,7 +797,7 @@ class Worker {
       });
     const result = method === 'session/load'
       ? await this._loadSession(params)
-      : await this._call(method, params, ACP_HANDSHAKE_TIMEOUT_MS);
+      : await this._call(method, params, this._handshakeTimeoutMs());
     this.sessionId = (result && result.sessionId) || sessionId;
     if (!this.sessionId) {
       const hint = this.runtime.workerErrorHint || `${this.runtime.name} persistent worker failed`;
@@ -848,4 +887,5 @@ module.exports = {
   Worker,
   WARM_MAX_CONCURRENT,
   ACP_HANDSHAKE_TIMEOUT_MS,
+  createHandshakeTimeoutControls,
 };

package/engine/{agent-worker-pool.js → agents/agent-worker-pool.js}

@@ -1,14 +1,14 @@
 /**
- * engine/agent-worker-pool.js — Fixed-size ACP worker pool for fleet agent
+ * engine/agents/agent-worker-pool.js — Fixed-size ACP worker pool for fleet agent
  * dispatches (P-4c6e8a72, W-mre7fhxz001ka5fa / P-9b3d5f61 plan).
  *
- * Modeled on engine/cc-worker-pool.js but with a DIFFERENT ownership model:
+ * Modeled on engine/agents/cc-worker-pool.js but with a DIFFERENT ownership model:
  * cc-worker-pool.js gives each CC/doc-chat tab a permanently-owned worker
  * (tabId → Worker, kept warm for the tab's lifetime); this pool instead
  * leases a worker to exactly one active fleet dispatch at a time and
  * returns it to a shared free set on release — 1 worker : 1 ACTIVE dispatch,
  * not 1 worker : 1 dispatch for life. Both pools share the same underlying
- * spawn + JSON-RPC transport (engine/acp-transport.js) — no duplicated
+ * spawn + JSON-RPC transport (engine/agents/acp-transport.js) — no duplicated
  * framing code.
  *
  * Public API:
@@ -63,10 +63,10 @@
 
 const path = require('path');
 const transport = require('./acp-transport');
-const { buildWorkerArgs } = require('./runtimes');
+const { buildWorkerArgs } = require('../runtimes');
 const { Worker, hashMcpServers, hashProcessContext } = transport;
 
-// Test seam — mirrors engine/cc-worker-pool.js's `_internals` pattern, but is
+// Test seam — mirrors engine/agents/cc-worker-pool.js's `_internals` pattern, but is
 // its OWN object (constructor-injected into Worker per acquisition) so this
 // pool's test stubs never collide with cc-worker-pool.js's.
 const _internals = {
@@ -74,7 +74,7 @@ const _internals = {
   killImmediate: transport.killImmediate,
   killRoot: transport.killRoot,
   async getProcessStartedAt(pid) {
-    const processes = await require('./shared').listAllProcessesAsync();
+    const processes = await require('../core/shared').listAllProcessesAsync();
     return Number(processes.find((entry) => entry.pid === pid)?.startedAt) || 0;
   },
   now() { return Date.now(); },
@@ -84,7 +84,7 @@ const _internals = {
 // chain (engine.agentAcpPoolSize > engine.maxConcurrent >
 // ENGINE_DEFAULTS.maxConcurrent) once the spawn-routing item (P-1d8f0b93)
 // wires `setPoolSize` in on config load. ENGINE_DEFAULTS.maxConcurrent is 5
-// (engine/shared.js) — mirrored here as the pre-wiring default so a caller
+// (engine/core/shared.js) — mirrored here as the pre-wiring default so a caller
 // exercising this module directly (e.g. tests) gets a sane cap.
 const DEFAULT_POOL_SIZE = 5;
 let _poolSize = DEFAULT_POOL_SIZE;
@@ -103,6 +103,12 @@ function getPoolSize() {
   return _poolSize;
 }
 
+// Issue #1105 — cold ACP handshake budget (`initialize` + `session/new` /
+// `session/load`). Pushed in by engine.js#_syncAgentWorkerPoolConfig() from
+// `engine.acpHandshakeTimeoutMs`; shares the transport factory with
+// engine/cc-worker-pool.js and writes this pool's own `_internals` seam.
+const { setHandshakeTimeoutMs, getHandshakeTimeoutMs } = transport.createHandshakeTimeoutControls(_internals);
+
 // AGENT_POOL_TRACE-gated structured trace logger — mirrors cc-worker-pool.js's
 // CC_POOL_TRACE convention but under its own env var so the two pools can be
 // traced independently. NO PII — dispatchId (caller-supplied), sessionIds
@@ -323,7 +329,7 @@ async function _spawnFreshWorker(req) {
 
 // Spawn + initialize + session/new a brand-new Worker for `req`. Attaches
 // the pool's own proc-exit eviction listener once the handshake succeeds —
-// Worker's own internal exit handler (engine/acp-transport.js) already marks
+// Worker's own internal exit handler (engine/agents/acp-transport.js) already marks
 // `.killed` and fails any pending/inflight calls; this listener runs after
 // it (registered later on the same EventEmitter) and removes the worker from
 // whichever pool collection it's currently sitting in, then re-pumps so a
@@ -682,6 +688,9 @@ module.exports = {
   abandon,
   setPoolSize,
   getPoolSize,
+  // Issue #1105 — configurable cold ACP handshake budget.
+  setHandshakeTimeoutMs,
+  getHandshakeTimeoutMs,
   setEnabled,
   isEnabled,
   beginDrain,

package/engine/{cc-worker-pool.js → agents/cc-worker-pool.js}

@@ -1,5 +1,5 @@
 /**
- * engine/cc-worker-pool.js — Persistent per-tab Copilot worker pool (W-mp3ioyh300056f36).
+ * engine/agents/cc-worker-pool.js — Persistent per-tab Copilot worker pool (W-mp3ioyh300056f36).
  *
  * Sub-task B of W-mp2w003600196c51 ("CC perf: persistent per-tab Copilot
  * worker"). Wraps `copilot --acp` (Agent Client Protocol — long-lived JSON-RPC
@@ -21,7 +21,7 @@
  *
  * Internal model (one process per tab):
  *
- *   tabs: Map<tabId, Worker> — Worker (engine/acp-transport.js) owns the
+ *   tabs: Map<tabId, Worker> — Worker (engine/agents/acp-transport.js) owns the
  *   spawn + JSON-RPC framing; this module owns per-tab lifecycle policy:
  *   eviction rules, idle reaping, and the warm-prewarm FIFO queue.
  *
@@ -73,9 +73,9 @@ const {
 // Test seam — every external side effect goes through `_internals` so
 // test/unit/cc-worker-pool.test.js can stub spawn/now/killImmediate. This
 // object is passed to each Worker constructed by this pool (constructor
-// injection, engine/acp-transport.js#Worker) rather than the transport
+// injection, engine/agents/acp-transport.js#Worker) rather than the transport
 // reaching for a module-level singleton — that keeps this pool's test stubs
-// isolated from engine/agent-worker-pool.js's own `_internals`.
+// isolated from engine/agents/agent-worker-pool.js's own `_internals`.
 const _internals = {
   spawnAcp: transport.spawnAcp,
   killImmediate: transport.killImmediate,
@@ -85,7 +85,7 @@ const _internals = {
 
 // 30 minutes default — matches ENGINE_DEFAULTS.ccWorkerIdleTimeoutMs. This is
 // now a runtime-configurable knob (W-mr0qs0vw): the pool stays dependency-free
-// at module load (no static `require('./shared')`), so the dashboard pushes the
+// at module load (no static `require('../core/shared')`), so the dashboard pushes the
 // configured value in via `setIdleTimeoutMs()` on every reloadConfig(). Shorter
 // = less idle memory/process footprint; longer = more context durability across
 // gaps between messages.
@@ -130,6 +130,13 @@ function getIdleTimeoutMs() {
   return _idleReaperMs;
 }
 
+// Issue #1105 — cold ACP handshake budget (`initialize` + `session/new` /
+// `session/load`). Pushed in by dashboard.js#reloadConfig() from
+// `engine.acpHandshakeTimeoutMs`; the accessors are shared with
+// engine/agent-worker-pool.js via the transport factory and write this pool's
+// own `_internals` seam, so warm workers pick the new budget up in place.
+const { setHandshakeTimeoutMs, getHandshakeTimeoutMs } = transport.createHandshakeTimeoutControls(_internals);
+
 // Returns true (and clears the notice) if `tabId`'s warm worker was killed by
 // the idle reaper since the last consume. One-shot: the dashboard calls this
 // once per turn while resolving session-reset state.
@@ -401,6 +408,9 @@ module.exports = {
   setIdleTimeoutMs,
   getIdleTimeoutMs,
   consumeIdleReapNotice,
+  // Issue #1105 — configurable cold ACP handshake budget.
+  setHandshakeTimeoutMs,
+  getHandshakeTimeoutMs,
   // Exposed for unit tests; engine code MUST go through the public API.
   _internals,
   _tabs,
@@ -414,7 +424,7 @@ module.exports = {
   // dashboard pool wrappers (and their tests) reference the same string
   // constants and so the doc-chat timeout path can stamp the same
   // `{ message, code, retriable }` shape the pool itself emits. Re-exported
-  // from engine/acp-transport.js (P-4c6e8a72) — this pool no longer defines
+  // from engine/agents/acp-transport.js (P-4c6e8a72) — this pool no longer defines
   // its own copy.
   ERROR_CODES,
   _typedError,

package/engine/{claude-md-context.js → agents/claude-md-context.js}

@@ -1,5 +1,5 @@
 /**
- * engine/claude-md-context.js — CLAUDE.md propagation for non-Claude runtimes.
+ * engine/agents/claude-md-context.js — CLAUDE.md propagation for non-Claude runtimes.
  *
  * W-mrdon0pe000l045a. CLAUDE.md auto-discovery is a Claude-Code-CLI-only
  * convention (the claude binary reads CLAUDE.md itself at startup). Copilot and
@@ -9,7 +9,7 @@
  *
  * This module discovers the *nearest applicable* CLAUDE.md files for a dispatch
  * (bounded walk-UP from path hints toward the project root — NOT a full monorepo
- * walk) and renders them into a prompt block. engine/playbook.js injects that
+ * walk) and renders them into a prompt block. engine/agents/playbook.js injects that
  * block as a "Project instructions (CLAUDE.md)" context layer, gated on the
  * runtime capability `claudeMdNativeDiscovery` (skip when true → Claude) and the
  * `propagateClaudeMdForNonClaudeRuntimes` config flag.
@@ -24,7 +24,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const { truncateTextBytes, ENGINE_DEFAULTS } = require('./shared');
+const { truncateTextBytes, ENGINE_DEFAULTS } = require('../core/shared');
 
 const CLAUDE_MD_FILENAME = 'CLAUDE.md';
 // Cap the number of CLAUDE.md files collected across all hints — defense against
@@ -130,7 +130,7 @@ function discoverClaudeMdFiles({ projectRoot, pathHints = [] } = {}) {
 
 /**
  * Build the CLAUDE.md propagation block (inner content, no outer header/fence —
- * engine/playbook.js owns those). Reads each discovered file, labels it by its
+ * engine/agents/playbook.js owns those). Reads each discovered file, labels it by its
  * repo-relative path, and truncates to stay within `maxBytes` total. Returns
  * `{ block, files }` where `block` is '' when nothing was found or all files
  * were empty.
@@ -176,7 +176,7 @@ function buildClaudeMdPropagationBlock({ projectRoot, pathHints = [], maxBytes =
  */
 function runtimeAutoDiscoversClaudeMd(cliName) {
   try {
-    const { resolveRuntime } = require('./runtimes');
+    const { resolveRuntime } = require('../runtimes');
     const rt = resolveRuntime(cliName);
     return !!(rt && rt.capabilities && rt.capabilities.claudeMdNativeDiscovery);
   } catch {

package/engine/{harness-context.js → agents/harness-context.js}

@@ -1,5 +1,5 @@
 /**
- * engine/harness-context.js — "Repo harnesses used" PR-body section.
+ * engine/agents/harness-context.js — "Repo harnesses used" PR-body section.
  *
  * W-mrtdmtwq000kf391. When Minions opens/updates a PR for a dispatch, we surface
  * the repo HARNESS assets that were actually USED by THAT dispatch's runtime +
@@ -11,12 +11,12 @@
  *
  * This module is pure REPORTING. It reuses the same read-only harness-diagnostics
  * source that backs `GET /api/harness/diagnostics` and `minions doctor --harness`
- * (engine/preflight.js `_runtimeHarnessRows`) plus the CLAUDE.md propagation
- * discovery (engine/claude-md-context.js). It never propagates, injects,
+ * (engine/agents/preflight.js `_runtimeHarnessRows`) plus the CLAUDE.md propagation
+ * discovery (engine/agents/claude-md-context.js). It never propagates, injects,
  * suppresses, or attests any repository harness asset — the runtime-adapter
  * harness methods are diagnostic-only (see docs/harness-propagation.md).
  *
- * engine/playbook.js renders the section into a dispatch prompt appendix that
+ * engine/agents/playbook.js renders the section into a dispatch prompt appendix that
  * instructs the agent to append the fenced block verbatim to its PR body. The
  * block is delimited by stable HTML-comment markers so a PR-description refresh
  * (the description audit) can replace it in place instead of duplicating it.
@@ -168,7 +168,7 @@ function computeDispatchHarnessInventory({
   let registry = null;
   try { claudeMdCtx = require('./claude-md-context'); } catch { /* optional */ }
   try { preflight = require('./preflight'); } catch { /* optional */ }
-  try { registry = require('./runtimes'); } catch { /* optional */ }
+  try { registry = require('../runtimes'); } catch { /* optional */ }
 
   // CLAUDE.md discovery is a runtime CAPABILITY (Claude reads CLAUDE.md itself;
   // Copilot/Codex do not). Prefer the caller-resolved value; fall back to the

package/engine/{harness.js → agents/harness.js}

@@ -1,5 +1,5 @@
 /**
- * engine/harness.js — Tri-agent harness mode for long-running missions.
+ * engine/agents/harness.js — Tri-agent harness mode for long-running missions.
  *
  * Inspired by Anthropic's Harness Design (April 2026), this module implements
  * the "tri_agent" mission mode: a schedule firing produces three coordinated
@@ -43,13 +43,13 @@
  *     generatorType: 'ask',          // remembered so iteration N+1 reuses it
  *   }
  *
- * Zero dependencies beyond Node built-ins + engine/shared.
+ * Zero dependencies beyond Node built-ins + engine/core/shared.
  */
 
 'use strict';
 
 const path = require('path');
-const shared = require('./shared');
+const shared = require('../core/shared');
 const { MINIONS_DIR, WI_STATUS, ts } = shared;
 
 const HARNESS_MODE = Object.freeze({

package/engine/{llm.js → agents/llm.js}

@@ -1,5 +1,5 @@
 /**
- * engine/llm.js — Shared LLM utilities for Minions engine + dashboard.
+ * engine/agents/llm.js — Shared LLM utilities for Minions engine + dashboard.
  *
  * Provides callLLM() / callLLMStreaming() (with optional session resume) and
  * trackEngineUsage(). As of P-5e1b7a3c the CC / doc-chat direct-spawn path
@@ -11,7 +11,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const shared = require('./shared');
+const shared = require('../core/shared');
 const {
   safeWrite, safeUnlink, uid, ts, runFile, cleanChildEnv,
   parseStreamJsonOutput, mutateJsonFileLocked, appendTextTail,
@@ -26,7 +26,7 @@ const {
   sanitizeInvocationOptions,
   resolveInvocationOptions,
   buildSpawnFlags,
-} = require('./runtimes');
+} = require('../runtimes');
 
 const MINIONS_DIR = shared.MINIONS_DIR;
 const ENGINE_DIR = path.join(MINIONS_DIR, 'engine');
@@ -111,7 +111,7 @@ function flushMetricsBuffer() {
   _pendingMetrics = { engine: Object.create(null), daily: Object.create(null) };
 
   try {
-    const { mutateMetrics } = require('./shared');
+    const { mutateMetrics } = require('../core/shared');
     mutateMetrics((metrics) => {
       if (!metrics._engine) metrics._engine = {};
       for (const [category, delta] of Object.entries(pending.engine)) {
@@ -361,7 +361,7 @@ function _buildSpawnAgentFlags(runtime, opts = {}) {
  * Direct path (`direct: true`): bypasses spawn-agent.js, spawns the runtime
  *   binary directly. Fewer file syscalls. Used by CC and doc-chat.
  *
- * Indirect path: uses engine/spawn-agent.js — mostly a fallback when the
+ * Indirect path: uses engine/agents/spawn-agent.js — mostly a fallback when the
  *   direct path can't resolve the binary cache. spawn-agent.js handles
  *   adapter resolution itself; we hand it the runtime plus an opaque options
  *   bag, so adding a harness flag does not require wrapper changes.
@@ -439,7 +439,7 @@ function _spawnProcess(promptText, sysPromptText, callOpts) {
   const pidPath = promptPath.replace(/prompt-/, 'pid-').replace(/\.md$/, '.pid');
   cleanupFiles.push(promptPath, sysPath, pidPath);
 
-  const spawnScript = runtime.spawnScript || path.join(ENGINE_DIR, 'spawn-agent.js');
+  const spawnScript = runtime.spawnScript || path.join(ENGINE_DIR, 'agents', 'spawn-agent.js');
   const indirectAdapterOpts = { ...adapterOpts };
   if (Array.isArray(indirectAdapterOpts.images) && indirectAdapterOpts.images.length) {
     const imagesPath = path.join(llmTmpDir, `runtime-images-${id}.json`);
@@ -735,7 +735,7 @@ function callLLM(promptText, sysPromptText, opts = {}) {
     cli: cliOverride,
     engineConfig,
     // Cross-runtime + Copilot opts:
-    maxBudget, bare, fallbackModel,
+    maxBudget, bare, fallbackModel, disableTools = false,
     stream, disableBuiltinMcps, reasoningSummaries,
     invocationScope,
     // P-7b2e4d01 — optional image attachments: [{ mimeType, dataBase64, filename? }]
@@ -751,7 +751,7 @@ function callLLM(promptText, sysPromptText, opts = {}) {
   if (imageGate.error) return _resolvedCallResult(_imageUnsupportedResult(runtime, imageGate.error));
   const runtimeOptions = resolveInvocationOptions(runtime, {
     model, maxTurns, allowedTools, effort, sessionId,
-    maxBudget, bare, fallbackModel, images: imageGate.images,
+    maxBudget, bare, fallbackModel, disableTools, images: imageGate.images,
     stream, disableBuiltinMcps, reasoningSummaries,
   }, { engineConfig: engineConfig || {}, invocationScope });
 
@@ -779,12 +779,14 @@ function callLLM(promptText, sysPromptText, opts = {}) {
       onTerminalResult: () => scheduleExitFallback(exitCode != null ? exitCode : 0),
     });
 
-    _abort = () => { shared.killImmediate(proc); };
+    _abort = () => { shared.terminateProcess('engine.llm.abort', proc); };
 
     proc.stdout.on('data', d => { acc.ingestStdout(d); });
     proc.stderr.on('data', d => { acc.ingestStderr(d); });
 
-    const timer = setTimeout(() => { shared.killImmediate(proc); }, timeout);
+    const timer = setTimeout(() => {
+      shared.terminateProcess('engine.llm.timeout', proc);
+    }, timeout);
 
     const finalizeAndResolve = (code) => {
       if (resolved) return;
@@ -866,7 +868,7 @@ function callLLMStreaming(promptText, sysPromptText, opts = {}) {
     onProgress = null,
     effort = null, direct = false,
     model: modelOverride, cli: cliOverride, engineConfig,
-    maxBudget, bare, fallbackModel,
+    maxBudget, bare, fallbackModel, disableTools = false,
     stream, disableBuiltinMcps, reasoningSummaries,
     invocationScope,
     // P-7b2e4d01 — optional image attachments: [{ mimeType, dataBase64, filename? }]
@@ -882,7 +884,7 @@ function callLLMStreaming(promptText, sysPromptText, opts = {}) {
   if (imageGate.error) return _resolvedCallResult(_imageUnsupportedResult(runtime, imageGate.error));
   const runtimeOptions = resolveInvocationOptions(runtime, {
     model, maxTurns, allowedTools, effort, sessionId,
-    maxBudget, bare, fallbackModel, images: imageGate.images,
+    maxBudget, bare, fallbackModel, disableTools, images: imageGate.images,
     stream, disableBuiltinMcps, reasoningSummaries,
   }, { engineConfig: engineConfig || {}, invocationScope });
 
@@ -915,12 +917,14 @@ function callLLMStreaming(promptText, sysPromptText, opts = {}) {
       onProgress,
     });
 
-    _abort = () => { shared.killImmediate(proc); };
+    _abort = () => { shared.terminateProcess('engine.llm.abort', proc); };
 
     proc.stdout.on('data', d => { acc.ingestStdout(d); });
     proc.stderr.on('data', d => { acc.ingestStderr(d); });
 
-    const timer = setTimeout(() => { shared.killImmediate(proc); }, timeout);
+    const timer = setTimeout(() => {
+      shared.terminateProcess('engine.llm.timeout', proc);
+    }, timeout);
 
     const finalizeAndResolve = (code) => {
       if (resolved) return;

package/engine/{model-discovery.js → agents/model-discovery.js}

@@ -1,5 +1,5 @@
 /**
- * engine/model-discovery.js — Per-runtime model catalog cache + REST helpers.
+ * engine/agents/model-discovery.js — Per-runtime model catalog cache + REST helpers.
  *
  * Backs the dashboard endpoints:
  *   GET  /api/runtimes                        → listAllRuntimes()
@@ -24,7 +24,7 @@
  */
 
 const fs = require('fs');
-const { resolveRuntime, listRuntimes } = require('./runtimes');
+const { resolveRuntime, listRuntimes } = require('../runtimes');
 
 // 1 hour — matches the spec ("< 1hr TTL"). Keep separate from ENGINE_DEFAULTS
 // so the test suite can override per-call without polluting the global config.