@quolu/lattice 0.15.0 → 0.17.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quolu/lattice",
-  "version": "0.15.0",
+  "version": "0.17.0",
   "description": "Lattice — phase-aware TODO graph compiler and conflict-aware orchestration runtime",
   "type": "module",
   "license": "MIT",
@@ -62,6 +62,7 @@
     "precheck": "node --check src/bridge-launch-agent.mjs",
     "check": "node --check bin/lattice.mjs && node --check bin/lattice-mcp.mjs && node --check bin/lattice-dashboard.mjs && node --check bin/lattice-bridge.mjs && node --check bin/lattice-scripted-adapter.mjs && node --check src/cli-stdio.mjs && node --check src/bridge-address.mjs && node --check src/bridge-registrar.mjs && node --check src/todo-independence-guidance.mjs && node --check src/todo-independence.mjs && node --check src/todo-independence-contracts.mjs && node --check src/seam-proposal-contracts.mjs && node --check src/seam-proposal-queries.mjs && node --check src/seam-proposal.mjs && node --check src/todo-gantt-layout.mjs && node --check src/todo-gantt-scope.mjs && node --check src/bridge-config.mjs && node --check src/bridge-server.mjs && node --check src/bridge-daemon.mjs && node --check src/bridge-cli.mjs && node --check src/project-cli.mjs && node --check src/sensor-cli.mjs && node --check src/sensor-runtime.mjs && node --check src/sensor-adapter.mjs && node --check src/factory-diagnostics.mjs && node --check src/runtime-errors.mjs && node --check src/runtime-contracts.mjs && node --check src/runtime-event-store.mjs && node --check src/runtime-adapter-registry.mjs && node --check src/runtime-scripted-adapter-controller.mjs && node --check src/hash-chain.mjs && node --check src/dag-chain.mjs && node --check src/todo-contracts.mjs && node --check src/todo-chain.mjs && node --check src/todo-store.mjs && node --check src/todo-migration.mjs && node --check src/todo-revision.mjs && node --check src/todo-status.mjs && node --check src/todo-cli.mjs && node --check src/todo-dashboard-registry.mjs && node --check src/todo-gantt-presentation.mjs && node --check src/todo-gantt-live.mjs && node --check src/bounded-seam.mjs && node --check src/todo-narrative-anchor.mjs && node --check src/todo-markdown-renderer.mjs && node --check src/todo-gantt-svg.mjs && node --check src/todo-gantt-html.mjs && node --check src/runtime-projection.mjs && node --check src/runtime-decision-verifier.mjs && node --check src/runtime-front-end.mjs && node --check src/runtime-cli.mjs && node --check src/rc3-dogfood-scaffold.mjs && node --check src/runtime-engine.mjs && node --check src/runtime-scripted-executor.mjs && node --check src/runtime-diff-observer.mjs && node --check src/runtime-worktree-executor.mjs && node --check src/runtime-hold-recompile.mjs && node --check src/rc3-scripted-campaign.mjs && node --check src/rc3-actual-dogfood.mjs && node --check src/rc4-stage1-dogfood.mjs && node --check research/fixtures/dispatch-record/src/dispatch-record.mjs && node --check test/research-dispatch-record.test.mjs",
     "check:project-identity": "node --check src/project-identity.mjs",
-    "ci": "npm run test && npm run test:sensor && npm run check && npm run check:project-identity"
+    "ci": "npm run test && npm run test:sensor && npm run check && npm run check:project-identity && npm run verify:todo-store",
+    "verify:todo-store": "node bin/lattice.mjs todo verify --json"
   }
 }

package/src/bridge-daemon.mjs

@@ -17,6 +17,9 @@ const STOP_REQUEST_SCHEMA = 'lattice.bridge_stop_request.v1';
 const STOP_RECEIPT_SCHEMA = 'lattice.bridge_stop_receipt.v1';
 const ACTIVE_MARKER_SCHEMA = 'lattice.bridge_daemon_active.v1';
 const CONTROL_MAX_BYTES = 65_536;
