@yemi33/minions 0.1.2453 → 0.1.2455

package/engine/core/shared.js

@@ -2044,6 +2044,116 @@ function uid() {
   return Date.now().toString(36) + _uidCounter.toString(36).padStart(4, '0') + crypto.randomBytes(2).toString('hex');
 }
 
+// ---------------------------------------------------------------------------
+// Temporary-agent friendly display identity (W-msd8zdzb00i550a8)
+//
+// Dynamically-created temp agents keep their canonical id (`temp-<uid>`) for
+// ALL machine identity — routing, SQL keys, filesystem paths, logs, APIs,
+// process ownership, memory rules, reconciliation. Friendly naming here is a
+// purely ADDITIVE display identity; it never renames the canonical id.
+//
+// The friendly call sign is DERIVED DETERMINISTICALLY from the immutable
+// canonical id, so it is stable for the agent's whole lifetime and across
+// engine/dashboard restarts and in historical records — with no persisted
+// state (no SQL, no JSON). The active set of agents never influences the
+// derivation, which is exactly what "preserve an already assigned name rather
+// than renaming when the active set changes" requires.
+//
+// Collision handling is deterministic: the call sign is an `<adjective> <name>`
+// pair, each element chosen from a curated, roster-disjoint vocabulary via an
+// independent FNV-1a hash stream of the canonical id. The combined space keeps
+// concurrently-visible temp agents distinct, and the curated `name` list is
+// disjoint from the shipped roster (Ripley/Dallas/Lambert/Rebecca/Ralph) so a
+// call sign never equals a configured display name. The always-visible "Temp"
+// badge disambiguates even in the rare full collision, and the canonical id
+// stays discoverable in tooltips/detail for debugging.
+//
+// NOTE: dashboard/js/agent-identity.js mirrors this vocabulary + algorithm for
+// a client-side fallback. Keep the two in sync (asserted by
+// test/unit/temp-agent-identity.test.js).
+const TEMP_AGENT_CALL_SIGN_ADJECTIVES = [
+  'Cosmic', 'Starry', 'Nebular', 'Twinkly', 'Lunar', 'Solar', 'Astral', 'Galactic',
+  'Stellar', 'Orbital', 'Meteoric', 'Cloudy', 'Sunny', 'Radiant', 'Sparkly', 'Dreamy',
+  'Breezy', 'Drifting', 'Glowing', 'Floaty', 'Skybound', 'Wandering', 'Whirling', 'Shimmery',
+];
+const TEMP_AGENT_CALL_SIGN_NAMES = [
+  'Comet', 'Nova', 'Luna', 'Sol', 'Astro', 'Orion', 'Nebula', 'Pluto',
+  'Halley', 'Vega', 'Rigel', 'Sirius', 'Polaris', 'Stardust', 'Cosmo', 'Nimbus',
+  'Zephyr', 'Aurora', 'Meteor', 'Galaxy', 'Twinkle', 'Cirrus', 'Cygnus', 'Juno',
+];
+
+// Case-insensitive canonical-temp-id test. Legacy mixed-case `Temp-*` ids are
+// treated as temp too; machine identity is unchanged, only display is affected.
+function isTempAgentId(id) {
+  return typeof id === 'string' && /^temp-/i.test(id.trim());
+}
+
+// FNV-1a 32-bit over a string → non-negative integer. Deterministic and
+// dependency-free; mirrored verbatim on the client.
+function _fnv1a32(str) {
+  let h = 0x811c9dc5;
+  for (let i = 0; i < str.length; i++) {
+    h ^= str.charCodeAt(i);
+    h = (h + ((h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24))) >>> 0;
+  }
+  return h >>> 0;
+}
+
+/**
+ * Deterministic friendly call sign for a temp agent id, e.g. "Cosmic Comet".
+ * Returns null for non-temp / malformed ids so callers can fall back to the
+ * canonical id. Derivation depends ONLY on the immutable canonical id.
+ */
+function tempAgentCallSign(id) {
+  if (!isTempAgentId(id)) return null;
+  const key = id.trim().toLowerCase();
+  // Single hash of the canonical id, then slice independent index streams from
+  // its low and high bits. Deriving both indices from ONE hash of the bare id
+  // (rather than hashing `id+':adj'` / `id+':name'`) is deliberate: a trailing
+  // discriminator suffix lets the identical suffix bytes dominate FNV-1a's low
+  // bits, collapsing the joint (adjective,name) distribution for the
+  // long-shared-prefix ids that concurrent temp allocation produces. Slicing
+  // one hash keeps the full id entropy in both indices.
+  const h = _fnv1a32(key);
+  const adj = TEMP_AGENT_CALL_SIGN_ADJECTIVES[h % TEMP_AGENT_CALL_SIGN_ADJECTIVES.length];
+  const name = TEMP_AGENT_CALL_SIGN_NAMES[
+    Math.floor(h / TEMP_AGENT_CALL_SIGN_ADJECTIVES.length) % TEMP_AGENT_CALL_SIGN_NAMES.length
+  ];
+  return `${adj} ${name}`;
+}
+
+/**
+ * Friendly display name for any agent id. For temp ids this is the deterministic
+ * call sign; for configured/permanent agents it is the configured display name
+ * (or the id when unknown). The canonical id is never mutated.
+ */
+function tempAgentDisplayName(id) {
+  return tempAgentCallSign(id) || (typeof id === 'string' ? id : '');
+}
+
+/**
+ * Structured display identity for an agent id. Returns canonical id, friendly
+ * display name, the call sign (temp only), the temporary flag, and a role hint.
+ * API payloads should expose these structured fields rather than replacing ids
+ * with formatted strings, so id-based clients stay compatible.
+ */
+function resolveAgentIdentity(id, config = null) {
+  const canonicalId = typeof id === 'string' ? id : '';
+  const temp = isTempAgentId(canonicalId);
+  const configured = config && config.agents ? config.agents[canonicalId] : null;
+  if (temp) {
+    const callSign = tempAgentCallSign(canonicalId);
+    return { id: canonicalId, displayName: callSign, callSign, isTemp: true, role: 'Temporary Agent' };
+  }
+  return {
+    id: canonicalId,
+    displayName: (configured && configured.name) || canonicalId,
+    callSign: null,
+    isTemp: false,
+    role: (configured && configured.role) || 'Agent',
+  };
+}
+
 /**
  * Return a unique filepath by appending -2, -3, etc. if the file already exists.
  * E.g. uniquePath('/plans/foo.json') → '/plans/foo-2.json' if foo.json exists.
@@ -5937,6 +6047,39 @@ function waitForDispatchFinalization(dispatchId) {
 // Structured completion protocol — fields agents must produce in ```completion blocks
 const COMPLETION_FIELDS = ['status', 'summary', 'files_changed', 'tests', 'pr', 'not_changed', 'failure_class', 'retryable', 'needs_rerun', 'verdict', 'artifacts', 'nonce', 'securityFlags', 'reviewLearnings', 'reviewLearningApplications'];
 
+// Generic runtime-reported billable-unit accumulator (W-msdcgitc).
+//
+// Adapters may report a NON-USD native billable unit — e.g. the Copilot CLI's
+// premium-request count — via `usage.billable = { unit, value, reported }`. This
+// folds such reports into `target.billableUnits[unit] = { total, reported,
+// unavailable }` so the engine accumulates credits by dispatch/agent/day WITHOUT
+// ever branching on the runtime name. USD is deliberately excluded: dollar cost
+// flows through the richer `costUsd` + token path, so routing it here too would
+// double-count. A report whose `reported` is not true (the CLI did not expose the
+// field for this run) is counted as an `unavailable` observation and does NOT
+// advance `total`/`reported`, keeping "unreported" distinct from a genuine 0.
+// The adapter value is already scoped to the finalized unit of work (per
+// invocation / per pooled turn), so summing is correct and no delta-vs-cumulative
+// diffing is required here.
+function accumulateBillableUnits(target, billable) {
+  if (!target || typeof target !== 'object') return;
+  if (!billable || typeof billable !== 'object') return;
+  const unit = billable.unit;
+  if (typeof unit !== 'string' || !unit || unit === 'usd') return;
+  if (!target.billableUnits || typeof target.billableUnits !== 'object') {
+    target.billableUnits = {};
+  }
+  const bucket = target.billableUnits[unit]
+    || { total: 0, reported: 0, unavailable: 0 };
+  if (billable.reported === true && Number.isFinite(billable.value)) {
+    bucket.total += billable.value;
+    bucket.reported += 1;
+  } else {
+    bucket.unavailable += 1;
+  }
+  target.billableUnits[unit] = bucket;
+}
+
 const DEFAULT_AGENT_METRICS = {
   tasksCompleted: 0, tasksErrored: 0,
   prsCreated: 0, prsApproved: 0, prsRejected: 0, prsMerged: 0,
@@ -8702,11 +8845,113 @@ function mergePrAuthorIdentity(existing, incoming) {
   return out;
 }
 
-// Human-readable label for a PR author (typed SQL column + filter/search text).
-function prAuthorLabel(author) {
+// A human-readable name from ONE identity fragment that never contains an email
+// address:
+//  - "Display Name <user@example.com>" → "Display Name"
+//  - "user@example.com"                → "user"   (local-part, domain dropped)
+//  - "Display Name"                    → "Display Name"
+// Any '@' anywhere forces local-part extraction, so a malformed address can
+// never leak through. Returns '' when nothing usable remains.
+function _authorFragmentName(raw) {
+  let s = _authorField(raw, 256);
+  if (!s) return '';
+  // "Name <addr>" — keep the display part when it is a real (non-email) name.
+  const m = s.match(/^\s*"?([^"<]*?)"?\s*<[^>]*>\s*$/);
+  if (m && m[1].trim() && m[1].indexOf('@') === -1) return m[1].trim();
+  if (s.indexOf('@') !== -1) {
+    s = s.replace(/<([^>]*)>/, '$1'); // unwrap a "<addr>"
+    return s.split('@')[0].replace(/^["'<\s]+|["'>\s]+$/g, '').trim();
+  }
+  return s;
+}
+
+// Human-readable author name that NEVER exposes an email address. Prefers a real
+// provider display name / login, and only when the sole usable identity is an
+// email does it fall back to the local-part (no domain). Returns '' (→ renders
+// "Unknown") when nothing usable is present. The structured identity fields
+// (login/id/descriptor) are untouched — this is a presentation label only.
+function prAuthorDisplayName(author) {
   const a = normalizePrAuthorIdentity(author);
   if (!a) return '';
-  return a.displayName || a.login || a.id || '';
+  return _authorFragmentName(a.displayName)
+    || _authorFragmentName(a.login)
+    || _authorField(a.id, 64)
+    || '';
+}
+
+// Human-readable label for a PR author (typed SQL column + filter/search text).
+// Routed through prAuthorDisplayName so the projected label is always email-free.
+function prAuthorLabel(author) {
+  return prAuthorDisplayName(author);
+}
+
+// ── Foreign-author ownership for the AutoFix guardrail (W-msd8pr2300ev95e1) ──
+//
+// Decide whether the CURRENT authenticated identity for a PR's provider authored
+// that PR, so the dashboard can warn when auto-fix is enabled on someone else's
+// PR (Minions would push commits to a PR the operator only asked to read/review).
+//
+// STABLE identities only — never display names or emails:
+//   GitHub: canonical login (case-insensitive) or numeric id.
+//   ADO:    identity id or descriptor (exact), or uniqueName login (ci).
+//
+// Fail CLOSED: returns 'unknown' whenever EITHER the PR author identity or the
+// current provider identity cannot be established. The caller must render an
+// "author ownership unknown" warning rather than treating unknown as self.
+//
+// `selfByProvider` is `{ github: { login, id }, ado: { id, descriptor, login } }`
+// resolved by the caller (queries.js) from the per-provider token identity; a
+// missing provider entry (or empty fields) yields 'unknown' for that provider.
+const PR_AUTHOR_OWNERSHIP = { SELF: 'self', FOREIGN: 'foreign', UNKNOWN: 'unknown' };
+
+function _ciEq(a, b) {
+  const x = _authorField(a, 256).toLowerCase();
+  const y = _authorField(b, 256).toLowerCase();
+  return !!x && x === y;
+}
+function _exactEq(a, b) {
+  const x = _authorField(a, 256);
+  const y = _authorField(b, 256);
+  return !!x && x === y;
+}
+
+function _prProviderFromRecord(pr, author) {
+  const p = _authorField(author && author.provider, 32).toLowerCase();
+  if (p === 'github' || p === 'ado') return p;
+  const id = _authorField(pr && pr.id, 128).toLowerCase();
+  if (id.startsWith('github:') || id.startsWith('gh:')) return 'github';
+  if (id.startsWith('ado:')) return 'ado';
+  const url = _authorField(pr && pr.url, 400).toLowerCase();
+  if (url.includes('github.com')) return 'github';
+  if (url.includes('dev.azure.com') || url.includes('visualstudio.com') || url.includes('/_git/')) return 'ado';
+  return '';
+}
+
+function resolvePrAuthorOwnership(pr, selfByProvider) {
+  const author = normalizePrAuthorIdentity(pr && pr.author);
+  if (!author) return PR_AUTHOR_OWNERSHIP.UNKNOWN;
+  const provider = _prProviderFromRecord(pr, author);
+  if (!provider) return PR_AUTHOR_OWNERSHIP.UNKNOWN;
+  const self = selfByProvider && selfByProvider[provider];
+  if (!self) return PR_AUTHOR_OWNERSHIP.UNKNOWN;
+
+  if (provider === 'github') {
+    const haveSelf = _authorField(self.login, 256) || _authorField(self.id, 64);
+    const haveAuthor = _authorField(author.login, 256) || _authorField(author.id, 64);
+    if (!haveSelf || !haveAuthor) return PR_AUTHOR_OWNERSHIP.UNKNOWN;
+    if (_exactEq(self.id, author.id) || _ciEq(self.login, author.login)) return PR_AUTHOR_OWNERSHIP.SELF;
+    return PR_AUTHOR_OWNERSHIP.FOREIGN;
+  }
+  // ADO: compare stable identity id/descriptor ONLY. ADO `login` is the
+  // uniqueName (a sign-in email), and the guardrail contract forbids comparing
+  // emails, so it is deliberately excluded here.
+  const haveSelf = _authorField(self.id, 64) || _authorField(self.descriptor, 256);
+  const haveAuthor = _authorField(author.id, 64) || _authorField(author.descriptor, 256);
+  if (!haveSelf || !haveAuthor) return PR_AUTHOR_OWNERSHIP.UNKNOWN;
+  if (_exactEq(self.id, author.id) || _exactEq(self.descriptor, author.descriptor)) {
+    return PR_AUTHOR_OWNERSHIP.SELF;
+  }
+  return PR_AUTHOR_OWNERSHIP.FOREIGN;
 }
 
 function _jsonEqual(a, b) {
@@ -9396,16 +9641,35 @@ function classifyPrRefForVerification(prRef, project = null) {
 // .parent_pr_url). Description-only PR mentions are INTENTIONALLY skipped
 // per the "structured-vs-loose split" — enrollment must be intentional.
 //
+// Enrollment mode is type-dependent (W-msd8pr2300ev95e1): mutating PR-requiring
+// types (fix / test / build-fix-complex) enroll AUTO-MANAGED (contextOnly:false)
+// — the normal coding workflow; a read-only `review` WI enrolls CONTEXT-ONLY so
+// a "review this PR" request never silently enables auto-fix on the PR.
+//
 // Returns:
-//   { skipped: true, reason }            — not a pr-requiring type / no ref / no URL / upsert error
-//   { alreadyEnrolled: true, id }        — PR already tracked
-//   { enrolled: true, id, scope }        — newly enrolled
+//   { skipped: true, reason }                       — not a pr-requiring type / no ref / no URL / upsert error
+//   { alreadyEnrolled: true, id }                   — PR already tracked
+//   { enrolled: true, id, scope, contextOnly }      — newly enrolled (contextOnly true for review)
 const _PR_REQUIRING_TYPES = new Set([
   WORK_TYPE.FIX,
   WORK_TYPE.BUILD_FIX_COMPLEX,
   WORK_TYPE.REVIEW,
   WORK_TYPE.TEST,
 ]);
+// W-msd8pr2300ev95e1 — READ-ONLY PR-requiring types. A `review` WI enrolls the
+// PR record so the review dispatch clears the `pr_not_found` gate (the #536
+// rationale), but a human "review this PR" request is one-shot / read-review
+// intent by default: it must NOT enable auto-fix, auto-review, auto-merge, or
+// any future automatic fix / re-review dispatch on someone else's PR. So a
+// review enrollment is context-only. The explicit review WI still dispatches
+// (isExplicitlyRequestedPrDispatch keeps work-item-sourced review dispatches
+// even on a contextOnly PR), and the upsert's non-demote guard means a review
+// WI that happens to target an ALREADY auto-managed PR (a normal coding
+// workflow) never demotes it. Mutating PR-requiring types (fix / test /
+// build-fix-complex) stay auto-managed — that is the normal coding workflow.
+const _READ_ONLY_PR_ENROLL_TYPES = new Set([
+  WORK_TYPE.REVIEW,
+]);
 function autoEnrollPrFromWorkItem(item, project, minionsDir) {
   if (!item || !_PR_REQUIRING_TYPES.has(item.type)) return { skipped: true, reason: 'not-pr-requiring-type' };
   const prRef = extractStructuredWorkItemPrRef(item);
@@ -9420,6 +9684,7 @@ function autoEnrollPrFromWorkItem(item, project, minionsDir) {
   const parsedUrl = parsePrUrl(url);
   const prNum = parsedUrl ? parsedUrl.prNumber : null;
   const prId = getCanonicalPrId(project, prRef, url);
+  const readOnlyEnroll = _READ_ONLY_PR_ENROLL_TYPES.has(item.type);
   try {
     const result = upsertPullRequestRecord(source, {
       id: prId,
@@ -9432,10 +9697,15 @@ function autoEnrollPrFromWorkItem(item, project, minionsDir) {
       status: 'active',
       created: new Date().toISOString(),
       url,
-      contextOnly: false,
+      // Read-review intent enrolls context-only with the per-row automation
+      // controls explicitly OFF (belt-and-suspenders over the contextOnly
+      // default derivation), so no later default change can silently re-enable
+      // auto-fix on a review-enrolled PR.
+      contextOnly: readOnlyEnroll,
+      ...(readOnlyEnroll ? { autoFixEnabled: false, autoReviewEnabled: false } : {}),
     }, { project, itemId: item.id });
     return result.created
-      ? { enrolled: true, id: result.id, scope: stateScope(source) }
+      ? { enrolled: true, id: result.id, scope: stateScope(source), contextOnly: readOnlyEnroll }
       : { alreadyEnrolled: true, id: result.id };
   } catch (e) {
     log('warn', `autoEnrollPrFromWorkItem ${item.id}: ${e.message}`);
@@ -10952,6 +11222,10 @@ module.exports = {
   readPullRequests,
   mutatePullRequests,
   uid,
+  isTempAgentId,
+  tempAgentCallSign,
+  tempAgentDisplayName,
+  resolveAgentIdentity,
   uniquePath,
   moveFileNoClobber,
   isPlainObject,
@@ -11008,7 +11282,7 @@ module.exports = {
   projectWorkSourceWarnings,
   backfillProjectWorkSourceDefaults,
   WORK_ITEM_PRIORITY, WORK_ITEM_PRIORITY_VALUES, WORK_ITEM_PRIORITY_ERROR_CODE, validateWorkItemPriority,
-  WI_STATUS, DONE_STATUSES, PLAN_TERMINAL_STATUSES, isPrdArchived, isDefunctPrd, WORK_TYPE, isFixLikeWorkType, WORKTREE_REQUIRING_TYPES, LIVE_VALIDATION_WORK_TYPES, VALID_WORK_TYPES, resolveWorkItemTypeFromPrdItem, PLAN_STATUS, PRD_ITEM_STATUS, PRD_MATERIALIZABLE, PR_STATUS, PR_POLLABLE_STATUSES, isPrPollable, resolveAbandonedPrRepollWindowMs, getPrAbandonedAtMs, stampPrAbandonedAt, clearPrAbandonedAt, PR_PENDING_REASON, BUILD_STATUS, REVIEW_STATUS, FETCH_TIMEOUT_MS, RETRY_DELAY_MS, ADO_TOKEN_REFRESH_MAX_RETRIES, DISPATCH_RESULT, mutateMetrics, mutateWatches, mutateScheduleRuns, mutatePipelineRuns, mutateManagedProcesses, mutateWorktreePool, mutateQaRuns, mutateQaSessions, trackReviewMetric, queuePlanToPrd, extractPlanDeclaredProject, extractPlanTargetProjects,
+  WI_STATUS, DONE_STATUSES, PLAN_TERMINAL_STATUSES, isPrdArchived, isDefunctPrd, WORK_TYPE, isFixLikeWorkType, WORKTREE_REQUIRING_TYPES, LIVE_VALIDATION_WORK_TYPES, VALID_WORK_TYPES, resolveWorkItemTypeFromPrdItem, PLAN_STATUS, PRD_ITEM_STATUS, PRD_MATERIALIZABLE, PR_STATUS, PR_POLLABLE_STATUSES, isPrPollable, resolveAbandonedPrRepollWindowMs, getPrAbandonedAtMs, stampPrAbandonedAt, clearPrAbandonedAt, PR_PENDING_REASON, BUILD_STATUS, REVIEW_STATUS, FETCH_TIMEOUT_MS, RETRY_DELAY_MS, ADO_TOKEN_REFRESH_MAX_RETRIES, DISPATCH_RESULT, mutateMetrics, accumulateBillableUnits, mutateWatches, mutateScheduleRuns, mutatePipelineRuns, mutateManagedProcesses, mutateWorktreePool, mutateQaRuns, mutateQaSessions, trackReviewMetric, queuePlanToPrd, extractPlanDeclaredProject, extractPlanTargetProjects,
   // W-ms5tb6ha016fda10 — explicit, fail-closed control-plane execution surface
   EXECUTION_SURFACE, EXECUTION_SURFACE_VALUES, CONTROL_PLANE_ELIGIBLE_TYPES, CLOUD_ELIGIBLE_TYPES,
   isControlPlaneEligibleType, validateExecutionSurface, readDeclaredExecutionSurface, isControlPlaneExecution,
@@ -11087,6 +11361,9 @@ module.exports = {
   normalizePrAuthorIdentity,
   mergePrAuthorIdentity,
   prAuthorLabel,
+  prAuthorDisplayName,
+  resolvePrAuthorOwnership,
+  PR_AUTHOR_OWNERSHIP,
   applyPrFieldDelta,
   normalizePrRecord,
   normalizePrRecords,

package/engine/db/migrations/032-review-enrolled-pr-context-only.js

@@ -0,0 +1,95 @@
+// engine/db/migrations/032-review-enrolled-pr-context-only.js
+//
+// W-msd8pr2300ev95e1 — repair PR records that were SILENTLY auto-enrolled by a
+// review request.
+//
+// Regression: PR #536 widened `autoEnrollPrFromWorkItem` from FIX-only to
+// {FIX, REVIEW, TEST} and enrolled every one with `contextOnly:false`. Because
+// `isPrAutoFixEnabled` / `isPrAutoReviewEnabled` derive from `!contextOnly`
+// when no explicit boolean is stored, a human "review this PR" request turned
+// another author's PR into an AUTO-MANAGED record — the engine then dispatched
+// fixes/re-reviews and pushed commits to a PR the operator only asked to read.
+// The code fix makes review enrollment context-only going forward; this
+// migration conservatively repairs records already enrolled that way.
+//
+// CONSERVATIVE, STRUCTURED-PROVENANCE ONLY — never title/description text:
+//   1. status === 'active'                     (don't touch merged/abandoned)
+//   2. contextOnly !== true                    (currently auto-managed by default)
+//   3. NO explicit autoFixEnabled/autoReviewEnabled boolean stored
+//        → an explicitly TRACKED PR (POST /api/pull-requests/link,
+//          /api/pr-action/track, or the per-row automation toggle) always
+//          persists these booleans, so this gate alone preserves every
+//          intentionally-tracked record.
+//   4. agent === 'human'                       (the sentinel autoEnroll stamps;
+//          excludes agent-authored/synced coding PRs, which stay tracked)
+//   5. prdItems links to >= 1 still-existing work item, and EVERY linked,
+//      still-existing work item is type `review` (no fix/test/implement/…):
+//        → proves the record's only provenance is a read-review request. If a
+//          mutating WI is linked, or no linked WI still exists, we cannot prove
+//          review-only provenance and DO NOT touch the record.
+//
+// Repair = set contextOnly:true + autoFixEnabled:false + autoReviewEnabled:false
+// (belt-and-suspenders), matching the new read-review enrollment shape.
+
+function _hasTable(db, table) {
+  return !!db.prepare(`
+    SELECT 1 FROM sqlite_master WHERE type='table' AND name=?
+  `).get(table);
+}
+
+module.exports = {
+  version: 32,
+  description: 'repair review-enrolled PRs to context-only (W-msd8pr2300ev95e1)',
+  up(db) {
+    if (!_hasTable(db, 'pull_requests')) return;
+
+    // Build id -> type map for every work item. Archived items live in the same
+    // `work_items` table (migration 021 added an `archived` column, not a
+    // separate table), so this single scan covers both live and archived rows.
+    const wiTypeById = new Map();
+    if (_hasTable(db, 'work_items')) {
+      for (const row of db.prepare('SELECT id, type FROM work_items').all()) {
+        if (row && row.id) wiTypeById.set(String(row.id), String(row.type || '').trim().toLowerCase());
+      }
+    }
+
+    const rows = db.prepare('SELECT scope, id, agent, status, data FROM pull_requests').all();
+    const update = db.prepare('UPDATE pull_requests SET data = ? WHERE scope = ? AND id = ?');
+
+    let repaired = 0;
+
+    for (const row of rows) {
+      let record;
+      try { record = JSON.parse(row.data); }
+      catch { continue; }
+      if (!record || typeof record !== 'object') continue;
+
+      // (1) active only.
+      if (String(record.status || row.status || '').toLowerCase() !== 'active') continue;
+      // (2) currently auto-managed by default (not already context-only).
+      if (record.contextOnly === true) continue;
+      // (3) no explicit per-row automation booleans → excludes intentional tracking.
+      if (typeof record.autoFixEnabled === 'boolean' || typeof record.autoReviewEnabled === 'boolean') continue;
+      // (4) enrolled under the human sentinel (autoEnroll stamp), not an agent author.
+      if (String(record.agent || row.agent || '').trim().toLowerCase() !== 'human') continue;
+
+      // (5) structured provenance: every linked, still-existing WI is a review.
+      const links = Array.isArray(record.prdItems) ? record.prdItems : [];
+      const knownTypes = [];
+      for (const wiId of links) {
+        const t = wiTypeById.get(String(wiId));
+        if (t) knownTypes.push(t);
+      }
+      if (knownTypes.length === 0) continue; // cannot prove provenance → leave alone
+      if (!knownTypes.every(t => t === 'review')) continue; // a mutating WI is linked → coding workflow
+
+      record.contextOnly = true;
+      record.autoFixEnabled = false;
+      record.autoReviewEnabled = false;
+      update.run(JSON.stringify(record), row.scope, row.id);
+      repaired += 1;
+    }
+
+    console.log(`[db-migrate] v32: repaired ${repaired} review-enrolled PR record(s) to context-only`);
+  },
+};

package/engine/operations/cli.js

@@ -45,6 +45,23 @@ function dispatchSessionBranch(item) {
   );
 }
 
+/**
+ * Coerce a CLI `--thread <id>` value to the positive integer thread id that the
+ * ADO comment layer requires. `--thread` always arrives as a string, but
+ * engine/ado/comment.js#_validateThreadId requires `typeof number`, so passing
+ * the raw string through threw `invalid threadId` for every ADO fix-summary call
+ * (W-msd9os8e00qnd628). Returns the coerced integer, or null when the value is
+ * not a positive integer (the GitHub path keeps the raw string node id and must
+ * not use this). Kept as a pure, exported helper so the coercion is unit-tested
+ * directly rather than only through source inspection.
+ */
+function coerceAdoThreadId(raw) {
+  if (raw === undefined || raw === null || raw === '') return null;
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n <= 0) return null;
+  return n;
+}
+
 function isEngineProcessAlive(control) {
   if (!control?.pid) return false;
   if (control.pid === process.pid) return true;
@@ -2199,6 +2216,13 @@ const commands = {
       console.log('  GitHub: minions pr comment <repo> <prNumber> --agent <id> --kind <k> [--wi <id>] (--body-file <path> | --body <text>)');
       console.log('  ADO:    minions pr comment <prNumber> --host ado --ado-org <org> --ado-project <proj> --repo-id <id> --agent <id> --kind <k> [--wi <id>] (--body-file <path> | --body <text>)');
       console.log('  --resolved              (ADO only) post the thread pre-resolved/closed — for non-actionable FYI/praise notes');
+      console.log('  --thread <id>           reply to an EXISTING originating review thread instead of opening a new one');
+      console.log('                          (ADO: numeric thread id; GitHub: review-thread GraphQL node id)');
+      console.log('  --resolve               with --thread, transition the thread to a resolved/fixed state (fix-summary path)');
+      console.log('  --resolve-status <s>    (ADO only) terminal status for --resolve: fixed (default) | closed');
+      console.log('');
+      console.log('Fix summaries for ADDRESSED review findings should reply to the originating thread with');
+      console.log('--thread <id> --resolve (keyed by structured finding/thread identity) — never open a fresh active thread.');
       console.log('');
       console.log('Posts a PR comment with the hidden minions marker and brand link folded in by the shared');
       console.log('builder — so engine classifiers identify agent-authored comments by');
@@ -2216,7 +2240,7 @@ const commands = {
     const positional = [];
     const flags = {};
     // Valueless boolean flags — present means true, no following value consumed.
-    const BOOLEAN_FLAGS = new Set(['resolved']);
+    const BOOLEAN_FLAGS = new Set(['resolved', 'resolve']);
     let i = 0;
     while (i < rest.length) {
       const a = rest[i];
@@ -2242,6 +2266,17 @@ const commands = {
 
     const isAdo = String(flags.host || '').toLowerCase() === 'ado';
 
+    // `--thread <id>` targets an EXISTING originating review thread: reply on it
+    // and (with `--resolve`) transition it to a resolved/fixed state, instead of
+    // opening a fresh active feedback thread for an addressed finding
+    // (W-msd9os8e00qnd628). `--resolve` is meaningless without a thread to
+    // transition, so require the pair.
+    const threadId = flags.thread;
+    if (flags.resolve === true && (threadId === undefined || threadId === '')) {
+      console.error('error: --resolve requires --thread <id> (the originating review thread to transition)');
+      process.exit(2);
+    }
+
     const agentId = flags.agent;
     const kind = flags.kind;
     const workItemId = flags.wi;
@@ -2287,6 +2322,41 @@ const commands = {
       }
       const orgBase = flags['org-base'] || `https://dev.azure.com/${adoOrg}`;
       const adoComment = require('../ado/comment');
+
+      // ── Reply-to-originating-thread + resolve (fix-summary path) ──
+      // When a thread id is supplied we reply on THAT thread and (with
+      // --resolve) transition it to fixed/closed, rather than creating a new
+      // active thread. --resolve-status picks the terminal status; default
+      // `fixed` for addressed findings, `closed` for non-actionable/deferred.
+      if (threadId !== undefined && threadId !== '') {
+        // ADO thread ids are numeric; `--thread` arrives as a string, and
+        // replyToAdoThread's _validateThreadId requires typeof number. Coerce +
+        // validate here (mirrors the prNumber handling above) so the fix-summary
+        // path doesn't throw `invalid threadId` (W-msd9os8e00qnd628).
+        const adoThreadId = coerceAdoThreadId(threadId);
+        if (adoThreadId === null) {
+          console.error(`error: invalid --thread: ${JSON.stringify(threadId)} (ADO expects a positive integer thread id)`);
+          process.exit(2);
+        }
+        const wantsResolve = flags.resolve === true;
+        const resolveStatus = flags['resolve-status'] || 'fixed';
+        adoComment.replyToAdoThread({
+          orgBase, project, repositoryId, prNumber, threadId: adoThreadId, body, agentId, kind, workItemId,
+          model: executionModel.model,
+          // `active` means "reply only, don't transition" inside replyToAdoThread.
+          status: wantsResolve ? resolveStatus : 'active',
+        }).then((result) => {
+          const parts = [`ADO thread ${result.threadId}`];
+          parts.push(result.replied ? 'replied' : (result.alreadyReplied ? 'reply already present' : 'no reply'));
+          if (wantsResolve) parts.push(result.resolved ? 'resolved' : 'not resolved');
+          console.log(parts.join('; '));
+        }).catch((e) => {
+          console.error(`error: ${e.message}`);
+          process.exit(1);
+        });
+        return;
+      }
+
       adoComment.postAdoPrComment({
         orgBase, project, repositoryId, prNumber, body, agentId, kind, workItemId,
         model: executionModel.model,
@@ -2316,6 +2386,36 @@ const commands = {
       process.exit(2);
     }
     const [repo, prNumberRaw] = positional;
+
+    // ── GitHub review-thread reply + resolve (fix-summary path) ──
+    // A `--thread <nodeId>` on GitHub is an inline review-thread GraphQL node id.
+    // We reply on that thread and resolve it via resolveReviewThread — the only
+    // GitHub surface with a real "resolved" state. Top-level conversation
+    // comments have no such state, so an addressed finding MUST come through
+    // here, not through a fresh `postPrComment` claiming "resolved"
+    // (W-msd9os8e00qnd628). The thread node id is self-contained, so only <repo>
+    // (for per-slug token routing) is required positionally — not <prNumber>.
+    if (threadId !== undefined && threadId !== '') {
+      if (!repo) {
+        console.error('Usage: minions pr comment <repo> --thread <reviewThreadNodeId> --agent <id> --kind <k> [--wi <id>] (--body-file <path> | --body <text>)');
+        process.exit(2);
+      }
+      try {
+        const result = ghComment.replyAndResolveReviewThread({
+          repo, threadId, body, agentId, kind, workItemId, model: executionModel.model,
+          resolve: true,
+        });
+        const parts = [`GitHub review thread ${result.threadId}`];
+        parts.push(result.replied ? 'replied' : (result.alreadyReplied ? 'reply already present' : 'no reply'));
+        parts.push(result.resolved ? 'resolved' : 'not resolved');
+        console.log(parts.join('; '));
+      } catch (e) {
+        console.error(`error: ${e.message}`);
+        process.exit(1);
+      }
+      return;
+    }
+
     if (!repo || prNumberRaw === undefined) {
       console.error('Usage: minions pr comment <repo> <prNumber> --agent <id> --kind <k> [--wi <id>] (--body-file <path> | --body <text>)');
       process.exit(2);
@@ -2518,6 +2618,7 @@ module.exports = {
   _normalizeSessionBranch: normalizeSessionBranch,
   _dispatchSessionBranch: dispatchSessionBranch,
   _resolveCommentExecutionModel: resolveCommentExecutionModel, // exported for testing
+  _coerceAdoThreadId: coerceAdoThreadId, // exported for testing (W-msd9os8e00qnd628)
   // W-mpcyvff6000pf828 (#2653) — heartbeat writer + factory exported for tests
   _writeHeartbeatNow: writeHeartbeatNow,
   _createHeartbeatInterval: createHeartbeatInterval,

package/engine/orchestration/lifecycle.js

@@ -4037,6 +4037,11 @@ function updateMetrics(agentId, dispatchItem, result, taskUsage, prsCreatedCount
       m.totalInputTokens = (m.totalInputTokens || 0) + (taskUsage.inputTokens || 0);
       m.totalOutputTokens = (m.totalOutputTokens || 0) + (taskUsage.outputTokens || 0);
       m.totalCacheRead = (m.totalCacheRead || 0) + (taskUsage.cacheRead || 0);
+      // Non-USD runtime-reported billable units (e.g. Copilot premium requests).
+      // Accumulated generically off typed usage metadata, never a runtime-name
+      // branch (W-msdcgitc). USD is skipped by the helper (it rides the costUsd
+      // path above), so this cannot double-count dollar cost.
+      shared.accumulateBillableUnits(m, taskUsage.billable);
     }
     // Track agent runs in _engine for LLM performance tile (alongside CC/doc-chat)
     if (!metrics._engine) metrics._engine = {};
@@ -4061,6 +4066,7 @@ function updateMetrics(agentId, dispatchItem, result, taskUsage, prsCreatedCount
       eng.outputTokens += taskUsage.outputTokens || 0;
       eng.cacheRead += taskUsage.cacheRead || 0;
       eng.cacheCreation = (eng.cacheCreation || 0) + (taskUsage.cacheCreation || 0);
+      shared.accumulateBillableUnits(eng, taskUsage.billable);
     }
 
     const today = dateStamp();
@@ -4074,6 +4080,7 @@ function updateMetrics(agentId, dispatchItem, result, taskUsage, prsCreatedCount
       daily.inputTokens += taskUsage.inputTokens || 0;
       daily.outputTokens += taskUsage.outputTokens || 0;
       daily.cacheRead += taskUsage.cacheRead || 0;
+      shared.accumulateBillableUnits(daily, taskUsage.billable);
     }
     const cutoff = new Date();
     cutoff.setDate(cutoff.getDate() - 30);

package/engine/orchestration/routing.js

@@ -263,7 +263,10 @@ function resolveAgent(workType, config, opts = {}) {
     _tempBudget--;
     const tempId = `temp-${shared.uid()}`;
     _claimedAgents.add(tempId);
-    tempAgents.set(tempId, { name: `Temp-${tempId.slice(5, 9)}`, role: 'Temporary Agent', createdAt: ts() });
+    // Friendly, deterministic call sign derived from the immutable temp id
+    // (shared.tempAgentCallSign) — stable across restarts; the canonical
+    // `temp-<uid>` id is unchanged and remains the machine identity.
+    tempAgents.set(tempId, { name: shared.tempAgentCallSign(tempId), role: 'Temporary Agent', createdAt: ts() });
     log('info', `Spawning temp agent ${tempId} — all permanent agents busy`);
     return tempId;
   }