@yemi33/minions 0.1.2453 → 0.1.2455

package/engine/ado/comment.js

@@ -31,18 +31,68 @@
  * `active` (1). ADO honors the status field on thread creation, so unlike GitHub
  * this needs no second API round-trip. Actionable comments (bugs, required
  * changes) stay `active` so they block/notify the author.
+ *
+ * Fix summaries on the ORIGINATING thread (W-msd9os8e00qnd628):
+ * `replyToAdoThread` posts a fix-summary reply onto an existing review thread
+ * and transitions that thread to `fixed` (2) / `closed` (4), rather than opening
+ * a fresh active summary thread. It reads the thread first so retries / restarts
+ * / duplicate callbacks are idempotent (marker-keyed reply dedupe; already-
+ * resolved threads left as-is) and a reply/PATCH partial failure is surfaced and
+ * retryable.
  */
 
-const { buildMinionsCommentBody } = require('../providers/comment-format');
+const { buildMinionsCommentBody, parseMinionsMarker } = require('../providers/comment-format');
 const { acquireAdoToken } = require('./token');
 
 const ADO_API_VERSION = '7.1';
 
-// ADO CommentThreadStatus enum values we use. `active` (1) is the default for
-// actionable threads; `closed` (4) is used for non-actionable threads posted
-// pre-resolved so they don't clutter the PR with noise the author must triage.
+// ADO CommentThreadStatus enum. `active` (1) is the default for actionable
+// threads; `fixed` (2) records a finding the fix agent addressed; `closed` (4)
+// is used for non-actionable threads posted pre-resolved so they don't clutter
+// the PR with noise the author must triage.
+const ADO_THREAD_STATUS_UNKNOWN = 0;
 const ADO_THREAD_STATUS_ACTIVE = 1;
+const ADO_THREAD_STATUS_FIXED = 2;
+const ADO_THREAD_STATUS_WONT_FIX = 3;
 const ADO_THREAD_STATUS_CLOSED = 4;
+const ADO_THREAD_STATUS_BY_DESIGN = 5;
+const ADO_THREAD_STATUS_PENDING = 6;
+
+// Canonical mapping from a caller-friendly status name to the ADO enum value.
+// Used by the reply-and-resolve path so a fix agent can transition the
+// ORIGINATING thread to a resolved state (`fixed`/`closed`) rather than opening
+// a new active summary thread. `active` is the "leave unresolved" sentinel.
+const ADO_THREAD_STATUS_BY_NAME = Object.freeze({
+  active: ADO_THREAD_STATUS_ACTIVE,
+  fixed: ADO_THREAD_STATUS_FIXED,
+  wontfix: ADO_THREAD_STATUS_WONT_FIX,
+  'wont-fix': ADO_THREAD_STATUS_WONT_FIX,
+  closed: ADO_THREAD_STATUS_CLOSED,
+  resolved: ADO_THREAD_STATUS_FIXED,
+  bydesign: ADO_THREAD_STATUS_BY_DESIGN,
+  'by-design': ADO_THREAD_STATUS_BY_DESIGN,
+  pending: ADO_THREAD_STATUS_PENDING,
+});
+
+// Thread statuses that mean "resolved" for idempotency purposes — a thread
+// already in one of these needs no further status PATCH.
+const ADO_RESOLVED_THREAD_STATUSES = new Set([
+  ADO_THREAD_STATUS_FIXED,
+  ADO_THREAD_STATUS_WONT_FIX,
+  ADO_THREAD_STATUS_CLOSED,
+  ADO_THREAD_STATUS_BY_DESIGN,
+]);
+
+function resolveAdoThreadStatus(status) {
+  if (typeof status === 'number' && Number.isInteger(status)) return status;
+  const key = String(status || '').trim().toLowerCase();
+  if (key === '') return ADO_THREAD_STATUS_ACTIVE;
+  const mapped = ADO_THREAD_STATUS_BY_NAME[key];
+  if (mapped === undefined) {
+    throw new Error(`invalid thread status: ${JSON.stringify(status)} (expected one of ${Object.keys(ADO_THREAD_STATUS_BY_NAME).join(', ')})`);
+  }
+  return mapped;
+}
 
 // ── Validation (ADO-specific) ────────────────────────────────────────────────
 // Field validation for the marker (agentId / kind / workItemId) is done inside
