@quolu/lattice 0.62.2 → 0.63.0

package/README.ja.md

@@ -228,6 +228,10 @@ lattice todo start --plan <key> --task <id> --parallel-frontier
 lattice todo start --plan <key> --task <id> --override-reason <reason>
 ```
 
+記録があるのに対象工程が未宣言・失効なら`todo start`は`INDEPENDENCE_UNVERIFIED`で拒否します。
+`independence compile`は`next_ready`がwitnessに無いとき`INDEPENDENCE_READY_UNDECLARED`で拒否します。
+remainingのA工程は同じwitnessへ含めます。競合の同時起動は助言のままです。
+
 `--serial-confirmed`と`--serialization-reviewed`は古い手順の互換として受理しますが、
 再実行の条件ではありません。直列理由の文言を審査して拒否することもありません。
 

package/README.md

@@ -193,6 +193,9 @@ lattice todo seam-proposal land    --plan <key> --names names.json
 parallel set. Starting one of them does not require `--parallel-frontier` or
 `--override-reason`. Those flags record intent; they are not gates.
 `--serial-confirmed` and `--serialization-reviewed` are accepted only for compatibility.
+If an independence record exists but the task is undeclared or stale, `todo start`
+fails with `INDEPENDENCE_UNVERIFIED`. `independence compile` fails with
+`INDEPENDENCE_READY_UNDECLARED` when `next_ready` is missing from the witness.
 
 ```bash
 lattice todo start --plan <key> --task <id>

package/package.json

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

@@ -156,7 +156,9 @@ ${TODO_INDEPENDENCE_WORKFLOW.join('\n')}
 
 判定していない工程は「競合が無い」ではなく「未検査」として扱われ、
 todo startのadvisoryとtodo independenceの投影が、その状況と次の一歩を返す。
-並列既定はstatusのdispatch_frontierとnext_actionが案内する。着手・作成を拒まない。
+記録があるのに対象工程が未宣言・失効なら todo start は拒否する。
+next_ready が witness に無い independence compile も拒否する。
+競合の同時起動は助言のまま。並列既定はstatusのdispatch_frontierとnext_actionが案内する。
 `,
   sensor: `Usage: lattice sensor <init|sync> [path] --json
        lattice sensor diff <rootA> <rootB> [options] --json

package/src/runtime-pull-intake.mjs

