@adhdev/daemon-core 0.9.82-rc.320 → 0.9.82-rc.322

package/dist/mesh/mesh-work-queue.d.ts

@@ -108,28 +108,6 @@ export declare function nodeSatisfiesRequiredTags(requiredTags: unknown, capabil
 export declare function resolveConvergeRequiredTags(meshId: string, taskMode: MeshTaskMode | undefined, explicitRequiredTags: string[], opts?: {
     targetNodeId?: string;
 }): string[];
-/**
- * Declarative task_mode → role affinity resolution (precedent: resolveConvergeRequiredTags).
- *
- * At enqueue time, auto-inject a `role=<role>` required tag derived from the task's
- * taskMode via the mesh's policy.taskAffinity (falling back to DEFAULT_TASKMODE_ROLE_MAP),
- * so the task hard-filters onto nodes advertising that role through the ordinary
- * required-tags path (nodeSatisfiesRequiredTags) — no claim/scheduler change needed.
- *
- * Strict precedence / backward compatibility — the injection is skipped (returns the
- * explicit tags unchanged) when ANY of:
- *   - the caller pinned an explicit targetNodeId (operator chose the node), or
- *   - the caller supplied their own non-empty required_tags (caller's routing wins), or
- *   - affinity resolves to no role (policy disabled, blank override, or unknown mode), or
- *   - SOFT fallback: no node in the mesh advertises the resolved role=<role> — injecting
- *     would block the task with zero eligible nodes, so we skip it and let least_loaded
- *     eligibility take over (a warning is logged so the misconfiguration is visible).
- * Idempotent: normalizeMeshCapabilityTags dedupes.
- */
-export declare function resolveTaskAffinityRequiredTags(meshId: string, taskMode: MeshTaskMode | undefined, explicitRequiredTags: string[], opts?: {
-    targetNodeId?: string;
-    callerSpecifiedRequiredTags?: boolean;
-}): string[];
 /**
  * M1: detect dependency cycles before enqueue. Walks the dependency graph of
  * existing queue entries plus the new task's edges. Fail-closed: a cycle

package/dist/repo-mesh-types.d.ts

@@ -119,62 +119,6 @@ export declare function resolveNodeSchedulingPriority(nodePolicy: Pick<RepoMeshN
  */
 export declare const MESH_CONVERGE_REFINE_TAG = "converge=refine";
 export declare const MESH_CONVERGE_FAST_FORWARD_TAG = "converge=fast_forward";
-/**
- * Standard mesh resource-pool roles. These are the dashboard-provided defaults for
- * the role=<x> routing tag (advertised by node policy.providerRoles and matched
- * through nodeSatisfiesRequiredTags). A mesh is free to declare additional custom
- * role strings in policy.taskAffinity; the dashboard role dropdown exposes the union
- * of these four standards plus any config-declared roles. Roles are lowercased
- * everywhere (the role=<x> tag is lowercased in roleCapabilityTags).
- */
-export declare const STANDARD_MESH_ROLES: readonly ["investigator", "coder", "validator", "converger"];
-export type StandardMeshRole = typeof STANDARD_MESH_ROLES[number];
-/**
- * Default taskMode → role mapping (all five task modes). A task enqueued with a
- * given taskMode auto-routes to a node advertising the mapped role=<x> tag, unless
- * the mesh overrides the mapping in policy.taskAffinity.byTaskMode. Keyed by the
- * MeshTaskMode string literals (the canonical union lives in mesh-work-queue.ts;
- * this map is keyed by string to avoid a types ↔ queue import cycle). Kept in sync
- * with MeshTaskMode by the exhaustive lookup in resolveTaskAffinityRole.
- */
-export declare const DEFAULT_TASKMODE_ROLE_MAP: Readonly<Record<string, StandardMeshRole>>;
-/**
- * Declarative task_mode → role affinity policy. When set, enqueueTask auto-injects a
- * `role=<role>` required tag (see resolveTaskAffinityRequiredTags) so the task
- * hard-filters onto nodes advertising that role — but only when the caller did NOT
- * already pin the task with an explicit target_node_id or its own required_tags.
- *
- * - `enabled`: master switch. Defaults to true so the built-in DEFAULT_TASKMODE_ROLE_MAP
- *   takes effect even when a mesh declares no taskAffinity block at all. Set false to
- *   fully disable affinity routing (today's pre-affinity behavior).
- * - `byTaskMode`: per-taskMode override of the default mapping. A role string here may
- *   be any of STANDARD_MESH_ROLES or a custom role declared by the operator. An empty
- *   string disables affinity for that one task mode.
- * - `customRoles`: extra (non-standard) role strings to surface in the dashboard role
- *   dropdown. Routing itself does not require a role to be pre-declared here — any role
- *   referenced in byTaskMode is injected regardless; customRoles only widens the UI list.
- */
-export interface RepoMeshTaskAffinityPolicy {
-    enabled?: boolean;
-    byTaskMode?: Record<string, string>;
-    customRoles?: string[];
-}
-/**
- * Resolve the affinity role for a task mode against a mesh's taskAffinity policy.
- * Returns the lowercased role string to inject as `role=<role>`, or null when no
- * affinity applies (affinity disabled, an explicit empty override, or an unknown mode).
- *
- * Precedence: policy.byTaskMode[mode] (operator override) → DEFAULT_TASKMODE_ROLE_MAP[mode].
- * A blank override string explicitly opts that mode out of affinity routing.
- */
-export declare function resolveTaskAffinityRole(taskMode: string | undefined, policy: RepoMeshTaskAffinityPolicy | null | undefined): string | null;
-/**
- * Union of the standard roles plus any operator-declared roles (byTaskMode values +
- * customRoles), lowercased and deduped, preserving standard-first ordering. Used by
- * the dashboard role dropdown so operators can pick a standard or a config-declared
- * custom role. Pure/UI-facing — does not gate routing.
- */
-export declare function resolveMeshRoleOptions(policy: RepoMeshTaskAffinityPolicy | null | undefined): string[];
 /**
  * Resolve whether the load-balancing scheduler should auto-inject a
  * `converge=refine` required tag onto code_change tasks so they hard-filter onto
@@ -224,18 +168,6 @@ export interface RepoMeshPolicy {
      * Defaults to false: code_change routing is unchanged unless opted in.
      */
     autoConvergeCodeChange?: boolean;
-    /**
-     * Declarative task_mode → role affinity routing. When present (and not disabled),
-     * enqueueTask auto-injects a `role=<role>` required tag for the task's taskMode so
-     * the work hard-filters onto nodes advertising that role. Explicit target_node_id
-     * routing and any caller-supplied required_tags are preserved (auto-injection only
-     * applies when the caller pinned neither). When the mapped role has no advertising
-     * node in the mesh, the task is NOT blocked — the role tag is skipped so the work
-     * falls back to ordinary least_loaded eligibility (soft affinity). Defaults to the
-     * built-in DEFAULT_TASKMODE_ROLE_MAP even when this block is omitted; set
-     * `{ enabled: false }` to fully restore pre-affinity routing.
-     */
-    taskAffinity?: RepoMeshTaskAffinityPolicy;
     /**
      * Whether sessions spawned by mesh/coordinator policy should auto-open as visible
      * dashboard tabs or start hidden. Defaults to 'visible' to preserve existing
@@ -278,21 +210,7 @@ export interface RepoMeshRelatedRepo {
     workspace: string;
 }
 /**
- * Per-(node, provider) role + parallelism declaration.
- *
- * `role` is a free-form resource-pool label (recommended values:
- * 'investigation' | 'coding' | 'orchestration') describing what this
- * (node, provider) combination is *for*. As of the load-balancing scheduler it
- * is ALSO routable: each declared role is advertised as a synthetic `role=<x>`
- * capability tag (see buildMeshNodeCapabilityTags), so a task enqueued with
- * requiredTags: ["role=validation"] is hard-filtered to nodes/providers that
- * declare that role — through the same nodeSatisfiesRequiredTags path as any
- * other tag. There is intentionally no separate "advertisedRoles" field: the
- * label and the routing tag are one mechanism. A task that does not require a
- * `role=` tag ignores roles entirely (opt-in, fully backward compatible).
- *
- * role is intentionally orthogonal to taskMode: taskMode classifies the *work*
- * (code_change vs live_debug_readonly), role classifies the *resource pool*.
+ * Per-(node, provider) parallelism declaration.
  *
  * `maxParallel` is the only enforced field: the queue will not assign a task
  * to this (node, provider) once it already has `maxParallel` active
@@ -300,12 +218,14 @@ export interface RepoMeshRelatedRepo {
  * provider) cap disagree, the stricter (lower effective) limit wins — a claim
  * must satisfy both. Omitting `maxParallel` means this provider is bounded only
  * by the global/taskMode caps (full backward compatibility).
+ *
+ * Routing is governed exclusively by required_tags (see nodeSatisfiesRequiredTags);
+ * this entry carries no routing role. To route work to a specific node, advertise an
+ * ordinary capability tag on the node and require it on the task.
  */
 export interface RepoMeshProviderRole {
     /** Provider type this entry governs (e.g. 'claude-cli', 'codex-cli'). */
     providerType: string;
-    /** Free-form role label; recommended: 'investigation' | 'coding' | 'orchestration'. */
-    role?: string;
     /** Max concurrent active tasks for this (node, provider). Omit = no per-provider cap. */
     maxParallel?: number;
 }
@@ -324,13 +244,11 @@ export interface RepoMeshNodePolicy {
     /** Ordered provider preference used when mesh_launch_session omits an explicit type. */
     providerPriority?: string[];
     /**
-     * Per-(node, provider) role + parallelism declarations. Each entry binds a
-     * providerType on THIS node to an optional free-form role label and an
-     * optional maxParallel cap. maxParallel is enforced (as an additional,
-     * stricter-wins constraint on top of the global maxParallelTasks/taskMode
-     * caps); role is advertised as a routable `role=<x>` capability tag so tasks
-     * can hard-filter by required role. Missing/empty: the node behaves exactly
-     * as before (global caps only, no role tags).
+     * Per-(node, provider) parallelism declarations. Each entry binds a
+     * providerType on THIS node to an optional maxParallel cap. maxParallel is
+     * enforced as an additional, stricter-wins constraint on top of the global
+     * maxParallelTasks/taskMode caps. Missing/empty: the node behaves exactly as
+     * before (global caps only). Routing is governed solely by required_tags.
      */
     providerRoles?: RepoMeshProviderRole[];
     /**
@@ -369,18 +287,12 @@ export declare const DEFAULT_MESH_POLICY: RepoMeshPolicy;
  * launch path merges the envelope as a settingsOverride on top of the provider defaults.
  */
 export declare function resolveDelegatedWorkerAutoApprove(meshPolicy?: Pick<RepoMeshPolicy, 'delegatedWorkerAutoApprove'> | null, nodePolicy?: Pick<RepoMeshNodePolicy, 'delegatedWorkerAutoApprove'> | null): boolean;
-/**
- * Resolve the per-(node, provider) role declaration from a node policy.
- * Case-insensitive, trimmed match on providerType. Returns undefined when the
- * node has no providerRoles entry for this provider (caller then applies only
- * the global caps). Defensive against malformed config — non-object entries and
- * blank providerTypes are skipped rather than throwing.
- */
-export declare function resolveProviderRole(nodePolicy: Pick<RepoMeshNodePolicy, 'providerRoles'> | null | undefined, providerType: string | null | undefined): RepoMeshProviderRole | undefined;
 /**
  * Resolve the enforced per-(node, provider) maxParallel cap, or undefined when
  * no finite, non-negative cap is declared for this provider. Used by the queue
  * claim path as a stricter-wins constraint layered on top of the global caps.
+ * Case-insensitive, trimmed match on providerType. Defensive against malformed
+ * config — non-object entries and blank providerTypes are skipped rather than throwing.
  */
 export declare function resolveProviderMaxParallel(nodePolicy: Pick<RepoMeshNodePolicy, 'providerRoles'> | null | undefined, providerType: string | null | undefined): number | undefined;
 export interface RepoMeshNodeCapabilities {

package/dist/shared-types.d.ts

@@ -302,6 +302,15 @@ export interface SessionEntry {
     seenCompletionMarker?: string;
     surfaceHidden?: boolean;
     settings?: Record<string, any>;
+    /**
+     * True owning-daemon id for a session a coordinator synthesises into its own
+     * status snapshot (mesh delegated sessions). The dashboard attributes the session
+     * to this daemon instead of the snapshot daemon so the worker node — not the
+     * coordinator — is shown as its machine.
+     */
+    ownerDaemonId?: string;
+    /** True owning-machine display name fallback when the owning daemon is not aggregated. */
+    ownerMachineName?: string;
     /** Set when this session is acting as a mesh coordinator for the given mesh. */
     coordinator?: {
         meshId: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.320",
+  "version": "0.9.82-rc.322",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -46,7 +46,7 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "0.9.82-rc.320",
+    "@adhdev/mesh-shared": "0.9.82-rc.322",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

package/src/commands/router.ts

@@ -85,6 +85,7 @@ import { basename as pathBasename, join as pathJoin, resolve as pathResolve } fr
 import * as fs from 'fs';
 import { execFileSync } from 'node:child_process';
 import { normalizeInteractivePromptResponse } from '../providers/types/interactive-prompt.js';
+import { workingDirBasename } from '../providers/working-dir.js';
 
 type ReleaseChannel = 'stable' | 'preview';
 const CHANNEL_NPM_TAG: Record<ReleaseChannel, 'latest' | 'next'> = { stable: 'latest', preview: 'next' };
@@ -128,22 +129,21 @@ function readProviderPriorityFromPolicy(policy: unknown): string[] {
 
 /**
  * Normalize a providerRoles array (RepoMeshNodePolicy.providerRoles) from raw
- * tool args. Each entry binds a providerType to an optional free-form `role`
- * label and an optional `maxParallel` cap. Entries without a usable providerType
- * are dropped; the last entry wins on duplicate providerType. Returns [] when no
- * valid entries — callers then omit the field entirely (full backward compat).
+ * tool args. Each entry binds a providerType to an optional `maxParallel` cap.
+ * Entries without a usable providerType are dropped; the last entry wins on
+ * duplicate providerType. Returns [] when no valid entries — callers then omit
+ * the field entirely (full backward compat). Routing is governed by required_tags;
+ * any legacy `role` field on the input is ignored.
  */
-function normalizeProviderRoles(value: unknown): Array<{ providerType: string; role?: string; maxParallel?: number }> {
+function normalizeProviderRoles(value: unknown): Array<{ providerType: string; maxParallel?: number }> {
     if (!Array.isArray(value)) return [];
-    const byType = new Map<string, { providerType: string; role?: string; maxParallel?: number }>();
+    const byType = new Map<string, { providerType: string; maxParallel?: number }>();
     for (const raw of value) {
         if (!raw || typeof raw !== 'object' || Array.isArray(raw)) continue;
         const rec = raw as Record<string, unknown>;
         const providerType = typeof rec.providerType === 'string' ? rec.providerType.trim() : '';
         if (!providerType) continue;
-        const entry: { providerType: string; role?: string; maxParallel?: number } = { providerType };
-        const role = typeof rec.role === 'string' ? rec.role.trim() : '';
-        if (role) entry.role = role;
+        const entry: { providerType: string; maxParallel?: number } = { providerType };
         const maxParallel = Number(rec.maxParallel);
         if (Number.isFinite(maxParallel) && maxParallel >= 0) entry.maxParallel = Math.floor(maxParallel);
         byType.set(providerType.toLowerCase(), entry);
@@ -224,11 +224,14 @@ function logRepoMeshStatusDebug(event: string, fields: Record<string, unknown>):
 // joinRepoPath + readGitSubmodules moved to @adhdev/mesh-shared (readGitSubmodules)
 // — used via sharedNormalizeGitStatus / sharedPickBestTransitGitStatus below.
 
-function buildMeshNodeDisplayLabel(node: Record<string, unknown>, nodeId: string, providerPriority: string[]): string {
+export function buildMeshNodeDisplayLabel(node: Record<string, unknown>, nodeId: string, providerPriority: string[]): string {
     const explicit = readStringValue(node.machineLabel, node.machine_label, node.machineNickname, node.machine_nickname, node.alias);
     if (explicit) return explicit;
     const workspace = readStringValue(node.workspace, node.repoRoot, node.repo_root);
-    const workspaceName = workspace ? pathBasename(workspace) : undefined;
+    // Use the OS-agnostic basename: a workspace reported by a Windows node
+    // (`D:\gh\adhdev-cloud`) must still collapse to its trailing segment even when
+    // this coordinator's own `path.basename` is POSIX-only and would not split `\`.
+    const workspaceName = workspace ? workingDirBasename(workspace) : undefined;
     const host = readStringValue(node.machineName, node.machine_name, node.hostname, node.host, node.daemonId, node.daemon_id, node.machineId, node.machine_id);
     const provider = providerPriority[0] || (Array.isArray(node.providers) ? readStringValue(...node.providers) : undefined);
     const parts = [workspaceName, host, provider].filter(Boolean);
@@ -874,6 +877,22 @@ function readCachedInlineMeshActiveSessions(node: any): string[] {
     return sessionId ? [sessionId] : [];
 }
 
+/**
+ * Resolve the owning-node attribution for a mesh node record so a coordinator can
+ * stamp the TRUE owner onto a synthetic session entry instead of letting the
+ * dashboard fall back to the coordinator's own daemonId. Returns whichever of the
+ * owning node's `daemonId` / display machine name could be read from the node's
+ * (possibly multi-serialization-path) shape; both may be undefined for a node that
+ * never carried machine identity.
+ */
+export function resolveMeshNodeAttribution(node: unknown): { daemonId?: string; machineName?: string } {
+    const record = readObjectRecord(node);
+    return {
+        daemonId: readMeshNodeDaemonId(record),
+        machineName: readMeshNodeDisplayMachineName(record),
+    };
+}
+
 export function readCachedInlineMeshActiveSessionDetails(node: any): Array<Record<string, unknown>> {
     const cachedStatus = readObjectRecord(node?.cachedStatus);
     const activeSession = readObjectRecord(cachedStatus.activeSession);

package/src/config/mesh-config.ts

@@ -20,9 +20,8 @@ import type {
     RepoMeshCoordinatorConfig,
     RepoMeshHostMetadata,
     RepoMeshDaemonRole,
-    RepoMeshTaskAffinityPolicy,
 } from '../repo-mesh-types.js';
-import { DEFAULT_MESH_POLICY, normalizeMeshSchedulingStrategy, STANDARD_MESH_ROLES } from '../repo-mesh-types.js';
+import { DEFAULT_MESH_POLICY, normalizeMeshSchedulingStrategy } from '../repo-mesh-types.js';
 import { createDefaultMeshHostMetadata } from '../mesh/mesh-host-ownership.js';
 
 // ─── Persistence ────────────────────────────────
@@ -37,12 +36,71 @@ function loadMeshConfig(): LocalMeshConfig {
     try {
         const raw = JSON.parse(readFileSync(path, 'utf-8'));
         if (!raw || !Array.isArray(raw.meshes)) return { meshes: [] };
-        return raw as LocalMeshConfig;
+        const config = raw as LocalMeshConfig;
+        const migrated = migrateLoadedMeshConfig(config);
+        // Persist eagerly when the on-load migration changed anything, so the
+        // dead field is gone from disk even on a pure-read path (mesh_status /
+        // mesh_list_nodes) that never otherwise mutates the config. Best-effort:
+        // a write failure (e.g. read-only fs) must not break reads, so swallow.
+        if (migrated) {
+            try {
+                saveMeshConfig(config);
+            } catch {
+                // keep the in-memory strip; disk converges on the next mutating op
+            }
+        }
+        return config;
     } catch {
         return { meshes: [] };
     }
 }
 
+/**
+ * In-place migration applied to every loaded meshes.json. Strips data that
+ * outlived the feature that wrote it so the persisted config converges on the
+ * current schema the next time it is saved.
+ *
+ * Currently: drops the dead `role` field from each node policy's providerRoles
+ * entries. providerRoles is retained for its `maxParallel` per-(node, provider)
+ * cap, but the routing `role` was removed (routing is governed solely by
+ * required_tags). A meshes.json written before the removal still carries
+ * `role: "validator"` etc.; this drops it on load so mesh_status / mesh_list_nodes
+ * never surface the dead field and the next saveMeshConfig() persists it gone.
+ *
+ * Returns true when the config was mutated (caller may persist eagerly).
+ */
+function migrateLoadedMeshConfig(config: LocalMeshConfig): boolean {
+    let changed = false;
+    for (const mesh of config.meshes) {
+        if (!mesh || !Array.isArray(mesh.nodes)) continue;
+        for (const node of mesh.nodes) {
+            if (stripDeadRoleFromProviderRoles(node?.policy)) changed = true;
+        }
+    }
+    return changed;
+}
+
+/**
+ * Drop the legacy `role` field from each providerRoles entry of a node policy,
+ * in place. Keeps providerType + maxParallel (the still-meaningful per-(node,
+ * provider) cap). Defensive against malformed entries — non-object items are
+ * left untouched. Returns true when at least one `role` field was removed.
+ */
+function stripDeadRoleFromProviderRoles(policy: unknown): boolean {
+    if (!policy || typeof policy !== 'object') return false;
+    const roles = (policy as { providerRoles?: unknown }).providerRoles;
+    if (!Array.isArray(roles)) return false;
+    let changed = false;
+    for (const entry of roles) {
+        if (entry && typeof entry === 'object' && !Array.isArray(entry)
+            && Object.prototype.hasOwnProperty.call(entry, 'role')) {
+            delete (entry as Record<string, unknown>).role;
+            changed = true;
+        }
+    }
+    return changed;
+}
+
 function normalizeCapabilityTags(value: unknown): string[] | undefined {
     if (!Array.isArray(value)) return undefined;
     const seen = new Set<string>();
@@ -135,79 +193,9 @@ function mergeMeshPolicy(base: RepoMeshPolicy | undefined, patch: Partial<RepoMe
     } else {
         delete policy.autoConvergeCodeChange;
     }
-    // Task-mode → role affinity: format-only validation (drop blanks). Unknown/custom
-    // roles are NOT blocked — only a warning is logged. Only persist when the block
-    // carries meaningful content so existing meshes.json stays untouched.
-    const normalizedAffinity = normalizeTaskAffinityPolicy(policy.taskAffinity);
-    if (normalizedAffinity) {
-        policy.taskAffinity = normalizedAffinity;
-    } else {
-        delete policy.taskAffinity;
-    }
     return policy;
 }
 
-/**
- * Format-only normalization of a task-affinity policy. Trims/lowercases role strings,
- * drops blank custom roles and blank byTaskMode keys, and warns (never blocks) when a
- * declared role is not one of the standard four. Returns undefined when the result is
- * empty/no-op so the field stays absent from persisted config.
- */
-function normalizeTaskAffinityPolicy(
-    value: unknown,
-): RepoMeshTaskAffinityPolicy | undefined {
-    if (!value || typeof value !== 'object' || Array.isArray(value)) return undefined;
-    const record = value as Record<string, unknown>;
-    const out: RepoMeshTaskAffinityPolicy = {};
-    let hasContent = false;
-
-    if (typeof record.enabled === 'boolean') {
-        out.enabled = record.enabled;
-        // `enabled:true` is the default — only persist the explicit `false`.
-        if (record.enabled === false) hasContent = true;
-        else delete out.enabled;
-    }
-
-    if (record.byTaskMode && typeof record.byTaskMode === 'object' && !Array.isArray(record.byTaskMode)) {
-        const byTaskMode: Record<string, string> = {};
-        for (const [mode, raw] of Object.entries(record.byTaskMode as Record<string, unknown>)) {
-            const modeKey = mode.trim();
-            if (!modeKey) continue;
-            if (typeof raw !== 'string') continue;
-            // A blank value is a deliberate opt-out for that mode — preserve it as ''.
-            const role = raw.trim().toLowerCase();
-            byTaskMode[modeKey] = role;
-            if (role && !STANDARD_MESH_ROLES.includes(role as any)) {
-                try {
-                    console.warn(`[mesh] task_affinity.byTaskMode.${modeKey}: custom role "${role}" is not a standard mesh role (${STANDARD_MESH_ROLES.join('/')}); routing still applies`);
-                } catch { /* best-effort */ }
-            }
-        }
-        if (Object.keys(byTaskMode).length > 0) {
-            out.byTaskMode = byTaskMode;
-            hasContent = true;
-        }
-    }
-
-    if (Array.isArray(record.customRoles)) {
-        const seen = new Set<string>();
-        const customRoles: string[] = [];
-        for (const raw of record.customRoles) {
-            if (typeof raw !== 'string') continue;
-            const role = raw.trim().toLowerCase();
-            if (!role || seen.has(role)) continue;
-            seen.add(role);
-            customRoles.push(role);
-        }
-        if (customRoles.length > 0) {
-            out.customRoles = customRoles;
-            hasContent = true;
-        }
-    }
-
-    return hasContent ? out : undefined;
-}
-
 function normalizeAutoFastForwardPolicy(value: unknown): NonNullable<RepoMeshPolicy['autoFastForward']> {
     const record = value && typeof value === 'object' && !Array.isArray(value)
         ? value as Record<string, unknown>

package/src/index.ts

@@ -135,8 +135,6 @@ export type {
   RepoMeshLedgerStatus,
   MeshAsyncJobLifecycle,
   RepoMeshSchedulingStrategy,
-  RepoMeshTaskAffinityPolicy,
-  StandardMeshRole,
 } from './repo-mesh-types.js';
 export {
   DEFAULT_MESH_POLICY,
@@ -148,10 +146,6 @@ export {
   MESH_CONVERGE_REFINE_TAG,
   MESH_CONVERGE_FAST_FORWARD_TAG,
   resolveAutoConvergeCodeChange,
-  STANDARD_MESH_ROLES,
-  DEFAULT_TASKMODE_ROLE_MAP,
-  resolveTaskAffinityRole,
-  resolveMeshRoleOptions,
 } from './repo-mesh-types.js';
 
 // ── Git Surface ──
@@ -237,7 +231,7 @@ export { buildMeshLedgerReconciliationEvidence, buildMeshLedgerReplicaEvidence }
 export type { AnyLedgerSlice, MeshLedgerReconciliationEvidence, MeshLedgerReplicaEvidence, MeshLedgerReplicaStatus } from './mesh/mesh-ledger-reconciliation.js';
 
 // ── Mesh Work Queue (GUPP) ──
-export { enqueueTask, recordDirectDispatchTask, getQueue, claimNextTask, updateTaskStatus, updateSessionTaskStatus, cancelTask, requeueTask, getMeshQueueStats, getMeshQueueRevision, normalizeMeshTaskMode, validateMeshTaskModeRequest, buildMeshNodeCapabilityTags, nodeSatisfiesRequiredTags, normalizeMeshCapabilityTags, resolveConvergeRequiredTags, resolveTaskAffinityRequiredTags, insertDirectDispatch, getActiveDirectDispatches, updateDirectDispatchStatus, cleanupTerminalDirectDispatches, markStaleDirectDispatches, deleteDirectDispatchesByTaskId, recordMeshToolCall, assertNoDependencyCycle, hasPendingDependents, describeTaskDependencyState } from './mesh/mesh-work-queue.js';
+export { enqueueTask, recordDirectDispatchTask, getQueue, claimNextTask, updateTaskStatus, updateSessionTaskStatus, cancelTask, requeueTask, getMeshQueueStats, getMeshQueueRevision, normalizeMeshTaskMode, validateMeshTaskModeRequest, buildMeshNodeCapabilityTags, nodeSatisfiesRequiredTags, normalizeMeshCapabilityTags, resolveConvergeRequiredTags, insertDirectDispatch, getActiveDirectDispatches, updateDirectDispatchStatus, cleanupTerminalDirectDispatches, markStaleDirectDispatches, deleteDirectDispatchesByTaskId, recordMeshToolCall, assertNoDependencyCycle, hasPendingDependents, describeTaskDependencyState } from './mesh/mesh-work-queue.js';
 export type { MeshWorkQueueEntry, MeshTaskStatus, MeshTaskMode, MeshWorkQueueStats, MeshQueueMutationOptions, MeshTaskModeValidationResult, DirectDispatchRecord, MeshToolCallRateResult } from './mesh/mesh-work-queue.js';
 export { buildCompactStaleDirectWorkSummary, buildMeshActiveWork, buildMeshActiveWorkSummary, classifyStaleDirectForPrune, PRUNABLE_ORPHAN_STALE_REASONS } from './mesh/mesh-active-work.js';
 export type { StaleDirectPruneClassification } from './mesh/mesh-active-work.js';
@@ -306,7 +300,7 @@ export type { CdpInitializerConfig } from './cdp/initializer.js';
 // ── Commands ──
 export { DaemonCommandHandler } from './commands/handler.js';
 export type { CommandResult, CommandContext } from './commands/handler.js';
-export { DaemonCommandRouter, readCachedInlineMeshActiveSessionDetails } from './commands/router.js';
+export { DaemonCommandRouter, readCachedInlineMeshActiveSessionDetails, resolveMeshNodeAttribution } from './commands/router.js';
 export type { CommandRouterDeps, CommandRouterResult } from './commands/router.js';
 export {
   maybeRunDaemonUpgradeHelperFromEnv,

package/src/mesh/coordinator-prompt.ts

@@ -269,20 +269,19 @@ function buildNodeConfigSection(mesh: LocalMeshEntry): string {
         const explicitMachineLabel = typeof (n as any).machineLabel === 'string' ? (n as any).machineLabel : '';
         const explicitLabel = explicitMachineLabel ? ` label: **${explicitMachineLabel}** |` : '';
         const providerPriority = n.policy?.providerPriority?.length ? ` | providers: ${n.policy.providerPriority.join(', ')}` : '';
-        // Per-(node, provider) role label + maxParallel cap. role is a hint surfaced
-        // here for delegation context; only maxParallel is enforced by the queue.
+        // Per-(node, provider) maxParallel cap. Only maxParallel is enforced by the
+        // queue; routing is governed by required_tags, not provider roles.
         const providerRoles = Array.isArray(n.policy?.providerRoles)
-            ? (n.policy!.providerRoles as Array<{ providerType?: unknown; role?: unknown; maxParallel?: unknown }>)
+            ? (n.policy!.providerRoles as Array<{ providerType?: unknown; maxParallel?: unknown }>)
                 .map(r => {
                     const type = typeof r?.providerType === 'string' ? r.providerType.trim() : '';
                     if (!type) return '';
-                    const role = typeof r?.role === 'string' && r.role.trim() ? `=${r.role.trim()}` : '';
                     const cap = Number.isFinite(Number(r?.maxParallel)) ? ` (max ${Math.floor(Number(r.maxParallel))})` : '';
-                    return `${type}${role}${cap}`;
+                    return `${type}${cap}`;
                 })
                 .filter(Boolean)
             : [];
-        const providerRolesSuffix = providerRoles.length ? ` | roles: ${providerRoles.join(', ')}` : '';
+        const providerRolesSuffix = providerRoles.length ? ` | caps: ${providerRoles.join(', ')}` : '';
         lines.push(`- ${explicitLabel} nodeId: \`${n.id}\` | workspace: \`${n.workspace}\`${n.daemonId ? ` | daemon: \`${n.daemonId}\`` : ''}${providerPriority}${providerRolesSuffix}${suffix}`);
         const nodePrompt = typeof (n as any).systemPrompt === 'string' ? (n as any).systemPrompt.trim() : '';
         if (nodePrompt) {