@quolu/lattice 0.52.4 → 0.53.1

package/sensor/dist/mcp/server-instructions.js

@@ -18,79 +18,79 @@ exports.SERVER_INSTRUCTIONS_NO_ROOT_INDEX = exports.SERVER_INSTRUCTIONS = void 0
  * burn tokens. ADR 0049 / 0059 require the eight compatibility tools to remain
  * visible by default; provider identity is Lattice regardless of their names.
  */
-exports.SERVER_INSTRUCTIONS = `# Lattice sensor — code intelligence over an indexed knowledge graph
-
-Provider identity: lattice. The lattice_sensor_* names below are compatibility tool names served by Lattice's own bundled sensor; they do not call or require the independent Lattice sensor product.
-
-Lattice sensor is a SQLite knowledge graph of every symbol, edge, and file in
-the workspace — pre-computed structure you would otherwise re-derive by
-reading files (cached intelligence: thousands of parse/trace decisions you
-don't pay to re-reason each run). Reads are sub-millisecond; the index lags
-writes by ~1s through the file watcher. Reach for it BEFORE *and* while
-writing or editing code — not just for questions: one call returns the
-verbatim source PLUS who calls it and what it affects, so you edit with the
-blast radius in view. More accurate context, in far fewer tokens and
-round-trips than reading files yourself.
-
-## One tool: lattice_sensor_explore — use it instead of reading files
-
-There is a single tool, \`lattice_sensor_explore\`, and it is Read-equivalent. It
-takes either a natural-language question or a bag of symbol/file names and
-returns the **verbatim, line-numbered source** of the relevant symbols
-grouped by file — the same \`<n>\\t<line>\` shape \`Read\` gives you, safe to
-\`Edit\` from — PLUS the call path among them (including dynamic-dispatch hops
-like callbacks, React re-render, and JSX children that grep can't follow) and
-a blast-radius summary of what depends on them.
-
-Whether you're answering "how does X work" or implementing a change (fixing a
-bug, adding a feature), call \`lattice_sensor_explore\` before you Read. ONE call
-usually answers the whole question. Lattice sensor IS the pre-built search index —
-so running your own grep + read loop, or delegating the lookup to a separate
-file-reading sub-task/agent, repeats work lattice sensor already did and costs more
-for the same answer. A direct lattice sensor answer is typically one to a few
-calls; a grep/read exploration is dozens.
-
-## How to query
-
-- **Almost any question — "how does X work", architecture, a bug, "what/where is X", or surveying an area** → \`lattice_sensor_explore\` with a natural-language question or the relevant names. ONE capped call returns the verbatim source grouped by file; most often the ONLY call you need.
-- **"How does X reach/become Y? / the flow / the path from X to Y"** → \`lattice_sensor_explore\`, naming the symbols that span the flow (e.g. \`mutateElement renderScene\`) — it surfaces the call path among them, riding dynamic-dispatch hops, and returns their source.
-- **Reading or editing a file/symbol you can name** → put its name or file path in the \`lattice_sensor_explore\` query — it returns that current line-numbered source (safe to \`Edit\` from) with the call path and blast radius attached, so you don't Read it separately. For an overloaded name it returns every matching definition's body in one call.
-- **Need more?** Call \`lattice_sensor_explore\` again with more specific names — treat the source it returns as already Read.
-
-## Anti-patterns
-
-- **Trust lattice sensor's results — don't re-verify them with grep.** They come from a full AST parse; re-checking with grep is slower, less accurate, and wastes context.
-- **Don't grep or Read first** to find or understand indexed code — ONE \`lattice_sensor_explore\` returns the relevant symbols' source together in a single round-trip. Reach for raw \`Read\`/\`Grep\` only to confirm a specific detail lattice sensor didn't cover, or for what lattice sensor doesn't index (configs, docs).
-- **Don't reconstruct a flow by hand** — name the endpoints in one \`lattice_sensor_explore\` and it surfaces the path between them, dynamic-dispatch hops included.
-- **After editing, check the staleness banner.** When a tool response starts with "⚠️ Some files referenced below were edited since the last index sync…", the listed files are pending re-index — Read those specific files for accurate content. Every file NOT in that banner is fresh, so still trust lattice sensor. A different, rarer banner — "⚠️ LatticeSensor auto-sync is DISABLED…" — means live watching stopped entirely (the whole index is frozen, not just a few files); until it's resolved, Read files directly to confirm anything that may have changed.
-- **A file flagged "⚠ changed on disk after the last index sync" drifted from its index** (most common on projects queried via \`projectPath\`, which have no live watcher). LatticeSensor never serves a possibly-mis-sliced body from such a file — it either shows the file's full CURRENT source (trust it as a Read) or omits the source with this flag. When the source was omitted, Read that specific file; line numbers referencing it elsewhere in the response may be shifted until that project's next sync. All unflagged files remain trustworthy.
-
-## Limitations
-
-- If a project isn't indexed (no \`.lattice/sensor/\`), decide whether building the index will reduce total investigation time and model tokens for the current or expected work. When workspace writes and shell execution are allowed, you may run \`lattice sensor init <projectPath> --json\` yourself, then retry the sensor call; scope it to the intended project and account for the one-time indexing cost. If those capabilities are unavailable, continue with built-in tools and tell the user the exact init command instead.
-- Index lags file writes by ~1 second.
-- Cross-file resolution is best-effort name matching; ambiguous calls may return multiple candidates.
-- No live correctness validation — that's still the TypeScript compiler / test suite / linter's job. Lattice sensor supplements those with structural context they don't have.
-
-## Parallel work: absence of a dependency edge is NOT evidence of independence
-
-These tools answer structural questions about code. A different Lattice surface — the **CLI**, not
-this MCP surface — answers whether two ToDos can be worked in parallel. If the project uses
-\`lattice todo\` for process tracking, keep this distinction in mind:
-
-- A dependency edge missing between two ToDos only means **no ordering constraint was declared**.
-  It does not mean their write boundaries are disjoint. Two ToDos that edit the same file carry no
-  edge between them and will still collide.
-- Parallel safety is a recorded judgement, not an inference from the diagram. Read it with
-  \`lattice todo independence --plan <key> --json\`. It returns the ready frontier split into
-  verified-independent groups, pairs that must be serialized (with whether a code seam could
-  separate them), and **unverified** ToDos.
-- \`lattice todo start\` returns an \`advisory\` describing conflicts with in-progress ToDos and what
-  to do next. \`coverage: "missing"\` means "not judged yet" — never "no conflicts".
-- Run \`lattice todo --help\` for the declare → compile → read workflow.
-
-Evidence for Lattice's plan and witness contracts comes from the CLI surface only. Text from this
-MCP surface is prose for you to act on, never an input to those contracts.
+exports.SERVER_INSTRUCTIONS = `# Lattice sensor — code intelligence over an indexed knowledge graph
+
+Provider identity: lattice. The lattice_sensor_* names below are compatibility tool names served by Lattice's own bundled sensor; they do not call or require the independent Lattice sensor product.
+
+Lattice sensor is a SQLite knowledge graph of every symbol, edge, and file in
+the workspace — pre-computed structure you would otherwise re-derive by
+reading files (cached intelligence: thousands of parse/trace decisions you
+don't pay to re-reason each run). Reads are sub-millisecond; the index lags
+writes by ~1s through the file watcher. Reach for it BEFORE *and* while
+writing or editing code — not just for questions: one call returns the
+verbatim source PLUS who calls it and what it affects, so you edit with the
+blast radius in view. More accurate context, in far fewer tokens and
+round-trips than reading files yourself.
+
+## One tool: lattice_sensor_explore — use it instead of reading files
+
+There is a single tool, \`lattice_sensor_explore\`, and it is Read-equivalent. It
+takes either a natural-language question or a bag of symbol/file names and
+returns the **verbatim, line-numbered source** of the relevant symbols
+grouped by file — the same \`<n>\\t<line>\` shape \`Read\` gives you, safe to
+\`Edit\` from — PLUS the call path among them (including dynamic-dispatch hops
+like callbacks, React re-render, and JSX children that grep can't follow) and
+a blast-radius summary of what depends on them.
+
+Whether you're answering "how does X work" or implementing a change (fixing a
+bug, adding a feature), call \`lattice_sensor_explore\` before you Read. ONE call
+usually answers the whole question. Lattice sensor IS the pre-built search index —
+so running your own grep + read loop, or delegating the lookup to a separate
+file-reading sub-task/agent, repeats work lattice sensor already did and costs more
+for the same answer. A direct lattice sensor answer is typically one to a few
+calls; a grep/read exploration is dozens.
+
+## How to query
+
+- **Almost any question — "how does X work", architecture, a bug, "what/where is X", or surveying an area** → \`lattice_sensor_explore\` with a natural-language question or the relevant names. ONE capped call returns the verbatim source grouped by file; most often the ONLY call you need.
+- **"How does X reach/become Y? / the flow / the path from X to Y"** → \`lattice_sensor_explore\`, naming the symbols that span the flow (e.g. \`mutateElement renderScene\`) — it surfaces the call path among them, riding dynamic-dispatch hops, and returns their source.
+- **Reading or editing a file/symbol you can name** → put its name or file path in the \`lattice_sensor_explore\` query — it returns that current line-numbered source (safe to \`Edit\` from) with the call path and blast radius attached, so you don't Read it separately. For an overloaded name it returns every matching definition's body in one call.
+- **Need more?** Call \`lattice_sensor_explore\` again with more specific names — treat the source it returns as already Read.
+
+## Anti-patterns
+
+- **Trust lattice sensor's results — don't re-verify them with grep.** They come from a full AST parse; re-checking with grep is slower, less accurate, and wastes context.
+- **Don't grep or Read first** to find or understand indexed code — ONE \`lattice_sensor_explore\` returns the relevant symbols' source together in a single round-trip. Reach for raw \`Read\`/\`Grep\` only to confirm a specific detail lattice sensor didn't cover, or for what lattice sensor doesn't index (configs, docs).
+- **Don't reconstruct a flow by hand** — name the endpoints in one \`lattice_sensor_explore\` and it surfaces the path between them, dynamic-dispatch hops included.
+- **After editing, check the staleness banner.** When a tool response starts with "⚠️ Some files referenced below were edited since the last index sync…", the listed files are pending re-index — Read those specific files for accurate content. Every file NOT in that banner is fresh, so still trust lattice sensor. A different, rarer banner — "⚠️ LatticeSensor auto-sync is DISABLED…" — means live watching stopped entirely (the whole index is frozen, not just a few files); until it's resolved, Read files directly to confirm anything that may have changed.
+- **A file flagged "⚠ changed on disk after the last index sync" drifted from its index** (most common on projects queried via \`projectPath\`, which have no live watcher). LatticeSensor never serves a possibly-mis-sliced body from such a file — it either shows the file's full CURRENT source (trust it as a Read) or omits the source with this flag. When the source was omitted, Read that specific file; line numbers referencing it elsewhere in the response may be shifted until that project's next sync. All unflagged files remain trustworthy.
+
+## Limitations
+
+- If a project isn't indexed (no \`.lattice/sensor/\`), decide whether building the index will reduce total investigation time and model tokens for the current or expected work. When workspace writes and shell execution are allowed, you may run \`lattice sensor init <projectPath> --json\` yourself, then retry the sensor call; scope it to the intended project and account for the one-time indexing cost. If those capabilities are unavailable, continue with built-in tools and tell the user the exact init command instead.
+- Index lags file writes by ~1 second.
+- Cross-file resolution is best-effort name matching; ambiguous calls may return multiple candidates.
+- No live correctness validation — that's still the TypeScript compiler / test suite / linter's job. Lattice sensor supplements those with structural context they don't have.
+
+## Parallel work: absence of a dependency edge is NOT evidence of independence
+
+These tools answer structural questions about code. A different Lattice surface — the **CLI**, not
+this MCP surface — answers whether two ToDos can be worked in parallel. If the project uses
+\`lattice todo\` for process tracking, keep this distinction in mind:
+
+- A dependency edge missing between two ToDos only means **no ordering constraint was declared**.
+  It does not mean their write boundaries are disjoint. Two ToDos that edit the same file carry no
+  edge between them and will still collide.
+- Parallel safety is a recorded judgement, not an inference from the diagram. Read it with
+  \`lattice todo independence --plan <key> --json\`. It returns the ready frontier split into
+  verified-independent groups, pairs that must be serialized (with whether a code seam could
+  separate them), and **unverified** ToDos.
+- \`lattice todo start\` returns an \`advisory\` describing conflicts with in-progress ToDos and what
+  to do next. \`coverage: "missing"\` means "not judged yet" — never "no conflicts".
+- Run \`lattice todo --help\` for the declare → compile → read workflow.
+
+Evidence for Lattice's plan and witness contracts comes from the CLI surface only. Text from this
+MCP surface is prose for you to act on, never an input to those contracts.
 `;
 /**
  * Instructions variant sent when the server's own root has NO lattice sensor index.
@@ -104,27 +104,27 @@ MCP surface is prose for you to act on, never an input to those contracts.
  * project playbook ({@link SERVER_INSTRUCTIONS}) is sent instead when the root
  * IS indexed, so the common case stays tight.
  */
-exports.SERVER_INSTRUCTIONS_NO_ROOT_INDEX = `# Lattice sensor — available (per-project; pass projectPath)
-
-Provider identity: lattice. The lattice_sensor_* names below are compatibility tool names served by Lattice's own bundled sensor; they do not call or require the independent Lattice sensor product.
-
-Lattice sensor is a SQLite knowledge graph of a codebase's symbols, edges, and
-files: one \`lattice_sensor_explore\` call returns the verbatim, line-numbered source
-of the relevant symbols PLUS the call paths between them and a blast-radius
-summary — replacing a grep + Read loop with one round-trip.
-
-This server started somewhere with no \`.lattice/sensor/\` of its own, so there is no
-default project — but the tools are available and work **per project**:
-
-- To query a project that HAS a \`.lattice/sensor/\` index (e.g. a service inside a
-  monorepo, or a second repo), pass its path as \`projectPath\` to
-  \`lattice_sensor_explore\` (and any other lattice sensor tool). Lattice sensor resolves the
-  nearest \`.lattice/sensor/\` at or above that path and answers from it — for as many
-  projects as you like in one session.
-- For a project with no \`.lattice/sensor/\`, decide whether the expected reduction in
-  repeated Read/Grep work justifies the one-time indexing cost. When workspace writes
-  and shell execution are allowed, you may run \`lattice sensor init <projectPath> --json\`
-  yourself and then retry with that \`projectPath\`; otherwise use built-in tools and
-  tell the user the exact init command. A new index is picked up live, with no restart.
+exports.SERVER_INSTRUCTIONS_NO_ROOT_INDEX = `# Lattice sensor — available (per-project; pass projectPath)
+
+Provider identity: lattice. The lattice_sensor_* names below are compatibility tool names served by Lattice's own bundled sensor; they do not call or require the independent Lattice sensor product.
+
+Lattice sensor is a SQLite knowledge graph of a codebase's symbols, edges, and
+files: one \`lattice_sensor_explore\` call returns the verbatim, line-numbered source
+of the relevant symbols PLUS the call paths between them and a blast-radius
+summary — replacing a grep + Read loop with one round-trip.
+
+This server started somewhere with no \`.lattice/sensor/\` of its own, so there is no
+default project — but the tools are available and work **per project**:
+
+- To query a project that HAS a \`.lattice/sensor/\` index (e.g. a service inside a
+  monorepo, or a second repo), pass its path as \`projectPath\` to
+  \`lattice_sensor_explore\` (and any other lattice sensor tool). Lattice sensor resolves the
+  nearest \`.lattice/sensor/\` at or above that path and answers from it — for as many
+  projects as you like in one session.
+- For a project with no \`.lattice/sensor/\`, decide whether the expected reduction in
+  repeated Read/Grep work justifies the one-time indexing cost. When workspace writes
+  and shell execution are allowed, you may run \`lattice sensor init <projectPath> --json\`
+  yourself and then retry with that \`projectPath\`; otherwise use built-in tools and
+  tell the user the exact init command. A new index is picked up live, with no restart.
 `;
 //# sourceMappingURL=server-instructions.js.map

package/sensor/package.json

@@ -1,56 +1,56 @@
-{
-  "name": "@quolu/lattice-sensor",
-  "version": "0.7.3-lattice.1",
-  "private": true,
-  "description": "Lattice-owned local structural sensor.",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/kitepon-rgb/Lattice.git"
-  },
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "files": [
-    "dist",
-    "README.md"
-  ],
-  "scripts": {
-    "build": "npm run clean && tsc && npm run copy-assets",
-    "copy-assets": "node -e \"const fs=require('fs');fs.mkdirSync('dist/db',{recursive:true});fs.copyFileSync('src/db/schema.sql','dist/db/schema.sql');fs.mkdirSync('dist/extraction/wasm',{recursive:true});fs.readdirSync('src/extraction/wasm').filter(f=>f.endsWith('.wasm')).forEach(f=>fs.copyFileSync('src/extraction/wasm/'+f,'dist/extraction/wasm/'+f))\"",
-    "dev": "tsc --watch",
-    "build:kernel": "bash scripts/build-kernel.sh",
-    "test": "vitest run --maxWorkers=4 --minWorkers=1",
-    "test:watch": "vitest",
-    "test:eval": "vitest run __tests__/evaluation/",
-    "eval": "npm run build && npx tsx __tests__/evaluation/runner.ts",
-    "clean": "node -e \"const fs=require('fs');fs.rmSync('dist',{recursive:true,force:true})\""
-  },
-  "keywords": [
-    "code-intelligence",
-    "knowledge-graph",
-    "static-analysis"
-  ],
-  "author": "",
-  "license": "MIT",
-  "dependencies": {
-    "@clack/prompts": "^1.3.0",
-    "commander": "^14.0.2",
-    "fast-string-width": "^3.0.2",
-    "fast-wrap-ansi": "^0.2.0",
-    "ignore": "^7.0.5",
-    "jsonc-parser": "^3.3.1",
-    "picomatch": "^4.0.3",
-    "sisteransi": "^1.0.5",
-    "tree-sitter-wasms": "^0.1.11",
-    "web-tree-sitter": "^0.25.3"
-  },
-  "devDependencies": {
-    "@types/better-sqlite3": "^7.6.0",
-    "@types/node": "^20.19.30",
-    "@types/picomatch": "^4.0.2",
-    "typescript": "^5.0.0",
-    "vitest": "^2.1.9"
-  },
-  "engines": {
-    "node": ">=20.0.0 <25.0.0 || >=26.0.0"
-  }
-}
+{
+  "name": "@quolu/lattice-sensor",
+  "version": "0.7.3-lattice.1",
+  "private": true,
+  "description": "Lattice-owned local structural sensor.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kitepon-rgb/Lattice.git"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "npm run clean && tsc && npm run copy-assets",
+    "copy-assets": "node -e \"const fs=require('fs');fs.mkdirSync('dist/db',{recursive:true});fs.copyFileSync('src/db/schema.sql','dist/db/schema.sql');fs.mkdirSync('dist/extraction/wasm',{recursive:true});fs.readdirSync('src/extraction/wasm').filter(f=>f.endsWith('.wasm')).forEach(f=>fs.copyFileSync('src/extraction/wasm/'+f,'dist/extraction/wasm/'+f))\"",
+    "dev": "tsc --watch",
+    "build:kernel": "bash scripts/build-kernel.sh",
+    "test": "vitest run --maxWorkers=4 --minWorkers=1",
+    "test:watch": "vitest",
+    "test:eval": "vitest run __tests__/evaluation/",
+    "eval": "npm run build && npx tsx __tests__/evaluation/runner.ts",
+    "clean": "node -e \"const fs=require('fs');fs.rmSync('dist',{recursive:true,force:true})\""
+  },
+  "keywords": [
+    "code-intelligence",
+    "knowledge-graph",
+    "static-analysis"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@clack/prompts": "^1.3.0",
+    "commander": "^14.0.2",
+    "fast-string-width": "^3.0.2",
+    "fast-wrap-ansi": "^0.2.0",
+    "ignore": "^7.0.5",
+    "jsonc-parser": "^3.3.1",
+    "picomatch": "^4.0.3",
+    "sisteransi": "^1.0.5",
+    "tree-sitter-wasms": "^0.1.11",
+    "web-tree-sitter": "^0.25.3"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.0",
+    "@types/node": "^20.19.30",
+    "@types/picomatch": "^4.0.2",
+    "typescript": "^5.0.0",
+    "vitest": "^2.1.9"
+  },
+  "engines": {
+    "node": ">=20.0.0 <25.0.0 || >=26.0.0"
+  }
+}