+/** control fileの差し替え競合だけを吸収する再読の上限と間隔（`readStrictJson`が唯一の使用者）。 */
+const CONTROL_READ_RETRY_LIMIT = 5;
+const CONTROL_READ_RETRY_DELAY_MS = 20;
 
 export function bridgeDaemonDescriptorPath(env = process.env) {
   return path.join(bridgeConfigPaths(env).root, 'bridge-daemon.json');
@@ -66,7 +69,16 @@ function isIsoTimestamp(value) {
   try { return new Date(value).toISOString() === value; } catch { return false; }
 }
 
-async function readStrictJson(ref, code, label) {
+/** 読み取り中の差し替え・消失につけるmarker。内容の異常と同じ顔をさせない。 */
+const CONTROL_READ_RACE = Symbol('bridge_control_read_race');
+
+function controlReadRace(message) {
+  const error = new Error(message);
+  error[CONTROL_READ_RACE] = true;
+  return error;
+}
+
+async function readStrictJsonOnce(ref, label) {
   let before;
   let handle;
   try {
@@ -77,12 +89,12 @@ async function readStrictJson(ref, code, label) {
     const opened = await handle.stat();
     if (!opened.isFile() || opened.dev !== before.dev || opened.ino !== before.ino
       || opened.size !== before.size || opened.size > CONTROL_MAX_BYTES) {
-      throw new Error(`${label} changed during validation`);
+      throw controlReadRace(`${label} changed during validation`);
     }
     const text = await handle.readFile('utf8');
     const after = await lstat(ref);
     if (after.dev !== opened.dev || after.ino !== opened.ino || after.size !== opened.size) {
-      throw new Error(`${label} changed during read`);
+      throw controlReadRace(`${label} changed during read`);
     }
     const errors = [];
     const tree = parseTree(text, errors, { allowTrailingComma: false, disallowComments: true });
@@ -91,11 +103,37 @@ async function readStrictJson(ref, code, label) {
     }
     return JSON.parse(text);
   } catch (error) {
-    if (error?.code === 'ENOENT' && before === undefined) return null;
-    throw new BridgeConfigError(code, `${label} invalid`, undefined, error);
+    // 最初のlstatで無い＝未起動。読み始めた後に消えたのは停止との競合で、再読でnullへ落ち着く。
+    if (error?.code === 'ENOENT') {
+      if (before === undefined) return null;
+      throw controlReadRace(`${label} removed during read`);
+    }
+    throw error;
   } finally { await handle?.close(); }
 }
 
+/**
+ * 公開はatomic renameなので、読み手はinodeの差し替えに必ず出会う。差し替えを跨いだ読みは
+ * 内容の異常ではなく再読で解ける競合であり、壊れたcontrol fileと同じerrorにしてはならない。
+ *
+ * 再試行するのは`CONTROL_READ_RACE`が付いた3条件だけである——検証中のinode／size変化、
+ * 読み取り中のinode／size変化、最初のlstat後の消失。最大`CONTROL_READ_RETRY_LIMIT`回、
+ * 間隔`CONTROL_READ_RETRY_DELAY_MS`で再読し、超えたら他と同じtyped errorで落とす。
+ * JSON不正・schema不正・mode不正は競合ではないので一度も再試行せず即fail closedにする。
+ */
+async function readStrictJson(ref, code, label) {
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      return await readStrictJsonOnce(ref, label);
+    } catch (error) {
+      if (error?.[CONTROL_READ_RACE] !== true || attempt >= CONTROL_READ_RETRY_LIMIT) {
+        throw new BridgeConfigError(code, `${label} invalid`, undefined, error);
+      }
+      await new Promise((resolve) => setTimeout(resolve, CONTROL_READ_RETRY_DELAY_MS));
+    }
+  }
+}
+
 async function readStrictControl(ref, schema, keys) {
   const value = await readStrictJson(ref, 'BRIDGE_STOP_CONTROL_INVALID', 'bridge stop control');
   if (value === null) return null;

package/src/seam-proposal-contracts.mjs

@@ -15,7 +15,10 @@ import {
   isGitSha,
   severabilityOfConflictKind,
 } from './todo-independence-contracts.mjs';
-import { SEAM_PROPOSAL_GUIDANCE_CODES } from './todo-independence-guidance.mjs';
+import {
+  SEAM_PROPOSAL_GUIDANCE_CODES,
+  seamProposalGuidanceCode,
+} from './todo-independence-guidance.mjs';
 
 export const SEAM_PROPOSAL_SCHEMA = 'lattice.seam_proposal.v1';
 export const SEAM_PROPOSAL_PROJECTION_SCHEMA = 'lattice.seam_proposal_projection.v1';
@@ -309,19 +312,21 @@ export function validateSeamProposal(value) {
   }
 }
 
-const PROJECTION_GUIDANCE_BY_COVERAGE = Object.freeze({
-  missing: 'seam_proposal_unrecorded',
-  stale: 'seam_proposal_stale',
-  superseded: 'seam_proposal_superseded',
-  verified: 'seam_proposal_verified',
-});
-
-function projectionGuidance(value, coverage) {
-  return exactRecord(value, ['code', 'message', 'next_action'])
-    && SEAM_PROPOSAL_GUIDANCE_CODES.includes(value.code)
-    && value.code === PROJECTION_GUIDANCE_BY_COVERAGE[coverage]
-    && boundedText(value.message)
-    && isTodoIdentifier(value.next_action);
+/**
+ * 案内は、鮮度と載っているunknownから一意に決まる。生成側の文言をそのまま載せる規約なので
+ * shapeだけを見ると、投影が状況と噛み合わない案内を載せても通ってしまう。codeは規則正本へ
+ * 引き直して照合する（ADR 0130 Decision 1・2）。
+ */
+function projectionGuidance(value, coverage, components) {
+  if (!exactRecord(value, ['code', 'message', 'next_action'])
+    || !SEAM_PROPOSAL_GUIDANCE_CODES.includes(value.code)
+    || !boundedText(value.message)
+    || !isTodoIdentifier(value.next_action)) return false;
+  const unknownKinds = Array.isArray(components)
+    ? components.flatMap((component) => (Array.isArray(component?.unknowns)
+      ? component.unknowns.map((unknown) => unknown?.kind) : []))
+    : [];
+  return value.code === seamProposalGuidanceCode({ coverage, unknownKinds });
 }
 
 function projectionComponent(value) {
@@ -383,7 +388,7 @@ export function validateSeamProposalProjection(value) {
       || !isTodoIdentifier(value.plan_key)
       || !TODO_INDEPENDENCE_COVERAGE.includes(value.coverage)
       || !isGitSha(value.current_base_sha)
-      || !projectionGuidance(value.guidance, value.coverage)
+      || !projectionGuidance(value.guidance, value.coverage, value.components)
       || !isTodoDigest(value.result_digest)) return false;
 
     if (value.coverage === 'missing') {

package/src/seam-proposal-queries.mjs

@@ -129,13 +129,30 @@ function assertRuntimeQuerySet(querySet) {
   }
 }
 
+function assertConcernSymbols(concernSymbols) {
+  if (!Array.isArray(concernSymbols) || concernSymbols.length > QUERY_LIMIT) {
+    fail('SEAM_QUERY_CONCERN_SYMBOLS_INVALID', 'concern_symbols_not_bounded_array');
+  }
+  for (const symbol of concernSymbols) {
+    if (!boundedText(symbol, 1_024)) {
+      fail('SEAM_QUERY_CONCERN_SYMBOL_INVALID', 'concern_symbol_invalid');
+    }
+  }
+  return sortedUnique(concernSymbols);
+}
+
 /**
  * Build the schema-less `lattice.run_request.v1.sensor_query_set` vocabulary used by
  * todo-independence. The wrapper records non-code conflicts without putting their targets
  * on the sensor command line.
+ *
+ * `concernSymbols` are the symbol names declared through witness `concern_anchors`. They only
+ * need the `query` operation: the binder asks whether the declared name resolves to exactly one
+ * symbol, and where it lives. Graph expansion stays owned by the conflict resources.
  */
-export function buildSeamProposalQuerySet({ conflictResources } = {}) {
+export function buildSeamProposalQuerySet({ conflictResources, concernSymbols = [] } = {}) {
   const resources = assertConflictResources(conflictResources);
+  const concerns = assertConcernSymbols(concernSymbols);
   const queryById = new Map([[
     'seam-00-status',
     { id: 'seam-00-status', operation: 'status' },
@@ -168,6 +185,13 @@ export function buildSeamProposalQuerySet({ conflictResources } = {}) {
     }
   }
 
+  // 宣言concern symbolの解決query。conflict symbolと同名なら既存queryがそのまま答えになる。
+  for (const symbol of concerns) {
+    const id = queryId('query', 'symbol', symbol);
+    if (queryById.has(id)) continue;
+    queryById.set(id, { id, operation: 'query', target: symbol });
+  }
+
   const querySet = {
     queries: [...queryById.values()]
       .sort((left, right) => compareText(left.id, right.id)),

package/src/seam-proposal.mjs

@@ -755,6 +755,122 @@ export function verifyVirtualCompileReceipt({ verification, ...options } = {}) {
   };
 }
 
+/** 宣言されたconcern symbolを、`query` operationの解決receiptから探す。 */
+function resolvedSymbolPath(queries, name) {
+  const receipt = queries.find((query) => (
+    query.operation === 'query'
+      && query.target === name
+      && query.outcome === 'resolved'
+      && query.resolved_name === name
+      && typeof query.resolved_path === 'string'
+      && query.resolved_path.length > 0
+  ));
+  return receipt === undefined ? null : receipt.resolved_path;
+}
+
+function pathContains(resourcePath, symbolPath) {
+  return resourcePath.endsWith('/')
+    ? symbolPath.startsWith(resourcePath)
+    : symbolPath === resourcePath;
+}
+
+/**
+ * Resolve declared concern anchors against fresh sensor evidence.
+ *
+ * A declaration only becomes a binding anchor when the sensor resolves the exact name to exactly
+ * one path and that path lies inside the declared resource. Fuzzy resolution to a neighbouring
+ * symbol, an absent name, or a symbol living outside the contested resource yields a typed
+ * unknown instead — a wrong declaration must never widen what the binder believes it knows.
+ *
+ * Two ToDos claiming the same symbol is a contradiction in the declarations themselves, not a cut
+ * to be discovered: the anchor is dropped from both and reported, so neither side can be bound by
+ * a claim the other also makes.
+ */
+export function resolveConcernAnchors({ manualWitness, taskIds, evidence } = {}) {
+  if (!plainRecord(manualWitness) || !Array.isArray(taskIds) || !plainRecord(evidence)) {
+    fail('concern anchor resolution input shapeが不正');
+  }
+  // receiptが1件も無い証拠は「解決しなかった」であって、宣言を素通しさせる理由にはしない。
+  const queries = Array.isArray(evidence.queries) ? evidence.queries : [];
+  const anchorsByTask = new Map();
+  const unknowns = [];
+  for (const taskId of taskIds) {
+    const anchors = [];
+    for (const entry of manualWitness[taskId]?.concern_anchors ?? []) {
+      const resourcePath = entry.within.kind === 'path'
+        ? entry.within.target
+        : resolvedSymbolPath(queries, entry.within.target);
+      if (resourcePath === null) {
+        unknowns.push({
+          kind: 'concern_anchor_resource_unresolved',
+          ref: `${taskId}:${entry.within.kind}:${entry.within.target}`,
+        });
+        continue;
+      }
+      for (const symbol of entry.symbols) {
+        const symbolPath = resolvedSymbolPath(queries, symbol);
+        if (symbolPath === null) {
+          unknowns.push({ kind: 'concern_anchor_unresolved', ref: `${taskId}:${symbol}` });
+          continue;
+        }
+        if (!pathContains(resourcePath, symbolPath)) {
+          unknowns.push({
+            kind: 'concern_anchor_outside_resource',
+            ref: `${taskId}:${symbol}:${symbolPath}`,
+          });
+          continue;
+        }
+        anchors.push(`concern:${symbolPath}\0${symbol}`);
+      }
+    }
+    anchorsByTask.set(taskId, sortedUnique(anchors));
+  }
+
+  // 同じsymbolを2 task以上が担当と主張したら、どちらの束縛根拠にもしない。
+  const claimantsByAnchor = new Map();
+  for (const [taskId, anchors] of anchorsByTask) {
+    for (const anchor of anchors) {
+      if (!claimantsByAnchor.has(anchor)) claimantsByAnchor.set(anchor, []);
+      claimantsByAnchor.get(anchor).push(taskId);
+    }
+  }
+  const overlapping = new Set();
+  for (const [anchor, claimants] of claimantsByAnchor) {
+    if (claimants.length < 2) continue;
+    overlapping.add(anchor);
+    const [path, symbol] = anchor.slice('concern:'.length).split('\0');
+    unknowns.push({
+      kind: 'concern_anchor_overlap',
+      ref: `${[...claimants].sort(compareText).join(',')}:${path}:${symbol}`,
+    });
+  }
+  if (overlapping.size > 0) {
+    for (const [taskId, anchors] of anchorsByTask) {
+      anchorsByTask.set(taskId, anchors.filter((anchor) => !overlapping.has(anchor)));
+    }
+  }
+
+  return {
+    anchorsByTask,
+    unknowns: unknowns.sort((left, right) => compareText(
+      `${left.kind}\0${left.ref}`, `${right.kind}\0${right.ref}`,
+    )),
+  };
+}
+
+/** witness set全体から、sensorへ問い合わせるconcern symbol名を集める。 */
+export function declaredConcernSymbols(manualWitness) {
+  if (!plainRecord(manualWitness)) fail('manual witness shapeが不正');
+  const names = [];
+  for (const witness of Object.values(manualWitness)) {
+    for (const entry of witness?.concern_anchors ?? []) {
+      names.push(...entry.symbols);
+      if (entry.within.kind === 'symbol') names.push(entry.within.target);
+    }
+  }
+  return sortedUnique(names);
+}
+
 function uniqueIntentAnchors(manualWitness, taskIds) {
   const anchorsByTask = new Map();
   const counts = new Map();
@@ -1008,6 +1124,12 @@ function canonicalPartitions(partitions) {
 }
 
 function anchorMatchesNode(anchor, node) {
+  if (anchor.startsWith('concern:')) {
+    const separator = anchor.indexOf('\0');
+    return node.kind === 'symbol'
+      && node.path === anchor.slice('concern:'.length, separator)
+      && node.target === anchor.slice(separator + 1);
+  }
   if (anchor.startsWith('owns:symbol\0')) {
     return node.kind === 'symbol' && node.target === anchor.slice('owns:symbol\0'.length);
   }
@@ -1021,18 +1143,32 @@ function anchorMatchesNode(anchor, node) {
   return false;
 }
 
-function bindSkeleton({ skeleton, graph, intentAnchors, taskIds }) {
+/**
+ * Bind tasks to partitions.
+ *
+ * Declared concern anchors take precedence over the coarse owns/writes/test anchors within one
+ * skeleton: a ToDo that named the symbols it touches inside the contested resource has given
+ * strictly more specific evidence than "it owns some file". The coarse anchors stay as the
+ * fallback for skeletons the declaration says nothing about, so declaring a concern for one
+ * conflict never blinds the binder to another.
+ */
+function bindSkeleton({ skeleton, graph, intentAnchors, concernAnchors, taskIds }) {
   const nodeByKey = new Map(graph.nodes.map((node) => [graphNodeKey(node), node]));
   const taskBindings = [];
   const unknowns = [];
-  for (const taskId of taskIds) {
-    const matches = [];
+  const matchesFor = (anchors) => {
+    const matched = [];
     skeleton.partitions.forEach((partition, index) => {
-      const anchors = intentAnchors.get(taskId).filter((anchor) => (
+      const hits = anchors.filter((anchor) => (
         partition.some((key) => anchorMatchesNode(anchor, nodeByKey.get(key)))
       ));
-      if (anchors.length > 0) matches.push({ index, anchors: sortedUnique(anchors) });
+      if (hits.length > 0) matched.push({ index, anchors: sortedUnique(hits) });
     });
+    return matched;
+  };
+  for (const taskId of taskIds) {
+    const declared = matchesFor(concernAnchors.get(taskId) ?? []);
+    const matches = declared.length > 0 ? declared : matchesFor(intentAnchors.get(taskId));
     if (matches.length === 0) {
       unknowns.push({
         kind: 'semantic_owner_binding_missing',
@@ -1068,15 +1204,54 @@ function bindSkeleton({ skeleton, graph, intentAnchors, taskIds }) {
   };
 }
 
+/**
+ * Build a cut skeleton for a contested repo path out of the declared concern anchors alone.
+ *
+ * A path conflict has no call graph to partition — the sensor was only asked which tests the file
+ * affects. What the declarations do give is a partition of the file's symbols by owner, which is
+ * exactly the shape a cut needs. Every task in the component must have named at least one symbol
+ * inside the path; otherwise there is nothing to say about who owns which half and the caller
+ * keeps reporting the resource as unavailable rather than guessing.
+ */
+function declaredPartitionSkeleton({ conflict, concernAnchors, taskIds }) {
+  const rootPath = conflict.target;
+  const root = { kind: 'path', target: rootPath, path: rootPath };
+  const nodes = [root];
+  const partitions = [];
+  for (const taskId of taskIds) {
+    const owned = (concernAnchors.get(taskId) ?? [])
+      .map((anchor) => {
+        const separator = anchor.indexOf('\0');
+        return {
+          path: anchor.slice('concern:'.length, separator),
+          name: anchor.slice(separator + 1),
+        };
+      })
+      .filter(({ path }) => pathContains(rootPath, path));
+    if (owned.length === 0) return null;
+    for (const { path, name } of owned) nodes.push({ kind: 'symbol', target: name, path });
+    partitions.push(owned.map(({ path, name }) => graphNodeKey({
+      kind: 'symbol', target: name, path,
+    })));
+  }
+  return {
+    root,
+    nodes,
+    partitions: canonicalPartitions(partitions),
+  };
+}
+
 /**
  * Enumerate structural cut skeletons from the in-memory sensor outcomes. Graph edges only shape
- * SCC/closure/frontier partitions; task ownership is bound exclusively by unique witness anchors.
+ * SCC/closure/frontier partitions; task ownership is bound exclusively by unique witness anchors
+ * and by declared concern anchors, never by the edges themselves.
  */
 export function enumerateCutSkeletons({
   component,
   request,
   evidence,
   rawCollected,
+  concernAnchors = new Map(),
 } = {}) {
   if (!plainRecord(component)
     || !Array.isArray(component.task_ids)
@@ -1087,7 +1262,9 @@ export function enumerateCutSkeletons({
   }
   const taskIds = [...component.task_ids].sort(compareText);
   const intentAnchors = uniqueIntentAnchors(request.manual_witness, taskIds);
-  const missingIntent = taskIds.filter((taskId) => intentAnchors.get(taskId).length === 0);
+  const missingIntent = taskIds.filter((taskId) => (
+    intentAnchors.get(taskId).length === 0 && (concernAnchors.get(taskId) ?? []).length === 0
+  ));
   if (missingIntent.length > 0) {
     return {
       skeletons: [],
@@ -1102,6 +1279,26 @@ export function enumerateCutSkeletons({
   const skeletonByLayout = new Map();
   const unknowns = [];
   for (const conflict of component.conflicts) {
+    if (conflict.kind === 'path') {
+      const declared = declaredPartitionSkeleton({ conflict, concernAnchors, taskIds });
+      if (declared === null || declared.partitions.length < 2) {
+        unknowns.push({ kind: 'raw_graph_unavailable', ref: conflict.resource_id });
+        continue;
+      }
+      const layoutKey = digestArtifact({
+        conflict_resource_id: conflict.resource_id,
+        partitions: declared.partitions,
+      });
+      skeletonByLayout.set(layoutKey, {
+        skeleton_id: `cut-${sha16(layoutKey)}`,
+        conflict_resource_id: conflict.resource_id,
+        cut_kinds: ['declared_partition'],
+        root_surface: structuredClone(declared.root),
+        partitions: declared.partitions,
+        raw_graph: { nodes: structuredClone(declared.nodes), edges: [] },
+      });
+      continue;
+    }
     if (conflict.kind !== 'symbol') {
       unknowns.push({ kind: 'raw_graph_unavailable', ref: conflict.resource_id });
       continue;
@@ -1154,6 +1351,7 @@ export function enumerateCutSkeletons({
       skeleton,
       graph: skeleton.raw_graph,
       intentAnchors,
+      concernAnchors,
       taskIds,
     }));
   for (const skeleton of skeletons) unknowns.push(...skeleton.binding_unknowns);
@@ -1251,6 +1449,7 @@ export function evaluateSeamProposalCandidates({
   evidence,
   candidateSpecs,
   explorationComplete = false,
+  concernAnchors = new Map(),
 } = {}) {
   if (!plainRecord(component)
     || !Array.isArray(component.task_ids)
@@ -1265,7 +1464,9 @@ export function evaluateSeamProposalCandidates({
   }
   const taskSet = new Set(taskIds);
   const intentAnchors = uniqueIntentAnchors(request.manual_witness, taskIds);
-  const missingIntent = taskIds.filter((taskId) => intentAnchors.get(taskId).length === 0);
+  const missingIntent = taskIds.filter((taskId) => (
+    intentAnchors.get(taskId).length === 0 && (concernAnchors.get(taskId) ?? []).length === 0
+  ));
   if (missingIntent.length > 0) {
     return decisionUnknown(component, missingIntent.map((taskId) => ({
       kind: 'semantic_owner_binding_missing',
@@ -1556,15 +1757,20 @@ export function compileSeamProposalDecision({
   sensorEvidence,
   evidence,
   rawCollected,
+  concernAnchors = new Map(),
+  concernUnknowns = [],
 } = {}) {
   const enumeration = enumerateCutSkeletons({
     component,
     request,
     evidence,
     rawCollected,
+    concernAnchors,
   });
-  if (enumeration.unknowns.length > 0) {
-    return decisionUnknown(component, enumeration.unknowns);
+  // 宣言が解決しなかった事実は、束縛が成功したかに関わらず記録から消さない。
+  const unknowns = [...concernUnknowns, ...enumeration.unknowns];
+  if (unknowns.length > 0) {
+    return decisionUnknown(component, unknowns);
   }
   const candidateSpecs = enumeration.skeletons.map((skeleton) => (
     skeletonCandidateSpec({ skeleton, component, request, evidence })
@@ -1582,6 +1788,7 @@ export function compileSeamProposalDecision({
     evidence,
     candidateSpecs,
     explorationComplete: enumeration.exploration_complete,
+    concernAnchors,
   });
 }
 
@@ -1730,13 +1937,25 @@ export function compileSeamProposalArtifact({
     baseSha: independenceArtifact.base_sha,
     requestId: `seam-proposal-${independenceArtifact.result_digest.slice(0, 24)}`,
   });
-  const decisions = conflictComponents(independenceArtifact).map((component) => (
+  const components = conflictComponents(independenceArtifact);
+  const concern = resolveConcernAnchors({
+    manualWitness: witnessSet.manual_witness,
+    taskIds: [...new Set(components.flatMap(({ task_ids: ids }) => ids))].sort(compareText),
+    evidence,
+  });
+  const decisions = components.map((component) => (
     compileSeamProposalDecision({
       component,
       request,
       sensorEvidence,
       evidence,
       rawCollected,
+      concernAnchors: concern.anchorsByTask,
+      // このcomponentのtaskに関する解決失敗だけを持ち込む。
+      concernUnknowns: concern.unknowns.filter((unknown) => (
+        component.task_ids.some((taskId) => unknown.ref.startsWith(`${taskId}:`)
+          || unknown.ref.split(':')[0].split(',').includes(taskId))
+      )),
     })
   )).sort((left, right) => compareText(left.component_id, right.component_id));
   const artifact = {

package/src/todo-cli.mjs

@@ -83,7 +83,7 @@ import {
   SEAM_PROPOSAL_PROJECTION_SCHEMA,
   validateSeamProposalProjection,
 } from './seam-proposal-contracts.mjs';
-import { compileSeamProposalArtifact } from './seam-proposal.mjs';
+import { compileSeamProposalArtifact, declaredConcernSymbols } from './seam-proposal.mjs';
 import {
   parseTodoSourceRef, todoLegacyReconciliationDigest, validatePhaseTodoRevision,
   validateTodoRevision, validateTodoRevisionSet,
@@ -893,6 +893,7 @@ async function seamProposalCompile({ repoRoot, planKey }) {
 
   const { query_set: querySet } = buildSeamProposalQuerySet({
     conflictResources: independenceArtifact.conflict_resources,
+    concernSymbols: declaredConcernSymbols(witnessSet.manual_witness),
   });
   const [sensorEvidence, proposalEvidence] = await Promise.all([
     collectWitnessSensorEvidence({ cwd: repoRoot, witnessSet }),
@@ -1012,7 +1013,10 @@ async function seamProposal({ repoRoot, requestedPlanKey }) {
     topology_digest: artifact?.source_binding.topology_digest ?? null,
     independence_result_digest: artifact?.source_binding.independence_result_digest ?? null,
     compiled_at: artifact?.compiled_at ?? null,
-    guidance: selectSeamProposalGuidance({ coverage }),
+    guidance: selectSeamProposalGuidance({
+      coverage,
+      unknownKinds: components.flatMap(({ unknowns }) => unknowns.map(({ kind }) => kind)),
+    }),
     component_count: artifact === null ? null : components.length,
     conflict_resource_count: artifact === null ? null : components
       .reduce((count, component) => count + component.conflicts.length, 0),

package/src/todo-independence-contracts.mjs

@@ -13,7 +13,19 @@ import {
 } from './runtime-contracts.mjs';
 import { TODO_INDEPENDENCE_GUIDANCE_CODES } from './todo-independence-guidance.mjs';
 
-export const TODO_WITNESS_SET_SCHEMA = 'lattice.todo_witness_set.v1';
+export const TODO_WITNESS_SET_SCHEMA = 'lattice.todo_witness_set.v2';
+/**
+ * まだ受理する旧witness set契約。v1はconcern anchorを持てないだけで、境界宣言としては
+ * v2と同値である。既存宣言を書き換えさせないために読み口を残す。
+ */
+export const TODO_WITNESS_SET_LEGACY_SCHEMAS = Object.freeze(['lattice.todo_witness_set.v1']);
+export const TODO_WITNESS_SET_SCHEMAS = Object.freeze([
+  TODO_WITNESS_SET_SCHEMA,
+  ...TODO_WITNESS_SET_LEGACY_SCHEMAS,
+]);
+
+/** 1 taskが宣言できるconcern anchorの資源数と、資源あたりのsymbol数の上限。 */
+export const TODO_CONCERN_ANCHOR_LIMIT = 256;
 export const TODO_INDEPENDENCE_SCHEMA = 'lattice.todo_independence.v3';
 export const TODO_INDEPENDENCE_PROJECTION_SCHEMA = 'lattice.todo_independence_projection.v2';
 export const TODO_INDEPENDENCE_LEGACY_MARKER_SCHEMA = 'lattice.todo_independence_legacy_marker.v1';
@@ -97,6 +109,10 @@ function boundedText(value, maximumBytes = 4_096) {
  * manual witnessとsensor query setの判定正本は`explainRunRequest`だけが持つ（ADR 0123）。
  * ここで同じ規則を書き直すと契約が二箇所へ分裂するため、検証もcompileもこの合成を通す。
  * `requestId`はplan identityとwitness digestから導出され、run lifecycleへは登録されない。
+ *
+ * `concern_anchors`はここで落とす。並列可否の判定はこの合成requestだけを入力にするので、
+ * 落としておけばconcern宣言が判定へ影響しないことが構造で保証される（testの主張ではない）。
+ * 宣言はseam束縛の入力であり、witness setから直接読む。
  */
 export function synthesizeWitnessRunRequest(witnessSet, { baseSha, requestId }) {
   const taskIds = Object.keys(witnessSet.manual_witness).sort(compareText);
@@ -106,7 +122,10 @@ export function synthesizeWitnessRunRequest(witnessSet, { baseSha, requestId })
     repo: { base_sha: baseSha, root_kind: 'git' },
     capacity: witnessSet.capacity,
     todos: taskIds.map((taskId) => ({ todo_id: taskId })),
-    manual_witness: witnessSet.manual_witness,
+    manual_witness: Object.fromEntries(taskIds.map((taskId) => {
+      const { concern_anchors: _concernAnchors, ...boundary } = witnessSet.manual_witness[taskId];
+      return [taskId, boundary];
+    })),
     sensor_query_set: witnessSet.sensor_query_set,
     executor_capability: { adapters: ['todo-independence'] },
     claim_mode: RUN_REQUEST_CLAIM_MODE,
@@ -117,10 +136,57 @@ export function synthesizeWitnessRunRequest(witnessSet, { baseSha, requestId })
 }
 
 /**
- * `lattice.todo_witness_set.v1`を検証し、拒否理由とpathを返す。
+ * 1 taskのconcern anchor宣言を検査する。
+ *
+ * `within`はそのtask自身が`owns`で主張している資源に限る。所有していない資源の内側に
+ * 担当を主張させない。symbol名の実在・資源内包含・task間排他はsensorとcompile側が見る。
+ */
+function explainConcernAnchors(anchors, owns, at) {
+  const reject = (reason, path) => ({ valid: false, reason, path });
+  if (!Array.isArray(anchors) || anchors.length > TODO_CONCERN_ANCHOR_LIMIT) {
+    return reject('bounded_collection_violation', at);
+  }
+  const ownedKeys = new Set(owns.map((own) => `${own.kind}\0${own.target}`));
+  for (const [index, entry] of anchors.entries()) {
+    const entryAt = `${at}/${index}`;
+    if (!exactRecord(entry, ['within', 'symbols'])) {
+      return reject('unexpected_or_missing_keys', entryAt);
+    }
+    if (!exactRecord(entry.within, ['kind', 'target'])
+      || !['symbol', 'path'].includes(entry.within.kind)) {
+      return reject('invalid_concern_anchor_resource', `${entryAt}/within`);
+    }
+    const targetValid = entry.within.kind === 'path'
+      ? repoRelativeResourceTarget(entry.within.target)
+      : boundedText(entry.within.target, 1_024);
+    if (!targetValid) return reject('invalid_concern_anchor_resource', `${entryAt}/within`);
+    if (!ownedKeys.has(`${entry.within.kind}\0${entry.within.target}`)) {
+      return reject('concern_anchor_resource_not_owned', `${entryAt}/within`);
+    }
+    if (!Array.isArray(entry.symbols) || entry.symbols.length < 1
+      || entry.symbols.length > TODO_CONCERN_ANCHOR_LIMIT) {
+      return reject('bounded_collection_violation', `${entryAt}/symbols`);
+    }
+    if (!entry.symbols.every((symbol) => boundedText(symbol, 1_024))) {
+      return reject('invalid_concern_anchor_symbol', `${entryAt}/symbols`);
+    }
+    if (!strictlySorted(entry.symbols)) {
+      return reject('unsorted_or_duplicate_collection', `${entryAt}/symbols`);
+    }
+  }
+  if (!strictlySorted(anchors, (entry) => `${entry.within.kind}\0${entry.within.target}`)) {
+    return reject('unsorted_or_duplicate_collection', at);
+  }
+  return { valid: true };
+}
+
+/**
+ * `lattice.todo_witness_set.v2`（およびconcern anchorを持たない旧v1）を検証し、
+ * 拒否理由とpathを返す。
  *
  * 自分のshapeだけをここで見て、witness本体はprobe requestへ合成して
  * `explainRunRequest`へ委譲する。probeのbase_shaは検証専用の定数であり永続化しない。
+ * `concern_anchors`はprobeから落ちるので、ここだけが判定正本になる。
  */
 export function explainTodoWitnessSet(value) {
   const reject = (reason, at = '') => ({ valid: false, reason, path: at });
@@ -129,7 +195,7 @@ export function explainTodoWitnessSet(value) {
       'schema', 'project_id', 'plan_key', 'capacity', 'sensor_query_set',
       'manual_witness', 'witness_set_digest',
     ])) return reject('unexpected_or_missing_top_level_keys');
-    if (value.schema !== TODO_WITNESS_SET_SCHEMA) return reject('schema_mismatch', '/schema');
+    if (!TODO_WITNESS_SET_SCHEMAS.includes(value.schema)) return reject('schema_mismatch', '/schema');
     if (!isTodoIdentifier(value.project_id)) return reject('invalid_identifier', '/project_id');
     if (!isTodoIdentifier(value.plan_key)) return reject('invalid_identifier', '/plan_key');
     if (!plain(value.manual_witness)) return reject('not_an_object', '/manual_witness');
@@ -146,6 +212,16 @@ export function explainTodoWitnessSet(value) {
     });
     const explained = explainRunRequest(probe);
     if (!explained.valid) return reject(explained.reason, explained.path);
+    // concern anchorはprobeへ写していないので、ここが唯一の判定正本になる。
+    const legacy = TODO_WITNESS_SET_LEGACY_SCHEMAS.includes(value.schema);
+    for (const taskId of taskIds) {
+      const witness = value.manual_witness[taskId];
+      const at = `/manual_witness/${taskId}/concern_anchors`;
+      if (!Object.hasOwn(witness, 'concern_anchors')) continue;
+      if (legacy) return reject('concern_anchors_require_witness_set_v2', at);
+      const anchors = explainConcernAnchors(witness.concern_anchors, witness.owns, at);
+      if (!anchors.valid) return reject(anchors.reason, anchors.path);
+    }
     return { valid: true };
   } catch {
     return reject('non_canonical_witness_set_bytes');

package/src/todo-independence-guidance.mjs

@@ -24,9 +24,39 @@ export const SEAM_PROPOSAL_GUIDANCE_CODES = Object.freeze([
   'seam_proposal_unrecorded',
   'seam_proposal_superseded',
   'seam_proposal_stale',
+  'seam_proposal_binding_overlap',
+  'seam_proposal_binding_outside_resource',
+  'seam_proposal_binding_symbol_unresolved',
+  'seam_proposal_binding_resource_unresolved',
+  'seam_proposal_binding_ambiguous',
+  'seam_proposal_binding_missing',
   'seam_proposal_verified',
 ]);
 
+/**
+ * 束縛失敗のunknown種別から案内codeを引く表。並びは優先順で、先頭ほど次の一歩が具体的である。
+ *
+ * 宣言が壊れている状況を、宣言が無い状況より上に置く。壊れている方は直す対象が
+ * 一意に決まるのに対し、無い方は何をどう宣言するかから決めることになるからである。
+ */
+const SEAM_PROPOSAL_BINDING_GUIDANCE = Object.freeze([
+  Object.freeze(['concern_anchor_overlap', 'seam_proposal_binding_overlap']),
+  Object.freeze(['concern_anchor_outside_resource', 'seam_proposal_binding_outside_resource']),
+  Object.freeze(['concern_anchor_unresolved', 'seam_proposal_binding_symbol_unresolved']),
+  Object.freeze(['concern_anchor_resource_unresolved', 'seam_proposal_binding_resource_unresolved']),
+  Object.freeze(['semantic_owner_binding_ambiguous', 'seam_proposal_binding_ambiguous']),
+  Object.freeze(['semantic_owner_binding_missing', 'seam_proposal_binding_missing']),
+]);
+
+/**
+ * 束縛の案内へ共通で添える、記録が更新される条件。
+ *
+ * concern_anchorsはwitness setにあり、seam提案はindependence記録のwitness_set_digestと
+ * 一致する宣言しか読まない。宣言を直しただけでは提案は変わらないので、そこまで述べないと
+ * 「直したのに同じunknownが出る」で止まる。
+ */
+const BINDING_RECOMPILE_HINT = '宣言はwitness setにあり、independence compileとseam-proposal compileを通し直すまで提案へ写らない。';
+
 const CATALOG = Object.freeze({
   independence_no_ready_frontier: Object.freeze({
     message: '着手候補が無いため、並列可否を述べる対象が無い。',
@@ -76,6 +106,30 @@ const CATALOG = Object.freeze({
     message: 'seam提案の生成後にHEADが進み、記録時点の構造証拠は現在のcodeを指していない。',
     next_action: 'compile_seam_proposal',
   }),
+  seam_proposal_binding_overlap: Object.freeze({
+    message: `同じ資源について、複数のToDoが同じsymbolを自分の担当として宣言している。どちら側へ切るか決まらないため、切断候補を束縛できない。${BINDING_RECOMPILE_HINT}`,
+    next_action: 'split_overlapping_concern_anchors_then_recompile',
+  }),
+  seam_proposal_binding_outside_resource: Object.freeze({
+    message: `concern_anchorsが挙げたsymbolが、withinで指した資源の外にある。その資源の分割を説明しないので束縛へ使えない。${BINDING_RECOMPILE_HINT}`,
+    next_action: 'correct_concern_anchors_then_recompile',
+  }),
+  seam_proposal_binding_symbol_unresolved: Object.freeze({
+    message: `concern_anchorsが挙げたsymbolを、sensorが同名同pathで解決できなかった。近い別symbolへは寄せないため、束縛は成立していない。${BINDING_RECOMPILE_HINT}`,
+    next_action: 'correct_concern_anchors_then_recompile',
+  }),
+  seam_proposal_binding_resource_unresolved: Object.freeze({
+    message: `concern_anchorsのwithinが指す資源をsensorで解決できなかった。宣言がどの資源についてのものか確定しない。${BINDING_RECOMPILE_HINT}`,
+    next_action: 'correct_concern_anchors_then_recompile',
+  }),
+  seam_proposal_binding_ambiguous: Object.freeze({
+    message: `宣言したsymbolが切断候補の複数側へ当たるため、どのToDoがどちらを所有するか一意に決まらない。${BINDING_RECOMPILE_HINT}`,
+    next_action: 'narrow_concern_anchors_then_recompile',
+  }),
+  seam_proposal_binding_missing: Object.freeze({
+    message: `係争資源の中でどのToDoが何を触るかが宣言されていないため、切断候補を所有者へ束縛できない。依存線でも呼び出し辺でも所有は決まらない。${BINDING_RECOMPILE_HINT}`,
+    next_action: 'declare_concern_anchors_then_recompile',
+  }),
   seam_proposal_verified: Object.freeze({
     message: 'seam提案の記録は現在のplan、並列可否記録、HEADと一致している。',
     next_action: 'none',
@@ -135,21 +189,37 @@ export function selectIndependenceGuidance({
   return todoIndependenceGuidance('independence_verified');
 }
 
-export function selectSeamProposalGuidance({ coverage }) {
-  const code = coverage === 'missing' ? 'seam_proposal_unrecorded'
-    : coverage === 'superseded' ? 'seam_proposal_superseded'
-      : coverage === 'stale' ? 'seam_proposal_stale'
-        : coverage === 'verified' ? 'seam_proposal_verified' : null;
-  if (code === null) throw new TypeError(`unknown seam proposal coverage: ${coverage}`);
-  return todoIndependenceGuidance(code);
+/**
+ * seam提案の状況から案内codeを引く。投影の生成側と契約の検査側が同じ規則を読むための正本。
+ *
+ * 鮮度（coverage）を束縛失敗より先に見る。記録が古い・別topologyについてのものである時、
+ * そこに載っているunknownは現在のcodeについての事実ではないため、先に再compileが要る。
+ * 記録が現在と一致している時だけ、束縛失敗が「今直せる状況」になる。
+ */
+export function seamProposalGuidanceCode({ coverage, unknownKinds = [] }) {
+  if (coverage === 'missing') return 'seam_proposal_unrecorded';
+  if (coverage === 'superseded') return 'seam_proposal_superseded';
+  if (coverage === 'stale') return 'seam_proposal_stale';
+  if (coverage !== 'verified') throw new TypeError(`unknown seam proposal coverage: ${coverage}`);
+  const kinds = new Set(unknownKinds);
+  const binding = SEAM_PROPOSAL_BINDING_GUIDANCE.find(([kind]) => kinds.has(kind));
+  return binding === undefined ? 'seam_proposal_verified' : binding[1];
+}
+
+export function selectSeamProposalGuidance({ coverage, unknownKinds = [] }) {
+  return todoIndependenceGuidance(seamProposalGuidanceCode({ coverage, unknownKinds }));
 }
 
 /**
  * 宣言からcompileを経て読むまでの順序。helpとMCP instructionsが同じ手順を語るための正本。
  * 面ごとに手順を書き直すと、片方だけが古くなる。
+ *
+ * 宣言できる欄を挙げる面はここだけなので、witness契約へ欄を足したらここへも足す。
+ * 足さないと、能力はあるのに機械が黙る面が残る（ADR 0130）。
  */
 export const TODO_INDEPENDENCE_WORKFLOW = Object.freeze([
   '1. 宣言する: .lattice/todo/witness/<plan_key>.json へ、ToDoごとのowns／reads／writes／affected_testsを書く',
+  '   係争資源しか所有していないToDoは、その資源の中で自分が触るsymbolをconcern_anchorsへ宣言できる（witness set v2）。並列可否の判定には写らず、切断候補の束縛だけに効く',
   '2. 判定する: lattice todo independence compile --plan <key> --input <ref>（実sensorを引き、clean worktreeが要る）',
   '3. 読む: lattice todo independence --plan <key> --json（sensorを引かず、記録とHEAD照合だけで返る）',
   '4. 追従する: plan改訂後は lattice todo independence witness migrate --plan <key> で宣言を写してから再compileする',