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

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.320",
+  "version": "0.9.82-rc.321",
   "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.321",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

package/src/commands/router.ts

@@ -128,22 +128,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);

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 ────────────────────────────────
@@ -135,79 +134,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';

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) {

package/src/mesh/mesh-work-queue.ts

@@ -1,7 +1,7 @@
 import { randomUUID } from 'crypto';
 import { requireMeshHostQueueOwner } from './mesh-host-ownership.js';
-import type { RepoMeshDaemonRole, LocalMeshNodeEntry } from '../repo-mesh-types.js';
-import { MESH_CONVERGE_REFINE_TAG, resolveAutoConvergeCodeChange, resolveTaskAffinityRole } from '../repo-mesh-types.js';
+import type { RepoMeshDaemonRole } from '../repo-mesh-types.js';
+import { MESH_CONVERGE_REFINE_TAG, resolveAutoConvergeCodeChange } from '../repo-mesh-types.js';
 import { MeshRuntimeStore } from './mesh-runtime-store.js';
 import { getMesh } from '../config/mesh-config.js';
 
@@ -204,45 +204,6 @@ function firstProviderPriority(policy: unknown): string | undefined {
     return raw.find(type => typeof type === 'string' && type.trim())?.trim();
 }
 
-/**
- * Synthetic `role=<x>` capability tags advertised by a node's policy.providerRoles.
- *
- * When a specific `providerType` is being evaluated, only that provider's declared
- * role is emitted — so role-based routing (requiredTags: ["role=validation"]) gates
- * the *selected* provider through the ordinary capability-tag filter. When no
- * provider is selected (node-level eligibility scan), every declared role is emitted
- * so the node passes the filter if ANY of its providers could satisfy the role; the
- * per-provider tag set then narrows it during provider selection.
- *
- * Roles are lowercased and deduped. Missing/empty providerRoles emits nothing, so a
- * node that never declares roles advertises no `role=` tags and is therefore only
- * matched by role-unconstrained tasks (full backward compatibility).
- */
-function roleCapabilityTags(policy: unknown, providerType: string | undefined): string[] {
-    const roles = policy && typeof policy === 'object' && !Array.isArray(policy)
-        ? (policy as Record<string, unknown>).providerRoles
-        : undefined;
-    if (!Array.isArray(roles)) return [];
-    const wantedProvider = typeof providerType === 'string' && providerType.trim()
-        ? providerType.trim().toLowerCase()
-        : '';
-    const out: string[] = [];
-    for (const entry of roles) {
-        if (!entry || typeof entry !== 'object') continue;
-        const type = typeof (entry as any).providerType === 'string'
-            ? (entry as any).providerType.trim().toLowerCase()
-            : '';
-        const role = typeof (entry as any).role === 'string'
-            ? (entry as any).role.trim().toLowerCase()
-            : '';
-        if (!role) continue;
-        // When narrowing to a selected provider, only emit that provider's role.
-        if (wantedProvider && type && type !== wantedProvider) continue;
-        out.push(`role=${role}`);
-    }
-    return out;
-}
-
 export function buildMeshNodeCapabilityTags(
     node: { capabilities?: unknown; policy?: unknown; isLocalWorktree?: unknown; worktreeBranch?: unknown } | undefined,
     providerType?: string,
@@ -273,13 +234,6 @@ export function buildMeshNodeCapabilityTags(
         //     the load-balancing scheduler auto-injects converge=refine for code_change
         //     so such work is hard-filtered onto refine-capable nodes.
         ...(node?.isLocalWorktree === true ? ['converge=refine'] : ['converge=fast_forward']),
-        // Role-based routing: advertise role=<x> for each (node, provider) role
-        // declared in policy.providerRoles. Narrowed to the selected provider when
-        // one is given so the chosen provider must match a task's required role;
-        // when no provider is selected, all declared roles are advertised for the
-        // node-level eligibility scan. Reuses the ordinary required-tags filter —
-        // no separate role field/gate.
-        ...roleCapabilityTags(node?.policy, providerType),
     ]);
 }
 
@@ -328,67 +282,6 @@ export function resolveConvergeRequiredTags(
     return normalizeMeshCapabilityTags([...explicitRequiredTags, MESH_CONVERGE_REFINE_TAG]);
 }
 
