@quolu/lattice 0.63.1 → 0.63.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quolu/lattice",
-  "version": "0.63.1",
+  "version": "0.63.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/runtime-control-store.mjs

@@ -319,6 +319,15 @@ async function replaceCanonical({ pathname, expectedBytes, value, validator, cra
   }
 }
 
+/**
+ * control-events.jsonを書く他module（gate storeのatomic commit）が、このstoreのappendと
+ * 同じper-directory直列化を共有するための入口。同一process内で書き手が2つの規律に
+ * 分かれると、appendがcommitの読みと置換の間へ挟まり偽のcommitted prefix衝突になる。
+ */
+export function withControlJournalMutation(runDir, mutation) {
+  return enqueue(path.resolve(runDir), mutation);
+}
+
 function enqueue(runDir, mutation) {
   const previous = mutationQueues.get(runDir) ?? Promise.resolve();
   const result = previous.then(mutation);

package/src/runtime-gate-store.mjs

@@ -4,6 +4,7 @@ import { lstat, mkdir, open, readFile, rename, unlink } from 'node:fs/promises';
 import path from 'node:path';
 
 import { canonicalizeArtifact } from './artifact-contracts.mjs';
+import { withControlJournalMutation } from './runtime-control-store.mjs';
 import { selfDigest } from './runtime-contracts.mjs';
 
 const SHA256 = /^[0-9a-f]{64}$/;
@@ -407,9 +408,17 @@ async function commitBuilt({ runDir, built, crashInjector, controlEventsPath = n
 }
 
 export async function commitRuntimeGateActivation(options) {
-  const built = await buildCommit(options);
-  return commitBuilt({ runDir: options.runDir, built, crashInjector: options.crashInjector,
-    controlEventsPath: options.controlEventsPath ?? null });
+  // control journalの読み(buildCommit)と置換(commitBuilt)の間へ、同一process内の
+  // control store appendが挟まると、committed prefix検査が偽のGATE_COMMIT_CONFLICTに
+  // なる（2026-08-22 CI負荷下で実被弾: managed recompileのepoch activationへdaemonの
+  // 並行appendが割り込んだ）。appendと同じper-directory直列化を共有して排除する。
+  // 別process間の競合検査は従来どおりprefix比較が持つ。
+  const eventsPath = options.controlEventsPath ?? path.join(options.runDir, 'control-events.json');
+  return withControlJournalMutation(path.dirname(eventsPath), async () => {
+    const built = await buildCommit(options);
+    return commitBuilt({ runDir: options.runDir, built, crashInjector: options.crashInjector,
+      controlEventsPath: options.controlEventsPath ?? null });
+  });
 }
 
 export async function recoverRuntimeGateCommit(options) {

package/src/runtime-managed-supervisor.mjs

@@ -1011,8 +1011,33 @@ async function activateManagedSupervisorController({ repoRoot, runDir, runId, ad
         fail('ADAPTER_LAUNCH_INVALID', 'existing endpoint ownerが一意でない');
       }
     }
-    const handshake = await exchangeControllerHandshake({ socketPath: handshakeConnectPath, runId,
-      supervisorSessionNonce, controllerSocketRef, timeoutMs });
+    // socket fileの出現はbindの証拠でありlistenの証拠ではない。負荷下ではcontrollerが
+    // bindとlistenの間でpreemptされ、fileを見て接続した一回だけECONNREFUSEDになる
+    // （2026-08-22 CI負荷下で実被弾）。起動したchildに限り、listen受理までを起動待ちに
+    // 含めてdeadline内はECONNREFUSEDだけを待ち直す。死んだcontrollerはexitCode検査が、
+    // 起動しないcontrollerはdeadlineが従来どおり落とす。既存endpoint（child無し）は
+    // owner検証済みのlistener前提なので単発のまま。
+    const handshakeDeadline = Date.now() + timeoutMs;
+    let handshake;
+    for (;;) {
+      try {
+        handshake = await exchangeControllerHandshake({ socketPath: handshakeConnectPath, runId,
+          supervisorSessionNonce, controllerSocketRef, timeoutMs });
+        break;
+      } catch (error) {
+        const listenPending = child !== null && error instanceof ManagedRuntimeError
+          && ['ECONNREFUSED', 'ENOENT'].some((code) => String(error.message).includes(code))
+          && Date.now() < handshakeDeadline;
+        if (!listenPending) throw error;
+        if (child.exitCode !== null) {
+          fail(
+            'ADAPTER_CONTROLLER_UNAVAILABLE',
+            `controller exited: ${child.exitCode}${childStderr ? `: ${childStderr.trim()}` : ''}`,
+          );
+        }
+        await new Promise((resolve) => setTimeout(resolve, 20));
+      }
+    }
     const controllerDescriptor = handshake.descriptor;
     if (controllerDescriptor.adapter_kind !== adapterKind || controllerDescriptor.socket_ref !== controllerSocketRef
       || controllerDescriptor.capabilities.capabilities_digest !== launch.capabilities_digest

package/src/runtime-multi-epoch-store.mjs

@@ -490,18 +490,11 @@ export async function activateEpochOneStore({
     }
   }
 
-  const meta = {
-    schema: 'lattice.run_meta.v2',
-    run_id: normalizedMeta.run_id,
-    executor_adapter: normalizedMeta.executor_adapter,
-    run_event_schema: 'lattice.run_event.v1',
-    control_event_schema: 'lattice.runtime_control_event.v1',
-    epoch_bundle_schema: 'lattice.runtime_epoch_bundle.v1',
-    created_plan_digest: compileArtifact.plan.plan_digest,
-  };
-  meta.meta_digest = digestArtifact(meta);
-  await replaceDurableJson(runDir, 'run-meta.json', meta);
-
+  // pointerをmetaより先に書く。読み手はmeta v2を見てからpointerを読むので、逆順だと
+  // 2書き込みの間にmeta v2だけが見え、並行するreaderがINVALID_RUN_STORE
+  // （committed epoch pointerを読めない）で落ちる（2026-08-22 CI負荷下で実被弾）。
+  // この順ならmeta v2の可視がpointer実在を含意し、途中crashはmeta v1のまま
+  // （余剰のpointerはlegacy読取りに影響せず、再activationが置換する）。
   const pointer = {
     schema: 'lattice.committed_epoch_pointer.v1',
     run_id: normalizedMeta.run_id,
@@ -513,6 +506,18 @@ export async function activateEpochOneStore({
   };
   pointer.pointer_digest = digestArtifact(pointer);
   await replaceDurableJson(runDir, 'committed-epoch.json', pointer);
+
+  const meta = {
+    schema: 'lattice.run_meta.v2',
+    run_id: normalizedMeta.run_id,
+    executor_adapter: normalizedMeta.executor_adapter,
+    run_event_schema: 'lattice.run_event.v1',
+    control_event_schema: 'lattice.runtime_control_event.v1',
+    epoch_bundle_schema: 'lattice.runtime_epoch_bundle.v1',
+    created_plan_digest: compileArtifact.plan.plan_digest,
+  };
+  meta.meta_digest = digestArtifact(meta);
+  await replaceDurableJson(runDir, 'run-meta.json', meta);
   return { bundle, meta, pointer };
 }
 

package/src/todo-store.mjs

@@ -486,6 +486,11 @@ function replay(plan, events, { now = new Date(), verifyEvidence, verifyImportSo
   const doneDigest = new Map();
   const completion = new Map();
   const authoredStartBindings = new Map();
+  // hard証拠検証は即時でなくreplay完了後、まだ現在状態を支えている記述子だけへ行う。
+  // reopen・再doneで差し替えられた古いdoneが指すblobは一度もcommitされないままGCで消え得るし、
+  // 履歴の完全性はevent_digest鎖が既に持つ。即時検証だと消えたblobを指す過去eventが
+  // storeを恒久的に書き込み不能へ落とす（2026-08-22実被弾: reopen済み旧doneのdangling blob）。
+  const pendingVerifications = new Map();
   const importedGenesis = events[0]?.payload.historical_import === true;
   let previousTime = null;
   for (const event of events) {
@@ -528,13 +533,15 @@ function replay(plan, events, { now = new Date(), verifyEvidence, verifyImportSo
           const state = states.get(migration.to_task_id);
           Object.assign(state, structuredClone(migration.state), { evidence_unverified: false });
           if (state.evidence !== null) {
+            const evidence = state.evidence;
+            const context = { plan_key: plan.plan_key, task_id: migration.to_task_id };
             if (state.imported) {
-              if (verifyImportSource) verifyImportSource(state.evidence, {
-                plan_key: plan.plan_key, task_id: migration.to_task_id,
-              });
-            } else if (verifyEvidence) verifyEvidence(state.evidence, {
-              plan_key: plan.plan_key, task_id: migration.to_task_id,
-            });
+              if (verifyImportSource) {
+                pendingVerifications.set(`task:${migration.to_task_id}`, () => verifyImportSource(evidence, context));
+              }
+            } else if (verifyEvidence) {
+              pendingVerifications.set(`task:${migration.to_task_id}`, () => verifyEvidence(evidence, context));
+            }
           }
           if (state.status === 'done') {
             doneDigest.set(migration.to_task_id, event.event_digest);
@@ -571,6 +578,7 @@ function replay(plan, events, { now = new Date(), verifyEvidence, verifyImportSo
         if (currentStatus !== 'gate_ready') fail('STORE_INCONSISTENT', 'phase_gate_not_ready');
         state.status = 'reviewing'; state.review_event_digest = event.event_digest;
         state.decision_event_digest = null; state.decision_evidence = null;
+        pendingVerifications.delete(`phase:${event.phase_id}`);
       } else if (event.kind === 'phase_accept') {
         const phase = phasesOf(plan).find(({ phase_id }) => phase_id === event.phase_id);
         const slots = event.payload.evidence_slots.map(({ slot_id }) => slot_id);
@@ -579,8 +587,12 @@ function replay(plan, events, { now = new Date(), verifyEvidence, verifyImportSo
           fail('STORE_INCONSISTENT', 'phase_accept_binding_invalid');
         }
         if (verifyEvidence) {
-          verifyEvidence(event.payload.decision_evidence);
-          for (const slot of event.payload.evidence_slots) verifyEvidence(slot.evidence);
+          const decisionEvidence = event.payload.decision_evidence;
+          const slotEvidence = event.payload.evidence_slots.map((slot) => slot.evidence);
+          pendingVerifications.set(`phase:${event.phase_id}`, () => {
+            verifyEvidence(decisionEvidence);
+            for (const evidence of slotEvidence) verifyEvidence(evidence);
+          });
         }
         state.status = 'accepted'; state.decision_event_digest = event.event_digest;
         state.decision_evidence = event.payload.decision_evidence;
@@ -588,7 +600,10 @@ function replay(plan, events, { now = new Date(), verifyEvidence, verifyImportSo
         if (currentStatus !== 'reviewing' || state.review_event_digest !== event.payload.review_event_digest) {
           fail('STORE_INCONSISTENT', 'phase_reject_binding_invalid');
         }
-        if (verifyEvidence) verifyEvidence(event.payload.decision_evidence);
+        if (verifyEvidence) {
+          const decisionEvidence = event.payload.decision_evidence;
+          pendingVerifications.set(`phase:${event.phase_id}`, () => verifyEvidence(decisionEvidence));
+        }
         state.status = 'rejected'; state.decision_event_digest = event.event_digest;
         state.decision_evidence = event.payload.decision_evidence;
       } else if (event.kind === 'phase_close_unaudited') {
@@ -597,6 +612,7 @@ function replay(plan, events, { now = new Date(), verifyEvidence, verifyImportSo
         if (currentStatus !== 'gate_ready') fail('STORE_INCONSISTENT', 'phase_gate_not_ready');
         state.status = 'closed_unaudited'; state.decision_event_digest = event.event_digest;
         state.decision_evidence = null;
+        pendingVerifications.delete(`phase:${event.phase_id}`);
       } else {
         // phase_reopen。ADR 0148裁定5: closed_unauditedもaccepted/rejectedと同じく
         // reopenで初期状態へ戻せる——監査せずに閉じた工程を、後から本当に監査したくなった時に
@@ -624,6 +640,7 @@ function replay(plan, events, { now = new Date(), verifyEvidence, verifyImportSo
           fail('STORE_INCONSISTENT', 'phase_reopen_has_started_successor');
         }
         Object.assign(state, emptyPhaseState(event.phase_id));
+        pendingVerifications.delete(`phase:${event.phase_id}`);
       }
       continue;
     }
@@ -635,9 +652,12 @@ function replay(plan, events, { now = new Date(), verifyEvidence, verifyImportSo
         if (!importedGenesis || state.status !== 'pending') {
           fail('STORE_INCONSISTENT', 'invalid_historical_import_start_transition');
         }
-        if (verifyImportSource) verifyImportSource(event.payload.evidence, {
-          plan_key: plan.plan_key, task_id: event.task_id,
-        });
+        if (verifyImportSource) {
+          const evidence = event.payload.evidence;
+          pendingVerifications.set(`task:${event.task_id}`, () => verifyImportSource(evidence, {
+            plan_key: plan.plan_key, task_id: event.task_id,
+          }));
+        }
         state.status = 'in-progress';
         state.started_at = event.payload.started_at === 'unknown_requires_evidence'
           ? null : event.payload.started_at;
@@ -686,18 +706,24 @@ function replay(plan, events, { now = new Date(), verifyEvidence, verifyImportSo
     } else if (event.kind === 'done') {
       if (event.payload.done_mode === 'authored') {
         if (state.status !== 'in-progress' || !dependenciesDone) fail('STORE_INCONSISTENT', 'invalid_done_transition');
-        if (verifyEvidence) verifyEvidence(event.payload.evidence, {
-          plan_key: plan.plan_key, task_id: event.task_id,
-        });
+        if (verifyEvidence) {
+          const evidence = event.payload.evidence;
+          pendingVerifications.set(`task:${event.task_id}`, () => verifyEvidence(evidence, {
+            plan_key: plan.plan_key, task_id: event.task_id,
+          }));
+        }
         state.status = 'done'; state.done_at = event.recorded_at; state.evidence = event.payload.evidence;
         state.test_result = event.payload.test_result ?? null;
         state.imported = false;
         completion.set(event.task_id, { mode: 'authored', completed_at: event.recorded_at });
       } else if (event.payload.done_mode === 'historical_import') {
         if (!importedGenesis || state.status !== 'pending') fail('STORE_INCONSISTENT', 'invalid_historical_import_transition');
-        if (verifyImportSource) verifyImportSource(event.payload.evidence, {
-          plan_key: plan.plan_key, task_id: event.task_id,
-        });
+        if (verifyImportSource) {
+          const evidence = event.payload.evidence;
+          pendingVerifications.set(`task:${event.task_id}`, () => verifyImportSource(evidence, {
+            plan_key: plan.plan_key, task_id: event.task_id,
+          }));
+        }
         state.status = 'done'; state.done_at = event.payload.completed_at === 'unknown_requires_evidence'
           ? null : event.payload.completed_at;
         state.evidence = event.payload.evidence; state.imported = true;
@@ -709,9 +735,12 @@ function replay(plan, events, { now = new Date(), verifyEvidence, verifyImportSo
           || doneDigest.get(event.task_id) !== event.payload.target_done_digest) {
           fail('STORE_INCONSISTENT', 'invalid_evidence_promotion');
         }
-        if (verifyEvidence) verifyEvidence(event.payload.evidence, {
-          plan_key: plan.plan_key, task_id: event.task_id,
-        });
+        if (verifyEvidence) {
+          const evidence = event.payload.evidence;
+          pendingVerifications.set(`task:${event.task_id}`, () => verifyEvidence(evidence, {
+            plan_key: plan.plan_key, task_id: event.task_id,
+          }));
+        }
         state.evidence = event.payload.evidence;
         completion.set(event.task_id, { mode: 'evidence_promotion', completed_at: current.completed_at });
       }
@@ -739,8 +768,10 @@ function replay(plan, events, { now = new Date(), verifyEvidence, verifyImportSo
       if (startedSuccessor && event.payload.override_reason === null) fail('STORE_INCONSISTENT', 'reopen_has_started_successor');
       state.status = 'in-progress'; state.done_at = null; state.evidence = null; state.test_result = null;
       completion.delete(event.task_id);
+      pendingVerifications.delete(`task:${event.task_id}`);
     }
   }
+  for (const verify of pendingVerifications.values()) verify();
   return [...states.values()].sort((left, right) => left.task_id < right.task_id ? -1 : left.task_id > right.task_id ? 1 : 0);
 }