@quolu/lattice 0.12.6 → 0.12.8

package/README.md

@@ -82,6 +82,9 @@ required evidenceを束縛した`todo phase accept`で重監査の判断を記
 session開始時のtyped discoveryで使う`lattice status --json`と、actor環境変数を持つ通常のTODO操作は
 active projectを自動登録し、一つのloopback dashboard daemonを再利用します。
 `/projects/`の一覧からproject固有の工程図を開け、各projectのSSE更新は互いに分離されます。
+dashboardはmanifestのfile identityが変わらない間のstable store readを再利用します。
+巨大工程図のrender中にhealth応答が遅れても、生存中dashboardを新daemonで置き換えず
+`DASHBOARD_DAEMON_UNRESPONSIVE`としてtyped拒否します。
 最近のsession activityが期限切れでも、Lattice storeの`active_set`が非空なprojectは一覧へ残ります。
 長時間の外部処理中にCLI呼出しが途切れても進行中projectを休眠扱いしません。
 LANや外部reverse proxyから閲覧するoptional bridgeは既定で無効です。明示したIPにだけbindする初回設定、

package/bin/lattice-dashboard.mjs

@@ -1,5 +1,8 @@
 #!/usr/bin/env node
 
+import { stat } from 'node:fs/promises';
+import path from 'node:path';
+
 import { readTodoStoreStable } from '../src/todo-store.mjs';
 import { projectTodoStatus } from '../src/todo-status.mjs';
 import { renderTodoGanttForProject } from '../src/todo-cli.mjs';
