@quolu/lattice 0.69.1 → 0.69.3

package/bin/lattice-bridge.mjs

@@ -33,6 +33,7 @@ const controller = bridgeRuntimeController({ env, instanceToken,
 let timer;
 let closing = false;
 let descriptorFingerprint = null;
+let heartbeatBinding = null;
 let checking = false;
 let failClosedError = null;
 let hubHeartbeatError = null;
@@ -53,9 +54,9 @@ try {
   }
   const config = await readBridgeConfig({ env });
   if (config === null || !config.enabled) throw Object.assign(new Error('bridge disabled'), { code: 'BRIDGE_DISABLED' });
-  await controller.reconcile();
-  await writeBridgeDaemonDescriptor({ config, env });
-  descriptorFingerprint = config.updated_at;
+  const binding = await controller.reconcile();
+  await writeBridgeDaemonDescriptor({ config, binding, env });
+  descriptorFingerprint = JSON.stringify([config.updated_at, binding.address, binding.port]);
 } catch (error) {
   process.stderr.write(`${JSON.stringify({ schema: 'lattice.bridge_daemon_error.v1',
     code: error?.code ?? 'BRIDGE_DAEMON_FAILED', message: error?.message ?? 'bridge daemon failed' })}\n`);
@@ -126,11 +127,12 @@ timer = setInterval(async () => {
       await removeBridgeDaemonActiveMarker({ env });
       process.exit(0);
     }
-    await controller.reconcile();
+    const binding = await controller.reconcile();
     failClosedError = null;
-    if (descriptorFingerprint !== config.updated_at) {
-      await writeBridgeDaemonDescriptor({ config, env });
-      descriptorFingerprint = config.updated_at;
+    const nextDescriptorFingerprint = JSON.stringify([config.updated_at, binding.address, binding.port]);
+    if (descriptorFingerprint !== nextDescriptorFingerprint) {
+      await writeBridgeDaemonDescriptor({ config, binding, env });
+      descriptorFingerprint = nextDescriptorFingerprint;
     }
     // Hub heartbeat failures are reported but never fail-close local traffic:
     // an unreachable hub is a routing problem for the hub's aggregate view,
@@ -139,7 +141,10 @@ timer = setInterval(async () => {
     // throws (sendBridgeHubHeartbeat's contract) — only a local error (e.g.
     // the terminal identity file) reaches this catch.
     try {
-      const heartbeat = await hubHeartbeat.tick({ config });
+      const bindingFingerprint = JSON.stringify([binding.address, binding.port]);
+      const forceHeartbeat = heartbeatBinding !== bindingFingerprint;
+      heartbeatBinding = bindingFingerprint;
+      const heartbeat = await hubHeartbeat.tick({ config, force: forceHeartbeat });
       // 直前に書いた指紋は、健全な状態へ戻った時にだけ捨てる。判定より前に捨てると
       // 比較相手が毎周期nullになり、同じ結果をpoll周期ごとに書き続ける。stderrの
       // 消費者が居ない常駐（WindowsのStartup launcher、LaunchAgent）では、この

package/docs/bridge-setup.md

@@ -64,6 +64,18 @@ fileを除去し、JSON結果の`recovery`へ処置を明示する。その後
 自動化・隔離testではabsoluteな`LATTICE_CONFIG_DIR`で設定rootを変更できる。無効な設定、低いport、
 使用中の明示port、危険なrequest target、到達不能upstreamはsilent fallbackせずtyped errorを返す。
 
+## DHCPによるIP変更への自動追従
+
+設定したIPが端末から消え、同一subnetに次のIPがある場合、bridgeは起動時にも稼働中にも
+そのIPへ自動で待受を移す。設定ファイルのIPを書き換えたり、利用者がdisableとreconfigureを
+順番に実行したりする必要はない。設定のIPは公開するnetworkの意図を保持し、稼働記録と
+health応答は実際の待受IPを示す。生存確認も実際の待受を使い、正常なbridgeを再起動しない。
+
+Hubへ接続している場合は、待受の変更に合わせて登録を更新する。Hubは登録接続の送信元IPを
+使うため、端末が新しいIPを申告する独自経路は設けない。配信の確認結果は従来どおり
+`lattice.dashboard_delivery.v1`で返す。別subnetやloopbackへの自動切替は行わず、同一subnetに
+移動先がない場合は`BRIDGE_LISTEN_ADDRESS_ABSENT`を返す。
+
 ## 常駐が黙って死んでいないか確かめる
 
 `reachable`は「設定したaddressで誰かが応答しているか」しか答えない。常駐設定（macOSのLaunchAgent、

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quolu/lattice",
-  "version": "0.69.1",
+  "version": "0.69.3",
   "description": "Schedulability compiler for multi-agent development: observe real code boundaries, refactor the conflicting seam, recompile the plan for parallel execution",
   "author": {
     "name": "Quo / クオ at kitepon.dev",

package/src/bridge-cli.mjs

@@ -405,6 +405,19 @@ export async function runBridgeCli({ argv, stdout, stderr, env = process.env,
         await clearStop({ env });
         const current = await readBridgeConfig({ env });
         const agentSnapshot = await launchAgent.snapshot({ env });
+        let activeBinding = null;
+        // DHCP追従済みdaemonの実socketを、手動で設定IPへ昇格させる場合がある。
+        // tokenでattest済みのdescriptorだけが、この同一portの予約を省略できる。
+        // それ以外の占有は従来どおりBRIDGE_PORT_UNAVAILABLEで止める。
+        if (command === 'reconfigure' && options.address !== undefined && options.port === undefined
+          && current?.enabled === true && current.listen.port !== undefined) {
+          const descriptor = await readBridgeDaemonDescriptor({ env });
+          const runtime = descriptor === null ? null : await runtimeIdentity({ env });
+          if (runtime?.state === 'running' && descriptor.address === options.address
+            && descriptor.port === current.listen.port) {
+            activeBinding = { address: descriptor.address, port: descriptor.port };
+          }
+        }
         const configured = await configureBridge({
           address: options.address ?? current?.listen.address,
           port: options.port === undefined ? (command === 'reconfigure' ? current?.listen.port ?? null : null) : options.port,
@@ -413,6 +426,7 @@ export async function runBridgeCli({ argv, stdout, stderr, env = process.env,
           allowedHosts: options.allowedHosts.length > 0 ? options.allowedHosts
             : current?.allowed_hosts?.filter((host) => host !== current.listen.address) ?? [],
           reuseCurrentPort: options.port === undefined,
+          activeBinding,
         });
         try {
           if (configured.hub !== null) await ensureDashboard({ env });

package/src/bridge-config.mjs

@@ -332,6 +332,7 @@ export async function configureBridge({
   createCandidateServer = () => createServer(),
   choosePort = () => randomInt(BRIDGE_PORT_MIN, BRIDGE_PORT_MAX + 1),
   reuseCurrentPort = true,
+  activeBinding = null,
 } = {}) {
   const normalized = validateMutation({ address, port, upstream, hub, allowedHosts });
   const refs = bridgeConfigPaths(env);
@@ -341,7 +342,11 @@ export async function configureBridge({
     const selectedPort = port ?? (reuseCurrentPort && current?.enabled && current.listen.address === address
       ? current.listen.port : null);
     const bindingUnchanged = current?.enabled === true && current.listen.address === address
-      && current.listen.port === selectedPort;
+      && current.listen.port === selectedPort
+      // activeBindingはbridge-cliがinstance tokenで本人確認した待受だけを渡す。
+      // DHCP追従済みの自分のsocketを再予約すると、無関係なport競合と誤認する。
+      || current?.enabled === true && activeBinding?.address === address
+        && activeBinding.port === selectedPort;
     let reservation = null;
     try {
       if (!bindingUnchanged) {

package/src/bridge-daemon.mjs

@@ -3,12 +3,14 @@ import { randomBytes } from 'node:crypto';
 import { constants as fsConstants } from 'node:fs';
 import { chmod, lstat, open, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { isIP } from 'node:net';
+import { networkInterfaces } from 'node:os';
 import path from 'node:path';
 import { parseTree } from 'jsonc-parser';
 
 import {
   BRIDGE_PORT_MAX, BRIDGE_PORT_MIN, BridgeConfigError, bridgeConfigPaths, readBridgeConfig,
 } from './bridge-config.mjs';
+import { resolveBridgeListenAddress } from './bridge-address.mjs';
 import packageJson from '../package.json' with { type: 'json' };
 
 const DESCRIPTOR_SCHEMA = 'lattice.bridge_daemon.v1';
@@ -202,7 +204,11 @@ export async function clearBridgeStopControl({ env = process.env } = {}) {
 export async function requestBridgeDaemonStop({ env = process.env, listen = null } = {}) {
   let descriptor = null;
   try { descriptor = await readBridgeDaemonDescriptor({ env }); } catch {}
-  if (descriptor !== null && await attest(descriptor) === null
+  let config = null;
+  try { config = await readBridgeConfig({ env }); } catch (error) {
+    if (!['BRIDGE_CONFIG_INVALID', 'BRIDGE_CONFIG_MODE_INVALID'].includes(error?.code)) throw error;
+  }
+  if (descriptor !== null && await attestKnownBinding(descriptor, config) === null
     && !await bridgeEndpointAvailable({ address: descriptor.address, port: descriptor.port })) {
     return { state: 'not_running', nonce: null };
   }
@@ -243,15 +249,22 @@ export async function requestBridgeDaemonStop({ env = process.env, listen = null
   throw new BridgeConfigError('BRIDGE_DAEMON_STOP_FAILED', 'bridge daemon stop receipt timed out');
 }
 
-export async function writeBridgeDaemonDescriptor({ config, env = process.env }) {
-  const instanceToken = env.LATTICE_BRIDGE_INSTANCE_TOKEN;
+export async function writeBridgeDaemonDescriptor({ config, binding = config?.listen, identity = null,
+  env = process.env } = {}) {
+  const instanceToken = identity?.instance_token ?? env.LATTICE_BRIDGE_INSTANCE_TOKEN;
   if (typeof instanceToken !== 'string' || !/^[0-9a-f]{64}$/u.test(instanceToken)) {
     throw new BridgeConfigError('BRIDGE_INSTANCE_TOKEN_INVALID', 'bridge instance token is invalid');
   }
-  const descriptor = { schema: DESCRIPTOR_SCHEMA, pid: process.pid,
-    address: config.listen.address, port: config.listen.port,
+  if (isIP(binding?.address) === 0 || !Number.isSafeInteger(binding?.port)
+    || binding.port < BRIDGE_PORT_MIN || binding.port > BRIDGE_PORT_MAX
+    || !Number.isSafeInteger(identity?.pid ?? process.pid) || (identity?.pid ?? process.pid) <= 0
+    || identity !== null && !isIsoTimestamp(identity.started_at)) {
+    throw new BridgeConfigError('BRIDGE_DAEMON_DESCRIPTOR_INVALID', 'bridge daemon descriptor identity is invalid');
+  }
+  const descriptor = { schema: DESCRIPTOR_SCHEMA, pid: identity?.pid ?? process.pid,
+    address: binding.address, port: binding.port,
     config_updated_at: config.updated_at, instance_token: instanceToken,
-    started_at: new Date().toISOString() };
+    started_at: identity?.started_at ?? new Date().toISOString() };
   await atomicDescriptor(bridgeDaemonDescriptorPath(env), descriptor);
   await atomicDescriptor(bridgeDaemonActiveMarkerPath(env), {
     schema: ACTIVE_MARKER_SCHEMA, address: descriptor.address, port: descriptor.port,
@@ -301,10 +314,10 @@ export async function waitForBridgeSocketClose({ listen, timeoutMs = STOP_TIMEOU
   return !await bridgeEndpointAvailable(listen);
 }
 
-async function attest(descriptor) {
+async function attest(descriptor, { address = descriptor?.address } = {}) {
   if (descriptor === null) return null;
   try {
-    const response = await fetch(`http://${healthHost(descriptor.address)}:${descriptor.port}/__lattice/bridge-health`, {
+    const response = await fetch(`http://${healthHost(address)}:${descriptor.port}/__lattice/bridge-health`, {
       headers: { 'x-lattice-bridge-instance-token': descriptor.instance_token },
       signal: AbortSignal.timeout(400),
     });
@@ -314,6 +327,29 @@ async function attest(descriptor) {
   } catch { return null; }
 }
 
+function currentBinding(config, interfaces = networkInterfaces()) {
+  if (config === null || config.enabled !== true) return null;
+  const address = resolveBridgeListenAddress({ configured: config.listen.address, interfaces }).effective;
+  return address === null ? null : { address, port: config.listen.port };
+}
+
+async function attestCurrentBinding(descriptor, config, { interfaces = networkInterfaces() } = {}) {
+  const binding = currentBinding(config, interfaces);
+  if (descriptor === null || binding === null || descriptor.port !== binding.port) return null;
+  const body = await attest(descriptor, { address: binding.address });
+  return body === null ? null : { body, binding };
+}
+
+// 設定変更から次のreconcileまでの間は、旧socketだけが本人確認に応答することがある。
+// 現在の待受に続いてdescriptorの既知の宛先を確認し、instance tokenによる本人確認を保つ。
+async function attestKnownBinding(descriptor, config, options = {}) {
+  const current = await attestCurrentBinding(descriptor, config, options);
+  if (current !== null) return current;
+  const body = await attest(descriptor);
+  return body === null ? null : { body,
+    binding: { address: descriptor.address, port: descriptor.port } };
+}
+
 const UNIDENTIFIED_RUNTIME = Object.freeze({ pid: null, version: null, node_path: null,
   node_version: null, bridge_path: null, last_heartbeat: null });
 
@@ -326,14 +362,22 @@ const UNIDENTIFIED_RUNTIME = Object.freeze({ pid: null, version: null, node_path
  * thrown: this feeds `lattice bridge status`, the command an operator reaches
  * for precisely when something is already broken.
  */
-export async function readBridgeRuntimeIdentity({ env = process.env } = {}) {
+export async function readBridgeRuntimeIdentity({ env = process.env, interfaces = networkInterfaces() } = {}) {
   let descriptor;
   try { descriptor = await readBridgeDaemonDescriptor({ env }); } catch (error) {
     if (error?.code !== 'BRIDGE_DAEMON_DESCRIPTOR_INVALID') throw error;
     return { ...UNIDENTIFIED_RUNTIME, state: 'descriptor_invalid' };
   }
   if (descriptor === null) return { ...UNIDENTIFIED_RUNTIME, state: 'not_running' };
-  const body = await attest(descriptor);
+  // 旧版daemonはDHCP移動後も設定IPをdescriptorへ残す。
+  // serverと共通の同一subnet条件で現在の待受を解決してから本人確認する。
+  let config = null;
+  try {
+    config = await readBridgeConfig({ env });
+  } catch (error) {
+    if (!['BRIDGE_CONFIG_INVALID', 'BRIDGE_CONFIG_MODE_INVALID'].includes(error?.code)) throw error;
+  }
+  const body = (await attestKnownBinding(descriptor, config, { interfaces }))?.body ?? null;
   if (body === null) return { ...UNIDENTIFIED_RUNTIME, state: 'unattested', pid: descriptor.pid };
   const text = (value) => (typeof value === 'string' ? value : null);
   return { state: 'running', pid: descriptor.pid, version: text(body.version),
@@ -344,31 +388,42 @@ export async function readBridgeRuntimeIdentity({ env = process.env } = {}) {
     last_heartbeat: body.last_heartbeat ?? null };
 }
 
-async function healthy(descriptor, config) {
-  if (descriptor === null || descriptor.address !== config.listen.address
-    || descriptor.port !== config.listen.port) return false;
-  const body = await attest(descriptor);
-  return body !== null && body.updated_at === config.updated_at;
+async function healthy(descriptor, config, options = {}) {
+  const attested = await attestCurrentBinding(descriptor, config, options);
+  return attested !== null && attested.body.updated_at === config.updated_at ? attested : null;
 }
 
-export async function ensureBridgeDaemon({ env = process.env } = {}) {
+async function preserveHealthyDescriptor(descriptor, config, options) {
+  const attested = await healthy(descriptor, config, options);
+  if (attested === null) return null;
+  if (descriptor.address === attested.binding.address && descriptor.port === attested.binding.port) return descriptor;
+  return writeBridgeDaemonDescriptor({ config, binding: attested.binding, identity: descriptor, env: options.env });
+}
+
+export async function ensureBridgeDaemon({ env = process.env, interfaces = networkInterfaces(),
+  spawnDaemon = spawn } = {}) {
   const config = await readBridgeConfig({ env });
   if (config === null || !config.enabled) throw new BridgeConfigError('BRIDGE_DISABLED', 'bridge is disabled');
   const previous = await readBridgeDaemonDescriptor({ env });
-  if (await healthy(previous, config)) return previous;
-  if (previous !== null && previous.address === config.listen.address
-    && previous.port === config.listen.port && await attest(previous) !== null) {
+  const options = { env, interfaces };
+  const alreadyHealthy = await preserveHealthyDescriptor(previous, config, options);
+  if (alreadyHealthy !== null) return alreadyHealthy;
+  if (previous !== null && previous.port === config.listen.port
+    && await attestKnownBinding(previous, config, options) !== null) {
     const deadline = Date.now() + START_TIMEOUT_MS;
     while (Date.now() < deadline) {
       await new Promise((resolve) => setTimeout(resolve, 50));
       const reconciled = await readBridgeDaemonDescriptor({ env });
-      if (reconciled?.pid === previous.pid && await healthy(reconciled, config)) return reconciled;
+      if (reconciled?.pid === previous.pid) {
+        const healthyDescriptor = await preserveHealthyDescriptor(reconciled, config, options);
+        if (healthyDescriptor !== null) return healthyDescriptor;
+      }
     }
     throw new BridgeConfigError('BRIDGE_DAEMON_UNAVAILABLE',
       'existing bridge daemon did not reconcile the updated config');
   }
   const instanceToken = randomBytes(32).toString('hex');
-  const child = spawn(process.execPath, [path.resolve(import.meta.dirname, '../bin/lattice-bridge.mjs')], {
+  const child = spawnDaemon(process.execPath, [path.resolve(import.meta.dirname, '../bin/lattice-bridge.mjs')], {
     detached: true, stdio: 'ignore', env: { ...env, LATTICE_BRIDGE_INSTANCE_TOKEN: instanceToken },
   });
   child.unref();
@@ -376,22 +431,27 @@ export async function ensureBridgeDaemon({ env = process.env } = {}) {
   while (Date.now() < deadline) {
     await new Promise((resolve) => setTimeout(resolve, 50));
     const descriptor = await readBridgeDaemonDescriptor({ env });
-    if (await healthy(descriptor, config)) {
+    const healthyDescriptor = await preserveHealthyDescriptor(descriptor, config, options);
+    if (healthyDescriptor !== null) {
       if (previous !== null && previous.pid !== descriptor.pid) {
-        if (await attest(previous) !== null) {
+        if (await attestCurrentBinding(previous, config, options) !== null) {
           try { process.kill(previous.pid, 'SIGTERM'); } catch {}
         }
       }
-      return descriptor;
+      return healthyDescriptor;
     }
   }
   throw new BridgeConfigError('BRIDGE_DAEMON_UNAVAILABLE', 'bridge daemon did not bind and become healthy');
 }
 
-export async function stopBridgeDaemon({ env = process.env } = {}) {
+export async function stopBridgeDaemon({ env = process.env, interfaces = networkInterfaces() } = {}) {
   const descriptor = await readBridgeDaemonDescriptor({ env });
   if (descriptor === null) return null;
-  if (await attest(descriptor) === null) {
+  let config = null;
+  try { config = await readBridgeConfig({ env }); } catch (error) {
+    if (!['BRIDGE_CONFIG_INVALID', 'BRIDGE_CONFIG_MODE_INVALID'].includes(error?.code)) throw error;
+  }
+  if (await attestKnownBinding(descriptor, config, { interfaces }) === null) {
     let alive = true;
     try { process.kill(descriptor.pid, 0); } catch { alive = false; }
     if (!alive) {

package/src/bridge-hub-heartbeat.mjs

@@ -197,12 +197,12 @@ export function createBridgeHubHeartbeatController({
     return result;
   };
   return Object.freeze({
-    async tick({ config }) {
+    async tick({ config, force = false }) {
       if (config?.hub == null) {
         lastSentAt = null; lastResult = null; lastResultAt = null; return null;
       }
       const nowMs = now();
-      if (lastSentAt !== null && nowMs - lastSentAt < intervalMs) return lastResult;
+      if (!force && lastSentAt !== null && nowMs - lastSentAt < intervalMs) return lastResult;
       lastSentAt = nowMs;
       // 名乗る集合は、この端末が実際に配信している集合そのものを使う。登録簿から別途
       // 数え直すと、配信している側と名乗る側が別々の基準を持ち、必ずずれる（ADR 0165）。

package/src/bridge-launch-agent.mjs

@@ -217,12 +217,11 @@ function healthHost(address) {
   return address.includes(':') ? `[${address}]` : address;
 }
 
-async function defaultWaitReady({ config, instanceToken, env, timeoutMs = START_TIMEOUT_MS }) {
+export async function waitForBridgeLaunchAgentReady({ config, instanceToken, env, timeoutMs = START_TIMEOUT_MS }) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
     const descriptor = await readBridgeDaemonDescriptor({ env });
-    if (descriptor?.address === config.listen.address && descriptor?.port === config.listen.port
-      && descriptor?.config_updated_at === config.updated_at) {
+    if (descriptor?.port === config.listen.port && descriptor?.config_updated_at === config.updated_at) {
       try {
         const response = await fetch(
           `http://${healthHost(descriptor.address)}:${descriptor.port}/__lattice/bridge-health`, {
@@ -231,6 +230,7 @@ async function defaultWaitReady({ config, instanceToken, env, timeoutMs = START_
           });
         const body = response.status === 200 ? await response.json() : null;
         if (body?.schema === 'lattice.bridge_health.v1' && body.pid === descriptor.pid
+          && body.address === descriptor.address && body.port === descriptor.port
           && body.updated_at === config.updated_at) return descriptor;
       } catch {}
     }
@@ -321,7 +321,7 @@ async function bootoutIfLoaded({ runner, uid }) {
 export async function installBridgeLaunchAgent({ config, env = process.env,
   runner = defaultLaunchctlRunner, uid = userId(), nodePath = process.execPath,
   bridgePath = DEFAULT_BRIDGE_PATH,
-  waitReady = defaultWaitReady, waitStopped = defaultWaitStopped,
+  waitReady = waitForBridgeLaunchAgentReady, waitStopped = defaultWaitStopped,
   stableNode = stableNodePath, previousListen = null } = {}) {
   if (config?.enabled !== true) throw fail('BRIDGE_DISABLED', 'bridge is disabled');
   const refs = bridgeLaunchAgentPaths(env);
@@ -360,7 +360,7 @@ export async function disableBridgeLaunchAgent({ snapshot, listen, env = process
 
 export async function restoreBridgeLaunchAgent({ snapshot, listen = null, env = process.env,
   runner = defaultLaunchctlRunner, uid = userId(), waitStopped = defaultWaitStopped,
-  config = undefined, waitReady = defaultWaitReady } = {}) {
+  config = undefined, waitReady = waitForBridgeLaunchAgentReady } = {}) {
   if (!snapshot || typeof snapshot.installed !== 'boolean' || typeof snapshot.loaded !== 'boolean'
     || (snapshot.installed && typeof snapshot.content !== 'string')) {
     throw new TypeError('bridge LaunchAgent snapshot required');

package/src/bridge-server.mjs

@@ -238,7 +238,8 @@ export async function startBridgeServer({
       // availability probe.
       response.end(`${JSON.stringify(attested
         ? { schema: 'lattice.bridge_health.v1', pid: process.pid,
-          address: currentConfig.listen.address, port: currentConfig.listen.port,
+          // 設定IPは公開networkの意図として保ち、healthは実際の待受を返す。
+          address: listenAddress, port: actualPort,
           updated_at: currentConfig.updated_at ?? null,
           version: packageJson.version, node_path: process.execPath,
           node_version: process.version, bridge_path: process.argv[1] ?? null,

package/src/bridge-startup-folder.mjs

@@ -198,12 +198,11 @@ function healthHost(address) {
   return address.includes(':') ? `[${address}]` : address;
 }
 
-async function defaultWaitReady({ config, instanceToken, env, timeoutMs = START_TIMEOUT_MS }) {
+export async function waitForBridgeStartupReady({ config, instanceToken, env, timeoutMs = START_TIMEOUT_MS }) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
     const descriptor = await readBridgeDaemonDescriptor({ env });
-    if (descriptor?.address === config.listen.address && descriptor?.port === config.listen.port
-      && descriptor?.config_updated_at === config.updated_at) {
+    if (descriptor?.port === config.listen.port && descriptor?.config_updated_at === config.updated_at) {
       try {
         const response = await fetch(
           `http://${healthHost(descriptor.address)}:${descriptor.port}/__lattice/bridge-health`, {
@@ -212,6 +211,7 @@ async function defaultWaitReady({ config, instanceToken, env, timeoutMs = START_
           });
         const body = response.status === 200 ? await response.json() : null;
         if (body?.schema === 'lattice.bridge_health.v1' && body.pid === descriptor.pid
+          && body.address === descriptor.address && body.port === descriptor.port
           && body.updated_at === config.updated_at) return descriptor;
       } catch {}
     }
@@ -300,7 +300,7 @@ async function stopRunning({ env, listen, runner, waitStopped }) {
 export async function installBridgeStartupFolder({ config, env = process.env,
   runner = defaultStartupRunner, nodePath = process.execPath,
   bridgePath = DEFAULT_BRIDGE_PATH, supervisorPath = DEFAULT_SUPERVISOR_PATH,
-  waitReady = defaultWaitReady, waitStopped = defaultWaitStopped,
+  waitReady = waitForBridgeStartupReady, waitStopped = defaultWaitStopped,
   stableNode = stableNodePath, previousListen = null } = {}) {
   if (config?.enabled !== true) throw fail('BRIDGE_DISABLED', 'bridge is disabled');
   const refs = bridgeStartupFolderPaths(env);
@@ -354,7 +354,7 @@ export async function disableBridgeStartupFolder({ snapshot, listen, env = proce
 
 export async function restoreBridgeStartupFolder({ snapshot, listen = null, env = process.env,
   runner = defaultStartupRunner, waitStopped = defaultWaitStopped,
-  config = undefined, waitReady = defaultWaitReady } = {}) {
+  config = undefined, waitReady = waitForBridgeStartupReady } = {}) {
   if (!snapshot || typeof snapshot.installed !== 'boolean'
     || (snapshot.installed
       && (typeof snapshot.launcherContent !== 'string' || typeof snapshot.descriptorContent !== 'string'))) {

package/src/runtime-pull-intake.mjs

@@ -25,6 +25,25 @@ import {
   readTodoIndependenceArtifact, readTodoStore, readTodoWitnessSet,
 } from './todo-store.mjs';
 
+export function ownScopeGrowth(taskId, finding) {
+  return finding?.kind === 'undeclared_write'
+    && Array.isArray(finding.todo_ids)
+    && finding.todo_ids.length === 1
+    && finding.todo_ids[0] === taskId
+    && typeof finding.path === 'string'
+    && finding.path.length > 0;
+}
+
+export function acceptFindings(taskId, findings) {
+  const blocking = [];
+  const added = [];
+  for (const finding of findings) {
+    if (ownScopeGrowth(taskId, finding)) added.push(finding.path);
+    else blocking.push(finding);
+  }
+  return { blocking, added_paths: [...new Set(added)].sort() };
+}
+
 export const PULL_RUN_META_SCHEMA = 'lattice.pull_run_meta.v1';
 const PULL_EVENT_SCHEMA = 'lattice.pull_run_event.v1';
 const PULL_EVENTS_FILE = 'pull-events.json';
@@ -1219,15 +1238,16 @@ export async function acceptPullTask({ repoRoot, runDir, taskId, environment = p
     const findings = [...direct, ...independent].filter((finding, index, all) => (
       index === all.findIndex((candidate) => digestArtifact(candidate) === digestArtifact(finding))
     ));
-    if (findings.length > 0) {
-      const affected = new Set(findings.flatMap((finding) => finding.todo_ids));
+    const { blocking, added_paths: addedPaths } = acceptFindings(taskId, findings);
+    if (blocking.length > 0) {
+      const affected = new Set(blocking.flatMap((finding) => finding.todo_ids));
       for (const affectedTaskId of [...affected].sort()) {
         const affectedIntake = project(current.events, current.meta).intakes
           .find((entry) => entry.task_id === affectedTaskId);
         if (!affectedIntake || affectedIntake.accepted !== null) continue;
         const intervention = { state: 'hold', reason: 'runtime_conflict',
           next_action: 'inspect_findings_and_resolve_or_split', lease_state: 'revoked',
-          detail: { findings: findings.filter((finding) => finding.todo_ids.includes(affectedTaskId)) } };
+          detail: { findings: blocking.filter((finding) => finding.todo_ids.includes(affectedTaskId)) } };
         current = await changeIntervention(runDir, current, affectedTaskId, intervention);
         const stoppedIntake = project(current.events, current.meta).intakes
           .find((entry) => entry.task_id === affectedTaskId);
@@ -1240,7 +1260,7 @@ export async function acceptPullTask({ repoRoot, runDir, taskId, environment = p
           }
         }
       }
-      fail('RUNTIME_CONFLICT_HOLD', 'observed diffがruntime conflictを生成した', { findings });
+      fail('RUNTIME_CONFLICT_HOLD', 'observed diffがruntime conflictを生成した', { findings: blocking });
     }
     if (intake.intervention.state === 'hold' && intake.intervention.reason === 'runtime_conflict') {
       const released = { state: 'none', reason: null, next_action: null,
@@ -1261,7 +1281,8 @@ export async function acceptPullTask({ repoRoot, runDir, taskId, environment = p
       events: current.events, meta: current.meta, kind: 'task_accepted', taskId,
       payload: { done_event_digest: done.event_digest,
         checkpoint_digest: checkpoint.checkpoint_digest, checkpoint,
-        head_sha: checkpoint.diff.head_sha },
+        head_sha: checkpoint.diff.head_sha,
+        ...(addedPaths.length > 0 ? { added_paths: addedPaths } : {}) },
     }));
 
     // 先着taskがacceptedになった後、planning conflictだけで待っていた後着を再投影する。