@yemi33/minions 0.1.2424 → 0.1.2425

package/engine/qa-sessions.js

@@ -14,8 +14,8 @@
  *             session parks at `awaiting-approval` for human review; in
  *             `auto` mode it auto-chains EXECUTE.
  *   EXECUTE → runs the drafted test against the managed-spawn target, writes
- *             agents/<id>/qa-run-result.json. The existing qa-runs lifecycle
- *             hook (engine/lifecycle.js:4340) ingests the sidecar; this
+ *             the engine-injected absolute qa-run-result.json path. The
+ *             qa-runs lifecycle hook ingests the run-correlated sidecar; this
  *             module then transitions the session done/failed based on the
  *             resulting qa-run terminal status.
  *
@@ -263,7 +263,7 @@ function validateSpec(spec) {
     errors.push(`flowsRaw exceeds ${LIMITS.flowsMax} chars`);
   }
 
-  const mode = spec.mode || 'confirm';
+  const mode = spec.mode === undefined ? 'confirm' : spec.mode;
   if (!VALID_MODES.has(mode)) {
     errors.push('mode must be one of: ' + [...VALID_MODES].join(', '));
   }
@@ -301,17 +301,18 @@ function validateSpec(spec) {
       errors.push(`projects exceeds ${LIMITS.projectsMax} entries`);
     } else {
       const seen = new Set();
-      for (const p of spec.projects) {
+      for (let index = 0; index < spec.projects.length; index += 1) {
+        const p = spec.projects[index];
         if (typeof p !== 'string' || p.length === 0) {
-          errors.push('projects entries must be non-empty strings');
+          errors.push(`projects[${index}] must be a non-empty string`);
           break;
         }
         if (p.length > LIMITS.projectMax) {
-          errors.push(`projects entry exceeds ${LIMITS.projectMax} chars`);
+          errors.push(`projects[${index}] exceeds ${LIMITS.projectMax} chars`);
           break;
         }
         if (seen.has(p)) {
-          errors.push(`projects contains duplicate entry: ${p}`);
+          errors.push(`projects[${index}] duplicates an earlier entry: ${p}`);
           break;
         }
         seen.add(p);
@@ -378,7 +379,7 @@ function createSession(spec) {
     spec: {
       target: { ...spec.target },
       flowsRaw: spec.flowsRaw,
-      mode: spec.mode || 'confirm',
+      mode: spec.mode === undefined ? 'confirm' : spec.mode,
       capture: {
         video: !!(spec.capture && spec.capture.video),
         screenshots: !!(spec.capture && spec.capture.screenshots),
@@ -611,7 +612,7 @@ function setSessionQaRunId(id, qaRunId) {
  * @returns {object} updated session
  * @throws Error on unknown id, unsafe id, or illegal transition
  */
-function transitionSession(id, toState, patch = {}) {
+function transitionSession(id, toState, patch = {}, options = {}) {
   if (!_isSafeSessionId(id)) throw new Error('qa-sessions: unsafe sessionId: ' + id);
   if (!isValidState(toState)) throw new Error('qa-sessions: invalid target state: ' + toState);
 
@@ -621,6 +622,12 @@ function transitionSession(id, toState, patch = {}) {
     if (!Array.isArray(sessions)) sessions = [];
     const session = sessions.find(s => s && s.id === id);
     if (!session) { transitionError = new Error(`qa-sessions: session not found: ${id}`); return sessions; }
+    if (options.expectedState && session.state !== options.expectedState) {
+      transitionError = new Error(
+        `qa-sessions: ${options.action || 'transition'} requires state ${options.expectedState}, got ${session.state}`,
+      );
+      return sessions;
+    }
     try { validateTransition(session.state, toState); }
     catch (e) { transitionError = e; return sessions; }
 
@@ -790,6 +797,8 @@ function buildSetupWorkItem(session, { project, primary, coServices, primaryProj
  * @param {string} [opts.feedback] - natural-language feedback from /edit, threaded into the prompt as steering
  */
 function buildDraftWorkItem(session, { project, feedback } = {}) {
+  const managedSpawnLookupPath = `/api/managed-processes/by-name/${encodeURIComponent(session.managedSpawnName)}`;
+  const testDir = qaTestsDirForSession(session.id);
   const lines = [
     `QA Session ${session.id} — DRAFT phase.`,
     '',
@@ -797,8 +806,8 @@ function buildDraftWorkItem(session, { project, feedback } = {}) {
     `Runner: ${session.spec.runner || '(auto-detected)'}`,
     `Mode: ${session.spec.mode}`,
     '',
-    `Managed-spawn target: \`${session.managedSpawnName}\` (live; query /api/managed-processes/by-name).`,
-    `Write the test file to \`engine/qa-tests/${session.id}/test.<ext>\` using the runner's native format.`,
+    `Managed-spawn target: \`${session.managedSpawnName}\` (live; query ${managedSpawnLookupPath}).`,
+    `Write the test file under \`${testDir}\` using the runner's native format.`,
     'See `playbooks/qa-session-draft.md` for the full contract.',
   ];
   if (feedback) {
@@ -813,10 +822,10 @@ function buildDraftWorkItem(session, { project, feedback } = {}) {
 
 /**
  * Build the EXECUTE work item. The agent invokes the runner against the live
- * spawn, captures artifacts per `capture`, and writes
- * agents/<id>/qa-run-result.json. The existing qaRunId hook at
- * engine/lifecycle.js:4340 ingests the sidecar; our own session hook below
- * transitions done/failed based on the resulting qa-run terminal status.
+ * spawn, captures artifacts per `capture`, and writes the injected absolute
+ * result sidecar. The qaRunId hook in engine/lifecycle.js ingests it; our own
+ * session hook below transitions done/failed based on the resulting qa-run
+ * terminal status.
  *
  * @param {object} session
  * @param {object} opts
@@ -832,12 +841,12 @@ function buildExecuteWorkItem(session, { qaRunId, project } = {}) {
     description: [
       `QA Session ${session.id} — EXECUTE phase.`,
       '',
-      `Run \`engine/qa-tests/${session.id}/${session.testFile || 'test.<ext>'}\` against \`${session.managedSpawnName}\`.`,
+      `Run \`${path.join(qaTestsDirForSession(session.id), session.testFile || 'test.<ext>')}\` against \`${session.managedSpawnName}\`.`,
       `qaRunId: ${qaRunId}`,
       '',
-      'Capture artifacts per session.spec.capture. Write a qa-run-result.json',
-      'sidecar to your agent dir (the engine ingests it and marks the linked',
-      'qa-runs record terminal). See `playbooks/qa-session-execute.md`.',
+      'Capture artifacts per session.spec.capture. Use the engine-injected',
+      'absolute artifact and qa-run-result.json paths so the linked qa-runs',
+      'record can ingest them. See `playbooks/qa-session-execute.md`.',
     ].join('\n'),
     project,
   });
@@ -872,18 +881,26 @@ function _summarizeTarget(target) {
 // dispatch + work-items are lazy-required inside _queueWorkItem to keep
 // `require('./qa-sessions')` cycle-safe at the top of lifecycle.js.
 
-function _queueWorkItem(wi, scope) {
-  shared.mutateWorkItems(scope, (items) => {
-    if (!Array.isArray(items)) items = [];
-    if (!items.some(i => i && i.id === wi.id)) items.push(wi);
-    return items;
-  });
+function _dispatchQueuedWorkItem(wi) {
   const dispatch = require('./dispatch');
   dispatch.addToDispatch({
     type: wi.type,
     agent: wi.agent || null,
     meta: { item: wi, playbook: wi.meta.playbook },
   });
+}
+
+function _persistWorkItem(wi, scope) {
+  shared.mutateWorkItems(scope, (items) => {
+    if (!Array.isArray(items)) items = [];
+    if (!items.some(item => item && item.id === wi.id)) items.push(wi);
+    return items;
+  });
+}
+
+function _queueWorkItem(wi, scope) {
+  _persistWorkItem(wi, scope);
+  _dispatchQueuedWorkItem(wi);
   return wi.id;
 }
 
@@ -1105,6 +1122,60 @@ function handleSetupComplete(sessionId, opts = {}) {
   return wi.id;
 }
 
+function _setupManagedSpawnRequirement(session, project) {
+  const projects = Array.isArray(session?.spec?.projects) ? session.spec.projects : [];
+  const isMulti = projects.length > 1;
+  const isPrimary = !isMulti || project === session.primaryProject;
+  const key = project || '__central__';
+  return {
+    name: session.managedSpawnName + (isPrimary ? '' : '-' + project),
+    wiId: isMulti
+      ? (session.setupStatus?.[key]?.wiId || '')
+      : (session.workItems?.setup || ''),
+  };
+}
+
+function managedSpawnNamesForSession(session) {
+  if (!session || !_isNonEmptyString(session.managedSpawnName)) return [];
+  const projects = Array.isArray(session.spec && session.spec.projects)
+    ? session.spec.projects.filter(_isNonEmptyString)
+    : [];
+  if (projects.length <= 1) return [session.managedSpawnName];
+  const primary = session.primaryProject || projects[0];
+  return projects.map(project => (
+    project === primary ? session.managedSpawnName : `${session.managedSpawnName}-${project}`
+  ));
+}
+
+function handleSetupCompleteAfterManagedSpawn(sessionId, opts = {}) {
+  const session = getSession(sessionId);
+  if (!session) throw new Error('qa-sessions: session not found: ' + sessionId);
+  if (!opts.success) return handleSetupComplete(sessionId, opts);
+
+  const requirement = _setupManagedSpawnRequirement(session, opts.project || null);
+  const record = require('./managed-spawn').getManagedSpecByName(requirement.name);
+  const hasExpectedOwner = _isNonEmptyString(requirement.wiId);
+  const ownerMatches = hasExpectedOwner && record?.owner_wi === requirement.wiId;
+  if (!record || record.alive !== true || record.healthy !== true || !ownerMatches) {
+    let state = 'not registered';
+    if (!hasExpectedOwner) {
+      state = 'missing its expected SETUP work-item owner';
+    } else if (record && !ownerMatches) {
+      state = `owned by work item ${record.owner_wi || 'unknown'} instead of ${requirement.wiId}`;
+    } else if (record) {
+      state = `registered but ${record.alive !== true ? 'not alive' : 'not healthy'}`;
+    }
+    return handleSetupComplete(sessionId, {
+      ...opts,
+      success: false,
+      failureClass: shared.FAILURE_CLASS.INVALID_MANAGED_SPAWN,
+      reason: `managed_spawn target ${requirement.name} is ${state}; QA SETUP cannot advance to DRAFT`,
+    });
+  }
+
+  return handleSetupComplete(sessionId, opts);
+}
+
 /**
  * Lifecycle hook: DRAFT WI completed. On success we either park at
  * awaiting-approval (confirm mode — user must call /approve) or auto-chain
@@ -1202,28 +1273,52 @@ function handleExecuteComplete(sessionId, opts = {}) {
 // ── User-initiated actions (called by dashboard endpoints) ─────────────────
 
 /**
- * POST /api/qa/sessions/<id>/approve — awaiting-approval → executing, queues
- * the EXECUTE WI. Caller creates the qa-runs record and passes its id.
+ * Atomically reserve an approval before its run or work item is created.
  */
-function approveDraft(sessionId, { scope, qaRunId, project } = {}) {
+function beginApproveDraft(sessionId, { qaRunId } = {}) {
+  if (!_isNonEmptyString(qaRunId)) throw new Error('qa-sessions: beginApproveDraft requires qaRunId');
+  return transitionSession(sessionId, QA_SESSION_STATE.EXECUTING, { qaRunId }, {
+    expectedState: QA_SESSION_STATE.AWAITING_APPROVAL,
+    action: 'approveDraft',
+  });
+}
+
+/** Queue EXECUTE after beginApproveDraft has committed its state transition. */
+function queueApprovedDraft(sessionId, { scope, qaRunId, project } = {}) {
   if (!_isNonEmptyString(scope)) throw new Error('qa-sessions: approveDraft requires scope');
   if (!_isNonEmptyString(qaRunId)) throw new Error('qa-sessions: approveDraft requires qaRunId');
-  const session = getSession(sessionId);
-  if (!session) throw new Error('qa-sessions: session not found: ' + sessionId);
-  if (session.state !== QA_SESSION_STATE.AWAITING_APPROVAL) {
-    throw new Error(`qa-sessions: approveDraft requires state awaiting-approval, got ${session.state}`);
-  }
-  markExecuting(sessionId, { qaRunId });
-  const updated = getSession(sessionId);
-  const wi = buildExecuteWorkItem(updated, {
-    qaRunId,
-    project: project || updated.spec.project || null,
+  if (!_isSafeSessionId(sessionId)) throw new Error('qa-sessions: unsafe sessionId: ' + sessionId);
+  let wi = null;
+  mutateQaSessions((sessions) => {
+    const session = sessions.find(item => item && item.id === sessionId);
+    if (!session) throw new Error('qa-sessions: session not found: ' + sessionId);
+    if (session.state !== QA_SESSION_STATE.EXECUTING || session.qaRunId !== qaRunId) {
+      throw new Error(
+        `qa-sessions: queueApprovedDraft requires state executing with matching qaRunId, got ${session.state}`,
+      );
+    }
+    wi = buildExecuteWorkItem(session, {
+      qaRunId,
+      project: project || session.spec.project || null,
+    });
+    _persistWorkItem(wi, scope);
+    if (!session.workItems || typeof session.workItems !== 'object') {
+      session.workItems = { setup: null, draft: null, execute: null };
+    }
+    session.workItems[SESSION_PHASE.EXECUTE] = wi.id;
+    session.updatedAt = ts();
+    _dispatchQueuedWorkItem(wi);
+    return sessions;
   });
-  _queueWorkItem(wi, scope);
-  setSessionWorkItem(sessionId, SESSION_PHASE.EXECUTE, wi.id);
   return wi.id;
 }
 
+/** Back-compatible one-shot wrapper for non-HTTP callers. */
+function approveDraft(sessionId, options = {}) {
+  beginApproveDraft(sessionId, options);
+  return queueApprovedDraft(sessionId, options);
+}
+
 /**
  * POST /api/qa/sessions/<id>/edit — awaiting-approval → drafting, re-queue the
  * DRAFT WI with the user's natural-language feedback threaded into the prompt.
@@ -1372,14 +1467,18 @@ module.exports = {
   // Chain helpers (impure — call dispatch + work-items)
   queueSetup,
   handleSetupComplete,
+  handleSetupCompleteAfterManagedSpawn,
   handleDraftComplete,
   handleExecuteComplete,
   // User actions
+  beginApproveDraft,
+  queueApprovedDraft,
   approveDraft,
   editDraft,
   cancelSession,
   killSession,
   dismissSession,
+  managedSpawnNamesForSession,
   // Status
   summarizeSessionsForStatus,
   summarizeActiveSessionsForStatus,

package/engine/quarantine-refs.js

@@ -1,22 +1,43 @@
 const shared = require('./shared');
 
+const QUARANTINE_REF_RETENTION_MS = 10 * 24 * 60 * 60 * 1000;
+const DELETE_CONCURRENCY = 8;
+
+function quarantineRefCreatedAtMs(ref, fallbackCreatedAt) {
+  const timestamp = String(ref || '').split('/').pop();
+  const fromRef = Number(timestamp);
+  if (Number.isFinite(fromRef) && fromRef > 0) return fromRef;
+  const fallback = Date.parse(fallbackCreatedAt || '');
+  return Number.isFinite(fallback) ? fallback : null;
+}
+
+async function _readProjectQuarantineRefs(project) {
+  const output = await shared.shellSafeGit([
+    'for-each-ref',
+    '--format=%(refname)|%(objectname)|%(creatordate:iso-strict)',
+    'refs/minions/quarantine/',
+    'refs/minions/quarantine-wip/',
+  ], { cwd: project.localPath, timeout: 15000 });
+  const seenRefs = new Set();
+  return String(output || '').split(/\r?\n/).filter(Boolean).map(line => {
+    const [ref, sha, fallbackCreatedAt] = line.split('|');
+    if (!ref || seenRefs.has(ref)) return null;
+    seenRefs.add(ref);
+    const createdAtMs = quarantineRefCreatedAtMs(ref, fallbackCreatedAt);
+    return { ref, sha, fallbackCreatedAt, createdAtMs };
+  }).filter(Boolean);
+}
+
 async function listQuarantineRefs(projects) {
   const candidates = (Array.isArray(projects) ? projects : []).filter(project => project?.localPath);
   const results = await Promise.allSettled(candidates.map(async project => {
-    const localPath = project?.localPath;
-    const output = await shared.shellSafeGit([
-      'for-each-ref',
-      '--format=%(refname)|%(objectname)|%(creatordate:iso-strict)',
-      'refs/minions/quarantine',
-      'refs/minions/quarantine-wip',
-    ], { cwd: localPath, timeout: 15000 });
-    return String(output || '').split(/\r?\n/).filter(Boolean).map(line => {
-      const [ref, sha, createdAt] = line.split('|');
+    const refs = await _readProjectQuarantineRefs(project);
+    return refs.map(({ ref, sha, fallbackCreatedAt, createdAtMs }) => {
       return {
         project: project.name || '',
         ref,
         sha,
-        createdAt: createdAt || '',
+        createdAt: createdAtMs ? new Date(createdAtMs).toISOString() : (fallbackCreatedAt || ''),
         kind: ref.startsWith('refs/minions/quarantine-wip/') ? 'wip' : 'commits',
       };
     });
@@ -30,4 +51,53 @@ async function listQuarantineRefs(projects) {
   return items.sort((a, b) => String(b.createdAt || '').localeCompare(String(a.createdAt || '')));
 }
 
-module.exports = { listQuarantineRefs };
+async function _mapWithConcurrency(items, limit, worker) {
+  let next = 0;
+  const runners = Array.from({ length: Math.min(limit, items.length) }, async () => {
+    while (next < items.length) {
+      const item = items[next++];
+      await worker(item);
+    }
+  });
+  await Promise.all(runners);
+}
+
+async function pruneExpiredQuarantineRefs(projects, {
+  now = Date.now(),
+  retentionMs = QUARANTINE_REF_RETENTION_MS,
+} = {}) {
+  const candidates = (Array.isArray(projects) ? projects : []).filter(project => project?.localPath);
+  const results = await Promise.allSettled(candidates.map(async project => {
+    const refs = await _readProjectQuarantineRefs(project);
+    const expired = refs.filter(item => item.createdAtMs !== null && now - item.createdAtMs >= retentionMs);
+
+    let removed = 0;
+    await _mapWithConcurrency(expired, DELETE_CONCURRENCY, async item => {
+      await shared.shellSafeGit(['update-ref', '-d', item.ref, item.sha], {
+        cwd: project.localPath,
+        timeout: 15000,
+      });
+      removed++;
+    });
+    return removed;
+  }));
+
+  let removed = 0;
+  const errors = [];
+  for (let i = 0; i < results.length; i++) {
+    const result = results[i];
+    if (result.status === 'fulfilled') removed += result.value;
+    else errors.push({
+      project: candidates[i]?.name || '',
+      error: result.reason?.message || String(result.reason),
+    });
+  }
+  return { removed, errors };
+}
+
+module.exports = {
+  QUARANTINE_REF_RETENTION_MS,
+  quarantineRefCreatedAtMs,
+  listQuarantineRefs,
+  pruneExpiredQuarantineRefs,
+};

package/engine/queries.js

@@ -10,6 +10,7 @@ const path = require('path');
 const os = require('os');
 const shared = require('./shared');
 const steering = require('./steering');
+const { normalizeExecutionModel, resolveWorkItemModel } = require('./execution-model');
 
 const { safeRead, safeReadDir, safeJson, safeJsonObj, safeWrite, getProjects, mutateJsonFileLocked,
   parseSkillFrontmatter, KB_CATEGORIES,
@@ -427,6 +428,10 @@ function getMetrics() {
   // SQL is the canonical (and only) metrics store after Phase 9.
   const store = require('./metrics-store');
   const metrics = store.readMetrics() || {};
+  const config = getConfig();
+  const engineConfig = config.engine || {};
+  const configuredAgents = config.agents || {};
+  const { resolveRuntime } = require('./runtimes');
 
   for (const [agentId, m] of Object.entries(metrics)) {
     if (agentId.startsWith('_')) continue;
@@ -493,6 +498,13 @@ function getMetrics() {
       m.totalRuntimeMs = runtimeByAgent[agentId];
       m.timedTasks = runtimeCountByAgent[agentId];
     }
+    const runtimeName = shared.resolveAgentCli(configuredAgents[agentId], engineConfig);
+    m.runtime = runtimeName;
+    try {
+      m.costTracking = resolveRuntime(runtimeName).capabilities?.costTracking === true;
+    } catch {
+      m.costTracking = false;
+    }
   }
 
   return metrics;
@@ -679,6 +691,112 @@ function getInbox() {
 // dispatch.completed (most recent) → done/error
 // neither → idle
 // Metadata (resultSummary, verdict, pr) is carried on dispatch entries.
+function _runtimeModelEvidenceKey(runtime, requestedModel, agentId) {
+  return `${runtime}\0${requestedModel || ''}\0${agentId || ''}`;
+}
+
+function buildRuntimeModelEvidence(dispatch) {
+  const evidence = new Map();
+  for (const section of ['active', 'completed']) {
+    for (const item of (dispatch?.[section] || [])) {
+      const runtime = typeof item?.runtimeName === 'string' ? item.runtimeName.trim() : '';
+      const reported = normalizeExecutionModel(item?.executionModel);
+      const requested = normalizeExecutionModel(item?.requestedModel);
+      if (!runtime || !reported || (requested && requested.toLowerCase() !== 'auto')) continue;
+      const startedAt = Date.parse(item?.started_at || item?.created_at || item?.created || '');
+      const recency = Number.isFinite(startedAt) ? startedAt : 0;
+      for (const agentId of [item?.agent || '', '']) {
+        const key = _runtimeModelEvidenceKey(runtime, requested?.toLowerCase() || '', agentId);
+        const current = evidence.get(key);
+        if (!current || recency >= current.recency) evidence.set(key, { model: reported, recency });
+      }
+    }
+  }
+  return evidence;
+}
+
+function resolveRuntimeModelDisplay({ runtime, configuredModel, agentId, dispatch, evidence } = {}) {
+  const runtimeName = typeof runtime === 'string' ? runtime.trim() : '';
+  const configured = normalizeExecutionModel(configuredModel);
+  const autoSelected = configured && configured.toLowerCase() === 'auto';
+  if (configured && !autoSelected) return { model: configured, source: 'configured' };
+  if (!runtimeName) return { model: null, source: 'unobserved' };
+
+  const index = evidence || buildRuntimeModelEvidence(dispatch || getDispatch());
+  const requested = autoSelected ? 'auto' : '';
+  const latest = index.get(_runtimeModelEvidenceKey(runtimeName, requested, agentId));
+  return latest
+    ? { model: latest.model, source: 'runtime-reported' }
+    : { model: null, source: 'unobserved' };
+}
+
+/**
+ * W-ms0ytfdd000d5a26 — Index each work item's owning dispatch entry so callers
+ * can report the model that ACTUALLY ran rather than re-deriving it from
+ * current config (which would rewrite history whenever an operator repins a
+ * model). An active dispatch is the live run and always beats a completed one;
+ * among entries of the same kind the most recently started wins.
+ *
+ * Note `dispatch.completed` is capped (engine/dispatch.js), so an old work item
+ * can legitimately have no entry here — callers must handle that.
+ */
+function buildWorkItemDispatchIndex(dispatch) {
+  const index = new Map();
+  const startedAtMs = (entry) => Date.parse(entry?.started_at || entry?.created_at || entry?.created || '') || 0;
+  const consider = (entry, active) => {
+    const key = _dispatchWorkItemIdentityKey(entry);
+    if (!key) return;
+    const current = index.get(key);
+    if (!current
+      || (active && !current.active)
+      || (active === current.active && startedAtMs(entry) >= startedAtMs(current.entry))) {
+      index.set(key, { entry, active });
+    }
+  };
+  for (const entry of (dispatch?.completed || [])) consider(entry, false);
+  for (const entry of (dispatch?.active || [])) consider(entry, true);
+  return index;
+}
+
+/**
+ * Current-config runtime + model for an agent, used only as the projection for
+ * work items that have never been dispatched. Shorthands are normalized through
+ * the adapter's own `resolveModel` so the projection matches what dispatch
+ * would actually send — capability-based, never a runtime-name branch.
+ */
+function resolveConfiguredAgentModel(config, agentId, cache) {
+  const key = agentId || '';
+  if (cache && cache.has(key)) return cache.get(key);
+  const engine = config?.engine || {};
+  const agentConfig = (agentId && config?.agents?.[agentId]) || null;
+  const runtimeName = shared.resolveAgentCli(agentConfig, engine);
+  const configured = shared.resolveAgentModel(agentConfig, engine) || null;
+  let model = configured;
+  try {
+    const runtime = require('./runtimes').resolveRuntime(runtimeName);
+    if (typeof runtime?.resolveModel === 'function') model = runtime.resolveModel(configured) || configured;
+  } catch { /* registry unavailable — fall back to the raw configured value */ }
+  const resolved = { runtimeName, model };
+  if (cache) cache.set(key, resolved);
+  return resolved;
+}
+
+/**
+ * Effective-model descriptor for a single work item, shaped like the
+ * `runtime`/`model`/`modelSource` triple getAgents() already publishes:
+ * `{ model, label, source, runtime, persisted }`.
+ */
+function resolveWorkItemModelInfo(item, { config, dispatchIndex, configCache } = {}) {
+  const found = dispatchIndex ? dispatchIndex.get(_workItemIdentityKey(item)) : null;
+  const agentId = item?.dispatched_to || item?.agent || '';
+  const configured = resolveConfiguredAgentModel(config, agentId, configCache);
+  return resolveWorkItemModel({
+    dispatchEntry: found ? found.entry : null,
+    configuredRuntime: configured.runtimeName,
+    configuredModel: configured.model,
+  });
+}
+
 function getAgentStatus(agentId, context = {}) {
   const dispatch = context.dispatch || getDispatch();
 
@@ -771,6 +889,7 @@ function getAgents(config) {
 
   // Include temp agents that are currently active so they show up in agent tiles
   const dispatch = getDispatch();
+  const runtimeModelEvidence = buildRuntimeModelEvidence(dispatch);
   let leanWorkItems = [];
   try { leanWorkItems = getWorkItems(config, { enrich: false }); } catch { /* optional fallback data */ }
   const seen = new Set(roster.map(a => a.id));
@@ -787,11 +906,16 @@ function getAgents(config) {
     // → engine.defaultCli → 'copilot'. Surfaced so the dashboard can show a
     // runtime tag next to the agent name.
     const runtime = shared.resolveAgentCli(a, config.engine || {});
-    // Resolve the model alongside the runtime so the dashboard can render a
-    // sibling chip (W-mpmwxk4y00053271). `resolveAgentModel` returns
-    // `undefined` when neither the per-agent override nor `engine.defaultModel`
-    // is set, which the renderer treats as "runtime default" and omits.
+    // Keep the configured model separate from the display model. When no model
+    // is pinned, the runtime-reported execution model is authoritative.
     const model = shared.resolveAgentModel(a, config.engine || {}) || null;
+    const modelDisplay = resolveRuntimeModelDisplay({
+      runtime,
+      configuredModel: model,
+      agentId: a.id,
+      dispatch,
+      evidence: runtimeModelEvidence,
+    });
     const inboxFiles = allInboxFiles.filter(f => f.includes(a.id));
     let steeringInboxFiles = [];
     try { steeringInboxFiles = steering.listUnreadSteeringMessages(a.id); } catch { steeringInboxFiles = []; }
@@ -826,7 +950,15 @@ function getAgents(config) {
     const chartered = fs.existsSync(path.join(AGENTS_DIR, a.id, 'charter.md'));
     if (lastAction.length > 120) lastAction = lastAction.slice(0, 120) + '...';
     return {
-      ...a, runtime, model, status: s.status, lastAction, lastActionPrefix, lastActionAt,
+      ...a,
+      runtime,
+      model,
+      displayModel: modelDisplay.model,
+      modelSource: modelDisplay.source,
+      status: s.status,
+      lastAction,
+      lastActionPrefix,
+      lastActionAt,
       // Descriptive capability tags; tolerate legacy `skills` configs by
       // normalizing to `expertise` for the dashboard/settings UI.
       expertise: a.expertise ?? a.skills ?? [],
@@ -1896,10 +2028,14 @@ function getWorkItems(config, opts) {
     }
   }
 
-  // Cross-reference with dispatch pending entries to surface skipReason + blockedBy (#617)
+  // Cross-reference with dispatch pending entries to surface allocation gates
+  // and skipReason + blockedBy (#617).
   const pendingByWiId = new Map();
   for (const d of (dispatch.pending || [])) {
-    if (d.meta?.item?.id && d.skipReason) {
+    if (
+      d.meta?.item?.id
+      && (d.skipReason || d._pendingReason || d._worktreeBranchHeld)
+    ) {
       pendingByWiId.set(_dispatchWorkItemIdentityKey(d), d);
     }
   }
@@ -1912,7 +2048,11 @@ function getWorkItems(config, opts) {
     for (const item of allItems) {
       const pendingEntry = pendingByWiId.get(_workItemIdentityKey(item));
       if (!pendingEntry) continue;
-      item._skipReason = pendingEntry.skipReason;
+      if (pendingEntry.skipReason) item._skipReason = pendingEntry.skipReason;
+      if (pendingEntry._pendingReason) item._pendingReason = pendingEntry._pendingReason;
+      if (pendingEntry._worktreeBranchHeld) {
+        item._worktreeBranchHeld = pendingEntry._worktreeBranchHeld;
+      }
       if (pendingEntry.skipReason === 'branch_locked' && pendingEntry.meta?.branch) {
         const blocker = branchToAgent.get(pendingEntry.meta.branch);
         if (blocker) item._blockedBy = blocker;
@@ -1972,6 +2112,9 @@ function getWorkItems(config, opts) {
     if (key) dispatchByWiId[key] = d.id;
   }
   const _agentDirCache = {};
+  // W-ms0ytfdd000d5a26 — effective-model resolution inputs, built once per call.
+  const _wiDispatchIndex = buildWorkItemDispatchIndex(dispatch);
+  const _wiModelConfigCache = new Map();
   const _inboxFiles = safeReadDir(INBOX_DIR);
   const _archiveFiles = safeReadDir(ARCHIVE_DIR);
   // Use snapshot — sync access; cold start before any async warm returns [].
@@ -1999,6 +2142,14 @@ function getWorkItems(config, opts) {
   for (const item of allItems) {
     const arts = shared.isPlainObject(item._artifacts) ? { ...item._artifacts } : {};
     const agentId = item.dispatched_to || item.agent;
+    // W-ms0ytfdd000d5a26 — the model this item actually ran on (or, for items
+    // that never ran, the projection from current config). Persisted dispatch
+    // evidence wins so repinning a model later cannot rewrite history.
+    item._model = resolveWorkItemModelInfo(item, {
+      config,
+      dispatchIndex: _wiDispatchIndex,
+      configCache: _wiModelConfigCache,
+    });
     if (agentId) {
       // Output log — match by dispatch ID (output-{dispatchId}.log)
       const dispatchId = dispatchByWiId[_workItemIdentityKey(item)];
@@ -3268,7 +3419,10 @@ module.exports = {
   _buildNotesByWiMap, // exported for testing
 
   // Agents
-  getAgentStatus, getAgents, getAgentDetail,
+  getAgentStatus, getAgents, getAgentDetail, buildRuntimeModelEvidence, resolveRuntimeModelDisplay,
+
+  // Effective work-item model (W-ms0ytfdd000d5a26)
+  buildWorkItemDispatchIndex, resolveConfiguredAgentModel, resolveWorkItemModelInfo,
 
   // Pull requests
   getPrs, getPullRequests,