@@ -29,12 +32,33 @@ const port = typeof configured === 'string' && /^(?:0|[1-9][0-9]{0,4})$/u.test(c
 const registry = createTodoGanttProjectRegistry();
 const roots = new Map();
 const reportedStoreReadFailures = new Set();
+const storeCache = new Map();
+
+function manifestFingerprint(value) {
+  return `${value.dev}:${value.ino}:${value.size}:${value.mtimeMs}:${value.ctimeMs}`;
+}
+
+async function readCachedStore(repoRoot) {
+  const manifestRef = path.join(repoRoot, '.lattice', 'todo', 'manifest.json');
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    const beforeFingerprint = manifestFingerprint(await stat(manifestRef));
+    const cached = storeCache.get(repoRoot);
+    if (cached?.fingerprint === beforeFingerprint) return cached.store;
+    const store = await readTodoStoreStable({ repoRoot });
+    const afterFingerprint = manifestFingerprint(await stat(manifestRef));
+    if (beforeFingerprint === afterFingerprint) {
+      storeCache.set(repoRoot, { fingerprint: afterFingerprint, store });
+      return store;
+    }
+  }
+  return readTodoStoreStable({ repoRoot });
+}
 
 async function synchronize() {
   const active = await readVisibleTodoDashboardProjects({ env,
     projectHasActiveRun: async (entry) => {
       try {
-        const active = projectTodoStatus(await readTodoStoreStable({ repoRoot: entry.repo_root })).active_set.length > 0;
+        const active = projectTodoStatus(await readCachedStore(entry.repo_root)).active_set.length > 0;
         reportedStoreReadFailures.delete(entry.project_id);
         return active;
       } catch (error) {
@@ -62,11 +86,12 @@ async function synchronize() {
       projectId: entry.project_id,
       displayName: entry.display_name,
       render: async ({ displayName }) => {
+        const store = await readCachedStore(entry.repo_root);
         const result = await renderTodoGanttForProject({ repoRoot: entry.repo_root,
-          stable: true, displayName });
+          stable: true, displayName, readModel: store });
         return { html: result.rendered.html, head_digest: result.metadata.manifest_digest };
       },
-      readHead: async () => (await readTodoStoreStable({ repoRoot: entry.repo_root })).manifest.manifest_digest,
+      readHead: async () => (await readCachedStore(entry.repo_root)).manifest.manifest_digest,
     });
     roots.set(entry.project_id, binding);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quolu/lattice",
-  "version": "0.12.6",
+  "version": "0.12.8",
   "description": "Lattice — phase-aware TODO graph compiler and conflict-aware orchestration runtime",
   "type": "module",
   "license": "MIT",

package/src/bridge-server.mjs

@@ -67,7 +67,9 @@ async function readDashboardDescriptor(ref) {
   } finally { await handle?.close(); }
 }
 
-export async function resolveBridgeUpstream(upstream, { env = process.env } = {}) {
+export async function resolveBridgeUpstream(upstream, {
+  env = process.env, healthTimeoutMs = 2_000,
+} = {}) {
   if (upstream.mode === 'url') return new URL(upstream.url);
   let descriptor;
   try {
@@ -84,7 +86,7 @@ export async function resolveBridgeUpstream(upstream, { env = process.env } = {}
   }
   try {
     const response = await fetch(`http://127.0.0.1:${descriptor.port}/__lattice/health`, {
-      signal: AbortSignal.timeout(500),
+      signal: AbortSignal.timeout(healthTimeoutMs),
     });
     const health = response.status === 200 ? await response.json() : null;
     if (health?.schema !== 'lattice.todo_dashboard_health.v1' || health.pid !== descriptor.pid

package/src/todo-cli.mjs

@@ -307,7 +307,7 @@ async function mutate({ repoRoot, env, planKey, taskId, kind, payload, evidenceR
     planKey,
     event: { kind, task_id: taskId, actor, payload: eventPayload },
   });
-  const task = snapshot.tasks.find(({ task_id: current }) => current === taskId);
+  const task = snapshot.tasks.find(({ task_id: current }) => current === event.task_id);
   const result = {
     schema: 'lattice.todo_mutation_result.v1',
     project_id: event.project_id,
@@ -328,9 +328,10 @@ async function mutate({ repoRoot, env, planKey, taskId, kind, payload, evidenceR
 
 async function startTask({ repoRoot, env, planKey, taskId, overrideReason, parallelFrontier }) {
   const projection = projectTodoStatus(await readTodoStore({ repoRoot }));
-  const targetReady = projection.next_ready.some((task) => (
-    task.plan_key === planKey && task.task_id === taskId
+  const readyTask = projection.next_ready.find((task) => (
+    task.plan_key === planKey && task.task_id.toLowerCase() === taskId.toLowerCase()
   ));
+  const targetReady = readyTask !== undefined;
   if (parallelFrontier && !targetReady) {
     throw new TodoStoreError('PARALLEL_DISPATCH_INVALID', 'parallel_frontier_not_applicable');
   }
@@ -344,7 +345,7 @@ async function startTask({ repoRoot, env, planKey, taskId, overrideReason, paral
         serial_reason_flag: '--override-reason',
       });
   }
-  return mutate({ repoRoot, env, planKey, taskId, kind: 'start',
+  return mutate({ repoRoot, env, planKey, taskId: readyTask?.task_id ?? taskId, kind: 'start',
     payload: { override_reason: overrideReason }, evidenceRef: null });
 }
 
@@ -634,9 +635,10 @@ function parseGanttDescriptor(bytes, descriptorRef) {
 }
 
 export async function renderTodoGanttForProject({
-  repoRoot, stable = false, displayName = null, env = process.env,
+  repoRoot, stable = false, displayName = null, env = process.env, readModel = null,
 }) {
-  const store = stable ? await readTodoStoreStable({ repoRoot }) : await readTodoStore({ repoRoot });
+  const store = readModel
+    ?? (stable ? await readTodoStoreStable({ repoRoot }) : await readTodoStore({ repoRoot }));
   const identity = displayName === null
     ? await resolveProjectIdentity({ repoRoot, projectId: store.project_id, env })
     : { displayName };

package/src/todo-dashboard-registry.mjs

@@ -171,11 +171,11 @@ function validDaemonDescriptor(descriptor) {
     && typeof descriptor.started_at === 'string' && Number.isFinite(Date.parse(descriptor.started_at));
 }
 
-async function daemonAttestation(descriptor) {
+async function daemonAttestation(descriptor, { timeoutMs = 2_000 } = {}) {
   if (!validDaemonDescriptor(descriptor)) return null;
   try {
     const response = await fetch(`http://127.0.0.1:${descriptor.port}/__lattice/health`, {
-      signal: AbortSignal.timeout(500),
+      signal: AbortSignal.timeout(timeoutMs),
     });
     if (response.status !== 200) return null;
     const body = await response.json();
@@ -257,13 +257,20 @@ export async function writeTodoDashboardDaemonDescriptor({ port, env = process.e
 
 export async function ensureTodoDashboardDaemon({ env = process.env, spawnDaemon = spawn,
   signalProcess = process.kill, isProcessAlive = processIsAlive, startupTimeoutMs = 4_000,
-  legacyStopTimeoutMs = 3_000, replacementIsProcessAlive = processIsAlive } = {}) {
+  legacyStopTimeoutMs = 3_000, replacementIsProcessAlive = processIsAlive,
+  attestationTimeoutMs = 2_000 } = {}) {
   const refs = paths(env);
   await mkdir(refs.root, { recursive: true, mode: 0o700 });
   return withLock(refs.startupLock, async () => {
     const existing = await readJson(refs.descriptor, null);
-    const existingAttestation = await daemonAttestation(existing);
+    const existingAttestation = await daemonAttestation(existing, { timeoutMs: attestationTimeoutMs });
     if (existingAttestation === 'current') return existing;
+    if (validDaemonDescriptor(existing) && existingAttestation === null
+      && await isProcessAlive(existing.pid)) {
+      const error = new Error('dashboard daemon is alive but temporarily unresponsive');
+      error.code = 'DASHBOARD_DAEMON_UNRESPONSIVE';
+      throw error;
+    }
     const legacy = existingAttestation === 'legacy' ? existing : null;
     const portText = env.LATTICE_DASHBOARD_PORT;
     const configuredPort = typeof portText === 'string' && /^(?:0|[1-9][0-9]{0,4})$/u.test(portText)

package/src/todo-store.mjs

@@ -1117,6 +1117,22 @@ function resolveTargetedEvent(input, storeMember) {
   return input;
 }
 
+function resolveCanonicalTaskId(plan, requestedTaskId) {
+  if (requestedTaskId === null || requestedTaskId === undefined) return requestedTaskId;
+  const exact = plan.tasks.find(({ task_id: taskId }) => taskId === requestedTaskId);
+  if (exact) return exact.task_id;
+  const folded = requestedTaskId.toLowerCase();
+  const matches = plan.tasks.filter(({ task_id: taskId }) => taskId.toLowerCase() === folded);
+  if (matches.length === 0) fail('TASK_NOT_FOUND', 'task_not_found', {
+    requested_task_id: requestedTaskId,
+  });
+  if (matches.length > 1) fail('TASK_ID_AMBIGUOUS', 'task_id_case_ambiguous', {
+    requested_task_id: requestedTaskId,
+    matching_task_ids: matches.map(({ task_id: taskId }) => taskId).sort(),
+  });
+  return matches[0].task_id;
+}
+
 export async function appendTodoEvent(options = {}) {
   requireWriter(options.writer, 'g5-authoring');
   const repoRoot = path.resolve(options.repoRoot ?? process.cwd());
@@ -1126,6 +1142,7 @@ export async function appendTodoEvent(options = {}) {
     if (!member) fail('STORE_INCONSISTENT', 'plan_not_active');
     const input = resolveTargetedEvent({
       ...options.event,
+      task_id: resolveCanonicalTaskId(member.plan, options.event.task_id),
       recorded_at: options.event.recorded_at ?? new Date().toISOString(),
     }, member);
     const event = nextEvent(input, member);
@@ -2575,7 +2592,19 @@ function validatePhaseV3SourceInventoryDiff(previousInventory, revision) {
   for (const entry of previousInventory.active) {
     const active = desired.active.find(({ task_id }) => task_id === entry.task_id);
     const continued = active?.source_ref === entry.source_ref && active.source_digest === entry.source_digest;
-    if (!continued && !desiredTombstoneKeys.has(`${entry.source_ref}\0${entry.source_digest}`)) {
+    const relocated = revision.source_cutover_batch.operations.some((operation, index) => {
+      if (operation.source_ref !== entry.source_ref || operation.source_digest !== entry.source_digest) {
+        return false;
+      }
+      const archiveRef = todoCutoverArchiveSourceRef(revision.source_cutover_batch, index);
+      return operation.disposition === 'active'
+        ? desired.active.some((candidate) => candidate.task_id === operation.task_id
+          && candidate.source_ref === archiveRef && candidate.source_digest === operation.source_digest)
+        : desired.excluded_tombstones.some((candidate) => candidate.source_ref === archiveRef
+          && candidate.source_digest === operation.source_digest);
+    });
+    if (!continued && !relocated
+      && !desiredTombstoneKeys.has(`${entry.source_ref}\0${entry.source_digest}`)) {
       fail('REVISION_INVALID', 'predecessor_source_silently_dropped', { task_id: entry.task_id });
     }
   }