@yemi33/minions 0.1.2378 → 0.1.2380

package/engine/agent-worker-pool.js

@@ -59,7 +59,7 @@
  */
 
 const transport = require('./acp-transport');
-const { Worker, hashMcpServers } = transport;
+const { Worker, hashMcpServers, hashProcessContext } = transport;
 
 // Test seam — mirrors engine/cc-worker-pool.js's `_internals` pattern, but is
 // its OWN object (constructor-injected into Worker per acquisition) so this
@@ -106,11 +106,13 @@ let _nextWorkerId = 1;
 const _free = [];              // Worker[] — idle, unleased
 const _busy = new Map();       // dispatchId → Worker — currently leased
 const _queue = [];             // pending acquire requests, FIFO
+const _leaseContexts = new Map(); // dispatchId → mutable session-only context
 // Slots reserved for a worker that's mid-reuse/respawn/fresh-spawn — pulled
 // out of `_free` (or not yet spawned) but not yet placed in `_busy`. Counted
 // toward `_poolSize` so a burst of concurrent acquireWorker calls can't
 // overshoot the configured pool size while spawns are still in flight.
 let _reserved = 0;
+let _draining = false;
 
 function _occupied() {
   return _free.length + _busy.size + _reserved;
@@ -130,7 +132,10 @@ function _pump() {
   while (_queue.length > 0) {
     const req = _queue[0];
 
-    const matchIdx = _free.findIndex((w) => w.mcpServersHash === req.mcpServersHash);
+    const matchIdx = _free.findIndex((w) =>
+      w.mcpServersHash === req.mcpServersHash
+      && w.processContextHash === req.processContextHash
+    );
     if (matchIdx >= 0) {
       _queue.shift();
       const worker = _free.splice(matchIdx, 1)[0];
@@ -165,6 +170,11 @@ async function _reuseWorker(worker, req) {
     await worker.newSession({ mcpServers: req.mcpServers, model: req.model, effort: req.effort, cwd: req.cwd });
     _trace(`dispatch=${req.dispatchId} reuse: worker=${worker.id} sessionId=${worker.sessionId}`);
     _reserved--;
+    if (_draining) {
+      try { worker.close(); } catch { /* already torn down */ }
+      req.reject(new Error('agent-worker-pool: draining'));
+      return;
+    }
     req.resolve(worker);
   } catch (err) {
     _reserved--;
@@ -181,6 +191,11 @@ async function _respawnWorker(stale, req) {
   try {
     const worker = await _bootWorker(req);
     _reserved--;
+    if (_draining) {
+      try { worker.close(); } catch { /* already torn down */ }
+      req.reject(new Error('agent-worker-pool: draining'));
+      return;
+    }
     req.resolve(worker);
   } catch (err) {
     _reserved--;
@@ -193,6 +208,11 @@ async function _spawnFreshWorker(req) {
   try {
     const worker = await _bootWorker(req);
     _reserved--;
+    if (_draining) {
+      try { worker.close(); } catch { /* already torn down */ }
+      req.reject(new Error('agent-worker-pool: draining'));
+      return;
+    }
     req.resolve(worker);
   } catch (err) {
     _reserved--;
@@ -215,6 +235,8 @@ async function _bootWorker(req) {
     effort: req.effort,
     mcpServers: req.mcpServers,
     mcpServersHash: req.mcpServersHash,
+    processEnv: req.processEnv,
+    processContextHash: req.processContextHash,
     cwd: req.cwd,
     internals: _internals,
     trace: _trace,
@@ -246,6 +268,7 @@ function _onWorkerExit(worker) {
   for (const [dispatchId, w] of _busy) {
     if (w === worker) {
       _busy.delete(dispatchId);
+      _clearLeaseContext(dispatchId);
       removed = true;
       break;
     }
@@ -272,6 +295,7 @@ async function _applyHermeticDirs(worker, hermeticDirs) {
       worker.stream(`/add-dir ${dir}`, {
         onDone: () => { _trace(`worker=${worker.id} add-dir ok: ${dir}`); resolve(); },
         onError: (err) => { _trace(`worker=${worker.id} add-dir failed: ${dir} (${err && err.message})`); resolve(); },
+        deferSystemPrompt: true,
       }).catch(() => resolve());
     });
   }
@@ -279,9 +303,20 @@ async function _applyHermeticDirs(worker, hermeticDirs) {
 
 // ── Public API ────────────────────────────────────────────────────────────
 
-async function acquireWorker({ dispatchId, cwd, model, effort, mcpServers, hermeticDirs } = {}) {
+function _clearLeaseContext(dispatchId) {
+  const context = _leaseContexts.get(dispatchId);
+  if (!context) return false;
+  for (const key of Object.keys(context)) delete context[key];
+  _leaseContexts.delete(dispatchId);
+  return true;
+}
+
+async function acquireWorker({
+  dispatchId, cwd, model, effort, mcpServers, hermeticDirs, processEnv, sessionContext,
+} = {}) {
   if (!dispatchId) throw new Error('agent-worker-pool.acquireWorker: dispatchId is required');
-  if (_busy.has(dispatchId)) {
+  if (_draining) throw new Error('agent-worker-pool: draining');
+  if (_busy.has(dispatchId) || _leaseContexts.has(dispatchId)) {
     throw new Error(
       `agent-worker-pool.acquireWorker: dispatchId ${dispatchId} already has an active worker ` +
       '(1 worker : 1 active dispatch invariant — call release() before acquiring again)'
@@ -289,17 +324,42 @@ async function acquireWorker({ dispatchId, cwd, model, effort, mcpServers, herme
   }
 
   const mcpServersHash = hashMcpServers(mcpServers);
-  const req = { dispatchId, cwd, model, effort, mcpServers, mcpServersHash };
+  const workerProcessEnv = processEnv && typeof processEnv === 'object'
+    ? Object.freeze({ ...processEnv })
+    : undefined;
+  const processContextHash = hashProcessContext(workerProcessEnv);
+  const leaseContext = sessionContext && typeof sessionContext === 'object'
+    ? { ...sessionContext }
+    : {};
+  const req = {
+    dispatchId, cwd, model, effort, mcpServers, mcpServersHash,
+    processEnv: workerProcessEnv, processContextHash,
+  };
+  _leaseContexts.set(dispatchId, leaseContext);
 
-  const worker = await new Promise((resolve, reject) => {
-    req.resolve = resolve;
-    req.reject = reject;
-    _queue.push(req);
-    _pump();
-  });
+  let worker;
+  try {
+    worker = await new Promise((resolve, reject) => {
+      req.resolve = resolve;
+      req.reject = reject;
+      _queue.push(req);
+      _pump();
+    });
 
-  await _applyHermeticDirs(worker, hermeticDirs);
-  _busy.set(dispatchId, worker);
+    if (_draining) throw new Error('agent-worker-pool: draining');
+    _busy.set(dispatchId, worker);
+    await _applyHermeticDirs(worker, hermeticDirs);
+    if (worker.killed) throw new Error('agent-worker-pool: worker died during acquisition');
+    if (_draining) throw new Error('agent-worker-pool: draining');
+  } catch (err) {
+    if (_busy.get(dispatchId) === worker) _busy.delete(dispatchId);
+    _clearLeaseContext(dispatchId);
+    if (worker) {
+      try { worker.close(); } catch { /* already torn down */ }
+      _pump();
+    }
+    throw err;
+  }
 
   return {
     dispatchId,
@@ -311,8 +371,20 @@ async function acquireWorker({ dispatchId, cwd, model, effort, mcpServers, herme
     // captured copy), since sessionId can rotate under a reused worker.
     get pid() { return (worker.proc && worker.proc.pid) || null; },
     get sessionId() { return worker.sessionId || null; },
-    stream: (promptText, opts) => worker.stream(promptText, opts),
-    cancel: () => worker.cancel(),
+    stream: async (promptText, opts = {}) => {
+      try {
+        return await worker.stream(promptText, {
+          ...opts,
+          trustedSessionContext: leaseContext,
+        });
+      } finally {
+        _clearLeaseContext(dispatchId);
+      }
+    },
+    cancel: () => {
+      _clearLeaseContext(dispatchId);
+      return worker.cancel();
+    },
     release: () => release(dispatchId),
   };
 }
@@ -325,6 +397,7 @@ async function acquireWorker({ dispatchId, cwd, model, effort, mcpServers, herme
 // never acquired) — safe to call defensively.
 function release(dispatchId) {
   const worker = _busy.get(dispatchId);
+  _clearLeaseContext(dispatchId);
   if (!worker) return false;
   _busy.delete(dispatchId);
   if (worker.killed) {
@@ -332,14 +405,44 @@ function release(dispatchId) {
     _pump();
     return true;
   }
+  if (_draining) {
+    try { worker.close(); } catch { /* already torn down */ }
+    _trace(`dispatch=${dispatchId} release: draining, worker=${worker.id} closed`);
+    return true;
+  }
   _free.push(worker);
   _trace(`dispatch=${dispatchId} release: worker=${worker.id} returned to free set`);
   _pump();
   return true;
 }
 
+function beginDrain() {
+  if (_draining) return;
+  _draining = true;
+  for (const req of _queue.splice(0)) {
+    try { req.reject(new Error('agent-worker-pool: draining')); } catch { /* already settled */ }
+  }
+  for (const worker of _free.splice(0)) {
+    try { worker.close(); } catch { /* already torn down */ }
+  }
+}
+
+function isDraining() {
+  return _draining;
+}
+
+function isDrained() {
+  return _busy.size === 0 && _reserved === 0;
+}
+
+function getActiveLeaseIds() {
+  return [..._busy.keys()];
+}
+
 function shutdown() {
+  _draining = true;
   for (const req of _queue.splice(0)) {
+    _clearLeaseContext(req.dispatchId);
     try { req.reject(new Error('agent-worker-pool: shutdown')); } catch { /* swallow */ }
   }
   for (const worker of _free.splice(0)) {
@@ -349,6 +452,7 @@ function shutdown() {
     try { worker.close(); } catch { /* swallow */ }
   }
   _busy.clear();
+  for (const dispatchId of [..._leaseContexts.keys()]) _clearLeaseContext(dispatchId);
   _reserved = 0;
 }
 
@@ -357,6 +461,10 @@ module.exports = {
   release,
   setPoolSize,
   getPoolSize,
+  beginDrain,
+  isDraining,
+  isDrained,
+  getActiveLeaseIds,
   shutdown,
   DEFAULT_POOL_SIZE,
   // Exposed for unit tests; engine code MUST go through the public API.
@@ -364,4 +472,5 @@ module.exports = {
   _free,
   _busy,
   _queue,
+  _leaseContexts,
 };

package/engine/bridge.js

@@ -1,11 +1,10 @@
 /**
  * engine/bridge.js — Constellation-bridge config + marker accessors.
  *
- * Pure helpers for the `minions bridge ...` subcommand and any future
- * code that wants to inspect or mutate the read-only Constellation bridge
- * surface. The bridge polling logic itself lives in the Constellation
- * repo (P-wi1-bridge-readonly) — this file owns ONLY the on/off flag, the
- * marker-file contract, and atomic config writes for the toggle.
+ * Pure helpers for the `minions bridge ...` subcommand and the versioned
+ * metadata snapshot consumed by Constellation. Minions remains authoritative:
+ * the Constellation agent polls the local dashboard and mirrors only the
+ * allowlisted projection returned by buildBridgeSnapshot().
  *
  * Strict semantics: only the literal boolean `true` enables the bridge.
  * Mirror this check on the Constellation reader to avoid truthy coercion
@@ -24,6 +23,258 @@ const {
 } = shared;
 
 const CONFIG_PATH = path.join(MINIONS_DIR, 'config.json');
+const BRIDGE_SNAPSHOT_PROTOCOL = 'minions.constellation.snapshot';
+const BRIDGE_SNAPSHOT_PROTOCOL_VERSION = 1;
+
+const SNAPSHOT_CAPS = Object.freeze({
+  id: 128,
+  status: 128,
+  agent: 128,
+  title: 512,
+  project: 128,
+  url: 2048,
+  timestamp: 64,
+  shortLabel: 128,
+  branch: 255,
+  name: 128,
+});
+const INACTIVE_AGENT_STATUSES = new Set(['idle', 'available', 'sleeping']);
+
+function _string(value, max, fallback = null) {
+  if (typeof value !== 'string') return fallback;
+  const trimmed = value.trim();
+  if (!trimmed) return fallback;
+  return trimmed.slice(0, max);
+}
+
+function _isoTime(value) {
+  if (value === null || value === undefined || value === '') return undefined;
+  const ms = typeof value === 'number' ? value : Date.parse(String(value));
+  if (!Number.isFinite(ms)) return undefined;
+  return new Date(ms).toISOString().slice(0, SNAPSHOT_CAPS.timestamp);
+}
+
+function _defined(obj) {
+  return Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== undefined));
+}
+
+function _projectList(items, projector) {
+  if (!Array.isArray(items)) return [];
+  const projected = [];
+  for (const item of items) {
+    if (!item || typeof item !== 'object') continue;
+    const value = projector(item);
+    if (value) projected.push(value);
+  }
+  return projected;
+}
+
+function _projectWorkItem(item) {
+  const id = _string(item.id, SNAPSHOT_CAPS.id);
+  if (!id) return null;
+  return _defined({
+    id,
+    title: _string(item.title, SNAPSHOT_CAPS.title, id),
+    type: _string(item.type, SNAPSHOT_CAPS.shortLabel) || undefined,
+    priority: _string(item.priority, SNAPSHOT_CAPS.shortLabel) || undefined,
+    status: _string(item.status, SNAPSHOT_CAPS.status, 'unknown'),
+    project: _string(item.project, SNAPSHOT_CAPS.project) || undefined,
+    agent: _string(item.agent, SNAPSHOT_CAPS.agent) || undefined,
+    createdBy: _string(item.createdBy, SNAPSHOT_CAPS.shortLabel) || undefined,
+    created: _isoTime(item.created),
+    dispatched_to: _string(item.dispatched_to, SNAPSHOT_CAPS.agent) || undefined,
+    dispatched_at: _isoTime(item.dispatched_at),
+    completedAt: _isoTime(item.completedAt || item.completed_at),
+  });
+}
+
+function _projectPullRequest(pr) {
+  const id = _string(pr.id, SNAPSHOT_CAPS.id);
+  const prNumber = Number(pr.prNumber);
+  const url = _string(pr.url, SNAPSHOT_CAPS.url);
+  if (!id || !url || !Number.isInteger(prNumber) || prNumber < 0) return null;
+  return _defined({
+    id,
+    prNumber,
+    title: _string(pr.title, SNAPSHOT_CAPS.title, id),
+    agent: _string(pr.agent, SNAPSHOT_CAPS.agent) || undefined,
+    branch: _string(pr.branch, SNAPSHOT_CAPS.branch) || undefined,
+    reviewStatus: _string(pr.reviewStatus, SNAPSHOT_CAPS.status, 'unknown'),
+    status: _string(pr.status, SNAPSHOT_CAPS.status, 'unknown'),
+    url,
+    created: _isoTime(pr.created),
+    lastReviewedAt: _isoTime(pr.lastReviewedAt),
+    lastPushedAt: _isoTime(pr.lastPushedAt),
+    lastDispatchedAt: _isoTime(pr.lastDispatchedAt),
+    mergeStatus: _string(pr.mergeStatus || pr.mergeStateStatus, SNAPSHOT_CAPS.shortLabel) || undefined,
+    mergeable: typeof pr.mergeable === 'boolean' ? pr.mergeable : undefined,
+    isDraft: typeof pr.isDraft === 'boolean' ? pr.isDraft : undefined,
+    behindBy: Number.isInteger(pr.behindBy) && pr.behindBy >= 0 ? pr.behindBy : undefined,
+  });
+}
+
+function _projectPlan(plan) {
+  const id = _string(plan.id || plan.file, SNAPSHOT_CAPS.id);
+  if (!id) return null;
+  return _defined({
+    id,
+    title: _string(plan.title || plan.summary || plan.plan_summary, SNAPSHOT_CAPS.title, id),
+    status: _string(plan.status, SNAPSHOT_CAPS.status, plan.archived ? 'archived' : 'unknown'),
+    agent: _string(plan.agent || plan.generatedBy || plan.generated_by, SNAPSHOT_CAPS.agent) || undefined,
+    project: _string(plan.project, SNAPSHOT_CAPS.project) || undefined,
+    createdAt: _isoTime(plan.createdAt || plan.generatedAt || plan.generated_at),
+    updatedAt: _isoTime(plan.updatedAt),
+  });
+}
+
+function _projectSchedule(schedule) {
+  const id = _string(schedule.id, SNAPSHOT_CAPS.id);
+  if (!id) return null;
+  return _defined({
+    id,
+    title: _string(schedule.title, SNAPSHOT_CAPS.title, id),
+    status: _string(schedule.status, SNAPSHOT_CAPS.status,
+      schedule.enabled === false ? 'disabled' : 'enabled'),
+    type: _string(schedule.type, SNAPSHOT_CAPS.shortLabel, 'schedule'),
+    project: _string(schedule.project, SNAPSHOT_CAPS.project) || undefined,
+    agent: _string(schedule.agent, SNAPSHOT_CAPS.agent) || undefined,
+    nextRun: _isoTime(schedule.nextRun),
+    lastRun: _isoTime(schedule.lastRun || schedule._lastRun || schedule._lastCompletedAt),
+  });
+}
+
+function _projectDispatch(entry, status) {
+  const id = _string(entry.id, SNAPSHOT_CAPS.id);
+  if (!id) return null;
+  const meta = entry.meta && typeof entry.meta === 'object' ? entry.meta : {};
+  const metaItem = meta.item && typeof meta.item === 'object' ? meta.item : {};
+  const metaProject = meta.project && typeof meta.project === 'object' ? meta.project : {};
+  return _defined({
+    id,
+    agent: _string(entry.agent, SNAPSHOT_CAPS.agent, 'unassigned'),
+    status: _string(entry.status, SNAPSHOT_CAPS.status, status),
+    type: _string(entry.type, SNAPSHOT_CAPS.shortLabel) || undefined,
+    project: _string(entry.project || metaProject.name, SNAPSHOT_CAPS.project) || undefined,
+    workItemId: _string(entry.workItemId || metaItem.id, SNAPSHOT_CAPS.id) || undefined,
+    prId: _string(entry.prId || entry.pr_id, SNAPSHOT_CAPS.id) || undefined,
+    startedAt: _isoTime(entry.startedAt || entry.started_at),
+    completedAt: _isoTime(entry.completedAt || entry.completed_at),
+    outcome: _string(entry.outcome || entry.result, SNAPSHOT_CAPS.shortLabel) || undefined,
+  });
+}
+
+function _projectDispatchQueue(dispatch) {
+  if (!dispatch || typeof dispatch !== 'object') return [];
+  const projected = [];
+  for (const [bucket, status] of [
+    ['pending', 'queued'],
+    ['active', 'active'],
+    ['review', 'review'],
+    ['completed', 'completed'],
+  ]) {
+    const entries = bucket === 'completed' && Array.isArray(dispatch[bucket])
+      ? dispatch[bucket].slice(-20)
+      : dispatch[bucket];
+    projected.push(..._projectList(entries, entry => _projectDispatch(entry, status)));
+  }
+  return projected;
+}
+
+function _projectAgent(agent) {
+  const id = _string(agent.id || agent.agent, SNAPSHOT_CAPS.agent);
+  if (!id) return null;
+  return _defined({
+    agent: id,
+    status: _string(agent.status, SNAPSHOT_CAPS.status, 'unknown'),
+    project: _string(agent.project, SNAPSHOT_CAPS.project) || undefined,
+    currentTaskId: _string(agent.currentTaskId || agent.currentDispatchId, SNAPSHOT_CAPS.id) || undefined,
+    currentTaskTitle: _string(agent.currentTaskTitle || agent.currentTask, SNAPSHOT_CAPS.title) || undefined,
+    updatedAt: _isoTime(agent.updatedAt || agent.lastActionAt),
+  });
+}
+
+/**
+ * Build the complete metadata-only state projection consumed by Constellation.
+ * Every field is copied explicitly so free-text task descriptions, prompts,
+ * completion reports, diffs, comments, paths, logs, and credentials cannot
+ * cross the bridge accidentally.
+ */
+function buildBridgeSnapshot(state = {}) {
+  const generatedAt = _isoTime(state.generatedAt) || new Date().toISOString();
+  const engine = state.control && typeof state.control === 'object' ? state.control : {};
+  const workItems = _projectList(state.workItems, _projectWorkItem);
+  const pullRequests = _projectList(state.pullRequests, _projectPullRequest);
+  const plans = _projectList(state.plans, _projectPlan);
+  const schedules = _projectList(state.schedules, _projectSchedule);
+  const agents = _projectList(state.agents, _projectAgent);
+  const dispatches = _projectDispatchQueue(state.dispatch);
+  const activeAgents = agents.filter(agent => !INACTIVE_AGENT_STATUSES.has(agent.status.toLowerCase())).length;
+  const minionsVersion = _string(state.minionsVersion, SNAPSHOT_CAPS.shortLabel);
+  const engineState = _string(engine.state, SNAPSHOT_CAPS.status, 'unknown');
+  const enginePid = Number.isInteger(engine.pid) && engine.pid > 0 ? engine.pid : null;
+  const projects = Array.isArray(state.projects) ? state.projects : [];
+
+  return {
+    protocol: BRIDGE_SNAPSHOT_PROTOCOL,
+    protocolVersion: BRIDGE_SNAPSHOT_PROTOCOL_VERSION,
+    complete: true,
+    generatedAt,
+    minionsVersion,
+    engine: {
+      state: engineState,
+      pid: enginePid,
+    },
+    entities: {
+      work_item: workItems,
+      pr: pullRequests,
+      plan: plans,
+      schedule: schedules,
+      dispatch: dispatches,
+      agent_status: agents,
+      device_summary: [{
+        name: 'Minions',
+        status: engineState,
+        lastSeen: generatedAt,
+        agentCount: agents.length,
+        activeAgentCount: activeAgents,
+        workItemCount: workItems.length,
+        pullRequestCount: pullRequests.length,
+        planCount: plans.length,
+        scheduleCount: schedules.length,
+        dispatchCount: dispatches.length,
+        projectCount: projects.length,
+        protocolVersion: BRIDGE_SNAPSHOT_PROTOCOL_VERSION,
+        minionsVersion,
+        snapshotGeneratedAt: generatedAt,
+        enginePid,
+      }],
+    },
+  };
+}
+
+function projectSnapshotHealthForBridge(snapshot) {
+  if (!snapshot || typeof snapshot !== 'object') return null;
+  if (snapshot.protocol !== BRIDGE_SNAPSHOT_PROTOCOL) return null;
+  if (snapshot.protocolVersion !== BRIDGE_SNAPSHOT_PROTOCOL_VERSION) return null;
+  if (snapshot.complete !== true || !snapshot.entities || typeof snapshot.entities !== 'object') return null;
+  const entities = snapshot.entities;
+  const summary = Array.isArray(entities.device_summary) ? entities.device_summary[0] || {} : {};
+  const count = key => (Array.isArray(entities[key]) ? entities[key].length : 0);
+  return {
+    protocolVersion: snapshot.protocolVersion,
+    minionsVersion: snapshot.minionsVersion ?? null,
+    engineState: snapshot.engine?.state ?? null,
+    enginePid: snapshot.engine?.pid ?? null,
+    agentCount: count('agent_status'),
+    activeAgentCount: summary.activeAgentCount ?? null,
+    workItemCount: count('work_item'),
+    pullRequestCount: count('pr'),
+    planCount: count('plan'),
+    scheduleCount: count('schedule'),
+    dispatchCount: count('dispatch'),
+    projectCount: summary.projectCount ?? null,
+  };
+}
 
 /**
  * Strict check: `true` ⇔ bridge enabled. Any other shape (missing field,
@@ -118,7 +369,11 @@ module.exports = {
   readBridgeMarker,
   setBridgeEnabled,
   formatRelativeAge,
+  buildBridgeSnapshot,
+  projectSnapshotHealthForBridge,
   projectStatusForBridge,
+  BRIDGE_SNAPSHOT_PROTOCOL,
+  BRIDGE_SNAPSHOT_PROTOCOL_VERSION,
   CONSTELLATION_BRIDGE_MARKER_PATH,
   CONSTELLATION_BRIDGE_MARKER_SCHEMA_VERSION,
 };