@adhdev/daemon-core 0.9.82-rc.323 → 0.9.82-rc.324

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

@@ -83,6 +83,7 @@ export declare function buildMeshNodeCapabilityTags(node: {
     policy?: unknown;
     isLocalWorktree?: unknown;
     worktreeBranch?: unknown;
+    userOverrides?: unknown;
 } | undefined, providerType?: string): string[];
 export declare function nodeSatisfiesRequiredTags(requiredTags: unknown, capabilityTags: unknown): boolean;
 /**

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

@@ -296,7 +296,13 @@ export declare function resolveDelegatedWorkerAutoApprove(meshPolicy?: Pick<Repo
  */
 export declare function resolveProviderMaxParallel(nodePolicy: Pick<RepoMeshNodePolicy, 'providerRoles'> | null | undefined, providerType: string | null | undefined): number | undefined;
 export interface RepoMeshNodeCapabilities {
+    /** Node's OS, raw NodeJS.Platform value ("darwin"/"win32"/"linux"). For
+     *  remote member nodes this is stamped by the member daemon at join time
+     *  (its own process.platform) and drives os= capability-tag routing. */
     platform?: string;
+    /** Node's CPU architecture, raw process.arch value ("arm64"/"x64"). Stamped
+     *  by the member daemon at join time; drives arch= capability-tag routing. */
+    arch?: string;
     packageManagers?: string[];
     detectedCommands?: DetectedCommand[];
     canRunLongJobs?: boolean;

package/package.json

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

package/src/commands/router.ts

@@ -2002,6 +2002,122 @@ export async function runMeshRefinePatchEquivalenceGate(
     }
 }
 
