@yemi33/minions 0.1.2382 → 0.1.2384

package/engine/llm.js

@@ -18,7 +18,15 @@ const {
   ENGINE_DEFAULTS,
   resolveCcCli, resolveCcModel,
 } = shared;
-const { resolveRuntime } = require('./runtimes');
+const {
+  resolveRuntime,
+  resolveRuntimeByCapability,
+  listRuntimes,
+  RUNTIME_IMAGES_FILE_OPTION,
+  sanitizeInvocationOptions,
+  resolveInvocationOptions,
+  buildSpawnFlags,
+} = require('./runtimes');
 
 const MINIONS_DIR = shared.MINIONS_DIR;
 const ENGINE_DIR = path.join(MINIONS_DIR, 'engine');
@@ -217,15 +225,17 @@ function _runtimeInstallHint(runtimeName, runtime) {
 function _missingRuntimeMessage(runtimeName, runtime, reason) {
   const selected = runtime?.name || runtimeName || 'configured';
   if (!runtime) {
+    const installLines = listRuntimes().map((name) => {
+      const adapter = resolveRuntime(name);
+      return `- ${name}: ${_runtimeInstallHint(name, adapter)}`;
+    });
     return [
       `Minions can't run the configured runtime "${selected}".`,
       '',
       reason || 'The configured runtime is not registered.',
       '',
       'Choose a supported runtime in Settings -> Engine -> defaultCli/ccCli, then install its CLI:',
-      '- Claude Code: npm install -g @anthropic-ai/claude-code or download from https://claude.ai/download',
-      '- OpenAI Codex CLI: npm install -g @openai/codex or brew install --cask codex',
-      '- GitHub Copilot CLI: install via GitHub CLI/gh-copilot or download from https://github.com/github/copilot-cli/releases',
+      ...installLines,
       '',
       'After installing, restart Minions so the dashboard and engine inherit the updated PATH.',
     ].join('\n');
@@ -239,10 +249,9 @@ function _missingRuntimeMessage(runtimeName, runtime, reason) {
     '',
     'After installing, restart Minions so the dashboard and engine inherit the updated PATH.',
   ];
-  if (selected === 'claude') {
-    lines.push('Or switch Settings -> Engine -> defaultCli/ccCli to "copilot" or "codex" after installing another supported runtime.');
-  } else {
-    lines.push('Or switch Settings -> Engine -> defaultCli/ccCli back to "claude" after installing Claude Code.');
+  const alternatives = listRuntimes().filter(name => name !== selected);
+  if (alternatives.length) {
+    lines.push(`Or switch Settings -> Engine -> defaultCli/ccCli to another installed runtime: ${alternatives.join(', ')}.`);
   }
   return lines.join('\n');
 }
@@ -337,37 +346,12 @@ function _runtimeUnavailableResult(callOpts = {}) {
 // ─── Spawn Helpers ───────────────────────────────────────────────────────────
 
 /**
- * Translate the unified opts bag into the named CLI flags consumed by
- * `engine/spawn-agent.js`. spawn-agent.js parses these back into an opts
- * object and calls `runtime.buildArgs(opts)` once — keeping the adapter as
- * the single source of truth and avoiding double-flag emission.
- *
- * Capability gating (matches engine.js _buildAgentSpawnFlags from P-2a6d9c4f):
- *   - effort/sessionId/maxBudget/bare/fallbackModel are dropped when the
- *     runtime's matching capability is false.
- *   - Copilot-specific opts (stream, disableBuiltinMcps,
- *     reasoningSummaries) are emitted unconditionally; the Claude adapter
- *     ignores them via the "tolerate unknown opts" rule.
+ * Encode the semantic invocation options through the stable runtime facade.
+ * Legacy named wrapper flags remain for compatibility; the opaque options bag
+ * is authoritative for adapter fields the wrapper does not know yet.
  */
 function _buildSpawnAgentFlags(runtime, opts = {}) {
-  const caps = (runtime && runtime.capabilities) || {};
-  const flags = ['--runtime', String(runtime?.name || 'claude')];
-
-  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));
-
-  if (caps.effortLevels && opts.effort) flags.push('--effort', String(opts.effort));
-  if (caps.sessionResume && opts.sessionId) flags.push('--resume', String(opts.sessionId));
-  if (caps.budgetCap && opts.maxBudget != null) flags.push('--max-budget-usd', String(opts.maxBudget));
-  if (caps.bareMode && opts.bare === true) flags.push('--bare');
-  if (caps.fallbackModel && opts.fallbackModel) flags.push('--fallback-model', String(opts.fallbackModel));
-
-  if (opts.stream === 'on' || opts.stream === 'off') flags.push('--stream', opts.stream);
-  if (opts.disableBuiltinMcps === true) flags.push('--disable-builtin-mcps');
-  if (opts.reasoningSummaries === true) flags.push('--enable-reasoning-summaries');
-
-  return flags;
+  return buildSpawnFlags(runtime, opts);
 }
 
 /**
@@ -379,15 +363,12 @@ function _buildSpawnAgentFlags(runtime, opts = {}) {
  *
  * Indirect path: uses engine/spawn-agent.js — mostly a fallback when the
  *   direct path can't resolve the binary cache. spawn-agent.js handles
- *   adapter resolution itself; we just hand it `--runtime <name>` plus the
- *   named flags it knows how to parse.
+ *   adapter resolution itself; we hand it the runtime plus an opaque options
+ *   bag, so adding a harness flag does not require wrapper changes.
  */
 function _spawnProcess(promptText, sysPromptText, callOpts) {
   const {
-    direct, label, runtime, model, maxTurns, allowedTools, effort, sessionId,
-    maxBudget, bare, fallbackModel,
-    stream, disableBuiltinMcps, reasoningSummaries,
-    images,
+    direct, label, runtime, adapterOptions = {},
   } = callOpts;
 
   const id = uid();
@@ -399,24 +380,10 @@ function _spawnProcess(promptText, sysPromptText, callOpts) {
   const cleanupFiles = [];
   const cleanupDirs = [llmTmpDir];
   const caps = (runtime && runtime.capabilities) || {};
-  const adapterOpts = {
-    model, maxTurns, allowedTools, effort, sessionId,
-    maxBudget, bare, fallbackModel,
-    stream, disableBuiltinMcps, reasoningSummaries,
-    images,
+  const adapterOpts = sanitizeInvocationOptions(runtime, {
+    ...adapterOptions,
     tmpDir: llmTmpDir,
-  };
-  // Capability-gate per-flag opts before prompt construction so adapters can
-  // make resume-aware prompt decisions from the same opts used for argv.
-  if (!caps.effortLevels) adapterOpts.effort = undefined;
-  if (!caps.sessionResume) adapterOpts.sessionId = undefined;
-  if (!caps.budgetCap) adapterOpts.maxBudget = undefined;
-  if (!caps.bareMode) adapterOpts.bare = undefined;
-  if (!caps.fallbackModel) adapterOpts.fallbackModel = undefined;
-  // P-7b2e4d01 — defense in depth: never forward images to a runtime that
-  // can't read them (callLLM/callLLMStreaming already gate + surface a typed
-  // error upstream; this protects any other _spawnProcess caller).
-  if (!caps.imageInput) adapterOpts.images = undefined;
+  });
   const finalPrompt = runtime.buildPrompt(promptText, sysPromptText, adapterOpts);
 
   // ── Direct path ──
@@ -426,7 +393,7 @@ function _spawnProcess(promptText, sysPromptText, callOpts) {
     // Only write a sys-prompt tmp file when the runtime actually consumes one
     // via --system-prompt-file (Claude) AND we're not resuming (resumed sessions
     // already have the sys prompt baked in).
-    if (!sessionId && sysPromptText && caps.systemPromptFile) {
+    if (!adapterOpts.sessionId && sysPromptText && caps.systemPromptFile) {
       sysTmpPath = path.join(llmTmpDir, `direct-sys-${id}.md`);
       fs.writeFileSync(sysTmpPath, sysPromptText);
       cleanupFiles.push(sysTmpPath);
@@ -472,12 +439,16 @@ function _spawnProcess(promptText, sysPromptText, callOpts) {
   const pidPath = promptPath.replace(/prompt-/, 'pid-').replace(/\.md$/, '.pid');
   cleanupFiles.push(promptPath, sysPath, pidPath);
 
-  const spawnScript = path.join(ENGINE_DIR, 'spawn-agent.js');
-  const adapterFlags = _buildSpawnAgentFlags(runtime, {
-    model, maxTurns, allowedTools, effort, sessionId,
-    maxBudget, bare, fallbackModel,
-    stream, disableBuiltinMcps, reasoningSummaries,
-  });
+  const spawnScript = runtime.spawnScript || path.join(ENGINE_DIR, 'spawn-agent.js');
+  const indirectAdapterOpts = { ...adapterOpts };
+  if (Array.isArray(indirectAdapterOpts.images) && indirectAdapterOpts.images.length) {
+    const imagesPath = path.join(llmTmpDir, `runtime-images-${id}.json`);
+    safeWrite(imagesPath, JSON.stringify(indirectAdapterOpts.images));
+    cleanupFiles.push(imagesPath);
+    indirectAdapterOpts[RUNTIME_IMAGES_FILE_OPTION] = imagesPath;
+    delete indirectAdapterOpts.images;
+  }
+  const adapterFlags = _buildSpawnAgentFlags(runtime, indirectAdapterOpts);
   const args = [spawnScript, promptPath, sysPath, ...adapterFlags];
 
   const proc = runFile(process.execPath, args, {
@@ -692,11 +663,16 @@ function _resolveModelForRuntime(runtime, callOpts) {
 function _resolveRuntimeFeatureOpts({
   stream, disableBuiltinMcps, reasoningSummaries, engineConfig,
 } = {}) {
-  const engine = engineConfig || {};
+  const runtime = resolveRuntimeByCapability('acpWorkerPool');
+  const resolved = resolveInvocationOptions(runtime, {
+    stream,
+    disableBuiltinMcps,
+    reasoningSummaries,
+  }, { engineConfig: engineConfig || {} });
   return {
-    stream: stream ?? engine.copilotStreamMode,
-    disableBuiltinMcps: disableBuiltinMcps ?? engine.copilotDisableBuiltinMcps,
-    reasoningSummaries: reasoningSummaries ?? engine.copilotReasoningSummaries,
+    stream: resolved.stream,
+    disableBuiltinMcps: resolved.disableBuiltinMcps,
+    reasoningSummaries: resolved.reasoningSummaries,
   };
 }
 
@@ -770,17 +746,17 @@ function callLLM(promptText, sysPromptText, opts = {}) {
   const model = _resolveModelForRuntime(runtime, { model: modelOverride, engineConfig });
   const imageGate = _resolveImageOpts(images, runtime && runtime.capabilities);
   if (imageGate.error) return _resolvedCallResult(_imageUnsupportedResult(runtime, imageGate.error));
-  const runtimeFeatureOpts = _resolveRuntimeFeatureOpts({
-    stream, disableBuiltinMcps, reasoningSummaries, engineConfig,
-  });
+  const runtimeOptions = resolveInvocationOptions(runtime, {
+    model, maxTurns, allowedTools, effort, sessionId,
+    maxBudget, bare, fallbackModel, images: imageGate.images,
+    stream, disableBuiltinMcps, reasoningSummaries,
+  }, { engineConfig: engineConfig || {} });
 
   let _abort = null;
   const promise = new Promise((resolve) => {
     const _startMs = Date.now();
     const { proc, cleanupFiles, cleanupDirs } = _spawnProcess(promptText, sysPromptText, {
-      direct, label, runtime, model, maxTurns, allowedTools, effort, sessionId,
-      maxBudget, bare, fallbackModel, images: imageGate.images,
-      ...runtimeFeatureOpts,
+      direct, label, runtime, adapterOptions: runtimeOptions,
     });
     let resolved = false;
     let exitFallbackTimer = null;
@@ -895,17 +871,17 @@ function callLLMStreaming(promptText, sysPromptText, opts = {}) {
   const model = _resolveModelForRuntime(runtime, { model: modelOverride, engineConfig });
   const imageGate = _resolveImageOpts(images, runtime && runtime.capabilities);
   if (imageGate.error) return _resolvedCallResult(_imageUnsupportedResult(runtime, imageGate.error));
-  const runtimeFeatureOpts = _resolveRuntimeFeatureOpts({
-    stream, disableBuiltinMcps, reasoningSummaries, engineConfig,
-  });
+  const runtimeOptions = resolveInvocationOptions(runtime, {
+    model, maxTurns, allowedTools, effort, sessionId,
+    maxBudget, bare, fallbackModel, images: imageGate.images,
+    stream, disableBuiltinMcps, reasoningSummaries,
+  }, { engineConfig: engineConfig || {} });
 
   let _abort = null;
   const promise = new Promise((resolve) => {
     const _startMs = Date.now();
     const { proc, cleanupFiles, cleanupDirs } = _spawnProcess(promptText, sysPromptText, {
-      direct, label, runtime, model, maxTurns, allowedTools, effort, sessionId,
-      maxBudget, bare, fallbackModel, images: imageGate.images,
-      ...runtimeFeatureOpts,
+      direct, label, runtime, adapterOptions: runtimeOptions,
     });
     let resolved = false;
     let exitFallbackTimer = null;

package/engine/managed-spawn.js

@@ -302,7 +302,22 @@ function _validateSpec(spec, index, limits, opts) {
   if (typeof spec.cwd === 'string' && spec.cwd.length > 500) {
     return { ok: false, reason: 'cwd-too-long' };
   }
-  if (_resolveRequireGitWorkdir(opts) && typeof spec.cwd === 'string' && spec.cwd.length > 0) {
+  if (opts.allowedCwdRoot) {
+    if (typeof spec.cwd !== 'string' || spec.cwd.length === 0) {
+      return { ok: false, reason: INVALID_WORKDIR_REASON_PREFIX + 'cwd-required-for-dispatch-confinement' };
+    }
+    try {
+      const cwdReal = shared.realPathForComparison(spec.cwd);
+      const rootReal = shared.realPathForComparison(opts.allowedCwdRoot);
+      if (!shared.isPathInsideOrEqual(cwdReal, rootReal)) {
+        return { ok: false, reason: INVALID_WORKDIR_REASON_PREFIX + 'cwd-outside-dispatch-worktree' };
+      }
+    } catch (err) {
+      return { ok: false, reason: INVALID_WORKDIR_REASON_PREFIX + 'cwd-containment-check-failed (' + err.message + ')' };
+    }
+  }
+  let normalizedCwd = typeof spec.cwd === 'string' ? spec.cwd : '';
+  if (_resolveRequireGitWorkdir(opts) && normalizedCwd.length > 0) {
     const wt = shared.isValidGitWorktree(spec.cwd, { memo: opts._gitWorktreeMemo });
     if (!wt.ok) {
       // W-mpbpa01y000qcdc2 — enrich the reject reason so the dispatcher prompt
@@ -319,6 +334,12 @@ function _validateSpec(spec, index, limits, opts) {
       return { ok: false, reason: INVALID_WORKDIR_REASON_PREFIX + detail };
     }
   }
+  if (normalizedCwd) {
+    try { normalizedCwd = shared.realPathForComparison(normalizedCwd); }
+    catch (err) {
+      return { ok: false, reason: INVALID_WORKDIR_REASON_PREFIX + 'cwd-canonicalization-failed (' + err.message + ')' };
+    }
+  }
 
   // env (optional). Validation has three independent layers:
   //   1. Shape guard: key matches /^[A-Za-z_][A-Za-z0-9_]*$/ (argv-smuggling
@@ -339,7 +360,7 @@ function _validateSpec(spec, index, limits, opts) {
   if (envKeys.length > maxEnv) {
     return { ok: false, reason: 'env-too-many (>' + maxEnv + ')' };
   }
-  const projectForSpec = _resolveProjectForCwd(
+  const projectForSpec = opts.project || _resolveProjectForCwd(
     typeof spec.cwd === 'string' ? spec.cwd : '',
     opts && Array.isArray(opts.projects) ? opts.projects : null,
   );
@@ -411,7 +432,7 @@ function _validateSpec(spec, index, limits, opts) {
       name: spec.name,
       cmd: spec.cmd,
       args: args,
-      cwd: typeof spec.cwd === 'string' ? spec.cwd : '',
+      cwd: normalizedCwd,
       env: env,
       ports: ports,
       ttl_minutes: ttlMinutes,
@@ -585,7 +606,7 @@ function buildManagedSpawnHint(opts) {
     '      "name": "constellation-host",',
     '      "cmd": "bun",',
     '      "args": ["run", "dev"],',
-    '      "cwd": "D:/repos/constellation",',
+    '      "cwd": "<absolute path at or below MINIONS_AGENT_CWD>",',
     '      "env": { "VITE_HOST": "127.0.0.1" },',
     '      "ports": [3001],',
     '      "ttl_minutes": ' + ttl + ',',
@@ -624,6 +645,7 @@ function buildManagedSpawnHint(opts) {
     '- Ports: 1024–65535, ≤ 20 per spec',
     '- TTL: ≤ ' + maxTtl + ' minutes (hard cap), defaults to ' + defaultTtl + ' if omitted',
     '- `attrs` serialized: ≤ 2048 bytes (opaque blob the engine surfaces to downstream agents)',
+    '- `cwd`: must resolve at or below this dispatch\'s `MINIONS_AGENT_CWD`. A worktree-mode project\'s operator checkout is rejected even though it is a valid Git checkout.',
     '',
     'If your file is invalid the engine marks this dispatch ERROR with `failure_class: invalid-managed-spawn` (non-retryable) — fix the file shape, don\'t retry blindly.',
     '',
@@ -875,6 +897,9 @@ function _toStateRecord(spec, runtime, ctx) {
     owner_agent: (ctx && ctx.owner_agent) || '',
     owner_wi: (ctx && ctx.owner_wi) || '',
     owner_project: (ctx && ctx.owner_project) || '',
+    owner_work_type: (ctx && ctx.owner_work_type) || '',
+    dispatch_root: (ctx && ctx.dispatch_root) || '',
+    checkout_mode: (ctx && ctx.checkout_mode) || '',
     cmd: spec.cmd,
     args: Array.isArray(spec.args) ? spec.args.slice() : [],
     cwd: typeof spec.cwd === 'string' ? spec.cwd : '',
@@ -1265,7 +1290,69 @@ function computeManagedSpecsEtag(opts) {
   return crypto.createHash('sha1').update(json).digest('hex').slice(0, 16);
 }
 
-function restartManagedSpec(name) {
+function validateManagedSpecExecutionContext(record, opts) {
+  opts = opts || {};
+  if (!record || typeof record.cwd !== 'string' || !record.cwd) {
+    return { ok: false, reason: 'cwd-missing' };
+  }
+  let projects;
+  try {
+    projects = Array.isArray(opts.projects) ? opts.projects : shared.getProjects(opts.config);
+  } catch {
+    return { ok: false, reason: 'project-config-unavailable' };
+  }
+  const project = record.owner_project
+    ? shared.findProjectByName(projects, record.owner_project)
+    : null;
+  for (const candidate of projects) {
+    if (!candidate?.localPath) continue;
+    const candidateMode = shared.resolveCheckoutMode(
+      candidate,
+      record.owner_work_type || shared.WORK_TYPE.IMPLEMENT,
+    );
+    if (candidateMode !== shared.CHECKOUT_MODES.WORKTREE) continue;
+    try {
+      if (shared.pathsOverlap(record.cwd, candidate.localPath)) {
+        return { ok: false, reason: 'cwd-overlaps-worktree-mode-operator-checkout' };
+      }
+    } catch {
+      return { ok: false, reason: 'cwd-overlap-check-failed' };
+    }
+  }
+  const mode = project
+    ? shared.resolveCheckoutMode(project, record.owner_work_type || shared.WORK_TYPE.IMPLEMENT)
+    : shared.CHECKOUT_MODES.WORKTREE;
+  if (project && mode === shared.CHECKOUT_MODES.LIVE) {
+    if (record.dispatch_root && !shared.sameResolvedPath(record.dispatch_root, project.localPath)) {
+      return { ok: false, reason: 'live-dispatch-root-mismatch' };
+    }
+    try {
+      if (!shared.isPathInsideOrEqual(record.cwd, project.localPath)) {
+        return { ok: false, reason: 'live-cwd-outside-project' };
+      }
+    } catch {
+      return { ok: false, reason: 'live-cwd-unavailable' };
+    }
+    return { ok: true, project, mode };
+  }
+
+  if (!record.dispatch_root) {
+    return record.checkout_mode
+      ? { ok: false, reason: 'dispatch-root-missing' }
+      : { ok: true, legacy: true, project, mode };
+  }
+  try {
+    shared.assertWorktreeOutsideProjects(record.dispatch_root, projects);
+    if (!shared.isPathInsideOrEqual(record.cwd, record.dispatch_root)) {
+      return { ok: false, reason: 'cwd-outside-dispatch-root' };
+    }
+  } catch {
+    return { ok: false, reason: 'dispatch-root-inside-operator-checkout' };
+  }
+  return { ok: true, project, mode };
+}
+
+function restartManagedSpec(name, opts) {
   if (typeof name !== 'string' || name.length === 0) {
     throw new Error('restartManagedSpec: name required');
   }
@@ -1273,6 +1360,11 @@ function restartManagedSpec(name) {
   if (!existing) {
     throw new Error('restartManagedSpec: spec not found: ' + name);
   }
+  const executionContext = validateManagedSpecExecutionContext(existing, opts);
+  if (!executionContext.ok) {
+    try { removeManagedSpec(name); } catch {}
+    throw new Error('restartManagedSpec: unsafe persisted execution context (' + executionContext.reason + ')');
+  }
   // Reconstruct a sidecar-shaped spec from the persisted state row. The
   // state shape keeps cmd/args/cwd/env/ports/attrs/healthcheck verbatim
   // (see _toStateRecord), so this is a direct projection.
@@ -1299,6 +1391,9 @@ function restartManagedSpec(name) {
     owner_agent: existing.owner_agent || '',
     owner_wi: existing.owner_wi || '',
     owner_project: existing.owner_project || '',
+    owner_work_type: existing.owner_work_type || '',
+    dispatch_root: existing.dispatch_root || '',
+    checkout_mode: existing.checkout_mode || '',
   };
   const runtime = spawnManagedSpec(spec, ctx);
   // recordManagedSpec replaces by name (item 2 idempotency contract) and
@@ -1380,6 +1475,12 @@ function _runManagedReconcile(opts) {
   const killBatch = typeof opts.killBatch === 'function'
     ? opts.killBatch
     : shared.killByPidsImmediate;
+  let projects;
+  try {
+    projects = Array.isArray(opts.projects) ? opts.projects : shared.getProjects(opts.config);
+  } catch {
+    projects = [];
+  }
   const stats = {
     scanned: 0,
     ttlExpired: 0,
@@ -1413,6 +1514,11 @@ function _runManagedReconcile(opts) {
         stats.deadDropped++;
         continue; // dead + not expired → drop
       }
+      const executionContext = validateManagedSpecExecutionContext(rec, { projects });
+      if (!executionContext.ok) {
+        ttlPidsToKill.push(rec.pid);
+        continue;
+      }
       kept.push(rec);
       survivors.push({ name: rec.name, log_path: rec.log_path || '', healthy: rec.healthy === true, last_health_at: rec.last_health_at || 0 });
     }
@@ -1550,6 +1656,7 @@ module.exports = {
   // Item 4 (P-4b8d2e57): discovery API (etag + state-driven respawn).
   computeManagedSpecsEtag: computeManagedSpecsEtag,
   restartManagedSpec: restartManagedSpec,
+  validateManagedSpecExecutionContext: validateManagedSpecExecutionContext,
   // Item 7 (P-8a4d6f29): TTL sweep + boot reconcile + project cleanup.
   sweepManagedSpawn: sweepManagedSpawn,
   bootReconcileManagedSpawn: bootReconcileManagedSpawn,

package/engine/memory-store.js

@@ -269,10 +269,12 @@ function searchMemoryRecords(query, options = {}) {
   }
   const limit = Math.max(1, Math.min(200, Number(options.limit) || 50));
   args.push(limit);
+  // CROSS JOIN pins FTS as the outer loop; Node 22's SQLite otherwise prefers
+  // the scope index and evaluates MATCH once for every scoped record.
   const sql = `
     SELECT m.*, bm25(memory_records_fts, 5.0, 1.0, 2.0, 3.0) AS fts_rank
     FROM memory_records_fts
-    JOIN memory_records m ON m.rowid=memory_records_fts.rowid
+    CROSS JOIN memory_records m ON m.rowid=memory_records_fts.rowid
     WHERE ${where.join(' AND ')}
     ORDER BY fts_rank
     LIMIT ?

package/engine/playbook.js

@@ -1214,12 +1214,10 @@ function formatPrContextSuffix(pr) {
 // ─── Work Discovery Helpers ──────────────────────────────────────────────────
 
 function buildBaseVars(agentId, config, project) {
-  // W-mq15r0cx — surface the LLM model id alongside the agent name so PR
-  // comment sign-offs can stamp `<agent> · <model>` and humans can tell
-  // which agent + which model authored the comment. Falls through to
-  // 'unknown' (defensive only) rather than crashing or omitting the
-  // field when neither agent.model nor engine.defaultModel resolves —
-  // omitting would leave a dangling `· ` in the rendered sign-off.
+  // This is the provisional requested model used in prompt examples. The
+  // `minions pr comment` path replaces it with runtime/session evidence from
+  // the active dispatch before posting; `unknown` survives only when neither
+  // runtime nor requested-model evidence exists.
   const resolvedModel = shared.resolveAgentModel(
     config?.agents?.[agentId] || null,
     config?.engine || null