@quolu/lattice 0.57.1 → 0.57.3

package/bin/lattice-bridge.mjs

@@ -140,12 +140,15 @@ timer = setInterval(async () => {
     // the terminal identity file) reaches this catch.
     try {
       const heartbeat = await hubHeartbeat.tick({ config });
-      hubHeartbeatError = null;
+      // 直前に書いた指紋は、健全な状態へ戻った時にだけ捨てる。判定より前に捨てると
+      // 比較相手が毎周期nullになり、同じ結果をpoll周期ごとに書き続ける。stderrの
+      // 消費者が居ない常駐（WindowsのStartup launcher、LaunchAgent）では、この
+      // 書込みが積み上がること自体が常駐を不安定にする。
       if (['unreachable', 'rejected', 'partial'].includes(heartbeat?.state)) {
         const fingerprint = JSON.stringify(heartbeat);
         if (fingerprint !== hubHeartbeatError) process.stderr.write(`${fingerprint}\n`);
         hubHeartbeatError = fingerprint;
-      }
+      } else hubHeartbeatError = null;
     } catch (error) {
       const failure = { schema: 'lattice.bridge_daemon_error.v1',
         code: error?.code ?? 'BRIDGE_HUB_HEARTBEAT_FAILED',

package/docs/bridge-setup.md

@@ -54,6 +54,11 @@ bridgeが無効な間は以下すべてnullで、bridgeを有効にしている
 | `node_path`・`node_exists` | 起動するNode実行体と、それが今も存在するか |
 | `bridge_path`・`bridge_exists` | 起動するbridge scriptと、それが今も存在するか |
 | `error` | `unreadable`のときだけtyped code（例`BRIDGE_LAUNCH_AGENT_PLIST_UNSAFE`） |
+| `error=BRIDGE_PERSISTENCE_STATE_SPLIT` | launcherまたはplistの片割れだけが残った状態。手でfileを消さず、`lattice bridge reconfigure --json`で常駐設定を揃える（0.57.2以降） |
+
+`BRIDGE_PERSISTENCE_STATE_SPLIT`は、常駐設定の一方（macOSのplist、またはWindowsのlauncher／descriptor）だけが
+存在することを示す。これは復旧対象そのものが壊れている状態なので、手作業でfileを削除せず、
+`lattice bridge reconfigure --json`を実行して正規のinstall経路で両方を再生成する。
 
 **`runtime`** — いま応答しているprocess自身の申告。`state`は`running`／`not_running`／`unattested`／
 `descriptor_invalid`で、`running`以外では各値がnullになる。`running`でも、identityを返さない

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quolu/lattice",
-  "version": "0.57.1",
+  "version": "0.57.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

@@ -112,6 +112,10 @@ async function bridgePersistence({ launchAgent, env }) {
     // `loaded` is launchd-specific; the Windows Startup folder has no such
     // concept and reports null rather than pretending to know.
     const loaded = typeof snapshot?.loaded === 'boolean' ? snapshot.loaded : null;
+    if (snapshot?.split === true) {
+      return { state: 'unreadable', ...UNREADABLE_PERSISTENCE, loaded,
+        error: 'BRIDGE_PERSISTENCE_STATE_SPLIT' };
+    }
     if (described === null) return { state: 'not_installed', ...UNREADABLE_PERSISTENCE, loaded, error: null };
     return { state: 'installed', loaded, ...described, error: null };
   } catch (error) {

package/src/bridge-launch-agent.mjs

@@ -247,10 +247,8 @@ export async function snapshotBridgeLaunchAgent({ env = process.env,
   await prepareDirectory(refs.directory, uid);
   const content = await strictPlist(refs.plist, uid);
   const loaded = await loadedState(runner, uid);
-  if (loaded && content === null) {
-    throw fail('BRIDGE_LAUNCH_AGENT_STATE_INVALID', 'loaded bridge LaunchAgent has no owned plist');
-  }
-  return Object.freeze({ installed: content !== null, loaded, content });
+  const split = loaded && content === null;
+  return Object.freeze({ installed: content !== null, loaded, split, content });
 }
 
 const PROGRAM_ARGUMENTS_PATTERN =
@@ -346,6 +344,10 @@ export async function restoreBridgeLaunchAgent({ snapshot, listen = null, env =
   await prepareDirectory(refs.directory, uid);
   const stopped = await bootoutIfLoaded({ runner, uid });
   if (stopped) await waitStopped({ listen, env });
+  if (snapshot.split === true) {
+    await rm(refs.plist, { force: true });
+    return snapshot;
+  }
   if (snapshot.installed) await atomicPlist(refs.plist, snapshot.content);
   else await rm(refs.plist, { force: true });
   if (snapshot.loaded) {

package/src/bridge-startup-folder.mjs

@@ -239,10 +239,9 @@ export async function snapshotBridgeStartupFolder({ env = process.env } = {}) {
   await prepareDirectory(refs.runtimeDirectory);
   const launcherContent = await strictFile(refs.launcher);
   const descriptorContent = await strictFile(refs.descriptor);
-  if ((launcherContent === null) !== (descriptorContent === null)) {
-    throw fail('BRIDGE_STARTUP_FOLDER_STATE_INVALID', 'startup launcher and descriptor disagree on installed state');
-  }
-  return Object.freeze({ installed: launcherContent !== null, launcherContent, descriptorContent });
+  const split = (launcherContent === null) !== (descriptorContent === null);
+  return Object.freeze({ installed: launcherContent !== null && descriptorContent !== null,
+    split, launcherContent, descriptorContent });
 }
 
 async function pathPresent(ref) {

package/src/runtime-pull-intake.mjs

@@ -681,8 +681,10 @@ export async function intakePullTask({ repoRoot, runDir, taskId, environment = p
           affected_tests: [], graph_evidence: [], witness_provenance: {}, manifest_digest: '',
         };
         manifest.manifest_digest = selfDigest(manifest, 'manifest_digest');
-        verdict.state = 'hold'; verdict.reason = 'boundary_unverified';
-        verdict.next_action = 'declare_and_recompile'; verdict.detail = { cause: error.code };
+        if (verdict.state !== 'hold') {
+          verdict.state = 'hold'; verdict.reason = 'boundary_unverified';
+          verdict.next_action = 'declare_and_recompile'; verdict.detail = { cause: error.code };
+        }
       }
       const constraint = verdict.state === 'none'
         ? planningConstraint(verdict.artifact, taskId, state, member) : null;
@@ -760,8 +762,10 @@ export async function intakePullTask({ repoRoot, runDir, taskId, environment = p
         affected_tests: [], graph_evidence: [], witness_provenance: {}, manifest_digest: '',
       };
       manifest.manifest_digest = selfDigest(manifest, 'manifest_digest');
-      verdict.state = 'hold'; verdict.reason = 'boundary_unverified';
-      verdict.next_action = 'declare_and_recompile'; verdict.detail = { cause: error.code };
+      if (verdict.state !== 'hold') {
+        verdict.state = 'hold'; verdict.reason = 'boundary_unverified';
+        verdict.next_action = 'declare_and_recompile'; verdict.detail = { cause: error.code };
+      }
     }
     const packet = packetFor({ meta: current.meta, taskId, baseSha, manifest });
     const worktreePath = await ensureScriptedWorktree({ repoRoot, runDir, packet });

package/src/todo-cli.mjs

@@ -1759,6 +1759,9 @@ async function independenceCompile({ repoRoot, planKey, inputRef }) {
     previousArtifact,
   });
   const { ref } = await writeTodoIndependenceArtifact({ repoRoot, artifact });
+  // compile成功後にだけ、受理した宣言をruntime readerが要求するcanonical bytesで固定する。
+  // inputがstore自身でも外部draftでも、唯一の正規writerを通して同じ契約へ収束させる。
+  await writeTodoWitnessSet({ repoRoot, witnessSet });
 
   const result = {
     schema: 'lattice.todo_independence_compile_result.v2',

package/src/todo-store.mjs

@@ -2286,8 +2286,19 @@ function localTaskRef(ref, plan, taskId) {
     && ref.task_id === taskId;
 }
 
+function removedTaskIdsFor(revision) {
+  return new Set(revision.task_migration
+    .filter(({ to_task_id, state_policy }) => to_task_id === 'removed' && state_policy === 'removed')
+    .map(({ from_task_id }) => from_task_id));
+}
+
+function removedTaskRef(ref, plan, removedTaskIds) {
+  return ref.project_id === plan.project_id && ref.plan_key === plan.plan_key
+    && removedTaskIds.has(ref.task_id);
+}
+
 function taskSemantics(plan, taskId, idMap, {
-  reconciliationMetadata = false, includeDesignMemo = false,
+  reconciliationMetadata = false, includeDesignMemo = false, removedTaskIds = new Set(),
 } = {}) {
   const task = plan.tasks.find(({ task_id }) => task_id === taskId);
   if (!task) return null;
@@ -2302,17 +2313,23 @@ function taskSemantics(plan, taskId, idMap, {
     compile_binding: task.compile_binding, parent_task_id: mapId(task.parent_task_id ?? null),
   };
   const edges = plan.hard_dependencies
-    .filter(({ from, to }) => localTaskRef(from, plan, taskId) || localTaskRef(to, plan, taskId))
+    .filter(({ from, to }) => !removedTaskRef(from, plan, removedTaskIds)
+      && !removedTaskRef(to, plan, removedTaskIds)
+      && (localTaskRef(from, plan, taskId) || localTaskRef(to, plan, taskId)))
     .map(({ from, to }) => ({ from: mappedNodeRef(from, plan, idMap), to: mappedNodeRef(to, plan, idMap) }))
     .sort((left, right) => canonicalizeTodoArtifact(left) < canonicalizeTodoArtifact(right) ? -1 : 1);
   const joins = plan.joins
-    .filter(({ after, before }) => localTaskRef(before, plan, taskId)
-      || after.some((ref) => localTaskRef(ref, plan, taskId)))
-    .map((join) => ({ ...join,
-      after: join.after.map((ref) => mappedNodeRef(ref, plan, idMap))
+    .flatMap((join) => {
+      if (removedTaskRef(join.before, plan, removedTaskIds)) return [];
+      const after = join.after.filter((ref) => !removedTaskRef(ref, plan, removedTaskIds));
+      if (after.length === 0 || (!localTaskRef(join.before, plan, taskId)
+        && !after.some((ref) => localTaskRef(ref, plan, taskId)))) return [];
+      return [{ ...join,
+        after: after.map((ref) => mappedNodeRef(ref, plan, idMap))
         .sort((left, right) => canonicalizeTodoArtifact(left) < canonicalizeTodoArtifact(right) ? -1 : 1),
-      before: mappedNodeRef(join.before, plan, idMap),
-    })).sort((left, right) => left.id < right.id ? -1 : 1);
+        before: mappedNodeRef(join.before, plan, idMap),
+      }];
+    }).sort((left, right) => left.id < right.id ? -1 : 1);
   const phaseAcceptDependencies = isDecoupledPhaseTodoPlanSchema(plan.schema)
     ? plan.phase_accept_dependencies
       .filter(({ to }) => localTaskRef(to, plan, taskId))
@@ -2323,7 +2340,7 @@ function taskSemantics(plan, taskId, idMap, {
 }
 
 function phaseV3CarrySemantics(plan, taskId, taskIdMap, phaseIdMap,
-  { reconciliationMetadata = false, includeDesignMemo = false } = {}) {
+  { reconciliationMetadata = false, includeDesignMemo = false, removedTaskIds = new Set() } = {}) {
   const task = plan.tasks.find(({ task_id: id }) => id === taskId);
   if (task === undefined) return null;
   const mapTaskRef = (ref) => ref.project_id === plan.project_id && ref.plan_key === plan.plan_key
@@ -2351,13 +2368,17 @@ function phaseV3CarrySemantics(plan, taskId, taskIdMap, phaseIdMap,
   const incoming = [];
   const outgoing = [];
   for (const edge of plan.hard_dependencies) {
+    if (removedTaskRef(edge.from, plan, removedTaskIds)
+      || removedTaskRef(edge.to, plan, removedTaskIds)) continue;
     const mapped = { kind: 'hard', from: mapTaskRef(edge.from), to: mapTaskRef(edge.to) };
     if (localTaskRef(edge.to, plan, taskId)) incoming.push(mapped);
     if (localTaskRef(edge.from, plan, taskId)) outgoing.push(mapped);
   }
   for (const join of plan.joins) {
+    if (removedTaskRef(join.before, plan, removedTaskIds)) continue;
     const to = mapTaskRef(join.before);
     for (const after of join.after) {
+      if (removedTaskRef(after, plan, removedTaskIds)) continue;
       const tuple = { kind: 'join', join_id: join.id, from: mapTaskRef(after), to };
       if (localTaskRef(join.before, plan, taskId)) incoming.push(tuple);
       if (localTaskRef(after, plan, taskId)) outgoing.push(tuple);
@@ -2375,11 +2396,12 @@ function validatePhaseV3Carry(previous, revision, migration, idMap, state) {
   const reconciliationMetadata = migration.state_policy === 'carry_reconciled_metadata';
   const predecessorTask = previous.plan.tasks.find(({ task_id }) => task_id === migration.from_task_id);
   const includeDesignMemo = !reconciliationMetadata && typeof predecessorTask?.design_memo === 'string';
+  const removedTaskIds = removedTaskIdsFor(revision);
   const phaseIdMap = new Map(revision.phase_migration
     .filter(({ from_phase_id, to_phase_id }) => from_phase_id !== null && to_phase_id !== 'removed')
     .map(({ from_phase_id, to_phase_id }) => [from_phase_id, to_phase_id]));
   const before = phaseV3CarrySemantics(previous.plan, migration.from_task_id, idMap, phaseIdMap,
-    { reconciliationMetadata, includeDesignMemo });
+    { reconciliationMetadata, includeDesignMemo, removedTaskIds });
   const after = phaseV3CarrySemantics(revision.desired_plan, migration.to_task_id,
     new Map(), new Map(),
     { reconciliationMetadata, includeDesignMemo });
@@ -2412,8 +2434,9 @@ function validateAcquirePhaseCarry(previous, revision, migration, idMap) {
     .map(({ from_phase_id, to_phase_id }) => [from_phase_id, to_phase_id]));
   const predecessorTask = previous.plan.tasks.find(({ task_id }) => task_id === migration.from_task_id);
   const includeDesignMemo = typeof predecessorTask?.design_memo === 'string';
+  const removedTaskIds = removedTaskIdsFor(revision);
   const before = phaseV3CarrySemantics(previous.plan, migration.from_task_id, idMap, phaseIdMap,
-    { includeDesignMemo });
+    { includeDesignMemo, removedTaskIds });
   const after = phaseV3CarrySemantics(revision.desired_plan, migration.to_task_id, new Map(), new Map(),
     { includeDesignMemo });
   if (before.task.phase_id !== null) {
@@ -2448,6 +2471,7 @@ function stateMigrationFor(previous, revision) {
   const idMap = new Map(revision.task_migration
     .filter(({ to_task_id }) => to_task_id !== 'removed')
     .map(({ from_task_id, to_task_id }) => [from_task_id, to_task_id]));
+  const removedTaskIds = removedTaskIdsFor(revision);
   const states = new Map(previous.tasks.map((state) => [state.task_id, state]));
   return revision.task_migration.map((migration) => {
     const carriesState = ['carry', 'carry_reconciled_metadata', 'acquire_phase'].includes(migration.state_policy);
@@ -2467,7 +2491,7 @@ function stateMigrationFor(previous, revision) {
           .find(({ task_id }) => task_id === migration.from_task_id);
         const includeDesignMemo = typeof predecessorTask?.design_memo === 'string';
         const before = taskSemantics(previous.plan, migration.from_task_id, idMap,
-          { includeDesignMemo });
+          { includeDesignMemo, removedTaskIds });
         const after = taskSemantics(revision.desired_plan, migration.to_task_id, new Map(),
           { includeDesignMemo });
         if (canonicalizeTodoArtifact(before) !== canonicalizeTodoArtifact(after)) {
@@ -2482,7 +2506,7 @@ function stateMigrationFor(previous, revision) {
       const includeDesignMemo = !reconciliationMetadata
         && typeof predecessorTask?.design_memo === 'string';
       const before = taskSemantics(previous.plan, migration.from_task_id, idMap,
-        { reconciliationMetadata, includeDesignMemo });
+        { reconciliationMetadata, includeDesignMemo, removedTaskIds });
       const after = taskSemantics(revision.desired_plan, migration.to_task_id, new Map(),
         { reconciliationMetadata, includeDesignMemo });
       if (canonicalizeTodoArtifact(before) !== canonicalizeTodoArtifact(after)) {