+export type MeshWorktreePatchContainmentSummary = {
+    /** True only when merging worktreeHead into ref introduces no new patch. */
+    contained: boolean;
+    ref: string;
+    worktreeHead: string;
+    mergeBase?: string;
+    mergedTree?: string;
+    /** patch-id of (ref -> synthesized merge tree); empty string when nothing new is added. */
+    residualPatchId?: string;
+    durationMs: number;
+    /** Set when the check could not run (treated conservatively as NOT contained). */
+    error?: string;
+};
+
+/**
+ * Patch-equivalence containment check for the worktree force-cleanup convergence
+ * guard. Answers a narrower question than {@link runMeshRefinePatchEquivalenceGate}:
+ * "are the worktree branch's changes ALREADY present in `ref` (e.g. origin/main),
+ * even though the worktree HEAD's commit SHA is not an ancestor of ref?"
+ *
+ * This is the cherry-pick / squash / rebase case: the same content landed on the
+ * default ref under a different commit SHA, so `merge-base --is-ancestor` (the
+ * primary cleanup guard) reports the worktree as un-converged and refuses to
+ * remove it. Refinery already accepts patch-equivalent landings via merge-tree +
+ * patch-id; this brings the same notion of "convergence" to the cleanup guard.
+ *
+ * Mechanism: synthesize the merge of `worktreeHead` into `ref` (reusing the same
+ * trivial-gitlink-fast-forward handling as the refine gate) and compute the
+ * patch-id of (ref -> mergedTree). If that residual diff is EMPTY, merging the
+ * worktree adds nothing new on top of ref — its changes are already present there
+ * and the worktree is safe to remove. A non-empty residual means the worktree
+ * still carries content not in ref, so it is NOT contained and must stay blocked.
+ *
+ * Conservative by construction: any merge-tree / patch-id failure, a genuine
+ * (non-trivial) submodule conflict, or any thrown error yields `contained: false`
+ * so an exception can never widen the cleanup allow-list.
+ */
+export async function checkWorktreeChangesPatchEquivalentInRef(
+    repoRoot: string,
+    ref: string,
+    worktreeHead: string,
+): Promise<MeshWorktreePatchContainmentSummary> {
+    const startedAt = Date.now();
+    try {
+        const { execFileSync } = await import('node:child_process');
+        const git = (gitArgs: string[]) => execFileSync('git', gitArgs, {
+            cwd: repoRoot,
+            encoding: 'utf8',
+            maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES,
+        });
+        const mergeBase = git(['merge-base', ref, worktreeHead]).trim();
+
+        // Reuse the refine gate's trivial-gitlink-fast-forward handling: a clean
+        // submodule pointer fast-forward must not block the cleanup, but a real
+        // (non-ff) submodule divergence must keep it blocked.
+        let mergedTree = '';
+        try {
+            mergedTree = git(['merge-tree', '--write-tree', ref, worktreeHead]).trim().split(/\s+/)[0] || '';
+        } catch (mergeTreeErr: any) {
+            const output = `${mergeTreeErr?.message || ''}\n${mergeTreeErr?.stdout || ''}\n${mergeTreeErr?.stderr || ''}`;
+            const isSubmoduleConflict = /(submodule|160000)/i.test(output)
+                || /Recursive merging with submodules/i.test(output);
+            if (!isSubmoduleConflict) throw mergeTreeErr;
+            const evaluation = evaluateGitlinkTrivialFastForward(repoRoot, ref, worktreeHead);
+            if (!evaluation.trivial) {
+                // A genuine submodule divergence (or unfetched objects): we cannot
+                // prove containment, so block conservatively.
+                return {
+                    contained: false,
+                    ref,
+                    worktreeHead,
+                    mergeBase: mergeBase || undefined,
+                    durationMs: Date.now() - startedAt,
+                    error: `merge-tree submodule conflict is not a trivial fast-forward: ${evaluation.reason || 'unknown'}`,
+                };
+            }
+            mergedTree = synthesizeTrivialFastForwardMergeTree(repoRoot, ref, worktreeHead, evaluation.gitlinks) || '';
+        }
+
+        if (!mergedTree) {
+            return {
+                contained: false,
+                ref,
+                worktreeHead,
+                mergeBase: mergeBase || undefined,
+                durationMs: Date.now() - startedAt,
+                error: 'could not resolve synthetic merge tree for containment check',
+            };
+        }
+
+        // Exclude proven fast-forward gitlinks from the residual diff for the same
+        // reason the refine gate does: advancing a submodule pointer to a strict
+        // descendant is a safe fast-forward and must not count as "new content".
+        const ffGitlinkExcludePaths = collectFastForwardGitlinkPaths(repoRoot, ref, worktreeHead);
+        const residualPatchId = await computeGitPatchId(repoRoot, ref, mergedTree, ffGitlinkExcludePaths);
+        const contained = residualPatchId === '';
+        return {
+            contained,
+            ref,
+            worktreeHead,
+            mergeBase: mergeBase || undefined,
+            mergedTree,
+            residualPatchId,
+            durationMs: Date.now() - startedAt,
+        };
+    } catch (e: any) {
+        return {
+            contained: false,
+            ref,
+            worktreeHead,
+            durationMs: Date.now() - startedAt,
+            error: e?.message || String(e),
+        };
+    }
+}
+
 /**
  * No-op guard: detect a "silent no-op" merge before the Refinery merge runs.
  *
@@ -3303,13 +3419,26 @@ function buildMemberJoinNode(mesh: any, args: any, fallbackDaemonId?: string): R
         : typeof source?.nodeId === 'string' && source.nodeId.trim()
             ? source.nodeId.trim()
             : undefined;
+    const baseOverrides = source?.userOverrides && typeof source.userOverrides === 'object' && !Array.isArray(source.userOverrides)
+        ? source.userOverrides as Record<string, unknown>
+        : {};
+    // This payload is built ON THE MEMBER DAEMON, so process.platform/process.arch
+    // are the member's OWN machine. Stamp them into userOverrides so the host
+    // stores the member's real platform/arch on the node record — the coordinator's
+    // buildMeshNodeCapabilityTags then advertises os=<member-os> instead of the
+    // coordinator's own platform. Only fill values the operator hasn't already set.
+    const userOverrides: Record<string, unknown> = {
+        ...baseOverrides,
+        ...(typeof baseOverrides.platform === 'string' && baseOverrides.platform.trim() ? {} : { platform: process.platform }),
+        ...(typeof baseOverrides.arch === 'string' && baseOverrides.arch.trim() ? {} : { arch: process.arch }),
+    };
     return {
         ...(nodeId ? { id: nodeId } : {}),
         workspace,
         ...(typeof source?.repoRoot === 'string' && source.repoRoot.trim() ? { repoRoot: source.repoRoot.trim() } : {}),
         ...(typeof source?.daemonId === 'string' && source.daemonId.trim() ? { daemonId: source.daemonId.trim() } : fallbackDaemonId ? { daemonId: fallbackDaemonId } : {}),
         ...(typeof source?.machineId === 'string' && source.machineId.trim() ? { machineId: source.machineId.trim() } : {}),
-        userOverrides: source?.userOverrides && typeof source.userOverrides === 'object' && !Array.isArray(source.userOverrides) ? source.userOverrides : {},
+        userOverrides,
         policy: source?.policy && typeof source.policy === 'object' && !Array.isArray(source.policy) ? source.policy : {},
         role: 'member',
     };
@@ -3915,6 +4044,7 @@ export class DaemonCommandRouter {
 
         const seen = new Set<string>();
         const checkedRefs: string[] = [];
+        const resolvedRefCommits: Array<{ ref: string; commit: string }> = [];
         for (const ref of candidateRefs) {
             if (!ref || seen.has(ref)) continue;
             seen.add(ref);
@@ -3925,6 +4055,7 @@ export class DaemonCommandRouter {
                 continue;
             }
             checkedRefs.push(ref);
+            resolvedRefCommits.push({ ref, commit });
             try {
                 await runGit(['merge-base', '--is-ancestor', head, commit], args.repoRoot);
                 return { allow: true, status: 'merged_to_default_ref', source: 'git_merge_base', ref };
@@ -3933,6 +4064,27 @@ export class DaemonCommandRouter {
             }
         }
 
+        // SHA-reachability fallback: the worktree HEAD is not an ancestor of any
+        // candidate ref, but its CONTENT may already be present via cherry-pick /
+        // squash / rebase (a different commit SHA carrying the same patch). The
+        // Refinery accepts such patch-equivalent landings; mirror that here so the
+        // cleanup guard does not falsely block a converged worktree. This is the
+        // heavier merge-tree/patch-id path, so it only runs after every ancestor
+        // check has already failed. Any failure stays conservative (NOT contained).
+        for (const { ref, commit } of resolvedRefCommits) {
+            let containment: MeshWorktreePatchContainmentSummary;
+            try {
+                containment = await checkWorktreeChangesPatchEquivalentInRef(args.repoRoot, commit, head);
+            } catch {
+                // Defensive: the helper is already exception-safe, but never let a
+                // thrown error escape into an allow.
+                continue;
+            }
+            if (containment.contained) {
+                return { allow: true, status: 'patch_equivalent_to_default_ref', source: 'git_patch_equivalence', ref };
+            }
+        }
+
         return {
             allow: false,
             status: metadataStatus || undefined,

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

@@ -30,6 +30,170 @@ const LIVE_DEBUG_READONLY_FORBIDDEN: Array<{ label: string; pattern: RegExp }> =
     { label: 'container_mutation', pattern: /\b(docker\s+(?:build|run|exec|push|tag|rmi|rm|create|start|stop|kill)|kubectl\s+(?:apply|delete|patch|replace|create|scale))\b/i },
 ];
 
+/**
+ * Negation cues that, when they appear shortly before a mutation keyword inside
+ * the same clause, mean the keyword is being *forbidden* or described rather
+ * than invoked (e.g. "do not git reset", "절대 push 하지 마세요"). Matched
+ * case-insensitively. The Korean cues intentionally include sub-string forms
+ * ("않", "금지", "말 것") so conjugated variants are caught.
+ */
+const NEGATION_CUES: string[] = [
+    "don't", 'do not', 'never', 'avoid', 'without', 'no longer', 'not', 'forbidden',
+    '하지 마', '하지 마세요', '말 것', '금지', '없음', '않',
+];
+
+/** How many whitespace-delimited tokens before a keyword we scan for negation. */
+const NEGATION_WINDOW_TOKENS = 6;
+
+/**
+ * Returns true if a negation cue appears within {@link NEGATION_WINDOW_TOKENS}
+ * tokens before `matchIndex`, staying inside the same clause — we stop at
+ * sentence/line/clause boundaries (newline, `.`/`!`/`?`, `;`) so a negation in a
+ * previous sentence does not suppress a real command in the next one.
+ */
+function hasNegationBefore(text: string, matchIndex: number): boolean {
+    const before = text.slice(0, matchIndex);
+    // Restrict to the current clause: cut at the last clause/sentence/line break.
+    const clauseStart = Math.max(
+        before.lastIndexOf('\n'),
+        before.lastIndexOf('. '),
+        before.lastIndexOf('! '),
+        before.lastIndexOf('? '),
+        before.lastIndexOf(';'),
+    );
+    const clause = before.slice(clauseStart + 1);
+    const lower = clause.toLowerCase();
+    // Whitespace tokens immediately preceding the keyword, within the window.
+    const tokens = clause.split(/\s+/).filter(Boolean);
+    const windowTokens = tokens.slice(Math.max(0, tokens.length - NEGATION_WINDOW_TOKENS));
+    const windowText = windowTokens.join(' ').toLowerCase();
+    for (const cue of NEGATION_CUES) {
+        const c = cue.toLowerCase();
+        // ASCII cues are word-ish phrases — match in the bounded window only.
+        // CJK cues have no spaces, so the window-join can miss them; for those
+        // fall back to scanning the whole clause (still clause-bounded).
+        if (/[^\x00-\x7f]/.test(c)) {
+            if (lower.includes(c)) return true;
+        } else if (windowText.includes(c)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+/**
+ * Korean (and other) negation often trails the verb it negates ("git reset 하지
+ * 마세요" = "do not git reset"). Returns true if a CJK negation cue appears
+ * shortly after `matchEnd`, within the same clause. Scoped to CJK cues only —
+ * trailing ASCII words rarely negate a preceding command and would over-match.
+ */
+function hasTrailingNegation(text: string, matchEnd: number): boolean {
+    const after = text.slice(matchEnd);
+    // Clause-bound the lookahead: stop at the next clause/line break.
+    const clauseEnd = (() => {
+        const stops = [after.indexOf('\n'), after.indexOf('. '), after.indexOf('; ')]
+            .filter(i => i >= 0);
+        return stops.length ? Math.min(...stops) : after.length;
+    })();
+    const clause = after.slice(0, clauseEnd).toLowerCase();
+    for (const cue of NEGATION_CUES) {
+        const c = cue.toLowerCase();
+        if (/[^\x00-\x7f]/.test(c) && clause.includes(c)) return true;
+    }
+    return false;
+}
+
+/**
+ * Returns true when the keyword at [matchStart, matchEnd) looks like an actual
+ * command invocation rather than a plain-prose mention. Command context is:
+ *   - inside a fenced code block (``` ... ```) or inline backticks (`...`)
+ *   - on a shell-prompt line (starts with `$ ` or `> `)
+ *   - at a command-call position: line start (leading whitespace allowed) or
+ *     right after a shell connective (`&&`, `||`, `|`, `;`) or an imperative
+ *     connective ("then"/"run"/"," ) that introduces a command.
+ * Plain mid-sentence prose mentions (no backticks, no command position) are not
+ * command context and are excluded from violations.
+ */
+function isMutationKeywordInCommandContext(text: string, matchStart: number, matchEnd: number): boolean {
+    if (isInsideBackticksOrFence(text, matchStart, matchEnd)) return true;
+
+    // The line containing the match, and the portion of it before the keyword.
+    const lineStart = text.lastIndexOf('\n', matchStart - 1) + 1;
+    const linePrefix = text.slice(lineStart, matchStart);
+
+    // Shell-prompt line: "$ ..." or "> ..." (leading whitespace allowed).
+    if (/^\s*[$>]\s/.test(text.slice(lineStart))) return true;
+
+    // Line start (only whitespace before the keyword on this line).
+    if (/^\s*$/.test(linePrefix)) return true;
+
+    // After a shell connective or imperative connective introducing a command.
+    // We look at what immediately precedes the keyword on the same line.
+    if (/(?:&&|\|\||\||;)\s*$/.test(linePrefix)) return true;
+    if (/(?:^|[\s,])(?:then|run|first)\s+$/i.test(linePrefix)) return true;
+    if (/,\s*$/.test(linePrefix)) return true;
+
+    return false;
+}
+
+/**
+ * True if [matchStart, matchEnd) lies inside an inline-backtick span or a fenced
+ * code block. Fenced blocks (```...```) take precedence; otherwise we count
+ * inline backticks before the match — an odd count means we are inside a span.
+ */
+function isInsideBackticksOrFence(text: string, matchStart: number, matchEnd: number): boolean {
+    // Fenced code blocks: count ``` fences before the match.
+    const fenceRe = /```/g;
+    let fenceCount = 0;
+    let m: RegExpExecArray | null;
+    while ((m = fenceRe.exec(text)) !== null) {
+        if (m.index >= matchStart) break;
+        fenceCount++;
+    }
+    if (fenceCount % 2 === 1) return true;
+
+    // Inline backticks: count single backticks before the match start, ignoring
+    // those that are part of a ``` fence (handled above). An odd count → inside.
+    let inlineCount = 0;
+    for (let i = 0; i < matchStart; i++) {
+        if (text[i] === '`') {
+            // Skip triple-fence backticks.
+            if (text[i + 1] === '`' && text[i + 2] === '`') {
+                i += 2;
+                continue;
+            }
+            inlineCount++;
+        }
+    }
+    return inlineCount % 2 === 1;
+}
+
+/**
+ * Decides whether a forbidden keyword match at [matchStart, matchEnd) should
+ * count as a real violation. A match counts only when it is in command context
+ * and not negated. Negation always wins (even inside a code block), per the
+ * conservative rule: code-block + negation → exclude; other code-block → keep.
+ */
+function isRealMutationMatch(text: string, matchStart: number, matchEnd: number): boolean {
+    if (hasNegationBefore(text, matchStart)) return false;
+    if (hasTrailingNegation(text, matchEnd)) return false;
+    return isMutationKeywordInCommandContext(text, matchStart, matchEnd);
+}
+
+/**
+ * Runs a global regex over `text` and returns true if any match is a real
+ * mutation (command context, not negated).
+ */
+function patternHasRealMutation(pattern: RegExp, text: string): boolean {
+    const re = new RegExp(pattern.source, pattern.flags.includes('g') ? pattern.flags : pattern.flags + 'g');
+    let match: RegExpExecArray | null;
+    while ((match = re.exec(text)) !== null) {
+        if (isRealMutationMatch(text, match.index, match.index + match[0].length)) return true;
+        if (match.index === re.lastIndex) re.lastIndex++; // avoid zero-width loop
+    }
+    return false;
+}
+
 /**
  * Git subcommands that mutate the working tree, index, refs, or remote.
  * `stash` and `checkout` are intentionally absent here: they have read-only
@@ -59,25 +223,32 @@ function detectGitMutation(message: string): boolean {
     let match: RegExpExecArray | null;
     while ((match = re.exec(message)) !== null) {
         const sub = match[1].toLowerCase();
-        if (GIT_MUTATION_SUBCOMMANDS.has(sub)) return true;
+        // Only treat a mutating `git <sub>` as a real violation when it appears
+        // as an actual command (code/command context) and is not negated. Plain
+        // prose mentions ("don't git reset", "we won't push") are ignored.
+        const isReal = () => isRealMutationMatch(message, match!.index, match!.index + match![0].length);
+        if (GIT_MUTATION_SUBCOMMANDS.has(sub)) {
+            if (isReal()) return true;
+            continue;
+        }
         if (sub === 'stash') {
             // Token following `git stash`; read-only only for list/show.
             const after = message.slice(re.lastIndex).match(/^\s+([a-z][a-z0-9-]*)/i);
             const next = after ? after[1].toLowerCase() : '';
-            if (!GIT_STASH_READONLY_SUBCOMMANDS.has(next)) return true; // bare stash = push, or pop/apply/drop/...
+            if (!GIT_STASH_READONLY_SUBCOMMANDS.has(next) && isReal()) return true; // bare stash = push, or pop/apply/drop/...
         } else if (sub === 'checkout') {
             // `git checkout <ref/path>` mutates; `git checkout-index` is matched
             // as its own token by the regex (sub === 'checkout-index') and is read-only.
-            return true;
+            if (isReal()) return true;
         } else if (sub === 'submodule') {
             // `git submodule update` mutates; `git submodule status` is read-only.
             const after = message.slice(re.lastIndex).match(/^\s+([a-z][a-z0-9-]*)/i);
             const next = after ? after[1].toLowerCase() : '';
-            if (next === 'update' || next === 'add' || next === 'sync' || next === 'deinit') return true;
+            if ((next === 'update' || next === 'add' || next === 'sync' || next === 'deinit') && isReal()) return true;
         } else if (sub === 'worktree') {
             const after = message.slice(re.lastIndex).match(/^\s+([a-z][a-z0-9-]*)/i);
             const next = after ? after[1].toLowerCase() : '';
-            if (next === 'add' || next === 'remove' || next === 'move' || next === 'prune') return true;
+            if ((next === 'add' || next === 'remove' || next === 'move' || next === 'prune') && isReal()) return true;
         }
         // checkout-index, stash-with-no-next-already-handled, status/diff/log/show/
         // rev-parse/branch/submodule status fall through as read-only.
@@ -100,8 +271,11 @@ export function validateMeshTaskModeRequest(mode: unknown, message: string): Mes
         return { valid: true, taskMode, violations: [] };
     }
     const text = message || '';
+    // Only flag keywords that look like real commands (code/command context) and
+    // are not negated — descriptive/prohibitive prose ("don't run `npm publish`",
+    // "read-only, no deploy") must not trip the guardrail.
     const violations = LIVE_DEBUG_READONLY_FORBIDDEN
-        .filter(rule => rule.pattern.test(text))
+        .filter(rule => patternHasRealMutation(rule.pattern, text))
         .map(rule => rule.label);
     if (detectGitMutation(text)) {
         violations.push('git_mutation');
@@ -204,8 +378,15 @@ function firstProviderPriority(policy: unknown): string | undefined {
     return raw.find(type => typeof type === 'string' && type.trim())?.trim();
 }
 
+function readNodeOverride(node: { userOverrides?: unknown } | undefined, key: 'platform' | 'arch'): string | null {
+    const overrides = node?.userOverrides;
+    if (!overrides || typeof overrides !== 'object' || Array.isArray(overrides)) return null;
+    const value = (overrides as Record<string, unknown>)[key];
+    return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
 export function buildMeshNodeCapabilityTags(
-    node: { capabilities?: unknown; policy?: unknown; isLocalWorktree?: unknown; worktreeBranch?: unknown } | undefined,
+    node: { capabilities?: unknown; policy?: unknown; isLocalWorktree?: unknown; worktreeBranch?: unknown; userOverrides?: unknown } | undefined,
     providerType?: string,
 ): string[] {
     const provider = typeof providerType === 'string' && providerType.trim()
@@ -214,10 +395,21 @@ export function buildMeshNodeCapabilityTags(
     const worktreeBranch = typeof node?.worktreeBranch === 'string' && node.worktreeBranch.trim()
         ? node.worktreeBranch.trim()
         : null;
+    // Per-node platform/arch: prefer the value the remote daemon stamped into
+    // its node record (userOverrides.platform/arch) so a Windows member advertises
+    // os=win32 even though the COORDINATOR computing these tags runs on darwin.
+    // Fall back to process.platform/process.arch only when absent — that covers the
+    // local coordinator node and local worktree nodes, where process.* IS correct.
+    // Vocabulary is raw process.platform/process.arch ("darwin"/"win32"/"linux",
+    // "arm64"/"x64") on both the advertiser and the required_tags matcher, which
+    // compares with plain string equality (nodeSatisfiesRequiredTags) — so this
+    // keeps the win32/darwin/linux vocabulary the matcher already expects.
+    const os = readNodeOverride(node, 'platform') ?? process.platform;
+    const arch = readNodeOverride(node, 'arch') ?? process.arch;
     return normalizeMeshCapabilityTags([
         ...(Array.isArray(node?.capabilities) ? node.capabilities : []),
-        `os=${process.platform}`,
-        `arch=${process.arch}`,
+        `os=${os}`,
+        `arch=${arch}`,
         ...(provider ? [`provider=${provider}`] : []),
         // Worktree nodes automatically expose a "worktree=<branch>" tag so that
         // mesh_enqueue_task with required_tags: ["worktree=<branch>"] routes

package/src/repo-mesh-types.ts

@@ -398,7 +398,13 @@ export function resolveProviderMaxParallel(
 // ─── Capabilities ───────────────────────────────
 
 export interface RepoMeshNodeCapabilities {
+    /** Node's OS, raw NodeJS.Platform value ("darwin"/"win32"/"linux"). For
+     *  remote member nodes this is stamped by the member daemon at join time
+     *  (its own process.platform) and drives os= capability-tag routing. */
     platform?: string;
+    /** Node's CPU architecture, raw process.arch value ("arm64"/"x64"). Stamped
+     *  by the member daemon at join time; drives arch= capability-tag routing. */
+    arch?: string;
     packageManagers?: string[];
     detectedCommands?: DetectedCommand[];
     canRunLongJobs?: boolean;