borgmcp 2.0.9 → 2.0.11

package/src/assimilate-cmd.ts

@@ -49,6 +49,7 @@ import type { ExpectedBinding, FinalizeServerSeatOutcome, PersistedLocalSeat } f
 import type { SeatBinding, BindPendingSeatOutcome } from './seats.js';
 import { createHash } from 'node:crypto';
 import { buildOpenCodeLaunchArgs, type LaunchApprovalDecision } from './cli-tool-approval.js';
+import { resolveWorkingRepo, type WorkingRepo } from './working-repo.js';
 
 const PRIVATE_STATE_UNAVAILABLE_COPY = [
   'Borg could not safely prepare its private local state.',
@@ -259,7 +260,7 @@ export interface AssimilateDeps {
   assimilate: (
     apiUrl: string,
     token: string,
-    params: { cube_id: string; role_id: string; hostname?: string | null; prior_drone_id?: string; remint_invalid_prior?: boolean; model?: string | null; agent_kind?: 'claude' | 'codex' | 'opencode' | null; session_operation?: ServerSessionOperation; session_expected?: ExpectedBinding; revalidate_at_prepare?: boolean },
+    params: { cube_id: string; role_id: string; hostname?: string | null; prior_drone_id?: string; remint_invalid_prior?: boolean; model?: string | null; agent_kind?: 'claude' | 'codex' | 'opencode' | null; working_repo?: WorkingRepo; session_operation?: ServerSessionOperation; session_expected?: ExpectedBinding; revalidate_at_prepare?: boolean },
     serverTrustIdentity?: string,
   ) => Promise<AssimilateResult>;
 
@@ -1183,6 +1184,7 @@ export async function runAssimilate(
       hostname: deps.getHostname(),
       agent_kind: cli,
       model: effectiveModel,
+      working_repo: resolveWorkingRepo(projectRoot),
       ...(reattachPriorId ? { prior_drone_id: reattachPriorId } : {}),
       ...(remintInvalidPrior ? { remint_invalid_prior: true } : {}),
       session_operation: sessionOperation,

package/src/assimilate-deps.ts

@@ -16,6 +16,7 @@ import { createInterface } from 'node:readline/promises';
 import prompts from 'prompts';
 import { readinessProbeEnv } from './readiness-probe.js';
 import { resolveMcpBinaryPath } from './self-path.js';
+import { buildRuntimeMetadataReport } from './runtime-metadata.js';
 
 import type { AssimilateDeps } from './assimilate-cmd.js';
 import {
@@ -322,10 +323,15 @@ export function buildDefaultAssimilateDeps(): AssimilateDeps {
             cubeId: params.cube_id,
             roleId: params.role_id,
             operation,
-            ...(params.prior_drone_id === undefined
-              ? {}
-              : { priorDroneId: params.prior_drone_id }),
-          },
+             ...(params.prior_drone_id === undefined
+               ? {}
+               : { priorDroneId: params.prior_drone_id }),
+            runtimeMetadata: buildRuntimeMetadataReport({
+              agentKind: params.agent_kind,
+              reportedModel: params.model,
+              workingRepo: params.working_repo,
+            }),
+           },
           pending.credential,
           { fetchImpl: trust.fetchImpl },
         );

package/src/index.ts

@@ -93,7 +93,11 @@ import {
   formatWakePathPrefix,
   shouldShowWakePathWarning,
 } from './stream-status.js';
-import { formatRoleAgentLabel, formatWorkingRepoLabel, renderRoster } from './roster-render.js';
+import {
+  RUNTIME_METADATA_ADVISORY,
+  renderRoster,
+  renderRuntimeMetadataLines,
+} from './roster-render.js';
 import { resolveWorkingRepo } from './working-repo.js';
 import {
   DroneEvictedError,
@@ -110,6 +114,7 @@ import { initConsolePrefix, consolePrefix } from './console-prefix.js';
 import {
   resolveSessionAgentKind,
 } from './codex-app-wake.js';
+import { resolveReportableSessionAgentKind } from './agent-runtime.js';
 import {
   connectOpenCodeDrone,
   injectOpenCodeEntry,
@@ -134,14 +139,15 @@ import {
 /**
  * Apply a template's roles + message_taxonomy to a cube.
  *
- * gh#473 PR2 — delegates to the NON-CLOBBERING server route. New roles
- * are inserted; existing template-named roles get ADD fragments (template
- * sections/classes the cube lacks) auto-applied, but EVOLVED (conflicting)
- * fragments are surfaced server-side and KEPT — never silently
- * overwritten. The old per-role blanket `updateRole`/whole-taxonomy
- * `updateCube` overwrite path is removed. Operators who want to take the
- * template version of a conflicting fragment use `borg_sync-roles` with a
- * `decisions` map. Returns `{ created, updated }` for the caller's toast.
+ * Client-orchestrated through the server's non-clobbering role and taxonomy
+ * primitives. New roles are inserted; existing template-named roles get ADD
+ * fragments (template sections/classes the cube lacks) auto-applied, but
+ * EVOLVED (conflicting) fragments are kept — never silently overwritten. The
+ * old per-role blanket `updateRole`/whole-taxonomy `updateCube` overwrite path
+ * is removed. Operators who want to take the template version of a conflicting
+ * fragment use `borg_sync-roles` with a `decisions` map. Primitive operations
+ * are sequential, so a later failure can leave earlier changes committed.
+ * Returns `{ created, updated }` for the caller's toast.
  */
 async function applyTemplateToCube(
   cubeId: string,
@@ -368,6 +374,7 @@ export async function main() {
           const result = await regen(active.sessionToken, active.apiUrl, {
             since,
             reportedModel,
+            agentKind: resolveReportableSessionAgentKind(),
             workingRepo: resolveWorkingRepo(),
             serverTrustIdentity: active.serverTrustIdentity,
           });
@@ -444,6 +451,7 @@ export async function main() {
           // — an evicted/revoked seat FAILS server-side and is surfaced).
           try {
             const result = await regen(active!.sessionToken, active!.apiUrl, {
+              agentKind: resolveReportableSessionAgentKind(),
               workingRepo: resolveWorkingRepo(),
               serverTrustIdentity: active!.serverTrustIdentity,
             });
@@ -1084,21 +1092,18 @@ export async function main() {
             return { content: [{ type: 'text', text: 'No drones in this cube yet.' }] };
           }
           const rolesById = new Map(roles.map((r: any) => [r.id, r]));
-          const lines = drones.map((d: any) => {
-            const r = rolesById.get(d.role_id) as any;
-            const roleLabel = formatRoleAgentLabel(r?.name ?? '?', d.agent_kind);
-            const wakeClass =
+           const lines = drones.map((d: any) => {
+             const r = rolesById.get(d.role_id) as any;
+             const wakeClass =
               d.wake_path_alert_class && d.wake_path_alert_class !== 'independent'
                 ? ` — wake-path-class: ${d.wake_path_alert_class}`
                 : '';
-            const reportedModel = d.reported_model
-              ? ` — Reported model: ${d.reported_model}`
-              : ' — Reported model: not reported';
-            const workingRepo = formatWorkingRepoLabel(d);
-            const workingRepoText = workingRepo ? ` — ${workingRepo}` : '';
-            return `- **${d.label}** (id: ${d.id}) — role: ${roleLabel} (${d.role_id}) — last seen ${d.last_seen}${wakeClass}${reportedModel}${workingRepoText}`;
-          });
-          return { content: [{ type: 'text', text: `Drones in cube ${cubeId} (${drones.length}):\n\n${lines.join('\n')}` }] };
+            return [
+              `- **${d.label}** (id: ${d.id}) — Role: ${r?.name ?? '?'} (${d.role_id}) — last seen ${d.last_seen}${wakeClass}`,
+              ...renderRuntimeMetadataLines(d),
+            ].join('\n');
+           });
+          return { content: [{ type: 'text', text: `Drones in cube ${cubeId} (${drones.length}):\n\n_${RUNTIME_METADATA_ADVISORY}_\n\n${lines.join('\n')}` }] };
         }
 
         case 'borg_list-roles': {

package/src/local-manage-tool-result.ts

@@ -1,6 +1,53 @@
 import { LocalManageRequiredError } from './server-errors.js';
 
+export interface RoleSectionConflictOperation {
+  roleId: string;
+  action: 'replace' | 'insert' | 'delete';
+  heading: string;
+  after?: string | null;
+}
+
+export class RoleSectionConflictError extends Error {
+  constructor(public readonly operation: RoleSectionConflictOperation) {
+    super('The role section patch conflicted with the current role text.');
+    this.name = 'RoleSectionConflictError';
+  }
+}
+
+const UNSAFE_OPERATION_CHARACTER =
+  /["\\`*_[\]()<>#!|~\u0000-\u001f\u007f-\u009f\u061c\u200e\u200f\u2028\u2029\u202a-\u202e\u2066-\u2069]/u;
+
+function safeOperationValue(value: string): string {
+  const escaped = Array.from(value, (character) =>
+    UNSAFE_OPERATION_CHARACTER.test(character)
+      ? `\\u{${character.codePointAt(0)!.toString(16)}}`
+      : character).join('');
+  return `"${escaped}"`;
+}
+
 export function formatLocalManageToolResult(error: unknown) {
+  if (error instanceof RoleSectionConflictError) {
+    const { roleId, action, heading, after } = error.operation;
+    const context = [
+      `action=${action}`,
+      `heading=${safeOperationValue(heading)}`,
+      ...(action === 'insert'
+        ? [`after=${after == null ? '<end>' : safeOperationValue(after)}`]
+        : []),
+    ].join(', ');
+    return {
+      content: [{
+        type: 'text' as const,
+        text:
+          `[ROLE-SECTION-CONFLICT] The requested role section operation conflicts with the current role text.\n\n` +
+          `Requested operation: ${context}\n\n` +
+          'No role text was changed by this request. ' +
+          `Read the current role with \`borg_role\` using role id ${safeOperationValue(roleId)}, ` +
+          'then retry `borg_patch-role-section` against that current text.',
+      }],
+      isError: true as const,
+    };
+  }
   if (!(error instanceof LocalManageRequiredError)) return null;
 
   return {

package/src/regen-format.ts

@@ -12,7 +12,10 @@ import {
 } from 'borgmcp-shared/templates';
 import { parseRoleSections } from 'borgmcp-shared/role-section';
 import { formatDroneAddressToken } from 'borgmcp-shared/drone-address';
-import { formatRoleAgentLabel } from './roster-render.js';
+import {
+  RUNTIME_METADATA_ADVISORY,
+  renderRuntimeMetadataLines,
+} from './roster-render.js';
 import { shellEscape } from './shell-escape.js';
 import { resolveInboxMonitorPath } from './self-path.js';
 
@@ -488,10 +491,12 @@ export function formatRegenMarkdown(
 
   const droneOverview =
     result.drones
-      .map((d: any) => {
-        const role = result.roles.find((r: any) => r.id === d.role_id);
-        const roleLabel = formatRoleAgentLabel(role?.name ?? '?', d.agent_kind);
-        return `- **${d.label}** (${roleLabel}) — last seen ${humanAgo(new Date(d.last_seen))}`;
+       .map((d: any) => {
+         const role = result.roles.find((r: any) => r.id === d.role_id);
+        return [
+          `- **${d.label}** (Role: ${role?.name ?? '?'}) — last seen ${humanAgo(new Date(d.last_seen))}`,
+          ...renderRuntimeMetadataLines(d),
+        ].join('\n');
       })
       .join('\n') || '_(no drones connected)_';
 
@@ -611,6 +616,8 @@ export function formatRegenMarkdown(
     roleOverview,
     '',
     `## Connected drones`,
+    `_${RUNTIME_METADATA_ADVISORY}_`,
+    '',
     droneOverview,
     '',
     `## Cube log`,

package/src/regen.ts

@@ -26,6 +26,7 @@ import {
   type AgentKind,
 } from './regen-format.js';
 import { resolveSessionAgentKind } from './codex-app-wake.js';
+import { resolveReportableSessionAgentKind } from './agent-runtime.js';
 import { handleVersionFlag } from './version.js';
 import { gateAllowsActivation } from './launch-gate.js';
 import { resolveWorkingRepo } from './working-repo.js';
@@ -85,6 +86,7 @@ async function main(): Promise<void> {
   let result: Awaited<ReturnType<typeof regen>> | null = null;
   try {
     result = await regen(active.sessionToken, active.apiUrl, {
+      agentKind: resolveReportableSessionAgentKind(),
       workingRepo: resolveWorkingRepo(),
       serverTrustIdentity: active.serverTrustIdentity,
     });

package/src/remote-client.ts

@@ -16,11 +16,14 @@ import {
 import { randomUUID } from 'node:crypto';
 import {
   createProtocolEnvelope,
+  decodeDroneRuntimeMetadataState,
   decodeEvictDroneResult,
   decodeProtocolEnvelope,
   decodeProtocolErrorEnvelope,
   decodeReassignDroneResult,
+  decodeUpdateDroneRuntimeMetadataResponse,
   ErrorCode,
+  type AgentKind,
   type EvictDroneResult,
   type ReassignDroneResult,
 } from 'borgmcp-shared/protocol';
@@ -33,6 +36,7 @@ import { getTemplate, type Template, type TemplateRole } from 'borgmcp-shared/te
 import { parseRoleSections } from 'borgmcp-shared/role-section';
 import type { FragmentView, NonClobberSyncResult } from './sync-roles-render.js';
 import type { WorkingRepo } from './working-repo.js';
+import { buildRuntimeMetadataPatch } from './runtime-metadata.js';
 import { loadBorgServerTrust, type ServerFetch } from './server-trust.js';
 import {
   BorgServerError,
@@ -50,6 +54,7 @@ import {
 } from './local-server-cursor.js';
 import { readBoundedResponseBody } from './server-response.js';
 import { resolveLocalLogRecipients } from './local-log-routing.js';
+import { RoleSectionConflictError } from './local-manage-tool-result.js';
 
 export interface RemoteConnection {
   apiUrl: string;
@@ -67,6 +72,7 @@ export const LOCAL_SERVER_RESPONSE_LIMIT_BYTES = 32 * 1024 * 1024;
 // A typed auth-error envelope is tiny; anything larger is hostile and the
 // bounded read throws → the 401 fails closed to non-destructive CREDENTIAL_REJECTED.
 const AUTH_ERROR_ENVELOPE_LIMIT_BYTES = 64 * 1024;
+const ROLE_SECTION_CONFLICT_CODE = 'ROLE_SECTION_CONFLICT';
 export const LOCAL_SERVER_REQUEST_TIMEOUT_MS = 5_000;
 const LOCAL_SERVER_RESPONSE_LIMIT_MESSAGE =
   'Local Borg server response exceeded the response limit';
@@ -400,18 +406,42 @@ async function localCubeComposition(active: ActiveCube): Promise<{
   if (!cubePayload || !rolePayload || !dronePayload) {
     throw new Error('Local Borg server returned an incomplete cube response');
   }
-  const drone = dronePayload.drones.find((candidate) => candidate.id === active.droneId);
+  const drones = dronePayload.drones.map(withValidatedRuntimeMetadata);
+  const drone = drones.find((candidate) => candidate.id === active.droneId);
   const role = rolePayload.roles.find((candidate) => candidate.id === drone?.role_id);
   if (!drone || !role) throw new Error('Local Borg server no longer recognizes this drone seat');
   return {
     cube: cubePayload.cube,
     roles: rolePayload.roles,
-    drones: dronePayload.drones,
+    drones,
     role,
     drone,
   };
 }
 
+function withValidatedRuntimeMetadata<T extends Record<string, unknown>>(drone: T): T {
+  const state = decodeDroneRuntimeMetadataState(drone);
+  return {
+    ...drone,
+    ...state.runtime_metadata,
+    runtime_metadata_reported: state.runtime_metadata_reported,
+  };
+}
+
+async function updateOwnRuntimeMetadata(
+  active: ActiveCube,
+  patch: ReturnType<typeof buildRuntimeMetadataPatch>,
+): Promise<void> {
+  const payload = await localServerRequest<Record<string, unknown>>(
+    active,
+    `/api/cubes/${active.cubeId}/drones/self/metadata`,
+    'PATCH',
+    { ...patch },
+  );
+  if (!payload) throw new Error('Local Borg server returned an empty runtime metadata response');
+  decodeUpdateDroneRuntimeMetadataResponse(payload);
+}
+
 function localCursorBinding(active: ActiveCube) {
   return {
     origin: active.apiUrl,
@@ -673,7 +703,30 @@ async function authedFetch(
         AUTH_ERROR_ENVELOPE_LIMIT_BYTES,
         'Local Borg server error response exceeded the response limit',
       );
-      code = decodeProtocolErrorEnvelope(JSON.parse(body)).error.code;
+      const parsed = JSON.parse(body);
+      try {
+        code = decodeProtocolErrorEnvelope(parsed).error.code;
+      } catch {
+        if (
+          parsed !== null && typeof parsed === 'object' &&
+          parsed.error !== null && typeof parsed.error === 'object' &&
+          parsed.error.code === ROLE_SECTION_CONFLICT_CODE
+        ) {
+          // Shared 0.6.2 intentionally omits this server-local code. Re-validate the whole
+          // envelope through the strict shared decoder with only the recognized
+          // code substituted; no server-provided diagnostic is ever surfaced.
+          decodeProtocolErrorEnvelope({
+            ...parsed,
+            error: {
+              ...parsed.error,
+              code: ErrorCode.INVALID_INPUT,
+              message: 'Role section conflict.',
+              ...(Object.hasOwn(parsed.error, 'details') ? { details: 'Redacted.' } : {}),
+            },
+          });
+          code = ROLE_SECTION_CONFLICT_CODE as ErrorCode;
+        }
+      }
     } catch {
       code = undefined;
     }
@@ -740,7 +793,7 @@ export async function whoami(
   sessionToken: string,
   apiUrl: string,
   serverTrustIdentity?: string,
-): Promise<{ cube_id: string; cube_name: string; drone_id: string; drone_label: string; role_id: string; role_name: string }> {
+): Promise<{ cube_id: string; cube_name: string; drone_id: string; drone_label: string; role_id: string; role_name: string; runtime_metadata: { agent_kind: AgentKind | null; reported_model: string | null; working_repo_name: string | null; working_repo_origin: string | null }; runtime_metadata_reported: boolean }> {
   const local = await localAuthorityContext(sessionToken, apiUrl, serverTrustIdentity);
   const composed = await localCubeComposition(local);
   return {
@@ -750,6 +803,13 @@ export async function whoami(
     drone_label: composed.drone.label,
     role_id: composed.role.id,
     role_name: composed.role.name,
+    runtime_metadata: {
+      agent_kind: composed.drone.agent_kind,
+      reported_model: composed.drone.reported_model,
+      working_repo_name: composed.drone.working_repo_name,
+      working_repo_origin: composed.drone.working_repo_origin,
+    },
+    runtime_metadata_reported: composed.drone.runtime_metadata_reported,
   };
 }
 
@@ -786,7 +846,7 @@ export async function getRoster(
       throw new Error('Local Borg server returned an incomplete roster response');
     }
     return {
-      drones: dronePayload.drones,
+      drones: dronePayload.drones.map(withValidatedRuntimeMetadata),
       roles: rolePayload.roles,
       message_taxonomy: cubePayload.cube.message_taxonomy ?? null,
       since: dronePayload.since ?? since,
@@ -944,6 +1004,8 @@ export async function regen(
     since?: string;
     /** Advisory self-report from the running agent; never model-routing config. */
     reportedModel?: string;
+    /** Positively identified running Agent CLI; null means explicitly unknown. */
+    agentKind?: AgentKind | null;
     /** Current cwd-derived identity; refreshed each regen to avoid stale routing data. */
     workingRepo?: WorkingRepo;
     /** Verified self-hosted authority from the caller's first active-state read. */
@@ -970,6 +1032,24 @@ export async function regen(
     apiUrl,
     opts.serverTrustIdentity,
   );
+  if (
+    opts.agentKind !== undefined ||
+    opts.reportedModel !== undefined ||
+    opts.workingRepo !== undefined
+  ) {
+    const patch = buildRuntimeMetadataPatch({
+      agentKind: opts.agentKind ?? null,
+      reportedModel: opts.reportedModel,
+      workingRepo: opts.workingRepo,
+    });
+    try {
+      await updateOwnRuntimeMetadata(local, patch);
+    } catch {
+      // Metadata is advisory. Preserve the prior server value and continue with
+      // the authenticated identity read; never echo rejected local input.
+      console.warn('Local regen: runtime metadata update unavailable; preserving the prior safe report.');
+    }
+  }
   const composed = await localCubeComposition(local);
   const cursor = opts.since === undefined
     ? await getLocalServerCursor(localCursorBinding(local))
@@ -1355,19 +1435,36 @@ export async function patchRoleSection(
   if (!active?.serverTrustIdentity) throw new Error('Selected Borg server authority state is missing or unreadable');
   const cubeId = targetCubeId ?? active.cubeId;
   assertUuidShape(cubeId, 'cube_id');
-  const result = await localManageRequest<{ role: any }>(
-    active,
-    `/api/cubes/${cubeId}/roles/${roleId}/section-patch`,
-    'POST',
-    {
-      operation: `${op.action} section ${manageCopyValue(op.heading)} ${op.action === 'delete' ? 'from' : 'in'} role ${manageCopyValue(roleId)} in cube ${manageCopyValue(cubeId === active.cubeId ? active.name : cubeId)}`,
-      cubeName: cubeId === active.cubeId ? active.name : cubeId,
-      noMutation: `No role section was ${op.action === 'insert' ? 'inserted' : op.action === 'replace' ? 'replaced' : 'deleted'}.`,
-    },
-    { ...op },
-    undefined,
-    connectionOverride,
-  );
+  let result: { role: any } | null;
+  try {
+    result = await localManageRequest<{ role: any }>(
+      active,
+      `/api/cubes/${cubeId}/roles/${roleId}/section-patch`,
+      'POST',
+      {
+        operation: `${op.action} section ${manageCopyValue(op.heading)} ${op.action === 'delete' ? 'from' : 'in'} role ${manageCopyValue(roleId)} in cube ${manageCopyValue(cubeId === active.cubeId ? active.name : cubeId)}`,
+        cubeName: cubeId === active.cubeId ? active.name : cubeId,
+        noMutation: `No role section was ${op.action === 'insert' ? 'inserted' : op.action === 'replace' ? 'replaced' : 'deleted'}.`,
+      },
+      { ...op },
+      undefined,
+      connectionOverride,
+    );
+  } catch (error) {
+    if (
+      error instanceof BorgServerHttpError &&
+      error.status === 409 &&
+      String(error.code) === ROLE_SECTION_CONFLICT_CODE
+    ) {
+      throw new RoleSectionConflictError({
+        roleId,
+        action: op.action,
+        heading: op.heading,
+        ...(op.action === 'insert' ? { after: op.after } : {}),
+      });
+    }
+    throw error;
+  }
   if (!result) throw new Error('Local Borg server returned an empty role response');
   return result;
 }
@@ -1494,16 +1591,17 @@ export async function getCube(cubeId: string, connection?: RemoteConnection): Pr
   return {
     ...cubePayload.cube,
     roles: rolePayload.roles,
-    drones: dronePayload.drones,
+    drones: dronePayload.drones.map(withValidatedRuntimeMetadata),
   };
 }
 
 /**
- * gh#473 PR2 — apply a named template to an existing cube via the
- * NON-CLOBBERING server route. New roles are inserted; existing
+ * Apply a named template through client-orchestrated, non-clobbering role and
+ * taxonomy primitives. New roles are inserted; existing
  * template-named roles get ADD fragments auto-applied (template
  * sections/classes the cube lacks) but their EVOLVED (conflicting)
- * fragments are surfaced server-side and KEPT, never overwritten. Returns
+ * fragments are kept, never overwritten. Primitive operations are sequential,
+ * so earlier changes may remain committed if a later operation fails. Returns
  * `{ created, updated }` counts. To selectively take template versions of
  * conflicting fragments, use `syncRoles` with a `decisions` map instead.
  */
@@ -1550,7 +1648,7 @@ export async function applyTemplate(
 }
 
 /**
- * gh#473 PR2 — NON-CLOBBERING sync of a cube's roles + message_taxonomy
+ * Client-orchestrated, non-clobbering sync of a cube's roles and taxonomy
  * against the current built-in template. Dry-run by default classifies
  * each fragment (role-text SECTION / short_description / flags / taxonomy
  * CLASS) as ADD / UNCHANGED / CONFLICT. Pass apply=true to commit:
@@ -1558,7 +1656,9 @@ export async function applyTemplate(
  * ONLY when their stable key appears in `decisions` as 'accept'.
  * Unspecified conflicts DEFAULT TO REJECT — the cube's evolved text is
  * never silently overwritten. Custom roles (names not in template) are
- * never touched. Returns a NonClobberSyncResult.
+ * never touched. Applied primitives are sequential rather than atomic, so an
+ * earlier operation may remain committed if a later operation fails. Returns a
+ * NonClobberSyncResult.
  */
 export async function syncRoles(
   cubeId: string,

package/src/roster-render.ts

@@ -16,6 +16,10 @@
  */
 
 import { formatDroneAddressToken } from 'borgmcp-shared/drone-address';
+import { escapeSyncDisplay } from './sync-roles-render.js';
+
+export const RUNTIME_METADATA_ADVISORY =
+  'Agent CLI, reported model, and working repository are advisory. They do not determine authority, role, health, activity, wake behavior, or routing.';
 
 export interface RosterDrone {
   id?: string;
@@ -47,6 +51,7 @@ export interface RosterDrone {
   /** Current cwd-derived repository identity, refreshed on regen. */
   working_repo_name?: string | null;
   working_repo_origin?: string | null;
+  runtime_metadata_reported?: boolean;
 }
 
 export interface RosterRole {
@@ -104,6 +109,54 @@ export function formatWorkingRepoLabel(drone: Pick<RosterDrone, 'working_repo_na
   return 'Working repo: not reported';
 }
 
+function metadataValue(
+  drone: RosterDrone,
+  value: string | null | undefined,
+): string {
+  if (drone.runtime_metadata_reported !== true) return 'not reported';
+  return value == null ? 'unknown' : escapeRuntimeMetadataDisplay(value);
+}
+
+/**
+ * Keep accepted advisory metadata readable without letting a Markdown renderer
+ * or link-detecting terminal turn cube-controlled text into a live target.
+ * The visible `[.]` / `[:]` markers preserve the reported value's differences.
+ */
+export function escapeRuntimeMetadataDisplay(value: string): string {
+  const escaped = escapeSyncDisplay(value);
+  const defangedScheme = escaped.replace(
+    /\b([A-Za-z][A-Za-z0-9+.-]*)\:\/\//g,
+    '$1\\[:]//',
+  );
+  return defangedScheme.replace(
+    /\b(?:[A-Za-z0-9-]+\.)+[A-Za-z]{2,63}\b/g,
+    (host) => host.replaceAll('.', '\\[.\\]'),
+  );
+}
+
+export function renderRuntimeMetadataLines(
+  drone: RosterDrone,
+  opts: { includeOrigin?: boolean } = {},
+): string[] {
+  const agent = drone.agent_kind === 'claude'
+    ? 'Claude Code'
+    : drone.agent_kind === 'codex'
+      ? 'Codex'
+      : drone.agent_kind === 'opencode'
+        ? 'OpenCode'
+        : null;
+  const lines = [
+    `  - **Agent CLI:** ${metadataValue(drone, agent)}`,
+    `  - **Reported model:** ${metadataValue(drone, drone.reported_model)}`,
+    `  - **Working repo:** ${metadataValue(drone, drone.working_repo_name)}`,
+  ];
+  if (opts.includeOrigin) {
+    const origin = drone.working_repo_origin?.replace(/^https:\/\//i, '');
+    lines.push(`  - **Origin:** ${metadataValue(drone, origin)}`);
+  }
+  return lines;
+}
+
 export interface RenderRosterInputs {
   cubeName: string;
   drones: RosterDrone[];
@@ -126,6 +179,8 @@ export function renderRoster(inputs: RenderRosterInputs): string {
   const lines: string[] = [];
   lines.push(`# Drones in cube: ${cubeName}`);
   lines.push('');
+  lines.push(`_${RUNTIME_METADATA_ADVISORY}_`);
+  lines.push('');
 
   if (resolvedSince) {
     // Surface the liveness-probe context so the reader knows what the
@@ -146,15 +201,9 @@ export function renderRoster(inputs: RenderRosterInputs): string {
   for (const d of drones) {
     const role = roleById.get(d.role_id);
     const roleName = role?.name ?? 'unknown';
-    const roleLabel = formatRoleAgentLabel(roleName, d.agent_kind);
     // gh#371: stable short-uuid address token beside the (renumber-prone) label.
     const addr = d.id ? ` ${formatDroneAddressToken(d.id)}` : '';
     const lastSeen = humanAgo(d.last_seen);
-    const reportedModelMarker = d.reported_model
-      ? ` · \`Reported model: ${d.reported_model}\``
-      : ' · `Reported model: not reported`';
-    const workingRepo = formatWorkingRepoLabel(d);
-    const workingRepoMarker = ` · \`${workingRepo}\``;
     const wakePathMarker =
       d.wake_path && d.wake_path !== 'live'
         ? ` · \`wake-path:${WAKE_PATH_DISPLAY[d.wake_path] ?? d.wake_path}\``
@@ -183,13 +232,14 @@ export function renderRoster(inputs: RenderRosterInputs): string {
       const isAwake = d.seen_since === true;
       const marker = isAwake ? '`awake`' : '`stale`';
       lines.push(
-        `- **${d.label}**${addr} (${roleLabel}) — last seen ${lastSeen} · ${marker}${regenCountMarker}${wakePathMarker}${wakePathClassMarker}${reportedModelMarker}${workingRepoMarker}`
+        `- **${d.label}**${addr} (Role: ${roleName}) — last seen ${lastSeen} · ${marker}${regenCountMarker}${wakePathMarker}${wakePathClassMarker}`
       );
     } else {
       lines.push(
-        `- **${d.label}**${addr} (${roleLabel}) — last seen ${lastSeen}${regenCountMarker}${wakePathMarker}${wakePathClassMarker}${reportedModelMarker}${workingRepoMarker}`
+        `- **${d.label}**${addr} (Role: ${roleName}) — last seen ${lastSeen}${regenCountMarker}${wakePathMarker}${wakePathClassMarker}`
       );
     }
+    lines.push(...renderRuntimeMetadataLines(d, { includeOrigin: true }));
   }
 
   return lines.join('\n');