total-recall-brain 3.41.1 → 3.41.3

package/scaffold/.agent/skills/total-recall/plugins/mesh/plugin.json

@@ -2,9 +2,15 @@
   "$schema": "https://github.com/gregiteen/total-recall/blob/main/metadata.plugin.schema.json",
   "id": "mesh",
   "name": "Headscale",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Control-server mesh administration, Tailscale SSH, and peer node discovery.",
   "license": "MIT",
+  "requires": [
+    {
+      "id": "auth",
+      "range": ">=1.2.1"
+    }
+  ],
   "branding": {
     "name": "Headscale",
     "color": "#818cf8",
@@ -90,10 +96,34 @@
         "effect": "write",
         "output": "json",
         "args": [
-          {"name":"operation","label":"Operation","type":"string","positional":true,"required":true},
-          {"name":"node","label":"Node","type":"string","positional":true,"required":true},
-          {"name":"source","label":"Source","type":"string","positional":true,"required":true},
-          {"name":"destination","label":"Destination","type":"string","positional":true,"required":true}
+          {
+            "name": "operation",
+            "label": "Operation",
+            "type": "string",
+            "positional": true,
+            "required": true
+          },
+          {
+            "name": "node",
+            "label": "Node",
+            "type": "string",
+            "positional": true,
+            "required": true
+          },
+          {
+            "name": "source",
+            "label": "Source",
+            "type": "string",
+            "positional": true,
+            "required": true
+          },
+          {
+            "name": "destination",
+            "label": "Destination",
+            "type": "string",
+            "positional": true,
+            "required": true
+          }
         ]
       },
       {
@@ -103,8 +133,30 @@
       },
       {
         "name": "view",
-        "description": "Inspect live mesh state",
-        "effect": "read"
+        "description": "Read independent owner observations for mesh screens",
+        "effect": "read",
+        "timeout_ms": 60000,
+        "args": [
+          {
+            "name": "screen",
+            "label": "Screen",
+            "type": "choice",
+            "positional": true,
+            "options": [
+              "machines",
+              "flows",
+              "placement",
+              "boundary",
+              "join"
+            ]
+          },
+          {
+            "name": "json",
+            "label": "JSON output",
+            "type": "boolean",
+            "flag": "--json"
+          }
+        ]
       },
       {
         "name": "nodes",
@@ -145,7 +197,7 @@
       {
         "name": "enroll",
         "description": "Mesh enroll operation",
-        "effect": "write"
+        "effect": "destructive"
       },
       {
         "name": "preauthkey",
@@ -292,5 +344,187 @@
   "distribution": {
     "tier": "official",
     "license": "open"
+  },
+  "mesh": {
+    "version": 1,
+    "description": "Declared support and observation contracts; declarations are not live readiness or primitive grants.",
+    "provides": [
+      {
+        "id": "node-inventory",
+        "operation": "status",
+        "runtime": "mesh",
+        "observation": "machines.status"
+      },
+      {
+        "id": "execution-probe",
+        "operation": "doctor",
+        "runtime": "mesh",
+        "observation": "doctor"
+      },
+      {
+        "id": "remote-execution",
+        "operation": "exec",
+        "runtime": "mesh",
+        "observation": "doctor"
+      },
+      {
+        "id": "path-probe",
+        "operation": "ping",
+        "runtime": "mesh",
+        "observation": "ping"
+      },
+      {
+        "id": "presence",
+        "operation": "presence",
+        "runtime": "presence",
+        "observation": "machines.presence"
+      },
+      {
+        "id": "file-push",
+        "operation": "file",
+        "runtime": "mesh",
+        "observation": null
+      },
+      {
+        "id": "secret-grants",
+        "operation": "grants",
+        "runtime": "mesh-identity",
+        "observation": "flows.grants"
+      },
+      {
+        "id": "control-policy",
+        "operation": "policy",
+        "runtime": "headscale-client",
+        "observation": "boundary.policy"
+      },
+      {
+        "id": "enrollment",
+        "operation": "enroll",
+        "runtime": "mesh-enroll",
+        "observation": "join.status"
+      }
+    ],
+    "integrations": [
+      {
+        "id": "auth",
+        "owner": "auth",
+        "purpose": "One host credential store; no values in views",
+        "observation": "machines.status",
+        "evidence": "control.verified"
+      },
+      {
+        "id": "headscale",
+        "owner": "mesh",
+        "purpose": "Control server authentication and membership",
+        "observation": "machines.status",
+        "evidence": "control.verified"
+      },
+      {
+        "id": "tailscale",
+        "owner": "mesh",
+        "purpose": "Client enrollment and mesh network state",
+        "observation": "machines.status",
+        "evidence": "network_available"
+      },
+      {
+        "id": "ssh",
+        "owner": "mesh",
+        "purpose": "Per-machine execution probes",
+        "observation": "doctor",
+        "evidence": "reachable per machine"
+      },
+      {
+        "id": "presence",
+        "owner": "mesh",
+        "purpose": "Authenticated fresh activity observations",
+        "observation": "machines.presence",
+        "evidence": "peer states and timestamps"
+      },
+      {
+        "id": "plugin-sharing",
+        "owner": "mesh",
+        "purpose": "Peer plugin inventories",
+        "observation": "flows.plugins",
+        "evidence": "peer status"
+      },
+      {
+        "id": "updates",
+        "owner": "core",
+        "purpose": "Last automatic maintenance report",
+        "observation": "flows.updates",
+        "evidence": "recorded last result"
+      },
+      {
+        "id": "schedules",
+        "owner": "user-automations",
+        "purpose": "Task declarations and node placement",
+        "observation": "flows.tasks",
+        "evidence": "node inventory; no execution inferred"
+      },
+      {
+        "id": "agents",
+        "owner": "core",
+        "purpose": "Running and recent process inventory",
+        "observation": "flows.agents",
+        "evidence": "process records"
+      },
+      {
+        "id": "alerts",
+        "owner": "operator-alerts",
+        "purpose": "Recorded delivery attempts",
+        "observation": "flows.alerts",
+        "evidence": "ledger result; no recipient view inferred"
+      },
+      {
+        "id": "deployments",
+        "owner": "deploy",
+        "purpose": "Selected project release state",
+        "observation": "flows.deployments",
+        "evidence": "configured slot; no fleet-wide inference"
+      }
+    ],
+    "endpoints": [
+      {
+        "path": "/api/mesh/presence/local",
+        "method": "GET",
+        "runtime": "route-mesh-presence",
+        "authentication": "mesh peer"
+      },
+      {
+        "path": "/api/mesh/plugins",
+        "method": "GET",
+        "runtime": "route-plugins-mesh",
+        "authentication": "mesh peer"
+      }
+    ],
+    "task_placement": "Declared task placement is selected-node or per-node; actual execution requires a verified daemon report.",
+    "unavailable": [
+      "transfer-history",
+      "service-health-cli",
+      "exit-node-management",
+      "subnet-route-management",
+      "tunnel-inventory",
+      "public-exposure-inventory",
+      "speed-measurement",
+      "messages",
+      "shared-file-spaces"
+    ]
+  },
+  "capability": {
+    "entry": "capability/index.mjs",
+    "dependencies": [],
+    "exports": [
+      "createControlServer",
+      "createHeadscaleApi",
+      "buildMeshSshPolicy",
+      "meshTargetOf",
+      "sshExec",
+      "assertSecureControlUrl",
+      "normalizeControlUrl",
+      "shellQuote",
+      "patchConfig",
+      "parseChecksum",
+      "consoleConfig"
+    ]
   }
 }

package/scaffold/.agent/skills/total-recall/plugins/mesh/src/cli/mesh.mjs

@@ -46,6 +46,7 @@ function printHelp() {
   Usage: total-recall mesh <command> [options]
 
     status                 Control-server reachability and credential state
+    view <screen>          Read Machines, Flows, Placement, Boundary or Join sources (--json)
     doctor                 Probe reachability & compute capabilities across all nodes
     nodes                  List mesh nodes and how to reach each one
     ssh <node> [cmd…]      Open a session using the node's recorded access
@@ -194,9 +195,9 @@ export default async function meshCli(argv = []) {
     }
 
     if (command === 'doctor' || command === 'diagnostics') {
-      console.log('\n🩺 Total Recall — Mesh Diagnostics & Compute Capability Audit\n');
       const enriched = listEnrichedMeshNodes(vaultRoot);
       const isJson = args.includes('--json');
+      if (!isJson) console.log('\n🩺 Total Recall — Mesh Diagnostics & Compute Capability Audit\n');
 
       const stripAnsi = (s) => String(s || '').replace(/\x1b\[[0-9;]*m/g, '');
       const pad = (s, l) => String(s || '') + ' '.repeat(Math.max(0, l - stripAnsi(s).length));
@@ -217,13 +218,17 @@ export default async function meshCli(argv = []) {
           reachable: false,
           error: null
         };
+        nodeInfo.tested_runtimes = ['ollama', 'docker', 'node', 'git'];
+        nodeInfo.tested_harnesses = ['agy', 'claude', 'codex', 'gemini'];
 
         if (node.self) {
           try {
             const { detectHarnesses } = await import('../core/meta-harness.mjs');
-            nodeInfo.harnesses = detectHarnesses().filter(h => h.available).map(h => h.id);
-          } catch {}
-          nodeInfo.runtimes = ['node', 'git'];
+            const detected = detectHarnesses();
+            nodeInfo.harnesses = detected.filter(h => h.available).map(h => h.id);
+            nodeInfo.tested_harnesses = detected.map(h => h.id);
+          } catch { nodeInfo.tested_harnesses = []; }
+          nodeInfo.runtimes = nodeInfo.tested_runtimes.filter(tool => spawnSync('/bin/sh', ['-c', 'command -v "$1"', 'mesh-probe', tool], { encoding: 'utf8', timeout: 3000 }).status === 0);
           nodeInfo.reachable = true;
         } else if (resolved.complete) {
           try {
@@ -233,16 +238,12 @@ export default async function meshCli(argv = []) {
             // reachable machines as down.
             const res = await execMeshCommand(node.hostname, probeCmd, { vaultRoot, timeoutMs: 15000 });
             nodeInfo.reachable = res.success;
-            if (res.success && !node.access?.verified_at) {
-              // A login that just worked is the only kind worth sharing with peers.
-              await setMeshNodeAccess(node.hostname, { verified_at: new Date().toISOString() }, { vaultRoot });
-            }
             if (res.success) {
               const parts = res.stdout.split(/\s+/);
               for (const part of parts) {
                 const [k, v] = part.split('=');
                 if (v && v.trim()) {
-                  if (['agy', 'claude', 'codex', 'gemini', 'ollama'].includes(k)) {
+                  if (['agy', 'claude', 'codex', 'gemini'].includes(k)) {
                     nodeInfo.harnesses.push(k);
                   } else {
                     nodeInfo.runtimes.push(k);
@@ -770,6 +771,10 @@ export default async function meshCli(argv = []) {
         if (reportPolicyModeError(err)) return;
         throw err;
       }
+      if (args.includes('--json')) {
+        console.log(JSON.stringify({ configured: current.configured, policy: current.policy, updatedAt: current.updatedAt || null }));
+        return;
+      }
       if (!current.configured) {
         console.log('No policy is set on the control server.');
         console.log('Run `total-recall mesh policy init-ssh` to enable Tailscale SSH.');

package/scaffold/.agent/skills/total-recall/plugins/mesh/src/cli/server.mjs

@@ -3,7 +3,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
-import { meshTargetOf, provisionHeadscale, updateHeadscale, updateConsole, sshExec } from '../core/headscale-server.mjs';
+import { meshTargetOf, provisionHeadscale, updateHeadscale, updateConsole, sshExec } from '../../capability/control-server.mjs';
 import { saveCredential } from '../core/credentials.mjs';
 import { brainDir } from '../core/config.mjs';
 import { PluginStateStore } from '../ssss-store.mjs';

package/scaffold/.agent/skills/total-recall/plugins/mesh/src/core/credentials.mjs

@@ -1,7 +1,8 @@
 import { importHostModule } from '../host-runtime.mjs';
 const { loadPluginModule: __loadOwnedPlugin } = await importHostModule('src/core/plugin-runtime.mjs');
 import { assertSecureControlUrl, normalizeControlUrl, headscaleUrlFromEnv, findHeadscaleKeyMeta } from './headscale-client.mjs';
-const { setSecret, defaultBrainDir } = await __loadOwnedPlugin('auth', 'secrets-store');
+const { setSecret } = await __loadOwnedPlugin('auth', 'secrets-store');
+const { hostSecretsBrainDir } = await __loadOwnedPlugin('auth', 'host-secrets-store');
 
 export async function verifyCredential(value, url, fetchImpl = fetch) {
   if (typeof value !== 'string' || !value.trim()) throw new Error('A credential is required');
@@ -18,8 +19,9 @@ export async function verifyCredential(value, url, fetchImpl = fetch) {
   return { verified: true, url: normalizeControlUrl(url) };
 }
 
-export async function saveCredential({ key, value, configuration = {}, brainDir = defaultBrainDir() }, dependencies = {}) {
+export async function saveCredential({ key, value, configuration = {} }, dependencies = {}) {
   if (key !== 'HEADSCALE_API_KEY') throw new Error('Unsupported mesh credential');
+  const brainDir = hostSecretsBrainDir();
   const meta = await findHeadscaleKeyMeta(brainDir);
   const url = configuration.controlUrl || headscaleUrlFromEnv() || meta?.headscale_url;
   if (!url) throw new Error('Set the control server URL before saving the credential');

package/scaffold/.agent/skills/total-recall/plugins/mesh/src/core/headscale-client.mjs

@@ -3,14 +3,19 @@ const { loadPluginModule: __loadOwnedPlugin } = await importHostModule('src/core
 /**
  * Headscale control-server client.
  *
- * Single implementation shared by the REST proxy (`routes/headscale.mjs`) and
- * automatic node enrollment (`mesh-enroll.mjs`). No control-server URL is ever
- * hardcoded here — it is resolved from the operator's own secret entry or
- * environment, so this works against any Headscale (or Tailscale SaaS) install.
+ * Host side of the Headscale client, shared by the REST proxy
+ * (`routes/headscale.mjs`) and automatic node enrollment (`mesh-enroll.mjs`).
+ * This module only resolves the operator's credential from the auth plugin and
+ * the throttled transport; the API calls themselves live in the host-free
+ * brick (`capability/headscale-api.mjs`). No control-server URL is ever
+ * hardcoded — it comes from the operator's own secret entry or environment.
  */
-import path from 'node:path';
-const { getSecretsCatalog, getSecret, defaultBrainDir } = await __loadOwnedPlugin('auth', 'secrets-store');
+const { getSecretsCatalog, getSecret } = await __loadOwnedPlugin('auth', 'secrets-store');
+const { hostSecretsBrainDir } = await __loadOwnedPlugin('auth', 'host-secrets-store');
 import { throttledFetch } from './throttled-fetch.mjs';
+import { createHeadscaleApi, assertSecureControlUrl, normalizeControlUrl, buildMeshSshPolicy } from '../../capability/headscale-api.mjs';
+
+export { assertSecureControlUrl, normalizeControlUrl, buildMeshSshPolicy };
 
 const DEFAULT_TIMEOUT_MS = 10_000;
 
@@ -20,34 +25,15 @@ export function headscaleUrlFromEnv() {
   return raw.trim() || null;
 }
 
-/**
- * Reject non-HTTPS control servers (loopback excepted for local development).
- * Bearer tokens must never travel in cleartext over a network hop.
- */
-export function assertSecureControlUrl(url) {
-  const parsed = new URL(url);
-  const isLoopback = ['localhost', '127.0.0.1', '::1'].includes(parsed.hostname);
-  if (parsed.protocol !== 'https:' && !(isLoopback && parsed.protocol === 'http:')) {
-    throw new Error('Headscale URL must use HTTPS (HTTP is allowed only for loopback development)');
-  }
-  return parsed;
-}
-
-/** Strip a trailing slash so path joining stays predictable. */
-export function normalizeControlUrl(url) {
-  const value = String(url || '').trim();
-  return value.endsWith('/') ? value.slice(0, -1) : value;
-}
-
 /**
  * Locate the operator's headscale credential without knowing its key name.
  * Any secret whose provider is `headscale` is treated as the control-server token.
  *
- * Only the explicitly selected auth store is searched. Missing credentials
- * and unlock failures never select another brain or ambient token.
+ * Auth selects its one store for this host (or explicit TR_SECRETS_BRAIN).
+ * The caller's project brain never creates or selects a second credential store.
  */
 async function locateHeadscaleKey(brainDir) {
-  const target = brainDir || defaultBrainDir();
+  const target = hostSecretsBrainDir();
 
   const local = await getSecretsCatalog(target);
   const hit = local.keys.find((k) => k.provider === 'headscale');
@@ -112,174 +98,41 @@ export async function describeHeadscaleAvailability(brainDir) {
   }
 }
 
+/** A brick client bound to this brain's credential, over the host's throttled transport. */
+async function hostApi(brainDir) {
+  const { url, token } = await resolveHeadscaleConfig(brainDir);
+  return createHeadscaleApi({
+    url,
+    token,
+    fetch: (target, { timeoutMs, ...options }) => throttledFetch(target, options, timeoutMs || DEFAULT_TIMEOUT_MS),
+  });
+}
+
 /**
  * Authenticated request against the control server's API.
- * `brainDir` is required so the caller's brain scope selects the credential.
+ * Credentials always come from the auth owner's host-store selector.
  */
 export async function headscaleFetch(path, options = {}, brainDir) {
-  const { url, token } = await resolveHeadscaleConfig(brainDir);
-  assertSecureControlUrl(url);
-
-  const cleanPath = path.startsWith('/') ? path : `/${path}`;
-  const targetUrl = `${normalizeControlUrl(url)}${cleanPath}`;
-
-  const res = await throttledFetch(
-    targetUrl,
-    {
-      ...options,
-      headers: {
-        ...options.headers,
-        Authorization: `Bearer ${token}`,
-        Accept: 'application/json',
-        'Content-Type': 'application/json',
-      },
-    },
-    options.timeoutMs || DEFAULT_TIMEOUT_MS,
-  );
-
-  if (!res.ok) {
-    const errorText = await res.text().catch(() => '');
-    const error = new Error(`Headscale API error (${res.status} ${res.statusText})`);
-    error.status = res.status;
-    error.detail = errorText.slice(0, 500);
-    throw error;
-  }
-
-  const contentType = res.headers.get('content-type') || '';
-  if (contentType.includes('application/json')) {
-    return res.json();
-  }
-  throw new Error('Control server returned a non-JSON response');
+  return (await hostApi(brainDir)).request(path, options);
 }
 
-/**
- * Resolve a control-server user to both of its identifying forms.
- *
- * User-facing names resolve to the current API numeric ID.
- */
+/** Resolve a control-server user to both of its identifying forms. */
 export async function resolveHeadscaleUser(brainDir, requested) {
-  const data = await headscaleFetch('/api/v1/user', {}, brainDir);
-  const users = data?.users || [];
-
-  if (requested) {
-    const match = users.find(
-      (u) =>
-        String(u.id) === String(requested) ||
-        u.name === requested ||
-        (u.email && u.email === requested),
-    );
-    if (match) return { id: String(match.id), name: match.name };
-    // Unknown to us — pass it through and let the control server decide.
-    return { id: String(requested), name: String(requested) };
-  }
-
-  if (!users.length) return null;
-  return { id: String(users[0].id), name: users[0].name };
+  return (await hostApi(brainDir)).resolveUser(requested);
 }
 
-/** Mint using the current numeric-user API without older-version retries. */
+/** Mint a pre-auth key for a registered numeric control-server user. */
 export async function createHeadscalePreAuthKey(options = {}, brainDir) {
-  const ttlMinutes = Number.isFinite(options.ttlMinutes) ? options.ttlMinutes : 10;
-  const expiration = options.expiration || new Date(Date.now() + ttlMinutes * 60_000).toISOString();
-  const ref = options.userRef || await resolveHeadscaleUser(brainDir, options.user);
-  if (!ref?.id || !/^[0-9]+$/.test(String(ref.id))) throw new Error('Select a registered numeric control-server user');
-  const user = String(ref.id);
-  const data = await headscaleFetch('/api/v1/preauthkey', {
-    method: 'POST', body: JSON.stringify({ user, reusable: options.reusable === true,
-      ephemeral: options.ephemeral === true, expiration, aclTags: options.aclTags || [] }),
-  }, brainDir);
-  const key = data?.preAuthKey?.key;
-  if (typeof key !== 'string' || !key) throw new Error('Headscale did not return a pre-auth key');
-  return { key, expiration, user, raw: data };
+  return (await hostApi(brainDir)).createPreAuthKey(options);
 }
 
-/**
- * Read the control server's ACL policy.
- *
- * Requires the server to run with `policy.mode: database` — in `file` mode the
- * policy lives on the control server's disk and the API cannot manage it.
- *
- * Headscale returns a 500 (not a 404) when database mode is on but the policy
- * table is still empty, so an unset policy is normalised to `policy: null`
- * rather than thrown. That distinction matters: "no policy yet" is the expected
- * first-run state, whereas a real transport or auth failure must still surface.
- */
+/** Read the control server's ACL policy; an empty policy table reads as `policy: null`. */
 export async function getHeadscalePolicy(brainDir) {
-  try {
-    const data = await headscaleFetch('/api/v1/policy', {}, brainDir);
-    return {
-      policy: data?.policy ?? null,
-      updatedAt: data?.updatedAt ?? null,
-      configured: Boolean(data?.policy),
-      raw: data,
-    };
-  } catch (err) {
-    const detail = String(err.detail || '');
-    const emptyPolicyTable =
-      err.status === 404 ||
-      (err.status === 500 && /policy|not found|no such/i.test(detail));
-    if (emptyPolicyTable) {
-      return { policy: null, updatedAt: null, configured: false, unset: true, raw: null };
-    }
-    if (err.status === 400 && /database/i.test(detail)) {
-      const modeError = new Error(
-        'Headscale is running in file policy mode; set `policy.mode: database` to manage the policy over the API',
-      );
-      modeError.status = err.status;
-      modeError.detail = err.detail;
-      modeError.code = 'POLICY_MODE_FILE';
-      throw modeError;
-    }
-    throw err;
-  }
+  return (await hostApi(brainDir)).getPolicy();
 }
 
-/**
- * Replace the control server's ACL policy.
- *
- * `policy` may be an object (serialised here) or an already-formatted
- * HuJSON/JSON string. Headscale validates server-side and rejects the write if
- * the policy's own `tests` block fails, so a bad policy never lands.
- */
+/** Replace the control server's ACL policy; Headscale validates it server-side. */
 export async function setHeadscalePolicy(policy, brainDir) {
   if (!policy) throw new Error('A policy is required');
-  const serialised = typeof policy === 'string' ? policy : JSON.stringify(policy, null, 2);
-
-  const data = await headscaleFetch(
-    '/api/v1/policy',
-    { method: 'PUT', body: JSON.stringify({ policy: serialised }) },
-    brainDir,
-  );
-  return { policy: data?.policy ?? serialised, updatedAt: data?.updatedAt ?? null, raw: data };
-}
-
-/**
- * Build a policy that lets every mesh member reach every other member, and use
- * Tailscale SSH between them as any non-root user.
- *
- * This is deliberately the simple single-operator shape: one person's own
- * machines, all equally trusted. It is NOT appropriate for a multi-tenant
- * tailnet — headscale membership is the trust boundary, so anything admitted to
- * the mesh inherits this access. Narrow `src`/`dst` before adding a node you do
- * not control.
- *
- * root is excluded via `autogroup:nonroot`: SSH-ing straight to root over the
- * mesh removes the audit trail that makes per-user access worth having.
- */
-export function buildMeshSshPolicy({ allowRoot = false } = {}) {
-  return {
-    acls: [{ action: 'accept', src: ['*'], dst: ['*:*'] }],
-    ssh: [
-      {
-        action: 'accept',
-        // autogroup:member, not autogroup:self. 'self' limits a member to SSH on their own
-        // devices, so no node on the mesh could reach any other one and every cross-machine
-        // operation fell back to key auth that had never been set up — which reads as the peer
-        // being unreachable. The point of this policy is that members reach each other.
-        src: ['autogroup:member'],
-        dst: ['autogroup:member'],
-        users: allowRoot ? ['autogroup:nonroot', 'root'] : ['autogroup:nonroot'],
-      },
-    ],
-  };
+  return (await hostApi(brainDir)).setPolicy(policy);
 }

package/scaffold/.agent/skills/total-recall/plugins/mesh/src/core/mesh-auth.mjs

@@ -2,8 +2,8 @@ import { importHostModule } from '../host-runtime.mjs';
 const { loadPluginModule: __loadOwnedPlugin } = await importHostModule('src/core/plugin-runtime.mjs');
 import crypto from 'node:crypto';
 import net from 'node:net';
-import { brainDir } from './config.mjs';
 const { getSecret } = await __loadOwnedPlugin('auth', 'secrets-store');
+const { hostSecretsBrainDir } = await __loadOwnedPlugin('auth', 'host-secrets-store');
 
 export function normalizeRemoteAddress(value) {
   const address = String(value || '').trim();
@@ -20,7 +20,7 @@ export function isMeshOrLoopbackAddress(value) {
 }
 
 export async function getMeshSyncToken() {
-  const result = await getSecret(brainDir, 'TR_MESH_SYNC_TOKEN', {
+  const result = await getSecret(hostSecretsBrainDir(), 'TR_MESH_SYNC_TOKEN', {
     action: 'use',
     actor: 'mesh-sync-auth',
   });