@quolu/lattice 0.58.1 → 0.58.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quolu/lattice",
-  "version": "0.58.1",
+  "version": "0.58.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/todo-cli.mjs

@@ -646,7 +646,7 @@ function terminalAuditDoneAdvisory(plan, phases) {
 
 async function mutate({
   repoRoot, env, planKey, taskId, kind, payload, evidenceRef, advisory = null,
-  noteContext = null,
+  noteContext = null, structureContext = null,
 }) {
   const actor = mutationActor(env);
   const evidence = evidenceRef === null ? null : await readEvidenceInput(repoRoot, evidenceRef);
@@ -674,7 +674,7 @@ async function mutate({
     throw new TypeError('start mutation requires note context');
   }
   const result = {
-    schema: includesNoteContext ? 'lattice.todo_mutation_result.v4' : 'lattice.todo_mutation_result.v2',
+    schema: includesNoteContext ? 'lattice.todo_mutation_result.v5' : 'lattice.todo_mutation_result.v2',
     project_id: event.project_id,
     plan_key: event.plan_key,
     plan_version: event.plan_version,
@@ -689,6 +689,7 @@ async function mutate({
     ...(includesNoteContext ? {
       design_memo: designMemoProjection(authoredTask),
       note_context: noteContext,
+      structure_context: structureContext,
     } : {}),
     result_digest: '',
   };
@@ -696,6 +697,38 @@ async function mutate({
   return result;
 }
 
+async function startStructureContext({ repoRoot, store, planKey, taskId }) {
+  const member = store.members.find(({ descriptor }) => descriptor.plan_key === planKey);
+  if (member === undefined) throw new TodoStoreError('STORE_INCONSISTENT', 'plan_not_active');
+  const source = await readTodoStructureSource({ repoRoot, planKey });
+  const binding = await readTodoStructureBinding({
+    repoRoot, planKey, planVersion: member.plan.plan_version,
+  });
+  if (source === null || binding === null) return {
+    status: 'not_enabled', enabled: false, freshness: null, stale_reasons: [],
+    structure_set_digest: null, task: null, next_actions: [],
+  };
+  if (source.structure_set_digest !== binding.structure_set_digest) {
+    throw new TodoStoreError('STRUCTURE_LIFECYCLE_GATE_FAILED',
+      'enabled_structure_source_unreadable', undefined, { plan_key: planKey });
+  }
+  const task = source.tasks.find(({ task_id: id }) => id === taskId);
+  if (task === undefined) {
+    throw new TodoStoreError('STRUCTURE_LIFECYCLE_GATE_FAILED',
+      'enabled_structure_task_missing', undefined, { plan_key: planKey, task_id: taskId });
+  }
+  const state = await readTodoStructureState({ repoRoot, store, planKey });
+  return {
+    status: 'available', enabled: true, freshness: state.status,
+    stale_reasons: state.stale_reasons,
+    structure_set_digest: source.structure_set_digest,
+    task: structuredClone(task),
+    next_actions: task.applicability === 'graph'
+      ? [`lattice todo structure realize --plan ${planKey} --task ${taskId} --input <realization.json>`]
+      : [],
+  };
+}
+
 function designMemoProjection(task) {
   if (typeof task.design_memo === 'string') {
     return { status: 'available', markdown: task.design_memo, prompt: TODO_DESIGN_MEMO_PROMPT };
@@ -898,8 +931,12 @@ async function startTask({
   const advisory = await startAdvisory({
     repoRoot, store, projection, planKey, taskId: resolvedTaskId,
   });
+  const structureContext = await startStructureContext({
+    repoRoot, store, planKey, taskId: resolvedTaskId,
+  });
   return mutate({ repoRoot, env, planKey, taskId: resolvedTaskId, kind: 'start',
-    payload: { override_reason: overrideReason }, evidenceRef: null, advisory, noteContext });
+    payload: { override_reason: overrideReason }, evidenceRef: null, advisory, noteContext,
+    structureContext });
 }
 
 async function retractStart({ repoRoot, env, planKey, taskId, reason }) {
@@ -2035,10 +2072,7 @@ async function structureCompile({ repoRoot, env, planKey, inputRef }) {
   const overlay = compileTodoStructureOverlay({
     structureSet,
     topology: mergedTopology(store),
-    taskStates: structureSet.tasks.map(({ task_id: taskId }) => ({
-      task_id: taskId,
-      status: member.tasks.find(({ task_id: id }) => id === taskId)?.status ?? 'pending',
-    })),
+    taskStates: member.tasks.map(({ task_id: taskId, status }) => ({ task_id: taskId, status })),
     sourceProjection: sourceEvidence.projection,
     gitProvenance,
     realizations,
@@ -2196,7 +2230,7 @@ async function structureFinalize({ repoRoot, env, planKey }) {
   const overlay = compileTodoStructureOverlay({
     structureSet: source,
     topology: mergedTopology(store),
-    taskStates: source.tasks.map(({ task_id: taskId }) => ({ task_id: taskId, status: 'done' })),
+    taskStates: member.tasks.map(({ task_id: taskId, status }) => ({ task_id: taskId, status })),
     sourceProjection: sourceEvidence.projection,
     gitProvenance,
     realizations,

package/src/todo-structure-overlay.mjs

@@ -62,12 +62,14 @@ function normalizeTaskStates(structureSet, taskStates) {
     if (!isPlain(entry) || Object.keys(entry).length !== 2
       || typeof entry.task_id !== 'string'
       || !['pending', 'in-progress', 'blocked', 'done'].includes(entry.status)
-      || !expected.has(entry.task_id) || states.has(entry.task_id)) {
+      || states.has(entry.task_id)) {
       fail('STRUCTURE_OVERLAY_INPUT_INVALID', 'task_state_entry_invalid');
     }
     states.set(entry.task_id, entry.status);
   }
-  if (states.size !== expected.size) fail('STRUCTURE_OVERLAY_INPUT_INVALID', 'task_state_coverage_invalid');
+  if ([...expected].some((taskId) => !states.has(taskId))) {
+    fail('STRUCTURE_OVERLAY_INPUT_INVALID', 'task_state_coverage_invalid');
+  }
   return states;
 }
 
@@ -302,7 +304,7 @@ function buildOverlayGraph(structureSet, states, latestRealizations, sourceProje
   return { nodes: uniqueNodes, edges, effective };
 }
 
-function connectionFindings(structureSet, effective, topologyDag) {
+function connectionFindings(structureSet, effective, topologyDag, states) {
   const findings = [];
   const externalById = new Map(structureSet.external_contracts
     .map((external) => [external.contract_id, external]));
@@ -322,7 +324,8 @@ function connectionFindings(structureSet, effective, topologyDag) {
   const structureTaskIds = new Set(structureSet.tasks.map(({ task_id: id }) => id));
   const extraTopologyTasks = topologyDag.nodes
     .filter(({ ref }) => ref.project_id === structureSet.project_id
-      && ref.plan_key === structureSet.plan_key && !structureTaskIds.has(ref.task_id))
+      && ref.plan_key === structureSet.plan_key && !structureTaskIds.has(ref.task_id)
+      && states.get(ref.task_id) !== 'done')
     .map(({ ref }) => ref.task_id).sort(compareText);
   if (extraTopologyTasks.length > 0) findings.push(finding({
     code: 'STRUCTURE_COVERAGE_MISSING', severity: 'error', taskIds: extraTopologyTasks,
@@ -557,7 +560,7 @@ export function compileTodoStructureOverlay({
   const rawFindings = [
     ...anchorFindings(structureSet, sourceProjection),
     ...missingEffectiveAnchors,
-    ...connectionFindings(structureSet, graph.effective, topologyDag),
+    ...connectionFindings(structureSet, graph.effective, topologyDag, states),
     ...realizationFindings(
       structureSet, states, normalizedRealizations, gitProvenance, graph.effective,
     ),