@@ -990,9 +990,24 @@ export async function attachPullWorker({ runDir, taskId, input, environment = pr
     const occupied = state.intakes.find((entry) => (
       entry.task_id !== taskId && entry.accepted === null && entry.worker?.pid === input.pid
     ));
-    if (occupied) {
+    if (occupied && occupied.intervention.state !== 'hold') {
       fail('WORKER_ALREADY_ATTACHED', `同じworkerは複数active intakeへattachできない: ${occupied.task_id}`);
     }
+    if (occupied && occupied.intervention.state === 'hold') {
+      if (occupied.worker.stopped) {
+        await signalAttachedWorker(occupied, 'SIGCONT');
+        current = await appendEvent(runDir, current, buildEvent({
+          events: current.events, meta: current.meta, kind: 'worker_resumed',
+          taskId: occupied.task_id, payload: { released_by: 'stale_hold_reattach' },
+        }));
+      }
+      current = await appendEvent(runDir, current, buildEvent({
+        events: current.events, meta: current.meta, kind: 'worker_detached',
+        taskId: occupied.task_id,
+        payload: { detached_by: actor, pid: occupied.worker.pid, resumed: occupied.worker.stopped },
+      }));
+      state = project(current.events, current.meta);
+    }
     if (intake.worker !== null) {
       if (digestArtifact(binding) !== digestArtifact({
         pid: intake.worker.pid, process_group_id: intake.worker.process_group_id,
@@ -1082,6 +1097,11 @@ export async function detachPullWorker({ runDir, taskId, environment = process.e
   } finally { await lock.release(); }
 }
 
+export function concurrentAttachBlocked(occupied) {
+  if (!occupied) return false;
+  return occupied.intervention?.state !== 'hold';
+}
+
 export function remainingRuntimeConflictFindings(findings, acceptedTaskId) {
   if (!Array.isArray(findings)) return [];
   return findings.filter((finding) => !(finding.todo_ids ?? []).includes(acceptedTaskId));

package/src/todo-cli.mjs

@@ -133,8 +133,10 @@ import {
   compileTodoIndependence,
   migrateWitnessSetTaskIds,
   projectIndependenceFrontier,
+  TodoIndependenceError,
 } from './todo-independence.mjs';
 import {
+  independenceStartRefusal,
   selectIndependenceGuidance,
   selectWitnessScaffoldGuidance,
   selectSeamProposalGuidance,
@@ -728,8 +730,9 @@ function designMemoProjection(task) {
 /**
  * 着手しようとしているtaskについて、記録済みの独立性から助言を組む（ADR 0128 Decision 5）。
  *
- * 助言であって拒否ではない。ADR 0063のdispatch契約は変えない。ただし助言を計算できない
- * 状況——git HEADが読めない等——はsilent degradeせず、呼び出し側でstart自体を止める。
+ * どの ready を取るかは助言のまま。記録があるのに対象工程が未検証なら呼び出し側が
+ * start を拒否する（ADR 0182）。助言を計算できない状況——git HEADが読めない等——は
+ * silent degradeせず、呼び出し側でstart自体を止める。
  */
 async function startAdvisory({ repoRoot, store, projection, planKey, taskId }) {
   const artifact = await readTodoIndependenceArtifact({ repoRoot, store, planKey });
@@ -861,6 +864,14 @@ async function startTask({
   const advisory = await startAdvisory({
     repoRoot, store, projection, planKey, taskId: resolvedTaskId,
   });
+  const refusal = independenceStartRefusal(advisory.guidance);
+  if (refusal !== null) {
+    throw new TodoStoreError('INDEPENDENCE_UNVERIFIED', refusal.code, refusal.message, {
+      plan_key: planKey,
+      task_id: resolvedTaskId,
+      next_action: refusal.next_action,
+    });
+  }
   const structureContext = await startStructureContext({
     repoRoot, store, planKey, taskId: resolvedTaskId,
   });
@@ -2388,9 +2399,41 @@ async function structure({ repoRoot, requestedPlanKey }) {
 
 async function independenceCompile({ repoRoot, planKey, inputRef }) {
   const witnessSet = await readWitnessSetInput(repoRoot, inputRef);
+  const storeForReady = await readTodoStore({ repoRoot });
+  const memberForReady = storeForReady.members.find(({ descriptor }) => descriptor.plan_key === planKey);
+  if (!memberForReady) {
+    throw new TodoStoreError('STORE_INCONSISTENT', 'plan_not_active', undefined, { plan_key: planKey });
+  }
+  const planTaskIds = new Set(memberForReady.plan.tasks.map(({ task_id: taskId }) => taskId));
+  const declaredIds = Object.keys(witnessSet.manual_witness ?? {});
+  const absentFromPlan = declaredIds.filter((taskId) => !planTaskIds.has(taskId)).sort();
+  if (absentFromPlan.length > 0) {
+    throw new TodoIndependenceError(
+      'INDEPENDENCE_TASK_ABSENT',
+      'witness_task_absent_from_plan',
+      { task_ids: absentFromPlan },
+    );
+  }
+  const readyIds = projectTodoStatus(storeForReady, TODO_STATUS_DISPATCH_ONLY).next_ready
+    .filter((task) => task.plan_key === planKey)
+    .map((task) => task.task_id);
+  const declared = new Set(declaredIds);
+  const missingReady = readyIds.filter((taskId) => !declared.has(taskId)).sort();
+  if (missingReady.length > 0) {
+    throw new TodoStoreError(
+      'INDEPENDENCE_READY_UNDECLARED',
+      'ready_tasks_missing_from_witness',
+      undefined,
+      {
+        plan_key: planKey,
+        missing_task_ids: missingReady,
+        next_action: 'add_task_to_witness_set_then_compile',
+      },
+    );
+  }
   const observation = await collectTodoIndependenceAuthoritativeObservation({ repoRoot, witnessSet });
   const baseSha = observation.head_sha;
-  const store = await readTodoStore({ repoRoot });
+  const store = storeForReady;
   const member = store.members.find(({ descriptor }) => descriptor.plan_key === planKey);
   if (!member) throw new TodoStoreError('STORE_INCONSISTENT', 'plan_not_active', undefined, { plan_key: planKey });
 

package/src/todo-independence-guidance.mjs

@@ -4,8 +4,10 @@
  * 状況から`{code, message, next_action}`を引く単一正本。advisory・投影・typed error・helpは
  * すべてここから引く。面ごとに文言を書けば必ずずれ、同じ状況に別の説明が付く。
  *
- * 文は事実と次の一歩だけを述べ、指示しない。dispatchの意思決定はhostが所有する
+ * 文は事実と次の一歩だけを述べ、指示しない。どのreadyを取るかはhostが所有する
  * （ADR 0063 Decision 5）。命令形にするとLatticeがagentを統制する面へ滑る。
+ * ただし記録があるのに対象工程が未検証なら start は拒否する（ADR 0182）。
+ * それは配車ではなく、intakeが hold する着手を journal へ書かない。
  */
 
 export const TODO_INDEPENDENCE_GUIDANCE_CODES = Object.freeze([
@@ -81,7 +83,7 @@ const CATALOG = Object.freeze({
     next_action: 'declare_witness_set_then_compile',
   }),
   independence_task_undeclared: Object.freeze({
-    message: 'この工程はwitness setで宣言されていないため、記録には含まれていない。',
+    message: 'この工程はwitness setで宣言されていないため、記録には含まれていない。startは拒否する。',
     next_action: 'add_task_to_witness_set_then_compile',
   }),
   independence_contract_superseded: Object.freeze({
@@ -173,6 +175,27 @@ const SEVERABILITY_HINT = Object.freeze({
   serial: '共有stateまたはeffectの衝突なので、分割では切り離せない。',
 });
 
+/**
+ * 記録があるのに対象工程が未検証なら start を拒否する code。
+ * 記録が無い（independence_unrecorded）は従来どおり助言だけで通す。
+ * 競合（conflict_*）はどの ready を取るかの dispatch なので拒否しない。
+ */
+export const INDEPENDENCE_START_REFUSAL_CODES = Object.freeze([
+  'independence_task_undeclared',
+  'independence_stale_for_task',
+  'independence_superseded',
+  'independence_contract_superseded',
+  'independence_verdicts_absent',
+]);
+
+export function independenceStartRefusal(guidance) {
+  if (guidance === null || typeof guidance !== 'object' || Array.isArray(guidance)) {
+    throw new TypeError('independence start refusal guidance is invalid');
+  }
+  if (!INDEPENDENCE_START_REFUSAL_CODES.includes(guidance.code)) return null;
+  return guidance;
+}
+
 export function todoIndependenceGuidance(code, { severability = null } = {}) {
   const entry = CATALOG[code];
   if (entry === undefined) {
@@ -305,9 +328,11 @@ export function selectSeamProposalGuidance({ coverage, unknownKinds = [] }) {
 export const TODO_INDEPENDENCE_WORKFLOW = Object.freeze([
   '1. 宣言する: .lattice/todo/witness/<plan_key>.json へ、ToDoごとのowns／reads／writes／affected_testsを書く',
   '   係争資源しか所有していないToDoは、ownsまたはwritesの内側で自分が触るsymbolをconcern_anchorsへ宣言できる（witness set v2）。並列可否の判定には写らず、切断候補の束縛だけに効く',
-  '2. 判定する: lattice todo independence compile --plan <key> --input <ref>（実sensorを引く。pretty-printやdigest未計算の下書きは機械が直す）',
+  '   remaining の A 工程（まだ done でない ready / blocked）も同じ witness に含める。現在の ready だけを compile すると、次の frontier の start が INDEPENDENCE_UNVERIFIED になる',
+  '2. 判定する: lattice todo independence compile --plan <key> --input <ref>（実sensorを引く。pretty-printやdigest未計算の下書きは機械が直す）。next_ready が witness に無い compile は拒否する',
   '3. 読む: lattice todo independence --plan <key> --json（sensorを引かず、記録とHEAD照合だけで返る）',
   '4. 追従する: plan改訂後は lattice todo independence witness migrate --plan <key> で宣言を写してから再compileする',
+  '5. 記録があるのに対象工程が未宣言・失効なら todo start は拒否する。競合の同時起動は助言のまま',
 ]);
 
 /**