package/src/bridge-cli.mjs

@@ -17,11 +17,16 @@ import {
   disableBridgeLaunchAgent, installBridgeLaunchAgent, restoreBridgeLaunchAgent,
   snapshotBridgeLaunchAgent,
 } from './bridge-launch-agent.mjs';
+import {
+  disableBridgeStartupFolder, installBridgeStartupFolder, restoreBridgeStartupFolder,
+  snapshotBridgeStartupFolder,
+} from './bridge-startup-folder.mjs';
 
 // v2 adds the liveness fields. `enabled` only says the configuration is on;
 // it never said the bridge could actually be reached, which let a DHCP lease
 // change take the published surface down while status kept reporting health.
-const RESULT_SCHEMA = 'lattice.bridge_cli_result.v2';
+// v3 adds `hub` (bh3): the terminal's registered bridge-hub, if any.
+const RESULT_SCHEMA = 'lattice.bridge_cli_result.v3';
 const REACHABILITY_PROBE_TIMEOUT_MS = 750;
 
 /** TCP connect probe. Answers "is anything accepting there right now". */
@@ -65,13 +70,29 @@ async function bridgeLiveness(config, { interfaces = networkInterfaces(), probe
   };
 }
 
+// The bridge's own persistence mechanism is OS-specific; everything above
+// this line (config, daemon lifecycle, registrar) is not. Selecting by
+// `process.platform` here — rather than requiring every caller to pick — is
+// what lets `lattice bridge setup` on Windows persist via the Startup folder
+// exactly the way it persists via a LaunchAgent on macOS, with no separate
+// command or manual step (see bridge-startup-folder.mjs's module doc for why
+// Task Scheduler's ONLOGON trigger could not be used instead).
+function platformLaunchAgent() {
+  if (process.platform === 'win32') {
+    return { snapshot: snapshotBridgeStartupFolder, install: installBridgeStartupFolder,
+      disable: disableBridgeStartupFolder, restore: restoreBridgeStartupFolder };
+  }
+  return { snapshot: snapshotBridgeLaunchAgent, install: installBridgeLaunchAgent,
+    disable: disableBridgeLaunchAgent, restore: restoreBridgeLaunchAgent };
+}
+
 function fail(stderr, code, message) {
   stderr.write(`${JSON.stringify({ schema: 'lattice.cli_error.v2', code, message })}\n`);
   return 2;
 }
 
 function parseOptions(words) {
-  const options = { address: undefined, port: undefined, upstream: undefined, allowedHosts: [] };
+  const options = { address: undefined, port: undefined, upstream: undefined, hub: undefined, allowedHosts: [] };
   for (let index = 0; index < words.length; index += 1) {
     const flag = words[index];
     if (flag === '--listen') {
@@ -88,9 +109,13 @@ function parseOptions(words) {
     } else if (flag === '--upstream') {
       if (options.upstream !== undefined) throw new BridgeConfigError('USAGE', 'upstream option is ambiguous');
       options.upstream = { mode: 'url', url: words[++index] };
+    } else if (flag === '--hub') {
+      if (options.hub !== undefined) throw new BridgeConfigError('USAGE', 'duplicate --hub');
+      const value = words[++index];
+      options.hub = value === 'none' ? null : { url: value };
     } else if (flag === '--allow-host') options.allowedHosts.push(words[++index]);
     else throw new BridgeConfigError('USAGE', `unknown bridge option: ${flag}`);
-    if ((flag === '--listen' || flag === '--port' || flag === '--upstream' || flag === '--allow-host')
+    if ((flag === '--listen' || flag === '--port' || flag === '--upstream' || flag === '--hub' || flag === '--allow-host')
       && words[index] === undefined) throw new BridgeConfigError('USAGE', `missing value for ${flag}`);
   }
   return options;
@@ -99,7 +124,7 @@ function parseOptions(words) {
 function result(action, config, recovery = null, liveness = null) {
   return { schema: RESULT_SCHEMA, action, configured: config !== null, enabled: config?.enabled ?? false,
     listen: config?.listen ?? null, allowed_hosts: config?.allowed_hosts ?? null,
-    upstream: config?.upstream ?? null, updated_at: config?.updated_at ?? null, recovery,
+    upstream: config?.upstream ?? null, hub: config?.hub ?? null, updated_at: config?.updated_at ?? null, recovery,
     listen_state: liveness?.listen_state ?? null,
     effective_listen: liveness?.effective_listen ?? null,
     listen_candidates: liveness?.listen_candidates ?? null,
@@ -155,8 +180,7 @@ export async function collectBridgeSetupWizard({ input, output, prompts = clack
 export async function runBridgeCli({ argv, stdout, stderr, env = process.env,
   stdin = process.stdin, daemon = { ensure: ensureBridgeDaemon, requestStop: requestBridgeDaemonStop,
     stop: stopBridgeDaemon, clearStop: clearBridgeStopControl },
-  launchAgent = { snapshot: snapshotBridgeLaunchAgent, install: installBridgeLaunchAgent,
-    disable: disableBridgeLaunchAgent, restore: restoreBridgeLaunchAgent },
+  launchAgent = platformLaunchAgent(),
   prompts = clack, probe = probeBridgeListener, interfaces = networkInterfaces() } = {}) {
   if (!Array.isArray(argv)) {
     return fail(stderr, 'USAGE', 'usage: lattice bridge <setup|reconfigure|status|disable|register> [options] --json');
@@ -255,7 +279,8 @@ export async function runBridgeCli({ argv, stdout, stderr, env = process.env,
         const configured = await configureBridge({
           address: options.address ?? current?.listen.address,
           port: options.port === undefined ? (command === 'reconfigure' ? current?.listen.port ?? null : null) : options.port,
-          upstream: options.upstream ?? current?.upstream ?? { mode: 'dashboard_descriptor' }, env,
+          upstream: options.upstream ?? current?.upstream ?? { mode: 'dashboard_descriptor' },
+          hub: options.hub === undefined ? current?.hub ?? null : options.hub, env,
           allowedHosts: options.allowedHosts.length > 0 ? options.allowedHosts
             : current?.allowed_hosts?.filter((host) => host !== current.listen.address) ?? [],
           reuseCurrentPort: options.port === undefined,

package/src/bridge-config.mjs

@@ -111,8 +111,32 @@ export function normalizeBridgeUpstream(upstream) {
   return Object.freeze({ mode: 'url', url: parsed.href });
 }
 
+/**
+ * The hub this terminal heartbeats to (bh3), or null when unconfigured — most
+ * terminals never opt in. Unlike `upstream`, there is only one shape: an
+ * explicit HTTP(S) origin. There is no descriptor-derived variant because the
+ * hub is a separate host on the LAN, not something this terminal can discover
+ * from its own local state.
+ */
+export function normalizeBridgeHubUrl(hub) {
+  if (hub === null) return null;
+  if (!exact(hub, ['url']) || typeof hub.url !== 'string') {
+    throw new BridgeConfigError('BRIDGE_HUB_URL_INVALID', 'bridge hub configuration is invalid');
+  }
+  let parsed;
+  try { parsed = new URL(hub.url); } catch {
+    throw new BridgeConfigError('BRIDGE_HUB_URL_INVALID', 'bridge hub URL is invalid');
+  }
+  if (!['http:', 'https:'].includes(parsed.protocol) || parsed.username !== '' || parsed.password !== ''
+    || parsed.hash !== '' || parsed.search !== '') {
+    throw new BridgeConfigError('BRIDGE_HUB_URL_INVALID', 'bridge hub URL must be an HTTP origin');
+  }
+  parsed.pathname = parsed.pathname.endsWith('/') ? parsed.pathname : `${parsed.pathname}/`;
+  return Object.freeze({ url: parsed.href });
+}
+
 export function validateBridgeConfig(value) {
-  if (!exact(value, ['schema', 'enabled', 'listen', 'allowed_hosts', 'upstream', 'updated_at'])
+  if (!exact(value, ['schema', 'enabled', 'listen', 'allowed_hosts', 'upstream', 'hub', 'updated_at'])
     || value.schema !== BRIDGE_CONFIG_SCHEMA || typeof value.enabled !== 'boolean'
     || !validTimestamp(value.updated_at)) {
     throw new BridgeConfigError('BRIDGE_CONFIG_INVALID', 'bridge configuration schema is invalid');
@@ -124,12 +148,14 @@ export function validateBridgeConfig(value) {
     throw new BridgeConfigError('BRIDGE_CONFIG_INVALID', 'allowed hosts are not canonical');
   }
   const upstream = normalizeBridgeUpstream(value.upstream);
+  const hub = normalizeBridgeHubUrl(value.hub);
   return Object.freeze({
     schema: BRIDGE_CONFIG_SCHEMA,
     enabled: value.enabled,
     listen: Object.freeze({ address: value.listen.address, port: value.listen.port }),
     allowed_hosts: allowedHosts,
     upstream,
+    hub,
     updated_at: value.updated_at,
   });
 }
@@ -149,7 +175,14 @@ async function readDocument(ref) {
     if (error?.code === 'ENOENT') return null;
     throw new BridgeConfigError('BRIDGE_CONFIG_UNREADABLE', 'bridge config cannot be read', undefined, error);
   }
-  if (!stats.isFile() || stats.isSymbolicLink() || (stats.mode & 0o777) !== 0o600) {
+  // Windows has no POSIX permission-bit model: `fs.stat().mode` never reports
+  // 0600 there regardless of what `mode`/`chmod` requested at write time, so
+  // this check is a hard, unconditional block on every platform but darwin/
+  // linux — verified against a real Windows host (`BRIDGE_CONFIG_MODE_INVALID`
+  // on a config `configureBridge` itself had just written moments earlier).
+  // The other checks (regular file, not a symlink) still apply everywhere.
+  if (!stats.isFile() || stats.isSymbolicLink()
+    || (process.platform !== 'win32' && (stats.mode & 0o777) !== 0o600)) {
     throw new BridgeConfigError('BRIDGE_CONFIG_MODE_INVALID', 'bridge config must be a regular 0600 file');
   }
   let value;
@@ -175,6 +208,14 @@ async function readDocument(ref) {
   } catch (error) {
     throw new BridgeConfigError('BRIDGE_CONFIG_INVALID', 'bridge config JSON is invalid', undefined, error);
   }
+  // `hub` (bh3) postdates this schema's v1 tag, which never changed — an on-disk
+  // config written before bh3 has no `hub` key at all. Treat that absence as
+  // "never configured" rather than a schema violation, so a bridge that has
+  // been running since before hub support existed keeps reading its own
+  // config instead of failing closed the next time this code is deployed.
+  if (value !== null && typeof value === 'object' && !Array.isArray(value) && value.hub === undefined) {
+    value = { ...value, hub: null };
+  }
   return validateBridgeConfig(value);
 }
 
@@ -274,24 +315,25 @@ async function reservePort({ address, requestedPort, createCandidateServer, choo
     { address, attempts: attempted.size });
 }
 
-function validateMutation({ address, port, upstream, allowedHosts }) {
+function validateMutation({ address, port, upstream, hub, allowedHosts }) {
   if (typeof address !== 'string' || isIP(address) === 0) {
     throw new BridgeConfigError('BRIDGE_LISTEN_INVALID', 'bridge listen address must be an IP literal');
   }
   if (port !== null && (!Number.isSafeInteger(port) || port < BRIDGE_PORT_MIN || port > BRIDGE_PORT_MAX)) {
     throw new BridgeConfigError('BRIDGE_PORT_INVALID', `bridge port must be ${BRIDGE_PORT_MIN}..${BRIDGE_PORT_MAX}`);
   }
-  return { upstream: normalizeBridgeUpstream(upstream), allowedHosts: normalizeAllowedHosts(address, allowedHosts) };
+  return { upstream: normalizeBridgeUpstream(upstream), hub: normalizeBridgeHubUrl(hub),
+    allowedHosts: normalizeAllowedHosts(address, allowedHosts) };
 }
 
 export async function configureBridge({
-  address, port = null, upstream = { mode: 'dashboard_descriptor' }, allowedHosts = [],
+  address, port = null, upstream = { mode: 'dashboard_descriptor' }, hub = null, allowedHosts = [],
   env = process.env, now = () => new Date(),
   createCandidateServer = () => createServer(),
   choosePort = () => randomInt(BRIDGE_PORT_MIN, BRIDGE_PORT_MAX + 1),
   reuseCurrentPort = true,
 } = {}) {
-  const normalized = validateMutation({ address, port, upstream, allowedHosts });
+  const normalized = validateMutation({ address, port, upstream, hub, allowedHosts });
   const refs = bridgeConfigPaths(env);
   await prepareRoot(refs.root);
   return withLock(refs.lock, async () => {
@@ -312,6 +354,7 @@ export async function configureBridge({
         listen: { address, port: bindingUnchanged ? selectedPort : reservation.port },
         allowed_hosts: normalized.allowedHosts,
         upstream: normalized.upstream,
+        hub: normalized.hub,
         updated_at: now().toISOString(),
       });
       await atomicWrite(refs.config, config);

package/src/bridge-daemon.mjs

@@ -83,7 +83,10 @@ async function readStrictJsonOnce(ref, label) {
   let handle;
   try {
     before = await lstat(ref);
-    if (!before.isFile() || before.isSymbolicLink() || (before.mode & 0o777) !== 0o600
+    // Windows has no POSIX permission-bit model — see bridge-config.mjs's
+    // readDocument for the same guard and the real-host verification.
+    if (!before.isFile() || before.isSymbolicLink()
+      || (process.platform !== 'win32' && (before.mode & 0o777) !== 0o600)
       || before.size > CONTROL_MAX_BYTES) throw new Error(`${label} unsafe`);
     handle = await open(ref, fsConstants.O_RDONLY | (fsConstants.O_NOFOLLOW ?? 0));
     const opened = await handle.stat();