@@ -72,6 +122,12 @@ function _validatePrNumber(prNumber) {
   }
 }
 
+function _validateThreadId(threadId) {
+  if (typeof threadId !== 'number' || !Number.isInteger(threadId) || threadId <= 0) {
+    throw new Error(`invalid threadId: ${JSON.stringify(threadId)} (expected positive integer)`);
+  }
+}
+
 /**
  * Build the ADO threads endpoint for a PR. `orgBase` already includes the org
  * (e.g. https://dev.azure.com/contoso). Project + repositoryId are URL-encoded.
@@ -82,6 +138,25 @@ function buildThreadsUrl({ orgBase, project, repositoryId, prNumber }) {
     + `/pullRequests/${prNumber}/threads?api-version=${ADO_API_VERSION}`;
 }
 
+/**
+ * Endpoint for a single existing thread (GET current status/comments, PATCH
+ * status). `orgBase` already includes the org.
+ */
+function buildThreadUrl({ orgBase, project, repositoryId, prNumber, threadId }) {
+  const base = String(orgBase).replace(/\/+$/, '');
+  return `${base}/${encodeURIComponent(project)}/_apis/git/repositories/${encodeURIComponent(repositoryId)}`
+    + `/pullRequests/${prNumber}/threads/${threadId}?api-version=${ADO_API_VERSION}`;
+}
+
+/**
+ * Endpoint for the comments collection of an existing thread (POST a reply).
+ */
+function buildThreadCommentsUrl({ orgBase, project, repositoryId, prNumber, threadId }) {
+  const base = String(orgBase).replace(/\/+$/, '');
+  return `${base}/${encodeURIComponent(project)}/_apis/git/repositories/${encodeURIComponent(repositoryId)}`
+    + `/pullRequests/${prNumber}/threads/${threadId}/comments?api-version=${ADO_API_VERSION}`;
+}
+
 /**
  * Default token acquisition — thin wrapper over engine/ado/token.js so callers
  * can inject a stub in tests. Returns the bearer token string or throws.
@@ -174,12 +249,193 @@ async function postAdoPrComment({
   };
 }
 
+/**
+ * Reply to an EXISTING review thread with a fix summary and transition that
+ * thread to a resolved status — instead of opening a new active summary thread.
+ *
+ * This is the fix-summary path for Azure DevOps (W-msd9os8e00qnd628): when a fix
+ * agent has evidence a review finding was addressed, it replies on the
+ * originating thread (identified by the structured `threadId` carried on the
+ * work item / completion report) and moves that thread to `fixed` (2) / `closed`
+ * (4). Contrast with `postAdoPrComment`, which creates a fresh thread.
+ *
+ * Idempotency (retries / engine restarts / duplicate completion callbacks /
+ * provider timeouts): the current thread is read first. A reply whose hidden
+ * marker already matches this dispatch's structured identity (agentId + kind +
+ * workItemId) is treated as already-posted and the reply POST is skipped; a
+ * thread already in a resolved status is left as-is. Resolution is keyed by the
+ * explicit `threadId` and the structured marker — never by body/title text — so
+ * sibling findings are never bulk-resolved.
+ *
+ * Partial-failure visibility: the reply POST and the status PATCH are distinct
+ * round-trips. If the reply succeeds but the status PATCH fails, we throw so the
+ * caller sees the failure and can retry; the retry re-reads the thread, finds
+ * the reply already present (skips it), and re-attempts only the PATCH. Local
+ * state is never marked resolved when the provider PATCH failed.
+ *
+ * @param {object} args
+ * @param {string} args.orgBase
+ * @param {string} args.project
+ * @param {string} args.repositoryId
+ * @param {number} args.prNumber
+ * @param {number} args.threadId       existing ADO thread id (positive integer)
+ * @param {string} args.body           reply body (pre-marker; builder prepends marker)
+ * @param {string} args.agentId
+ * @param {string} args.kind
+ * @param {string} [args.workItemId]
+ * @param {string} [args.model]
+ * @param {(string|number)} [args.status='fixed']  target status; 'active' leaves the thread unresolved
+ * @param {number} [args.timeoutMs=30000]
+ * @param {Function} [args.acquireToken]
+ * @param {Function} [args.fetchImpl]
+ * @returns {Promise<{threadId:number, commentId:(number|undefined), replied:boolean, alreadyReplied:boolean, resolved:boolean, alreadyResolved:boolean, statusApplied:(number|null)}>}
+ */
+async function replyToAdoThread({
+  orgBase,
+  project,
+  repositoryId,
+  prNumber,
+  threadId,
+  body,
+  agentId,
+  kind,
+  workItemId,
+  model,
+  status = 'fixed',
+  timeoutMs = 30000,
+  acquireToken = _defaultAcquireToken,
+  fetchImpl,
+} = {}) {
+  _validateOrgBase(orgBase);
+  _validateProject(project);
+  _validateRepositoryId(repositoryId);
+  _validatePrNumber(prNumber);
+  _validateThreadId(threadId);
+
+  const targetStatus = resolveAdoThreadStatus(status);
+
+  // buildMinionsCommentBody validates marker fields and throws on bad input.
+  const finalBody = buildMinionsCommentBody({ agentId, kind, workItemId, model, body });
+
+  const token = await acquireToken();
+  if (!token || typeof token !== 'string') {
+    throw new Error('ADO comment: could not acquire an access token (az account get-access-token failed)');
+  }
+
+  const doFetch = fetchImpl || (typeof fetch === 'function' ? fetch : null);
+  if (!doFetch) throw new Error('ADO comment: no fetch implementation available');
+
+  const authHeaders = {
+    'Authorization': `Bearer ${token}`,
+    'Content-Type': 'application/json',
+  };
+  const threadUrl = buildThreadUrl({ orgBase, project, repositoryId, prNumber, threadId });
+
+  // ── 1. Read the current thread (status + existing comments) for idempotency ──
+  const getRes = await doFetch(threadUrl, {
+    method: 'GET',
+    headers: authHeaders,
+    signal: AbortSignal.timeout(timeoutMs),
+  });
+  if (!getRes.ok) {
+    const detail = await getRes.text().catch(() => '');
+    throw new Error(`ADO thread GET ${getRes.status} ${getRes.statusText}: ${String(detail).slice(0, 500)}`);
+  }
+  const thread = await getRes.json().catch(() => ({}));
+  const existingComments = Array.isArray(thread.comments) ? thread.comments : [];
+  const currentStatus = typeof thread.status === 'number'
+    ? thread.status
+    : resolveAdoThreadStatus(thread.status || 'active');
+
+  // Idempotency: has THIS dispatch (structured marker identity) already replied?
+  const alreadyReplied = existingComments.some((c) => {
+    const marker = parseMinionsMarker(String(c?.content || ''));
+    if (!marker) return false;
+    if (marker.agentId !== agentId || marker.kind !== kind) return false;
+    // When a workItemId is supplied it is the structured finding identity — a
+    // match on it (or its absence on both sides) confirms this is our reply.
+    if (workItemId) return marker.workItemId === workItemId;
+    return marker.workItemId === undefined;
+  });
+
+  // The first comment id anchors a reply to the originating thread.
+  const parentCommentId = existingComments.length > 0 && Number.isInteger(existingComments[0]?.id)
+    ? existingComments[0].id
+    : 1;
+
+  let replied = false;
+  let commentId;
+  if (!alreadyReplied) {
+    const commentsUrl = buildThreadCommentsUrl({ orgBase, project, repositoryId, prNumber, threadId });
+    const postRes = await doFetch(commentsUrl, {
+      method: 'POST',
+      headers: authHeaders,
+      body: JSON.stringify({ parentCommentId, content: finalBody, commentType: 1 }),
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+    if (!postRes.ok) {
+      const detail = await postRes.text().catch(() => '');
+      throw new Error(`ADO thread reply POST ${postRes.status} ${postRes.statusText}: ${String(detail).slice(0, 500)}`);
+    }
+    const postJson = await postRes.json().catch(() => ({}));
+    commentId = postJson && postJson.id;
+    replied = true;
+  }
+
+  // ── 2. Transition the thread status (skip when unresolved requested or the
+  //       thread is already in the requested/equivalent resolved state) ──
+  const wantsResolve = targetStatus !== ADO_THREAD_STATUS_ACTIVE
+    && targetStatus !== ADO_THREAD_STATUS_UNKNOWN;
+  const alreadyResolved = wantsResolve && currentStatus === targetStatus;
+  let resolved = ADO_RESOLVED_THREAD_STATUSES.has(currentStatus);
+  let statusApplied = null;
+
+  if (wantsResolve && currentStatus !== targetStatus) {
+    // The reply above may already be committed. A PATCH failure here throws so
+    // the caller can retry; the retry skips the (now-present) reply and PATCHes
+    // again — local state is never marked resolved on a failed PATCH.
+    const patchRes = await doFetch(threadUrl, {
+      method: 'PATCH',
+      headers: authHeaders,
+      body: JSON.stringify({ status: targetStatus }),
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+    if (!patchRes.ok) {
+      const detail = await patchRes.text().catch(() => '');
+      throw new Error(`ADO thread status PATCH ${patchRes.status} ${patchRes.statusText}: ${String(detail).slice(0, 500)} (reply ${replied ? 'was' : 'was not'} posted; retry is idempotent)`);
+    }
+    statusApplied = targetStatus;
+    resolved = true;
+  }
+
+  return {
+    threadId,
+    commentId,
+    replied,
+    alreadyReplied,
+    resolved,
+    alreadyResolved: !!alreadyResolved,
+    statusApplied,
+  };
+}
+
 module.exports = {
   postAdoPrComment,
+  replyToAdoThread,
   buildThreadsUrl,
+  buildThreadUrl,
+  buildThreadCommentsUrl,
+  resolveAdoThreadStatus,
   ADO_API_VERSION,
+  ADO_THREAD_STATUS_UNKNOWN,
   ADO_THREAD_STATUS_ACTIVE,
+  ADO_THREAD_STATUS_FIXED,
+  ADO_THREAD_STATUS_WONT_FIX,
   ADO_THREAD_STATUS_CLOSED,
+  ADO_THREAD_STATUS_BY_DESIGN,
+  ADO_THREAD_STATUS_PENDING,
+  ADO_THREAD_STATUS_BY_NAME,
+  ADO_RESOLVED_THREAD_STATUSES,
   // Re-export the neutral builder so ADO callers have a single import surface,
   // mirroring engine/providers/gh-comment.js.
   buildMinionsCommentBody,
@@ -188,5 +444,6 @@ module.exports = {
   _validateProject,
   _validateRepositoryId,
   _validatePrNumber,
+  _validateThreadId,
   _defaultAcquireToken,
 };

package/engine/agents/llm.js

@@ -55,6 +55,26 @@ function _emptyDailyDelta() {
   return { costUsd: 0, inputTokens: 0, outputTokens: 0, cacheRead: 0 };
 }
 
+// Merge a source billableUnits map ({unit:{total,reported,unavailable}}) into a
+// target object's billableUnits (W-msdcgitc). Used to fold buffered CC/doc-chat
+// deltas into the persisted metrics and to re-merge on a failed flush. Generic
+// over unit name so no runtime-name branch is needed.
+function _mergeBillableUnits(target, source) {
+  if (!source || typeof source !== 'object') return;
+  if (!target.billableUnits || typeof target.billableUnits !== 'object') {
+    target.billableUnits = {};
+  }
+  for (const [unit, b] of Object.entries(source)) {
+    if (!b || typeof b !== 'object') continue;
+    const bucket = target.billableUnits[unit]
+      || { total: 0, reported: 0, unavailable: 0 };
+    bucket.total += b.total || 0;
+    bucket.reported += b.reported || 0;
+    bucket.unavailable += b.unavailable || 0;
+    target.billableUnits[unit] = bucket;
+  }
+}
+
 function _ensureFlushTimer() {
   if (_flushTimer) return;
   const interval = shared.ENGINE_DEFAULTS.metricsFlushIntervalMs || 10000;
@@ -74,6 +94,7 @@ function trackEngineUsage(category, usage) {
   cat.outputTokens += usage.outputTokens || 0;
   cat.cacheRead += usage.cacheRead || 0;
   cat.cacheCreation += usage.cacheCreation || 0;
+  shared.accumulateBillableUnits(cat, usage.billable);
   if (usage.durationMs) {
     cat.totalDurationMs += usage.durationMs;
     cat.timedCalls += 1;
@@ -86,6 +107,7 @@ function trackEngineUsage(category, usage) {
   daily.inputTokens += usage.inputTokens || 0;
   daily.outputTokens += usage.outputTokens || 0;
   daily.cacheRead += usage.cacheRead || 0;
+  shared.accumulateBillableUnits(daily, usage.billable);
 
   _ensureFlushTimer();
 }
@@ -135,6 +157,7 @@ function flushMetricsBuffer() {
             cat.errorsByCode[code] = (cat.errorsByCode[code] || 0) + count;
           }
         }
+        _mergeBillableUnits(cat, delta.billableUnits);
       }
       if (!metrics._daily) metrics._daily = {};
       for (const [day, delta] of Object.entries(pending.daily)) {
@@ -146,6 +169,7 @@ function flushMetricsBuffer() {
         d.inputTokens += delta.inputTokens;
         d.outputTokens += delta.outputTokens;
         d.cacheRead += delta.cacheRead;
+        _mergeBillableUnits(d, delta.billableUnits);
       }
       return metrics;
     });
@@ -164,12 +188,14 @@ function flushMetricsBuffer() {
           c.errorsByCode[code] = (c.errorsByCode[code] || 0) + count;
         }
       }
+      _mergeBillableUnits(c, delta.billableUnits);
     }
     for (const [day, delta] of Object.entries(pending.daily)) {
       if (!_pendingMetrics.daily[day]) _pendingMetrics.daily[day] = _emptyDailyDelta();
       const d = _pendingMetrics.daily[day];
       d.costUsd += delta.costUsd; d.inputTokens += delta.inputTokens;
       d.outputTokens += delta.outputTokens; d.cacheRead += delta.cacheRead;
+      _mergeBillableUnits(d, delta.billableUnits);
     }
     console.error('metrics flush:', e.message);
   }

package/engine/agents/playbook.js

@@ -1373,7 +1373,8 @@ function _checkPlaybookSections(content, context = '') {
 
 // Lean system prompt: agent identity + rules only (~2-4KB, never grows)
 function buildSystemPrompt(agentId, config, project) {
-  const agent = config.agents[agentId] || tempAgents.get(agentId) || { name: agentId, role: 'Temporary Agent', expertise: [] };
+  const agent = config.agents[agentId] || tempAgents.get(agentId)
+    || { name: shared.tempAgentDisplayName(agentId), role: 'Temporary Agent', expertise: [] };
   const charter = safeRead(path.join(AGENTS_DIR, agentId, 'charter.md')); // returns '' for temp agents (no charter file)
   project = project || getProjects(config)[0] || {};
 

package/engine/api/settings-validation.js

@@ -108,6 +108,7 @@ const ENGINE_SPECIAL_FIELDS = new Set([
   'ccWorkerIdleTimeoutMs',
   'worktreeRoot',
   'operatorLogin',
+  'operatorAdoIdentity',
   'defaultCli',
   'defaultModel',
   'ccCli',
@@ -338,6 +339,30 @@ function applyEngineSettings(candidate, bodyEngine, errors) {
     const value = parseClearableString(bodyEngine.operatorLogin, 'engine.operatorLogin', errors);
     setOrDelete(engine, 'operatorLogin', value);
   }
+  if (hasOwn(bodyEngine, 'operatorAdoIdentity')) {
+    // Structured ADO self-identity used ONLY by the AutoFix foreign-author
+    // guardrail (id/descriptor — never email). An empty object clears it.
+    const raw = bodyEngine.operatorAdoIdentity;
+    if (raw === null || raw === undefined || CLEAR_SENTINELS.has(raw)) {
+      delete engine.operatorAdoIdentity;
+    } else if (typeof raw === 'object') {
+      const next = {};
+      if (raw.id !== undefined && raw.id !== null && raw.id !== '') {
+        const id = parseString(raw.id, 'engine.operatorAdoIdentity.id', errors);
+        if (id) next.id = id;
+      }
+      if (raw.descriptor !== undefined && raw.descriptor !== null && raw.descriptor !== '') {
+        const descriptor = parseString(raw.descriptor, 'engine.operatorAdoIdentity.descriptor', errors);
+        if (descriptor) next.descriptor = descriptor;
+      }
+      if (Object.keys(next).length) engine.operatorAdoIdentity = next;
+      else delete engine.operatorAdoIdentity;
+    } else {
+      errors.add('engine.operatorAdoIdentity', 'invalid-object',
+        'engine.operatorAdoIdentity must be an object with id and/or descriptor', raw,
+        { expected: 'object' });
+    }
+  }
   for (const key of ['defaultCli', 'ccCli']) {
     if (!hasOwn(bodyEngine, key)) continue;
     const value = parseRuntimeName(bodyEngine[key], `engine.${key}`, errors);

package/engine/core/operator-identity.js

@@ -75,9 +75,31 @@ function resolveOperatorLogin(config, { force = false } = {}) {
 
 // Clear the process-lifetime cache. Called by the dashboard when the operator
 // login override changes in Settings so the next resolve picks up the new value.
-function _resetOperatorLoginCacheForTest() { _cached = null; }
+function _resetOperatorLoginCacheForTest() { _cached = null; _cachedGithubViewer = null; }
+
+// ── Strict GitHub viewer login (W-msd8pr2300ev95e1) ─────────────────────────
+// Unlike resolveOperatorLogin, this NEVER falls back to the git-email localpart
+// or the OS username — those are not GitHub logins and must never be used to
+// decide "did the current GitHub token author this PR?". It accepts ONLY:
+//   1. `config.engine.operatorLogin` — explicit Settings override
+//   2. `gh api user --jq .login`     — the token's own canonical login
+// and returns '' otherwise, so the caller fails CLOSED (author ownership
+// "unknown") rather than guessing self-authorship from a weak fallback.
+let _cachedGithubViewer = null;
+function resolveGithubViewerLoginStrict(config, { force = false } = {}) {
+  if (!force && _cachedGithubViewer !== null) return _cachedGithubViewer;
+  const override = config?.engine?.operatorLogin;
+  if (override && typeof override === 'string' && override.trim()) {
+    _cachedGithubViewer = override.trim();
+    return _cachedGithubViewer;
+  }
+  const ghLogin = _execImpl('gh api user --jq .login');
+  _cachedGithubViewer = ghLogin ? ghLogin : '';
+  return _cachedGithubViewer;
+}
 
 module.exports = {
   resolveOperatorLogin,
+  resolveGithubViewerLoginStrict,
   _resetOperatorLoginCacheForTest,
 };

package/engine/core/queries.js

@@ -501,9 +501,15 @@ function getMetrics() {
     const runtimeName = shared.resolveAgentCli(configuredAgents[agentId], engineConfig);
     m.runtime = runtimeName;
     try {
-      m.costTracking = resolveRuntime(runtimeName).capabilities?.costTracking === true;
+      const caps = resolveRuntime(runtimeName).capabilities || {};
+      m.costTracking = caps.costTracking === true;
+      // Typed native billable unit for the display layer (W-msdcgitc). Copilot
+      // reports 'premiumRequests'; adapters without one default to 'usd'. The
+      // dashboard reads THIS, never the runtime name, to decide labels/units.
+      m.billableUnit = typeof caps.billableUnit === 'string' ? caps.billableUnit : 'usd';
     } catch {
       m.costTracking = false;
+      m.billableUnit = 'usd';
     }
   }
 
@@ -895,7 +901,21 @@ function getAgents(config) {
   const seen = new Set(roster.map(a => a.id));
   for (const d of (dispatch.active || [])) {
     if (d.agent && d.agent.startsWith('temp-') && !seen.has(d.agent)) {
-      roster.push({ id: d.agent, name: d.agentName || d.agent, role: d.agentRole || 'Temp Agent', emoji: '\u{1F4A8}', expertise: [], _temp: true });
+      // Additive friendly display identity; the canonical `id` (temp-<uid>)
+      // stays the machine identity for routing/SQL/paths/memory. `name` falls
+      // back to the deterministic call sign when the dispatch record predates
+      // friendly naming (e.g. after a restart with no in-memory tempAgents).
+      const identity = shared.resolveAgentIdentity(d.agent, config);
+      roster.push({
+        id: d.agent,
+        name: d.agentName || identity.displayName || d.agent,
+        role: d.agentRole || 'Temporary Agent',
+        emoji: '\u{1F4A8}',
+        expertise: [],
+        _temp: true,
+        isTemp: true,
+        callSign: identity.callSign,
+      });
       seen.add(d.agent);
     }
   }
@@ -949,8 +969,13 @@ function getAgents(config) {
 
     const chartered = fs.existsSync(path.join(AGENTS_DIR, a.id, 'charter.md'));
     if (lastAction.length > 120) lastAction = lastAction.slice(0, 120) + '...';
+    // Structured display identity (canonical id stays authoritative; friendly
+    // name + temp flag are additive). Clients render a "Temp" badge from `isTemp`.
+    const isTemp = a.isTemp === true || shared.isTempAgentId(a.id);
     return {
       ...a,
+      isTemp,
+      callSign: isTemp ? (a.callSign || shared.tempAgentCallSign(a.id)) : null,
       runtime,
       model,
       displayModel: modelDisplay.model,
@@ -1151,6 +1176,28 @@ function getPullRequests(config) {
   const projectByName = new Map(projects.map(p => [p.name, p]));
   const allPrs = [];
 
+  // W-msd8pr2300ev95e1 — resolve the CURRENT authenticated identity per provider
+  // ONCE (cached) so we can stamp each PR's author-ownership tri-state for the
+  // AutoFix foreign-author guardrail. STABLE identities only (GitHub canonical
+  // login / numeric id; ADO id / descriptor) — never display names or emails.
+  // Fails CLOSED: a missing/blank provider entry yields 'unknown'.
+  const selfByProvider = {};
+  try {
+    const ghLogin = require('./operator-identity').resolveGithubViewerLoginStrict(config);
+    if (ghLogin) selfByProvider.github = { login: ghLogin };
+  } catch { /* identity resolution is best-effort; absence → unknown */ }
+  try {
+    const adoSelf = config?.engine?.operatorAdoIdentity;
+    if (adoSelf && typeof adoSelf === 'object') {
+      const entry = {};
+      if (adoSelf.id) entry.id = String(adoSelf.id);
+      if (adoSelf.descriptor) entry.descriptor = String(adoSelf.descriptor);
+      // Deliberately NOT copying uniqueName/login: ADO login is an email, and
+      // the guardrail contract forbids comparing emails.
+      if (Object.keys(entry).length) selfByProvider.ado = entry;
+    }
+  } catch { /* best-effort */ }
+
   // SQL is the canonical (and only) PR store after Phase 9.
   const store = require('../persistence/pull-requests-store');
   const sqlPrs = store.readAllPullRequests() || [];
@@ -1231,6 +1278,10 @@ function getPullRequests(config) {
     // dashboards / API consumers can render a chip without re-parsing
     // _noOpFixes themselves.
     pr._pausedCauses = shared.getPrPausedCauses(pr);
+    // W-msd8pr2300ev95e1 — author-ownership tri-state for the AutoFix
+    // foreign-author warning. 'self' | 'foreign' | 'unknown' (fail closed).
+    try { pr._authorOwnership = shared.resolvePrAuthorOwnership(pr, selfByProvider); }
+    catch { pr._authorOwnership = shared.PR_AUTHOR_OWNERSHIP.UNKNOWN; }
     allPrs.push(pr);
   }
   allPrs.sort((a, b) => {