@quolu/lattice 0.59.0 → 0.60.0

package/src/runtime-engine.mjs

@@ -32,18 +32,10 @@ import {
 
 const ENGINE_ACTOR = 'lattice-runtime';
 /**
- * workerへ配る禁止操作。
- *
- * `commit`は含めない。自分の隔離worktreeでdetached HEADへ進めるcommitは、canonical branchを
- * 動かさず外部へ効果を出さない一方で、進行中の成果を耐久化し、diff観測が生み出した木そのものを
- * 縛れるようにする（ADR 0139）。
- *
- * 禁止のままにするのは、HEADをbaseの子孫から外す操作と、外部へ効果を出す操作である。
- * 前者は観測の前提を壊し、後者は承認なしに行わないという公開契約に当たる。
+ * v1 packetの互換field。操作権限はhostへ委ね、Latticeからは禁止操作を配らない。
+ * worktree観測に必要な前提は、実際のHEADとdiffを観測して判定する（ADR 0178）。
  */
-const FORBIDDEN_OPERATIONS = Object.freeze([
-  'push', 'branch', 'merge', 'rebase', 'reset', 'stash',
-]);
+const FORBIDDEN_OPERATIONS = Object.freeze([]);
 
 function fail(reason) {
   throw new TypeError(`runtime engine契約違反: ${reason}`);

package/src/runtime-pull-intake.mjs

@@ -18,6 +18,7 @@ import {
   BOUNDARY_MANIFEST_SCHEMA, selfDigest, validateRuntimeBoundaryManifest, validateRuntimePlan,
 } from './runtime-contracts.mjs';
 import { TODO_INDEPENDENCE_SCHEMA } from './todo-independence-contracts.mjs';
+import { pullIntakeReadinessGuidance } from './todo-independence-guidance.mjs';
 import {
   readTodoIndependenceArtifact, readTodoStore, readTodoWitnessSet,
 } from './todo-store.mjs';
@@ -315,6 +316,29 @@ function activeMember(store, planKey) {
   return member;
 }
 
+async function pullPlanReadiness({ repoRoot, planKey }) {
+  const store = await readTodoStore({ repoRoot });
+  const member = activeMember(store, planKey);
+  const [artifact, witnessSet] = await Promise.all([
+    readTodoIndependenceArtifact({ repoRoot, store, planKey }),
+    readTodoWitnessSet({ repoRoot, planKey }),
+  ]);
+  const ready = artifact !== null
+    && artifact.schema === TODO_INDEPENDENCE_SCHEMA
+    && artifact.project_id === store.project_id
+    && artifact.plan_key === planKey
+    && artifact.plan_version === member.plan.plan_version
+    && artifact.topology_digest === member.plan.topology_digest
+    && artifact.outcome === 'compiled'
+    && witnessSet?.project_id === store.project_id
+    && witnessSet?.plan_key === planKey
+    && witnessSet?.witness_set_digest === artifact.witness_set_digest;
+  return pullIntakeReadinessGuidance({
+    coordinationMode: member.coordination?.mode ?? null,
+    ready,
+  });
+}
+
 function literalEvent(member, { kind, taskId, actor }) {
   return member.journal?.events?.findLast((event) => (
     event.kind === kind && event.task_id === taskId
@@ -354,6 +378,10 @@ function pathTouches(boundary, changed) {
 }
 
 async function boundaryVerdict({ repoRoot, store, member, meta, taskId, intakeBase }) {
+  const pullRequired = pullIntakeReadinessGuidance({
+    coordinationMode: member.coordination?.mode ?? null,
+    ready: false,
+  });
   let artifact;
   let witnessSet;
   try {
@@ -362,7 +390,7 @@ async function boundaryVerdict({ repoRoot, store, member, meta, taskId, intakeBa
       readTodoWitnessSet({ repoRoot, planKey: meta.plan_key }),
     ]);
   } catch (error) {
-    return { state: 'hold', reason: 'boundary_unverified', next_action: 'recompile_independence',
+    return { state: 'hold', reason: 'boundary_unverified', next_action: pullRequired.next_action,
       detail: { cause: error?.code ?? 'artifact_read_failed' }, artifact: null, witnessSet: null };
   }
   const bindingValid = artifact !== null
@@ -375,11 +403,11 @@ async function boundaryVerdict({ repoRoot, store, member, meta, taskId, intakeBa
     && witnessSet?.plan_key === meta.plan_key
     && witnessSet?.witness_set_digest === artifact.witness_set_digest;
   if (!bindingValid) {
-    return { state: 'hold', reason: 'boundary_unverified', next_action: 'recompile_independence',
+    return { state: 'hold', reason: 'boundary_unverified', next_action: pullRequired.next_action,
       detail: { cause: 'artifact_binding_mismatch' }, artifact, witnessSet };
   }
   if (artifact.outcome !== 'compiled') {
-    return { state: 'hold', reason: 'boundary_unverified', next_action: 'recompile_independence',
+    return { state: 'hold', reason: 'boundary_unverified', next_action: pullRequired.next_action,
       detail: { cause: 'independence_outcome_unknown' }, artifact, witnessSet };
   }
   const boundary = boundaryFor(artifact, taskId);
@@ -603,6 +631,7 @@ export async function startPullRun({ repoRoot, runDir, runId, planKey, equipment
     || !identifier(runId) || !identifier(planKey) || equipment !== 'detached-worktree') {
     fail('INVALID_PULL_START', 'pull start入力が不正');
   }
+  const intakeReadiness = await pullPlanReadiness({ repoRoot, planKey });
   const temporary = await mkdtemp(path.join(path.dirname(runDir), `.${runId}.pull-tmp-`));
   const meta = {
     schema: PULL_RUN_META_SCHEMA,
@@ -634,9 +663,10 @@ export async function startPullRun({ repoRoot, runDir, runId, planKey, equipment
     throw error;
   }
   return {
-    schema: 'lattice.pull_run_start_result.v1',
+    schema: 'lattice.pull_run_start_result.v2',
     outcome: 'started', run_id: runId, plan_key: planKey,
     selection: 'pull', equipment, intake_count: 0,
+    intake_readiness: intakeReadiness,
   };
 }
 

package/src/runtime-work-order-contracts.mjs

@@ -57,7 +57,7 @@ export function validateRunWorkOrder(value) {
     && GIT_SHA1.test(value.base_sha ?? '')
     && stringArray(value.scope_writes, { paths: true })
     && stringArray(value.verifier_refs)
-    && stringArray(value.forbidden_operations, { min: 1 })
+    && stringArray(value.forbidden_operations)
     && SHA256.test(value.packet_digest ?? '')
     && SHA256.test(value.order_digest ?? '')
     && selfDigest(value, 'order_digest') === value.order_digest;

package/src/todo-cli.mjs

@@ -88,6 +88,7 @@ import { compileTodoStructureOverlay } from './todo-structure-overlay.mjs';
 import {
   buildTodoStructureCompileArtifact,
   projectTodoStructureEffective,
+  readTodoStructureArtifactDiagnostics,
   readTodoStructureFinalizationState,
   readTodoStructureFinalizationsForStatus,
   readTodoStructureState,
@@ -97,7 +98,9 @@ import {
   appendTodoExtraction,
   compileTodoExtraction,
   explainTodoExtraction,
+  isTodoExtractionConnectionOnly,
   TODO_EXTRACTION_SCHEMA_V3,
+  TODO_EXTRACTION_SCHEMA_V4,
   validateTodoExtraction,
 } from './todo-migration.mjs';
 import {
@@ -139,6 +142,7 @@ import {
 } from './seam-proposal-contracts.mjs';
 import { compileSeamProposalArtifact, declaredConcernSymbols } from './seam-proposal.mjs';
 import { collectSensorEvidence } from './sensor-adapter.mjs';
+import { collectTodoIndependenceAuthoritativeObservation } from './todo-independence-authoritative-observation.mjs';
 import { applySeamProposal } from './seam-apply.mjs';
 import { todoPlanPrecedences } from './seam-verification.mjs';
 import {
@@ -188,7 +192,7 @@ const TODO_SCHEMA_COMMANDS = Object.freeze({
   'revise-phase': {
     title: 'lattice.phase_todo_revision.v3', file: 'lattice.phase_todo_revision.v3.schema.json',
   },
-  migrate: { title: 'lattice.todo_extraction.v3', file: 'lattice.todo_extraction.v3.schema.json' },
+  migrate: { title: 'lattice.todo_extraction.v4', file: 'lattice.todo_extraction.v4.schema.json' },
   structure: {
     title: 'lattice.todo_structure_set.v1', file: 'lattice.todo_structure_set.v1.schema.json',
   },
@@ -418,9 +422,9 @@ async function readMigrationInput(repoRoot, inputRef, { requireValid = true } =
     throw new TodoStoreError('INVALID_JSON', 'json_parse_failed');
   }
   if (!requireValid) return extraction;
-  if (extraction?.schema !== TODO_EXTRACTION_SCHEMA_V3) {
-    throw new TodoStoreError('DESIGN_MEMO_REQUIRED', 'todo_extraction_v3_required', undefined, {
-      design_memo_prompt: TODO_DESIGN_MEMO_PROMPT,
+  if (![TODO_EXTRACTION_SCHEMA_V3, TODO_EXTRACTION_SCHEMA_V4].includes(extraction?.schema)) {
+    throw new TodoStoreError('INVALID_TODO_EXTRACTION', 'todo_extraction_schema_unsupported', undefined, {
+      expected: TODO_EXTRACTION_SCHEMA_V4,
       next_action: 'lattice todo migrate --schema --json',
     });
   }
@@ -1256,21 +1260,42 @@ async function migrate({ repoRoot, inputRef, serializationReviewed = false }) {
     });
   }
   const registered = extraction.tasks.filter(({ disposition }) => disposition.startsWith('register_'));
-  if (registered.length === 0) throw new TodoStoreError('MIGRATION_EMPTY', 'no_registered_tasks');
+  const connectionOnly = isTodoExtractionConnectionOnly(extraction);
+  if (registered.length === 0 && !connectionOnly) {
+    throw new TodoStoreError('MIGRATION_EMPTY', 'no_registered_tasks');
+  }
 
-  const dispatchShape = computeTodoDispatchShapeForPlan({
+  const dispatchShape = connectionOnly ? null : computeTodoDispatchShapeForPlan({
     projectId: extraction.project_id,
     planKey: extraction.plan_key,
     taskIds: registered.map(({ task_id: taskId }) => taskId),
     hardDependencies: extraction.hard_dependencies,
     joins: extraction.joins,
   });
-  assertTodoDispatchShapeReviewed({ shape: dispatchShape, reviewed: serializationReviewed });
+  if (dispatchShape !== null) {
+    assertTodoDispatchShapeReviewed({ shape: dispatchShape, reviewed: serializationReviewed });
+  }
 
   const imported = await appendTodoExtraction({ repoRoot, extraction });
+  let companion = null;
+  if ((imported.crossPlanDependencies ?? []).length > 0) {
+    const connectedStore = await readTodoStore({ repoRoot });
+    const event = imported.crossPlanDependencies[0];
+    companion = {
+      repair: event.payload.from,
+      target: event.payload.to,
+      reason: event.payload.reason,
+      event_digest: event.event_digest,
+      connected_frontier: computeReadyFrontier(connectedStore),
+      next_action: imported.connectionOnly === true ? 'lattice todo status --json'
+        : isPhaselessTodoPlanSchema(imported.plan.schema)
+        ? `lattice todo revise-phase --plan ${imported.plan.plan_key} --input <phase-revision.json>`
+        : 'lattice todo status --json',
+    };
+  }
   const result = {
-    // ob03: 調整方式の案内をv3で足す。ADR 0054のとおり既存versionへのin-place追加はしない。
-    schema: 'lattice.todo_migrate_result.v3',
+    // companionを足す時点でv4へ上げ、通常移行もnullを常在させてresult shapeを固定する。
+    schema: 'lattice.todo_migrate_result.v4',
     project_id: imported.plan.project_id,
     plan_key: imported.plan.plan_key,
     plan_version: imported.plan.plan_version,
@@ -1282,7 +1307,7 @@ async function migrate({ repoRoot, inputRef, serializationReviewed = false }) {
     snapshot_ref: imported.descriptor.snapshot_ref,
     topology_digest: imported.plan.topology_digest,
     journal_head_digest: imported.events.at(-1).event_digest,
-    dispatch_shape: {
+    dispatch_shape: dispatchShape === null ? null : {
       task_count: dispatchShape.task_count,
       critical_path_length: dispatchShape.critical_path_length,
       max_frontier_width: dispatchShape.max_frontier_width,
@@ -1291,8 +1316,8 @@ async function migrate({ repoRoot, inputRef, serializationReviewed = false }) {
     // ADR 0147裁定3: phase無しplanの作成は拒否せず、終端監査が要ることを結果へ明示するに
     // 留める。extraction経由のmigrateは常にphase無しplan(todo_plan.v2)を作るが、将来の
     // 拡張に備えisPhaselessTodoPlanSchemaで動的に判定する。
-    terminal_audit_required: isPhaselessTodoPlanSchema(imported.plan.schema),
-    phase_guidance: isPhaselessTodoPlanSchema(imported.plan.schema) ? {
+    terminal_audit_required: imported.connectionOnly !== true && isPhaselessTodoPlanSchema(imported.plan.schema),
+    phase_guidance: imported.connectionOnly !== true && isPhaselessTodoPlanSchema(imported.plan.schema) ? {
       capability: 'acquire_phase',
       preserves_completed_state: true,
       schema_command: 'lattice todo revise-phase --schema --json',
@@ -1301,11 +1326,12 @@ async function migrate({ repoRoot, inputRef, serializationReviewed = false }) {
     } : null,
     // ob03: 起票直後のplanは必ず調整方式が未宣言である。ここで案内しないと、選ぶ機会が
     // 「誰も呼ぶ動機の無いdrilldown」にしか無くなる——前campaignの監査待ちと同じ形になる。
-    coordination_guidance: {
+    coordination_guidance: imported.connectionOnly === true ? null : {
       mode: null,
       modes: [...TODO_COORDINATION_MODES],
       next_action: `lattice todo independence mode --plan ${imported.plan.plan_key} --set <witness|conversation> --reason <text>`,
     },
+    companion,
     result_digest: '',
   };
   result.result_digest = todoSelfDigest(result, 'result_digest');
@@ -1399,8 +1425,9 @@ function extractionAuthoringViolations(extraction, now = new Date()) {
   }
   const registered = new Set(tasks.filter(({ disposition }) => typeof disposition === 'string'
     && disposition.startsWith('register_')).map(({ task_id: taskId }) => taskId));
+  const connectionOnly = isTodoExtractionConnectionOnly(extraction);
   const unresolvedLocal = (ref) => ref?.project_id === extraction?.project_id
-    && ref?.plan_key === extraction?.plan_key && !registered.has(ref?.task_id);
+    && ref?.plan_key === extraction?.plan_key && !connectionOnly && !registered.has(ref?.task_id);
   for (const [index, edge] of edges.entries()) {
     for (const side of ['from', 'to']) {
       if (unresolvedLocal(edge?.[side])) {
@@ -1425,12 +1452,15 @@ async function migrateDryRun({ repoRoot, inputRef, serializationReviewed = false
   const extraction = await readMigrationInput(repoRoot, inputRef, { requireValid: false });
   const violations = [];
   const tasks = Array.isArray(extraction?.tasks) ? extraction.tasks : [];
-  const invalidMemos = tasks.map((task, index) => ({
+  const designMemoSchema = [TODO_EXTRACTION_SCHEMA_V3, TODO_EXTRACTION_SCHEMA_V4].includes(extraction?.schema);
+  const invalidMemos = (designMemoSchema ? tasks : []).map((task, index) => ({
     task, index, explained: explainTodoDesignMemo(task?.design_memo),
   })).filter(({ explained }) => !explained.valid).slice(0, 64);
-  if (extraction?.schema !== TODO_EXTRACTION_SCHEMA_V3) {
+  const supportedSchema = [TODO_EXTRACTION_SCHEMA_V3, TODO_EXTRACTION_SCHEMA_V4]
+    .includes(extraction?.schema);
+  if (!supportedSchema) {
     violations.push({ code: 'schema_retired', path: '/schema', task_ids: [],
-      expected: TODO_EXTRACTION_SCHEMA_V3,
+      expected: TODO_EXTRACTION_SCHEMA_V4,
       actual: typeof extraction?.schema === 'string' ? extraction.schema
         : { type: typeof extraction?.schema },
       next_action: 'lattice todo migrate --schema --json' });
@@ -1441,8 +1471,7 @@ async function migrateDryRun({ repoRoot, inputRef, serializationReviewed = false
       expected: explained.expected, actual: explained.actual,
       prompt: TODO_DESIGN_MEMO_PROMPT, next_action: 'lattice todo migrate --schema --json' });
   }
-  const schemaValid = extraction?.schema === TODO_EXTRACTION_SCHEMA_V3
-    && validateTodoExtraction(extraction);
+  const schemaValid = supportedSchema && validateTodoExtraction(extraction);
   if (!schemaValid) {
     const explained = explainTodoExtraction(extraction);
     if (!explained.valid && !explained.path.endsWith('/design_memo')) {
@@ -1467,28 +1496,38 @@ async function migrateDryRun({ repoRoot, inputRef, serializationReviewed = false
   }
   const registered = tasks.filter(({ disposition }) => typeof disposition === 'string'
     && disposition.startsWith('register_'));
-  if (registered.length === 0) {
+  const connectionOnly = schemaValid && isTodoExtractionConnectionOnly(extraction);
+  if (registered.length === 0 && !connectionOnly) {
     violations.push({ code: 'no_registered_tasks', path: '/tasks', task_ids: [],
       next_action: 'register_at_least_one_task' });
   }
 
   let dispatchShape = null;
   let plannedPlan = null;
-  if (schemaValid && unresolvedTaskIds.length === 0 && registered.length > 0) {
+  let plannedConnection = null;
+  if (schemaValid && unresolvedTaskIds.length === 0 && (registered.length > 0 || connectionOnly)) {
     try {
       const compiled = compileTodoExtraction(extraction, repoRoot);
-      plannedPlan = buildTodoPlan(compiled.plan);
-      dispatchShape = computeTodoDispatchShapeForPlan({
-        projectId: extraction.project_id, planKey: extraction.plan_key,
-        taskIds: registered.map(({ task_id: taskId }) => taskId),
-        hardDependencies: extraction.hard_dependencies, joins: extraction.joins,
-      });
-      try {
-        assertTodoDispatchShapeReviewed({ shape: dispatchShape, reviewed: serializationReviewed });
-      } catch (error) {
-        violations.push({ code: error?.detail?.reason ?? 'plan_shape_too_serial', path: '/hard_dependencies',
-          task_ids: error?.detail?.critical_path_task_ids ?? [],
-          next_action: 'reconsider_parallel_seams_or_pass_serialization_reviewed' });
+      if (connectionOnly) {
+        plannedConnection = {
+          source: compiled.crossPlanDependencies[0].from,
+          target: compiled.crossPlanDependencies[0].to,
+          reason: compiled.crossPlanDependencies[0].reason,
+        };
+      } else {
+        plannedPlan = buildTodoPlan(compiled.plan);
+        dispatchShape = computeTodoDispatchShapeForPlan({
+          projectId: extraction.project_id, planKey: extraction.plan_key,
+          taskIds: registered.map(({ task_id: taskId }) => taskId),
+          hardDependencies: extraction.hard_dependencies, joins: extraction.joins,
+        });
+        try {
+          assertTodoDispatchShapeReviewed({ shape: dispatchShape, reviewed: serializationReviewed });
+        } catch (error) {
+          violations.push({ code: error?.detail?.reason ?? 'plan_shape_too_serial', path: '/hard_dependencies',
+            task_ids: error?.detail?.critical_path_task_ids ?? [],
+            next_action: 'reconsider_parallel_seams_or_pass_serialization_reviewed' });
+        }
       }
     } catch (error) {
       plannedPlan = null;
@@ -1523,13 +1562,19 @@ async function migrateDryRun({ repoRoot, inputRef, serializationReviewed = false
   }
   const bounded = violations.slice(0, 64);
   const result = {
-    schema: 'lattice.todo_migrate_dry_run_result.v1',
+    schema: 'lattice.todo_migrate_dry_run_result.v2',
     valid: bounded.length === 0,
     project_id: isTodoIdentifier(extraction?.project_id) ? extraction.project_id : null,
     plan_key: isTodoIdentifier(extraction?.plan_key) ? extraction.plan_key : null,
     violations: bounded,
     overflow_count: Math.max(0, violations.length - bounded.length),
-    planned: plannedPlan === null ? null : {
+    planned: plannedConnection !== null ? {
+      connection_only: true,
+      source: plannedConnection.source,
+      target: plannedConnection.target,
+      reason: plannedConnection.reason,
+    } : plannedPlan === null ? null : {
+      connection_only: false,
       plan_schema: plannedPlan.schema,
       task_count: registered.length,
       topology_digest: plannedPlan.topology_digest,
@@ -1649,13 +1694,15 @@ async function splitTodo({ repoRoot, env, planKey, inputRef }) {
 
 async function status({ repoRoot }) {
   const store = await readTodoStore({ repoRoot });
-  return projectTodoStatus(store, {
+  const result = projectTodoStatus(store, {
     planNotes: await readTodoPlanNotesForStatus({ repoRoot, store }),
     parallelCandidates: await readTodoParallelCandidatesForStatus({
       repoRoot, store, gitHead: currentHeadSha, changedPathsSince,
     }),
     structureFinalizations: await readTodoStructureFinalizationsForStatus({ repoRoot, store }),
   });
+  result.result_digest = todoSelfDigest(result, 'result_digest');
+  return result;
 }
 
 async function adoptDashboardRoot({ repoRoot, env }) {
@@ -2468,8 +2515,8 @@ async function structure({ repoRoot, requestedPlanKey }) {
 
 async function independenceCompile({ repoRoot, planKey, inputRef }) {
   const witnessSet = await readWitnessSetInput(repoRoot, inputRef);
-  requireCleanWorktree(repoRoot);
-  const baseSha = currentHeadSha(repoRoot);
+  const observation = await collectTodoIndependenceAuthoritativeObservation({ repoRoot, witnessSet });
+  const baseSha = observation.head_sha;
   const store = await readTodoStore({ repoRoot });
   const member = store.members.find(({ descriptor }) => descriptor.plan_key === planKey);
   if (!member) throw new TodoStoreError('STORE_INCONSISTENT', 'plan_not_active', undefined, { plan_key: planKey });
@@ -2484,7 +2531,7 @@ async function independenceCompile({ repoRoot, planKey, inputRef }) {
     plan: member.plan,
     baseSha,
     compiledAt: new Date().toISOString(),
-    sensorEvidence: await collectWitnessSensorEvidence({ cwd: repoRoot, witnessSet }),
+    sensorEvidence: observation.sensor_evidence,
     previousArtifact,
   });
   const { ref } = await writeTodoIndependenceArtifact({ repoRoot, artifact });
@@ -3555,6 +3602,20 @@ async function verify({ repoRoot, requestedPlanKey }) {
       },
     };
   });
+  const structureDiagnostics = [];
+  for (const member of members) {
+    const diagnostics = await readTodoStructureArtifactDiagnostics({
+      repoRoot,
+      store: { ...store, members: [member] },
+    });
+    structureDiagnostics.push(...diagnostics);
+  }
+  if (structureDiagnostics.length > 0) {
+    throw new TodoStoreError(
+      'STRUCTURE_ARTIFACT_INVALID', structureDiagnostics[0].reason, undefined,
+      { diagnostics: structureDiagnostics },
+    );
+  }
   const result = {
     schema: 'lattice.todo_verify_result.v3',
     project_id: store.project_id,
@@ -3857,10 +3918,13 @@ export async function runTodoCli({ argv, cwd, stdout, stderr, env = process.env
     action = (repoRoot) => migrateDryRun({
       repoRoot, inputRef: argv[2], serializationReviewed: argv.length === 6,
     });
-  } else if ((argv.length === 3 || argv.length === 4) && argv[0] === 'migrate' && argv[1] === '--input'
-    && isTodoRef(argv[2]) && (argv.length === 3 || argv[3] === '--serialization-reviewed')) {
+  } else if ((argv.length === 3 || argv.length === 4 || argv.length === 5)
+    && argv[0] === 'migrate' && argv[1] === '--input' && isTodoRef(argv[2])
+    && (argv.length === 3
+      || (argv.length === 4 && ['--json', '--serialization-reviewed'].includes(argv[3]))
+      || (argv.length === 5 && argv[3] === '--serialization-reviewed' && argv[4] === '--json'))) {
     action = (repoRoot) => migrate({
-      repoRoot, inputRef: argv[2], serializationReviewed: argv.length === 4,
+      repoRoot, inputRef: argv[2], serializationReviewed: argv[3] === '--serialization-reviewed',
     });
   } else if (argv.length === 5 && argv[0] === 'revise'
     && argv[1] === '--plan' && isTodoIdentifier(argv[2])

package/src/todo-independence-authoritative-observation.mjs

@@ -0,0 +1,116 @@
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+
+import { gitSpawnSync } from './git-process.mjs';
+import { runSensorCli } from './sensor-cli.mjs';
+import { collectWitnessSensorEvidence } from './todo-independence.mjs';
+
+export class TodoIndependenceObservationError extends Error {
+  constructor(code, reason, detail = {}) {
+    super(reason);
+    this.name = 'TodoIndependenceObservationError';
+    this.code = code;
+    this.detail = { reason, ...detail };
+  }
+}
+
+function fail(code, reason, detail = {}) {
+  throw new TodoIndependenceObservationError(code, reason, detail);
+}
+
+function git({ cwd, args, operation }) {
+  const result = gitSpawnSync(args, {
+    cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  if (result.error !== undefined || result.status !== 0 || result.signal !== null) {
+    fail('INDEPENDENCE_OBSERVATION_GIT_FAILED', 'observation_git_command_failed', {
+      operation, status: result.status ?? null, signal: result.signal ?? null,
+      cause: result.error?.message ?? null,
+    });
+  }
+  return result.stdout.trim();
+}
+
+function memoryStream() {
+  let value = '';
+  return {
+    stream: { write: (chunk) => { value += String(chunk); } },
+    read: () => value,
+  };
+}
+
+async function initializeSensor(observationRoot) {
+  const stdout = memoryStream();
+  const stderr = memoryStream();
+  const status = await runSensorCli({
+    argv: ['init', observationRoot, '--json'],
+    stdout: stdout.stream,
+    stderr: stderr.stream,
+  });
+  if (status !== 0) {
+    fail('INDEPENDENCE_OBSERVATION_SENSOR_INIT_FAILED', 'observation_sensor_init_failed', {
+      sensor_error: stderr.read(),
+    });
+  }
+}
+
+/** 共有repoのdirtyな状態を観測せず、current HEADのclean worktreeでsensorを実行する。 */
+export async function collectTodoIndependenceAuthoritativeObservation({ repoRoot, witnessSet } = {}) {
+  if (typeof repoRoot !== 'string' || repoRoot.length === 0
+    || witnessSet === null || typeof witnessSet !== 'object') {
+    fail('INDEPENDENCE_OBSERVATION_INPUT_INVALID', 'observation_input_invalid');
+  }
+
+  const headSha = git({
+    cwd: repoRoot, args: ['rev-parse', '--verify', 'HEAD^{commit}'], operation: 'resolve_head',
+  });
+  const temporaryRoot = await mkdtemp(path.join(tmpdir(), 'lattice-independence-observation-'));
+  const observationRoot = path.join(temporaryRoot, 'worktree');
+  let registered = false;
+  let operationError = null;
+  let result;
+  try {
+    git({
+      cwd: repoRoot,
+      args: ['worktree', 'add', '--detach', '--quiet', observationRoot, headSha],
+      operation: 'worktree_add',
+    });
+    registered = true;
+    const observedHead = git({
+      cwd: observationRoot, args: ['rev-parse', '--verify', 'HEAD^{commit}'],
+      operation: 'verify_observation_head',
+    });
+    if (observedHead !== headSha) {
+      fail('INDEPENDENCE_OBSERVATION_HEAD_MISMATCH', 'observation_head_mismatch', {
+        expected_head_sha: headSha, actual_head_sha: observedHead,
+      });
+    }
+    await initializeSensor(observationRoot);
+    result = await collectWitnessSensorEvidence({ cwd: observationRoot, witnessSet });
+  } catch (error) {
+    operationError = error;
+  }
+
+  let cleanupError = null;
+  try {
+    if (registered) {
+      git({
+        cwd: repoRoot,
+        args: ['worktree', 'remove', '--force', observationRoot],
+        operation: 'worktree_remove',
+      });
+    }
+    await rm(temporaryRoot, { recursive: true, force: true });
+  } catch (error) {
+    cleanupError = error;
+  }
+  if (cleanupError !== null) {
+    fail('INDEPENDENCE_OBSERVATION_CLEANUP_FAILED', 'observation_cleanup_failed', {
+      operation_error: operationError?.message ?? null,
+      cleanup_error: cleanupError?.message ?? String(cleanupError),
+    });
+  }
+  if (operationError !== null) throw operationError;
+  return { head_sha: headSha, sensor_evidence: result };
+}

package/src/todo-independence-guidance.mjs

@@ -154,6 +154,19 @@ const CATALOG = Object.freeze({
   }),
 });
 
+const PULL_INTAKE_READINESS = Object.freeze({
+  required: Object.freeze({
+    code: 'pull_independence_required',
+    message: 'pull設備のintakeには有効なindependence artifactが必須である。conversation調整はwitness督促を消すが、この実行前提は満たさない。',
+    next_action: 'compile_independence_or_choose_non_pull_execution',
+  }),
+  ready: Object.freeze({
+    code: 'pull_independence_ready',
+    message: 'pull設備が読むplan-level independence bindingは有効である。task固有境界とruntime競合はintake時に検査する。',
+    next_action: 'none',
+  }),
+});
+
 /** 切断可能性の言い換え。conflictの案内へ添える。 */
 const SEVERABILITY_HINT = Object.freeze({
   code_seam: 'symbol／pathの衝突なので、境界を分けるrefactorで並列化しうる。記録済みの競合からseam-proposal compileを検討できる。',
@@ -173,6 +186,18 @@ export function todoIndependenceGuidance(code, { severability = null } = {}) {
   };
 }
 
+export function pullIntakeReadinessGuidance({ coordinationMode = null, ready }) {
+  if (![null, 'witness', 'conversation'].includes(coordinationMode)
+    || typeof ready !== 'boolean') {
+    throw new TypeError('pull intake readiness input is invalid');
+  }
+  return {
+    ...(ready ? PULL_INTAKE_READINESS.ready : PULL_INTAKE_READINESS.required),
+    plan_binding_ready: ready,
+    coordination_mode: coordinationMode,
+  };
+}
+
 /**
  * 記録済みの宣言膨張を、AIが分割を検討するための助言へ写す。
  *