-/**
- * Whether any node in the mesh advertises the given `role=<role>` capability tag.
- * Reuses buildMeshNodeCapabilityTags (node-level scan: every declared providerRole is
- * advertised) so the membership test matches the exact tag the claim/eligibility filter
- * would see. Used to keep task-affinity SOFT — if no node can satisfy the role, the
- * injection is skipped so the task falls back to ordinary least_loaded eligibility
- * rather than being blocked.
- */
-function meshHasNodeAdvertisingRole(nodes: LocalMeshNodeEntry[] | undefined, role: string): boolean {
-    if (!Array.isArray(nodes) || nodes.length === 0) return false;
-    const wanted = `role=${role}`;
-    return nodes.some(node => buildMeshNodeCapabilityTags(node as any).includes(wanted));
-}
-
-/**
- * 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 function resolveTaskAffinityRequiredTags(
-    meshId: string,
-    taskMode: MeshTaskMode | undefined,
-    explicitRequiredTags: string[],
-    opts?: { targetNodeId?: string; callerSpecifiedRequiredTags?: boolean },
-): string[] {
-    // Caller pinned the node, or brought their own required_tags → respect it verbatim.
-    if (typeof opts?.targetNodeId === 'string' && opts.targetNodeId.trim()) return explicitRequiredTags;
-    if (opts?.callerSpecifiedRequiredTags === true) return explicitRequiredTags;
-
-    let mesh;
-    try {
-        mesh = getMesh(meshId);
-    } catch {
-        return explicitRequiredTags;
-    }
-    const role = resolveTaskAffinityRole(taskMode, mesh?.policy?.taskAffinity);
-    if (!role) return explicitRequiredTags;
-
-    // SOFT affinity: only hard-filter when the role actually exists in the mesh.
-    if (!meshHasNodeAdvertisingRole(mesh?.nodes, role)) {
-        try {
-            console.warn(`[mesh] task_affinity: no node advertises role=${role} for taskMode=${taskMode} in mesh ${meshId}; skipping injection (least_loaded fallback)`);
-        } catch { /* logging is best-effort */ }
-        return explicitRequiredTags;
-    }
-    return normalizeMeshCapabilityTags([...explicitRequiredTags, `role=${role}`]);
-}
-
 function withQueueLock<T>(_meshId: string, fn: () => T): T {
     return MeshRuntimeStore.getInstance().transaction(fn);
 }
@@ -474,31 +367,18 @@ export function enqueueTask(
             throw new Error(`duplicate_task_id: task '${id}' already exists in mesh '${meshId}'`);
         }
         assertNoDependencyCycle(meshId, id, dependsOn);
-        // Did the caller bring their own routing tags? Affinity auto-injection is
-        // suppressed when so (caller's required_tags win), matching the spec — measured
-        // against the ORIGINAL caller tags, before convergence augmentation below.
         const callerTags = normalizeMeshCapabilityTags(opts?.requiredTags);
-        const callerSpecifiedRequiredTags = callerTags.length > 0;
         // Convergence routing (opt-in): auto-inject converge=refine for code_change
         // tasks so they hard-filter onto refine-capable worktree nodes. No-op unless
         // the mesh opts in; explicit target_node_id / required_tags are preserved.
-        let resolvedRequiredTags = resolveConvergeRequiredTags(
+        // Routing is otherwise governed solely by the caller's required_tags (hard
+        // filter through nodeSatisfiesRequiredTags) — no role/taskMode auto-routing.
+        const resolvedRequiredTags = resolveConvergeRequiredTags(
             meshId,
             modeValidation.taskMode,
             callerTags,
             { targetNodeId: opts?.targetNodeId },
         );
-        // Declarative task_mode → role affinity (precedent: convergence routing above):
-        // inject role=<role> for the task's taskMode unless the caller pinned a node or
-        // supplied their own required_tags. SOFT — skipped when no node advertises the
-        // role (least_loaded fallback). Built-in default mapping applies even without a
-        // taskAffinity config block; { enabled:false } disables it.
-        resolvedRequiredTags = resolveTaskAffinityRequiredTags(
-            meshId,
-            modeValidation.taskMode,
-            resolvedRequiredTags,
-            { targetNodeId: opts?.targetNodeId, callerSpecifiedRequiredTags },
-        );
         const entry: MeshWorkQueueEntry = {
             id,
             meshId,