@moretea-labs/forge 1.7.2 → 1.8.1

package/scripts/check-runtime-architecture.mjs

@@ -43,9 +43,20 @@ function forbidBetween(path, startNeedle, endNeedle, expression, description) {
   }
   if (expression.test(source.slice(start, end))) failures.push(`${path} violates ${description}`);
 }
+const GENERATED_SOURCE_DIRECTORY_NAMES = new Set([
+  'node_modules',
+  'dist',
+  'build',
+  'coverage',
+  'target',
+]);
+
 function sourceFiles(directory) {
+  const absolute = resolve(root, directory);
+  if (!existsSync(absolute)) return [];
   const files = [];
-  for (const entry of readdirSync(resolve(root, directory), { withFileTypes: true })) {
+  for (const entry of readdirSync(absolute, { withFileTypes: true })) {
+    if (entry.isDirectory() && GENERATED_SOURCE_DIRECTORY_NAMES.has(entry.name)) continue;
     const path = `${directory}/${entry.name}`;
     if (entry.isDirectory()) files.push(...sourceFiles(path));
     else if (entry.isFile() && path.endsWith('.ts')) files.push(path);
@@ -53,18 +64,133 @@ function sourceFiles(directory) {
   return files;
 }
 
-function relativeStaticTypeScriptDependencyGraph(directory = 'src') {
-  let ts;
+function productionTypeScriptFiles() {
+  return [
+    ...sourceFiles('src'),
+    ...sourceFiles('packages'),
+    ...sourceFiles('adapters'),
+    ...sourceFiles('apps'),
+    ...sourceFiles('plugins'),
+  ].sort();
+}
+
+let typeScriptCompiler;
+let typeScriptCompilerLoadAttempted = false;
+function loadTypeScriptCompiler() {
+  if (typeScriptCompilerLoadAttempted) return typeScriptCompiler;
+  typeScriptCompilerLoadAttempted = true;
   try {
-    ts = createRequire(import.meta.url)('typescript');
+    typeScriptCompiler = createRequire(import.meta.url)('typescript');
   } catch (error) {
-    failures.push(`TypeScript dependency is required for architecture import-cycle analysis: ${error instanceof Error ? error.message : String(error)}`);
-    return new Map();
+    failures.push(`TypeScript dependency is required for architecture import analysis: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  return typeScriptCompiler;
+}
+
+const WORK_LIFECYCLE_PATCH_FIELDS = new Set(['status', 'phase', 'dispatchState', 'evidenceState', 'workKind']);
+
+function unwrapTypeScriptExpression(ts, node) {
+  let current = node;
+  while (ts.isParenthesizedExpression(current)
+      || ts.isAsExpression(current)
+      || ts.isTypeAssertionExpression(current)
+      || ts.isNonNullExpression(current)
+      || (typeof ts.isSatisfiesExpression === 'function' && ts.isSatisfiesExpression(current))) {
+    current = current.expression;
+  }
+  return current;
+}
+
+function staticTypeScriptPropertyName(ts, name) {
+  if (ts.isIdentifier(name) || ts.isStringLiteralLike(name) || ts.isNumericLiteral(name)) return name.text;
+  if (ts.isComputedPropertyName(name) && ts.isStringLiteralLike(name.expression)) return name.expression.text;
+  return undefined;
+}
+
+function inlineWorkLifecyclePatchFields(ts, node) {
+  const expression = unwrapTypeScriptExpression(ts, node);
+  if (!ts.isObjectLiteralExpression(expression)) return [];
+  const fields = new Set();
+  for (const property of expression.properties) {
+    if (ts.isSpreadAssignment(property)) {
+      for (const field of inlineWorkLifecyclePatchFields(ts, property.expression)) fields.add(field);
+      continue;
+    }
+    if (!(ts.isPropertyAssignment(property)
+        || ts.isShorthandPropertyAssignment(property)
+        || ts.isMethodDeclaration(property)
+        || ts.isGetAccessorDeclaration(property)
+        || ts.isSetAccessorDeclaration(property))) continue;
+    const name = staticTypeScriptPropertyName(ts, property.name);
+    if (name && WORK_LIFECYCLE_PATCH_FIELDS.has(name)) fields.add(name);
+  }
+  return [...fields].sort();
+}
+
+function genericWorkLifecycleMutationRecords(files) {
+  const ts = loadTypeScriptCompiler();
+  if (!ts) return [];
+  const records = [];
+  for (const path of [...files].sort()) {
+    const sourceFile = ts.createSourceFile(path, text(path), ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    function visit(node) {
+      if (ts.isCallExpression(node) && node.arguments.length >= 3) {
+        const callee = node.expression;
+        const callName = ts.isIdentifier(callee)
+          ? callee.text
+          : ts.isPropertyAccessExpression(callee)
+            ? callee.name.text
+            : undefined;
+        if (callName === 'updateWorkContract') {
+          const fields = inlineWorkLifecyclePatchFields(ts, node.arguments[2]);
+          if (fields.length > 0) {
+            const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+            records.push({ path, line: line + 1, fields });
+          }
+        }
+      }
+      ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+  }
+  return records;
+}
+
+function staticTypeScriptImportRecords(files) {
+  const ts = loadTypeScriptCompiler();
+  if (!ts) return [];
+  const records = [];
+  for (const path of [...files].sort()) {
+    const sourceFile = ts.createSourceFile(path, text(path), ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    function visit(node) {
+      let specifier;
+      if ((ts.isImportDeclaration(node) || ts.isExportDeclaration(node))
+          && node.moduleSpecifier
+          && ts.isStringLiteralLike(node.moduleSpecifier)) {
+        specifier = node.moduleSpecifier.text;
+      } else if (ts.isImportEqualsDeclaration(node)
+          && ts.isExternalModuleReference(node.moduleReference)
+          && node.moduleReference.expression
+          && ts.isStringLiteralLike(node.moduleReference.expression)) {
+        specifier = node.moduleReference.expression.text;
+      } else if (ts.isCallExpression(node)
+          && node.expression.kind === ts.SyntaxKind.ImportKeyword
+          && node.arguments.length === 1
+          && ts.isStringLiteralLike(node.arguments[0])) {
+        specifier = node.arguments[0].text;
+      }
+      if (specifier) records.push({ from: path, specifier });
+      ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
   }
+  return records;
+}
 
-  const files = sourceFiles(directory).sort();
-  const known = new Set(files);
-  const graph = new Map(files.map((path) => [path, new Set()]));
+function staticTypeScriptDependencyGraph(files) {
+  const orderedFiles = [...files].sort();
+  const known = new Set(orderedFiles);
+  const graph = new Map(orderedFiles.map((path) => [path, new Set()]));
 
   function resolveTypeScriptImport(fromPath, specifier) {
     if (!specifier.startsWith('.')) return undefined;
@@ -79,28 +205,390 @@ function relativeStaticTypeScriptDependencyGraph(directory = 'src') {
     return candidates.find((candidate) => known.has(candidate));
   }
 
-  for (const path of files) {
-    const sourceFile = ts.createSourceFile(path, text(path), ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-    for (const statement of sourceFile.statements) {
-      let specifier;
-      if ((ts.isImportDeclaration(statement) || ts.isExportDeclaration(statement))
-          && statement.moduleSpecifier
-          && ts.isStringLiteralLike(statement.moduleSpecifier)) {
-        specifier = statement.moduleSpecifier.text;
-      } else if (ts.isImportEqualsDeclaration(statement)
-          && ts.isExternalModuleReference(statement.moduleReference)
-          && statement.moduleReference.expression
-          && ts.isStringLiteralLike(statement.moduleReference.expression)) {
-        specifier = statement.moduleReference.expression.text;
+  for (const { from, specifier } of staticTypeScriptImportRecords(orderedFiles)) {
+    const target = resolveTypeScriptImport(from, specifier);
+    if (target) graph.get(from).add(target);
+  }
+  return graph;
+}
+
+function relativeStaticTypeScriptDependencyGraph(directory = 'src') {
+  return staticTypeScriptDependencyGraph(sourceFiles(directory));
+}
+
+function productionStaticTypeScriptDependencyGraph() {
+  return staticTypeScriptDependencyGraph(productionTypeScriptFiles());
+}
+
+function dependencyEdges(graph) {
+  const edges = [];
+  for (const [from, targets] of graph) {
+    for (const to of targets) edges.push(`${from} -> ${to}`);
+  }
+  return edges.sort();
+}
+
+function edgeSet(graph, predicate) {
+  return new Set(dependencyEdges(graph).filter((edge) => predicate(edge)));
+}
+
+function edgeParts(edge) {
+  const separator = edge.indexOf(' -> ');
+  return { from: edge.slice(0, separator), to: edge.slice(separator + 4) };
+}
+
+function architectureRoot(path) {
+  if (path.startsWith('packages/kernel/')) return path.split('/').slice(0, 3).join('/');
+  if (path.startsWith('adapters/')) return path.split('/').slice(0, 2).join('/');
+  if (path.startsWith('apps/')) return path.split('/').slice(0, 2).join('/');
+  if (path.startsWith('plugins/')) return path.split('/').slice(0, 2).join('/');
+  if (path.startsWith('src/runtime/root/')) return 'src/runtime/root';
+  return path.startsWith('src/') ? 'src' : path.split('/')[0];
+}
+
+function requireExactShrinkingDebt(label, actual, allowed) {
+  for (const edge of actual) {
+    if (!allowed.has(edge)) failures.push(`${label} introduced forbidden dependency: ${edge}`);
+  }
+  for (const edge of allowed) {
+    if (!actual.has(edge)) failures.push(`${label} allowlist contains retired dependency; remove it so the debt ledger only shrinks: ${edge}`);
+  }
+}
+
+function requireExactShrinkingInventory(label, actual, allowed) {
+  for (const entry of actual) {
+    if (!allowed.has(entry)) failures.push(`${label} introduced forbidden entry: ${entry}`);
+  }
+  for (const entry of allowed) {
+    if (!actual.has(entry)) failures.push(`${label} allowlist contains retired entry; remove it so the debt ledger only shrinks: ${entry}`);
+  }
+}
+
+// Thin rh_work boundary: semantic Requirement/Plan/Work records and explicit
+// launcher/schedule/workflow intent only. Repository execution, checks and Git
+// delivery stay on their typed capability surfaces; old lifecycle verbs are gone.
+requireText('adapters/mcp/runtime-gateway/runtime-tools.ts', "if (name === 'rh_work') return callWorkAdapter(ctx, args);");
+requireText('adapters/mcp/runtime-gateway/work-controller-operations.ts', "const RH_WORK_CONTROLLER_OPERATIONS = new Set(['launcher_start']);");
+requireText('adapters/mcp/runtime-gateway/work-adapter.ts', "if (operation === 'launcher_start')");
+requireText('adapters/mcp/runtime-gateway/work-requirement-operations.ts', 'export async function callRhWorkRequirementOperation');
+requireText('adapters/mcp/runtime-gateway/work-plan-operations.ts', 'export async function callRhWorkPlanOperation');
+requireText('adapters/mcp/runtime-gateway/work-plan-operations.ts', 'export async function callRhWorkPlanCreateOperation');
+requireText('adapters/mcp/runtime-gateway/work-adapter.ts', 'callRhWorkRequirementOperation(ctx, repository, operation, args)');
+requireText('adapters/mcp/runtime-gateway/work-adapter.ts', 'callRhWorkPlanOperation(store, operation, args)');
+requireText('adapters/mcp/runtime-gateway/work-adapter.ts', 'callRhWorkPlanCreateOperation(store, operation, args');
+forbid('adapters/mcp/runtime-gateway/work-adapter.ts', /operation === ['"](?:continue|verify|review|finalize|stop|delegate|controller_get_owner|controller_claim|controller_disposition|controller_release)['"]/, 'thin rh_work must not route retired lifecycle/controller operations');
+forbid('adapters/mcp/runtime-gateway/work-adapter.ts', /\b(?:transitionWorkHandle|writeWorkHandle|markWorkHandleFailed|executeWorkVerification|requestWorkImplementationReview)\b/, 'rh_work must not own mechanical execution, verification or review authority');
+forbid('adapters/mcp/runtime-gateway/work-adapter.ts', /repositoryGit(?:Commit|FinishWorkflow|MergeBranch|DeleteBranch|RebaseOnto)\s*\(/, 'rh_work must not perform physical Git delivery');
+forbid('adapters/mcp/runtime-gateway/work-adapter.ts', /control-plane\/facade\/work-contract-store|kernel\/work\/infrastructure/, 'rh_work must consume canonical semantic APIs instead of persistence infrastructure');
+forbid('adapters/mcp/runtime-gateway/work-plan-operations.ts', /plan_approve|plan_accept_step|plan_supersede|approvePlanContractAsync|acceptPlanStepEvidence|supersedePlanContract/, 'retired Plan approval/acceptance/supersession APIs must not remain on the runtime surface');
+forbid('src/runtime/control-plane/facade/plan-contract-store.ts', /approvePlanContract|approvePendingPlanRevision|supersedePlanContract|plan_revision_approved/, 'legacy Plan approval/supersession writers must stay retired');
+
+// #197 MCP mega-adapter decomposition. These are debt ledgers, not target
+// architecture: entries may only disappear. New domain-authority imports or
+// switch cases must be implemented in the owning domain adapter/application API,
+// never added to runtime-tools/router while decomposition is in progress.
+const MCP_GATEWAY_AUTHORITY_IMPORT_PATTERN = /(?:packages\/kernel\/|src\/runtime\/|src\/cli\/(?:repositories|editing)\/)/;
+
+function gatewayAuthorityImportInventoryFromSources(sources, importPattern = MCP_GATEWAY_AUTHORITY_IMPORT_PATTERN) {
+
+  const ts = loadTypeScriptCompiler();
+  if (!ts) return new Set();
+  const records = new Set();
+  for (const { path, source } of sources) {
+    const sourceFile = ts.createSourceFile(path, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    function visit(node) {
+      if ((ts.isImportDeclaration(node) || ts.isExportDeclaration(node))
+          && node.moduleSpecifier
+          && ts.isStringLiteralLike(node.moduleSpecifier)
+          && importPattern.test(node.moduleSpecifier.text)) {
+        records.add(`${path}::${node.moduleSpecifier.text}`);
       }
-      if (!specifier) continue;
-      const target = resolveTypeScriptImport(path, specifier);
-      if (target) graph.get(path).add(target);
+      ts.forEachChild(node, visit);
     }
+    visit(sourceFile);
   }
-  return graph;
+  return records;
+}
+
+function runtimeToolSwitchCaseInventory(source) {
+  const marker = 'export async function callRuntimeTool';
+  const start = source.indexOf(marker);
+  if (start < 0) return new Set();
+  return new Set([...source.slice(start).matchAll(/case\s+['"]([^'"]+)['"]\s*:/g)].map((match) => match[1]));
+}
+
+const SUPERVISOR_CONCRETE_BROWSER_TRANSPORT_IMPORT_PATTERN = /(?:browser-macos-bridge|browser-adapter|chrome-extension|native-messaging)/;
+
+function supervisorConcreteBrowserTransportImportsFromSources(sources) {
+  return gatewayAuthorityImportInventoryFromSources(sources, SUPERVISOR_CONCRETE_BROWSER_TRANSPORT_IMPORT_PATTERN);
+}
+
+const supervisorComputerBoundaryFixture = process.env.FORGE_SUPERVISOR_COMPUTER_BOUNDARY_FIXTURE;
+if (supervisorComputerBoundaryFixture) {
+  const fixture = JSON.parse(supervisorComputerBoundaryFixture);
+  const sources = Array.isArray(fixture.sources) ? fixture.sources : [];
+  const actual = supervisorConcreteBrowserTransportImportsFromSources(sources);
+  if (actual.size > 0) {
+    console.error('[supervisor-computer-boundary-guardrail] FAILED');
+    for (const record of actual) console.error(`- Workflow Supervisor semantic code must depend on Computer target ports, never concrete Browser transports: ${record}`);
+    process.exit(1);
+  }
+  console.log('[supervisor-computer-boundary-guardrail] OK');
+  process.exit(0);
+}
+
+const MCP_RUNTIME_GATEWAY_AUTHORITY_IMPORT_DEBT = new Set([
+  'adapters/mcp/runtime-gateway/runtime-tools.ts::../../../src/runtime/execution/process-runtime/check-result',
+]);
+
+const MCP_RUNTIME_TOOLS_SWITCH_CASE_DEBT = new Set();
+
+const mcpAdapterBoundaryFixture = process.env.FORGE_MCP_RUNTIME_ADAPTER_BOUNDARY_FIXTURE;
+if (mcpAdapterBoundaryFixture) {
+  const fixture = JSON.parse(mcpAdapterBoundaryFixture);
+  const sources = Array.isArray(fixture.sources) ? fixture.sources : [];
+  requireExactShrinkingDebt(
+    'MCP runtime adapter authority-import fixture debt',
+    gatewayAuthorityImportInventoryFromSources(sources),
+    new Set(Array.isArray(fixture.allowedImports) ? fixture.allowedImports : []),
+  );
+  const runtimeSource = sources.find((entry) => entry.path === 'adapters/mcp/runtime-gateway/runtime-tools.ts')?.source ?? '';
+  requireExactShrinkingInventory(
+    'MCP runtime-tools switch-case fixture debt',
+    runtimeToolSwitchCaseInventory(runtimeSource),
+    new Set(Array.isArray(fixture.allowedCases) ? fixture.allowedCases : []),
+  );
+  if (failures.length) {
+    console.error('[mcp-runtime-adapter-boundary-guardrail] FAILED');
+    for (const failure of failures) console.error(`- ${failure}`);
+    process.exit(1);
+  }
+  console.log('[mcp-runtime-adapter-boundary-guardrail] OK');
+  process.exit(0);
+}
+
+requireExactShrinkingDebt(
+  'MCP runtime mega-adapter direct domain-authority import debt',
+  gatewayAuthorityImportInventoryFromSources([
+    { path: 'adapters/mcp/runtime-gateway/runtime-tools.ts', source: text('adapters/mcp/runtime-gateway/runtime-tools.ts') },
+    { path: 'adapters/mcp/runtime-gateway/router.ts', source: text('adapters/mcp/runtime-gateway/router.ts') },
+  ]),
+  MCP_RUNTIME_GATEWAY_AUTHORITY_IMPORT_DEBT,
+);
+requireExactShrinkingInventory(
+  'MCP runtime-tools switch-case debt',
+  runtimeToolSwitchCaseInventory(text('adapters/mcp/runtime-gateway/runtime-tools.ts')),
+  MCP_RUNTIME_TOOLS_SWITCH_CASE_DEBT,
+);
+const supervisorSemanticSources = sourceFiles('supervisor')
+  .filter((path) => !path.startsWith('supervisor/native-messaging/'))
+  .map((path) => ({ path, source: text(path) }));
+requireExactShrinkingDebt(
+  'Workflow Supervisor concrete Browser transport imports',
+  supervisorConcreteBrowserTransportImportsFromSources(supervisorSemanticSources),
+  new Set(),
+);
+for (const path of supervisorSemanticSources.map((entry) => entry.path)) {
+  forbid(path, /\b(?:windowId|tabId|window\.name)\b/, 'Workflow Supervisor semantic code must not own provider tab/window identity; Computer target authority owns provider bindings');
+}
+
+
+const MCP_PURE_TRANSPORT_FORBIDDEN_IMPORT_PATTERN = /(?:packages\/kernel\/|src\/runtime\/)/;
+requireExactShrinkingDebt(
+  'MCP pure transport adapter authority imports',
+  gatewayAuthorityImportInventoryFromSources([
+    { path: 'adapters/mcp/runtime-gateway/shared-adapter.ts', source: text('adapters/mcp/runtime-gateway/shared-adapter.ts') },
+    { path: 'adapters/mcp/runtime-gateway/result-adapter.ts', source: text('adapters/mcp/runtime-gateway/result-adapter.ts') },
+  ], MCP_PURE_TRANSPORT_FORBIDDEN_IMPORT_PATTERN),
+  new Set(),
+);
+
+// Hard cutover: retired lifecycle decoders remain absent. One bounded
+// frozen-session wire decoder may translate the pre-Thin semantic.v1 carrier
+// and current-conversation enrollment into current owners because host MCP
+// schemas can remain frozen across Runtime reconnect. That decoder owns no
+// lifecycle or persistence and must not grow retired lifecycle carriers.
+for (const path of [
+  'adapters/mcp/runtime-gateway/work-controller-recovery-operations.ts',
+  'adapters/mcp/controller-round-compatibility.ts',
+  'adapters/mcp/frozen-client-semantic-compatibility.ts',
+]) requireMissing(path);
+requireText(
+  'adapters/mcp/runtime-gateway/work-input-wire-migration.ts',
+  "const FROZEN_SEMANTIC_V1_PREFIX = 'semantic.v1:';",
+);
+requireText(
+  'adapters/mcp/runtime-gateway/work-input-wire-migration.ts',
+  "const FROZEN_CURRENT_CONVERSATION_ENROLLMENT = 'controller.current_conversation.enroll';",
+);
+forbid(
+  'adapters/mcp/runtime-gateway/work-input-wire-migration.ts',
+  /schedule\.delete:|work\.review:|controller\.(?:authority|provider|disposition|round):|plan\.step\.retry:/,
+  'the bounded frozen-session decoder must not restore retired lifecycle carriers',
+);
+for (const path of sourceFiles('adapters/mcp')) {
+  if (path === 'adapters/mcp/runtime-gateway/work-input-wire-migration.ts') continue;
+  forbid(path, /semantic\.v1:/, 'semantic.v1 frozen-session decoding must have exactly one transport owner');
+}
+
+const SEMANTIC_AUTHORITY_CRITICAL_ROOTS = [
+  'packages/kernel',
+  'src/runtime/control-plane',
+  'src/runtime/execution',
+  'adapters/mcp/runtime-gateway',
+  'src/cli/local-bridge',
+];
+const HUMAN_READABLE_SEMANTIC_FIELDS = new Set(['message', 'reason', 'description', 'checkId', 'check_id']);
+const HUMAN_READABLE_STRING_MATCH_METHODS = new Set(['includes', 'startsWith', 'endsWith', 'match', 'search']);
+
+function humanReadableSemanticExpression(ts, node) {
+  if (ts.isIdentifier(node)) return HUMAN_READABLE_SEMANTIC_FIELDS.has(node.text);
+  if (ts.isPropertyAccessExpression(node)) return HUMAN_READABLE_SEMANTIC_FIELDS.has(node.name.text);
+  if (ts.isElementAccessExpression(node)
+      && node.argumentExpression
+      && ts.isStringLiteralLike(node.argumentExpression)) {
+    return HUMAN_READABLE_SEMANTIC_FIELDS.has(node.argumentExpression.text);
+  }
+  if (ts.isParenthesizedExpression(node)
+      || ts.isAsExpression(node)
+      || ts.isTypeAssertionExpression(node)
+      || ts.isNonNullExpression(node)) {
+    return humanReadableSemanticExpression(ts, node.expression);
+  }
+  if (ts.isConditionalExpression(node)) {
+    return humanReadableSemanticExpression(ts, node.whenTrue)
+      || humanReadableSemanticExpression(ts, node.whenFalse);
+  }
+  if (ts.isCallExpression(node)
+      && ts.isPropertyAccessExpression(node.expression)
+      && ['trim', 'toLowerCase', 'toUpperCase'].includes(node.expression.name.text)) {
+    return humanReadableSemanticExpression(ts, node.expression.expression);
+  }
+  return false;
+}
+
+function isHumanReadableSemanticMatcherCall(ts, node) {
+  if (!ts.isCallExpression(node) || !ts.isPropertyAccessExpression(node.expression)) return false;
+  const method = node.expression.name.text;
+  if (HUMAN_READABLE_STRING_MATCH_METHODS.has(method)
+      && humanReadableSemanticExpression(ts, node.expression.expression)) return true;
+  return method === 'test' && node.arguments.some((argument) => humanReadableSemanticExpression(ts, argument));
+}
+
+function semanticAuthorityStringMatchRecordsFromSources(sources) {
+  const ts = loadTypeScriptCompiler();
+  if (!ts) return new Set();
+  const records = new Set();
+  for (const { path, source } of [...sources].sort((left, right) => left.path.localeCompare(right.path))) {
+    const sourceFile = ts.createSourceFile(path, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    function collectCondition(expression) {
+      function visitCondition(node) {
+        if (isHumanReadableSemanticMatcherCall(ts, node)) {
+          records.add(`${path}::${node.getText(sourceFile).replace(/\s+/g, ' ').trim()}`);
+        }
+        ts.forEachChild(node, visitCondition);
+      }
+      visitCondition(expression);
+    }
+    function visit(node) {
+      if (ts.isIfStatement(node) || ts.isWhileStatement(node) || ts.isDoStatement(node)) collectCondition(node.expression);
+      else if (ts.isConditionalExpression(node)) collectCondition(node.condition);
+      else if (ts.isForStatement(node) && node.condition) collectCondition(node.condition);
+      ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+  }
+  return records;
+}
+
+function semanticAuthorityProductionStringMatchRecords() {
+  const paths = SEMANTIC_AUTHORITY_CRITICAL_ROOTS.flatMap((directory) => sourceFiles(directory));
+  return semanticAuthorityStringMatchRecordsFromSources(paths.map((path) => ({ path, source: text(path) })));
+}
+
+const LEGACY_INTERACTION_AUTHORITY_OWNER_DECLARATION = /\b(?:class|interface|type|function|const)\s+\w*(?:Browser|Desktop)\w*(?:Authority|Persistence)\b/;
+function legacyInteractionAuthorityOwnerRecordsFromSources(sources) {
+  const records = new Set();
+  for (const { path, source } of sources) {
+    for (const line of String(source).split('\n')) {
+      if (LEGACY_INTERACTION_AUTHORITY_OWNER_DECLARATION.test(line)) records.add(`${path}::${line.trim()}`);
+    }
+  }
+  return records;
+}
+
+const interactionAuthorityGuardrailFixture = process.env.FORGE_INTERACTION_AUTHORITY_GUARDRAIL_FIXTURE;
+if (interactionAuthorityGuardrailFixture) {
+  const fixture = JSON.parse(interactionAuthorityGuardrailFixture);
+  const actual = legacyInteractionAuthorityOwnerRecordsFromSources(Array.isArray(fixture.sources) ? fixture.sources : []);
+  if (actual.size > 0) {
+    console.error('[interaction-authority-guardrail] FAILED');
+    for (const record of actual) console.error(`- Browser/Desktop durable interaction authority must live only in Computer target authority: ${record}`);
+    process.exit(1);
+  }
+  console.log('[interaction-authority-guardrail] OK');
+  process.exit(0);
 }
 
+const semanticAuthorityGuardrailFixture = process.env.FORGE_SEMANTIC_AUTHORITY_GUARDRAIL_FIXTURE;
+if (semanticAuthorityGuardrailFixture) {
+  const fixture = JSON.parse(semanticAuthorityGuardrailFixture);
+  const actual = semanticAuthorityStringMatchRecordsFromSources(Array.isArray(fixture.sources) ? fixture.sources : []);
+  const allowed = new Set(Array.isArray(fixture.allowed) ? fixture.allowed : []);
+  requireExactShrinkingInventory('semantic authority fixture debt', actual, allowed);
+  if (failures.length) {
+    console.error('[semantic-authority-guardrail] FAILED');
+    for (const failure of failures) console.error(`- ${failure}`);
+    process.exit(1);
+  }
+  console.log(`[semantic-authority-guardrail] OK (${actual.size} debt entries)`);
+  process.exit(0);
+}
+
+const SEMANTIC_STRING_AUTHORITY_DEBT = new Set([
+  `adapters/mcp/runtime-gateway/execution-tools.ts::message.includes(':')`,
+  `adapters/mcp/runtime-gateway/process-tools.ts::message.includes(':')`,
+  `adapters/mcp/runtime-gateway/context-adapter.ts::error.message.startsWith('PLUGIN_NOT_FOUND:')`,
+  `packages/kernel/controller/domain/controller-round-transition-policy.ts::reason.startsWith('consecutive_failures:')`,
+  `packages/kernel/controller/domain/controller-round-transition-policy.ts::reason.startsWith('repeated_state:')`,
+  `packages/kernel/controller/domain/controller-round-transition-policy.ts::reason.startsWith('round_budget_exhausted:')`,
+  `packages/kernel/controller/application/continuation-service.ts::error.message.startsWith('CONTROLLER_RELAY_ROUND_ALREADY_OPEN:')`,
+  `src/cli/local-bridge/job-store.ts::message.startsWith(\"LOCAL_JOB_ID_REQUIRED:\")`,
+  `src/cli/local-bridge/job-store.ts::message.startsWith(\"LOCAL_JOB_PATH_INVALID:\")`,
+  `src/cli/local-bridge/server.ts::message.startsWith(\"REPOSITORY_SELF_PROTECTED\")`,
+  `src/runtime/control-plane/execution/work-execution-support.ts::reason.includes('infrastructure')`,
+  `src/runtime/control-plane/execution/work-execution-support.ts::reason.includes('terminal')`,
+  `src/runtime/control-plane/execution/work-execution-support.ts::reason.includes('timed out')`,
+  `src/runtime/control-plane/execution/work-execution-support.ts::reason.includes('unavailable')`,
+  `src/runtime/control-plane/execution/work-head-settlement.ts::error.message.includes('CONTROL_PLANE_REVISION_CONFLICT')`,
+  `src/runtime/control-plane/facade/requirement-authority.ts::error.message.startsWith('REQUIREMENT_ALREADY_EXISTS:')`,
+  `src/runtime/control-plane/global-scheduler/reconciliation.ts::message.includes(':')`,
+  `src/runtime/control-plane/global-scheduler/scheduler.ts::error.message.startsWith('LOCK_HELD:')`,
+  `src/runtime/control-plane/launcher/chatgpt-work-continuation.ts::error.message.includes(':')`,
+  `src/runtime/control-plane/persistence/sqlite-store.ts::(error instanceof Error ? error.message : String(error)).startsWith('CONTROL_PLANE_SQLITE_BUSY:')`,
+  `src/runtime/control-plane/persistence/sqlite-store.ts::/database is locked|SQLITE_BUSY/i.test(message)`,
+  `src/runtime/control-plane/persistence/sqlite-store.ts::message.startsWith('CONTROL_PLANE_')`,
+  `src/runtime/control-plane/persistence/sqlite-store.ts::message.startsWith('CONTROL_PLANE_SQLITE_CORRUPT:')`,
+  `src/runtime/execution/process-runtime/lightweight-managed.ts::error.message.startsWith('PROCESS_REQUEST_CONFLICT:')`,
+  `src/runtime/execution/process-runtime/process-runner-entry.ts::message.startsWith('PROCESS_RUNNER_ALREADY_STARTED:')`,
+  `src/runtime/execution/process-runtime/process-runner-entry.ts::message.startsWith('PROCESS_RUNNER_RECEIPT_CORRUPT:')`,
+  `src/runtime/execution/thin-harness/fast-executor.ts::message.includes(':')`,
+  `src/runtime/execution/thin-harness/fast-executor.ts::message.includes('\\0')`,
+  `src/runtime/execution/thin-harness/fingerprint-worker.ts::error.message.startsWith('SNAPSHOT_BUDGET')`,
+  `src/runtime/execution/thin-harness/fingerprint-worker.ts::message.startsWith('CANCELLED')`,
+  `src/runtime/execution/thin-harness/fingerprint-worker.ts::message.startsWith('SNAPSHOT_BUDGET')`,
+  `src/runtime/execution/thin-harness/fingerprint-worker.ts::message.startsWith('SNAPSHOT_TOO_DIRTY')`,
+  `src/runtime/execution/thin-harness/fingerprint-worker.ts::message.startsWith('SNAPSHOT_WORKER_TIMEOUT')`,
+  `src/runtime/execution/workers/executor.ts::message.startsWith('LEGACY_JOB_TIMEOUT:')`,
+]);
+requireExactShrinkingInventory(
+  'human-readable semantic authority debt',
+  semanticAuthorityProductionStringMatchRecords(),
+  SEMANTIC_STRING_AUTHORITY_DEBT,
+);
+
+// Kernel V2 B7 graph analysis. Legacy boundary debt below is exact and must only shrink.
+// Inventory is derived from the production graph before the gate is activated.
 function stronglyConnectedComponents(graph) {
   let index = 0;
   const indices = new Map();
@@ -143,7 +631,7 @@ function stronglyConnectedComponents(graph) {
 }
 
 function requireAcyclicProductionTypeScript() {
-  const graph = relativeStaticTypeScriptDependencyGraph('src');
+  const graph = productionStaticTypeScriptDependencyGraph();
   const cyclic = stronglyConnectedComponents(graph).filter((component) =>
     component.length > 1 || (component.length === 1 && graph.get(component[0])?.has(component[0])),
   );
@@ -159,7 +647,7 @@ const architectureRootMarkdown = readdirSync(resolve(root, 'docs/architecture'),
   .sort();
 for (const name of architectureRootMarkdown) {
   if (!allowedArchitectureRootMarkdown.has(name)) {
-    failures.push(`docs/architecture/${name} must be archived under docs/architecture/history/ instead of acting as parallel root architecture authority`);
+    failures.push(`docs/architecture/${name} must be merged into CURRENT.md/EVOLUTION.md or deleted instead of acting as parallel root architecture authority; Git history is the archive`);
   }
 }
 
@@ -170,7 +658,7 @@ for (const path of ['README.md', 'docs/ROADMAP.md', 'docs/architecture/CURRENT.m
 }
 
 const required = [
-  'src/runtime/gateway/mcp/router.ts',
+  'adapters/mcp/runtime-gateway/router.ts',
   'src/cli/agent-jobs/executable-resolver.ts',
   'src/runtime/control-plane/global-scheduler/scheduler.ts',
   'src/runtime/control-plane/global-scheduler/config.ts',
@@ -195,27 +683,59 @@ const required = [
   'src/runtime/execution/workers/worker-entry.ts',
   'src/runtime/execution/thin-harness/index.ts',
   'src/runtime/execution/thin-harness/execution-router.ts',
-  'src/runtime/control-plane/routing/route-policy.ts',
-  'src/runtime/control-plane/routing/workspace-admission.ts',
   'src/runtime/control-plane/facade/requirement-authority.ts',
   'src/runtime/control-plane/facade/repository-work-admission.ts',
   'src/runtime/control-plane/execution/retained-work-resume.ts',
   'src/runtime/control-plane/execution/work-handle-authority.ts',
   'src/runtime/control-plane/execution/work-verification-context.ts',
   'src/runtime/control-plane/execution/work-verification-service.ts',
+  'src/runtime/control-plane/execution/implementation-review-content.ts',
+  'packages/protocols/handoff/status.ts',
+  'packages/kernel/work/domain/implementation-review.ts',
+  'packages/kernel/work/domain/state-machine.ts',
+  'packages/kernel/identity/domain/scope.ts',
+  'packages/kernel/memory/domain/operational-prior.ts',
+  'packages/kernel/memory/api/index.ts',
+  'packages/kernel/memory/index.ts',
+  'src/runtime/evidence/operational-shadow.ts',
+  'src/runtime/control-plane/persistence/operational-prior-store.ts',
+  'evaluation/lib/shadow-operational-prior.ts',
+  'packages/kernel/work/domain/check-receipt.ts',
+  'packages/kernel/work/domain/execution-snapshot.ts',
+  'packages/kernel/work/domain/repository-completion-receipt.ts',
+  'packages/kernel/work/domain/types.ts',
+  'packages/kernel/work/application/work-service.ts',
+  'packages/kernel/work/ports/work-contract-store.ts',
+  'packages/kernel/work/infrastructure/work-contract-store.ts',
+  'packages/kernel/work/api/index.ts',
+  'packages/kernel/controller/domain/types.ts',
+  'packages/kernel/controller/ports/controller-host.ts',
+  'packages/kernel/controller/infrastructure/controller-session-store.ts',
+  'packages/kernel/controller/application/controller-service.ts',
+  'packages/kernel/controller/api/index.ts',
   'src/runtime/control-plane/execution/repository-work-attribution.ts',
   'src/runtime/control-plane/execution/work-completion-authority.ts',
   'src/runtime/control-plane/execution/work-evidence-policy.ts',
   'src/runtime/control-plane/execution/work-execution-support.ts',
-  'src/runtime/control-plane/execution/work-finalization-service.ts',
   'src/runtime/control-plane/execution/work-preparation-service.ts',
   'src/runtime/control-plane/execution/work-operation-service.ts',
-  'src/runtime/control-plane/facade/work-state-machine.ts',
   'src/runtime/evidence/process-check-execution.ts',
   'src/runtime/context/semantic-navigation-contract.ts',
-  'src/cli/mcp/tool-contract.ts',
+  'packages/protocols/mcp/tool-contract.ts',
+  'packages/protocols/mcp/execution-context.ts',
   'src/cli/github/contracts.ts',
-  'src/runtime/gateway/mcp/runtime-tool-definitions.ts',
+  'adapters/mcp/runtime-gateway/runtime-tool-definitions.ts',
+  'adapters/mcp/server.ts',
+  'adapters/mcp/oauth.ts',
+  'adapters/mcp/multi-repository.ts',
+  'adapters/mcp/toolset.ts',
+  'adapters/mcp/tool-mapping/tools.ts',
+  'adapters/mcp/tool-mapping/legacy-tool-service.ts',
+  'adapters/mcp/tool-mapping/repository-tools.ts',
+  'adapters/mcp/tool-mapping/access-tools.ts',
+  'adapters/mcp/transports/http.ts',
+  'adapters/mcp/transports/stdio.ts',
+  'adapters/mcp/transports/session-registry.ts',
   'docs/architecture/CURRENT.md',
   'src/runtime/resources/leases/store.ts',
   'src/runtime/evidence/event-ledger.ts',
@@ -245,17 +765,138 @@ const required = [
 ];
 for (const path of required) text(path);
 requireAcyclicProductionTypeScript();
+// Operational priors retain their bounded mechanical consumers. The accepted
+// assistant-loop ADR adds semantic experience through its own API/adapter;
+// neither consumer may move persistence or semantic acceptance into the reducer.
+const stage7fMemoryImports = staticTypeScriptImportRecords(productionTypeScriptFiles());
+const stage7fKernelMemoryConsumers = new Set([
+  'src/runtime/evidence/operational-shadow.ts',
+  'src/runtime/control-plane/persistence/operational-prior-store.ts',
+  'src/runtime/context/assistant-context.ts',
+  'src/runtime/context/assistant-work-context.ts',
+  'src/runtime/control-plane/persistence/experience-store.ts',
+  'src/cli/commands/brain-assistant.ts',
+]);
+const stage7fOperationalStoreConsumers = new Set([
+  'src/runtime/control-plane/execution/work-verification-service.ts',
+  'src/runtime/execution/process-runtime/check-facade.ts',
+]);
+for (const { from, specifier } of stage7fMemoryImports) {
+  if (from.startsWith('packages/kernel/memory/') && /(?:src\/runtime|control-plane|sqlite-store|context-plane)/.test(specifier)) {
+    failures.push(`Stage7F Kernel Memory must remain pure and persistence-free: ${from} -> ${specifier}`);
+  }
+  if (/packages\/kernel\/memory/.test(specifier)
+      && !stage7fKernelMemoryConsumers.has(from)
+      && !from.startsWith('packages/kernel/memory/')) {
+    failures.push(`Stage7F Memory has an unauthorized production consumer: ${from} -> ${specifier}`);
+  }
+  if (/operational-shadow/.test(specifier) && from !== 'src/runtime/control-plane/persistence/operational-prior-store.ts') {
+    failures.push(`Stage7F typed operational extractor may feed only the derived persistence adapter: ${from} -> ${specifier}`);
+  }
+  if (/operational-prior-store/.test(specifier) && !stage7fOperationalStoreConsumers.has(from)) {
+    failures.push(`Stage7F operational Memory store has an unauthorized active consumer: ${from} -> ${specifier}`);
+  }
+}
+forbid('src/runtime/control-plane/persistence/operational-prior-store.ts', /context-plane|brain|pks|requirement-authority|plan-contract|approval|authorization/, 'Stage7F operational Memory must remain mechanical derived state only');
+requireText('src/runtime/control-plane/persistence/operational-prior-store.ts', "OPERATIONAL_MEMORY_NAMESPACE = 'operational_memory_prior'");
+requireText('src/runtime/control-plane/persistence/operational-prior-store.ts', 'resolveCheckCompletionGraceWaitMs');
+requireText('src/runtime/execution/process-runtime/check-facade.ts', 'resolveCheckCompletionGraceWaitMs');
 for (const path of sourceFiles('src/runtime/control-plane')) {
   forbid(path, /(?:from\s+['"]|import\s*\(\s*['"])(?:\.\.\/)+gateway\//, 'control-plane domain/application code must not depend on Gateway transport');
 }
-requireText('src/runtime/control-plane/routing/route-policy.ts', "export function decideRoute");
-requireText('src/runtime/control-plane/routing/route-policy.ts', 'inputFingerprint');
-requireText('src/runtime/control-plane/routing/route-policy.ts', 'policyVersion');
+for (const path of [
+  'adapters/mcp/tool-mapping/repository-tools.ts',
+  'adapters/mcp/tool-mapping/legacy-tool-service.ts',
+  'adapters/mcp/runtime-gateway/runtime-observation-adapter.ts',
+]) {
+  forbid(path, /assessWorkMode|parseExplicitTaskMode|assess_work_mode|assess_work_request|recommendedMode\s*:/, 'production capability/context surfaces must not expose or infer engineering work modes');
+}
+// Engineering execution strategy belongs to the model. Forge must not carry a
+// route/mode/driver vocabulary, a task-size or complexity heuristic, or a
+// second router that decides Direct/Work/Goal, worker/provider, verify, review,
+// or completion on the model's behalf.
+requireMissing('src/runtime/control-plane/routing/route-policy.ts');
+requireMissing('src/runtime/control-plane/routing/index.ts');
+for (const path of [...sourceFiles('src'), ...sourceFiles('adapters'), ...sourceFiles('packages')]) {
+  forbid(
+    path,
+    /\bRouteExecutionMode\b|\bRouteWorkMode\b|\bRouteExecutionPath\b|\bExplicitTaskMode\b|\bWorkRouteDecisionSnapshot\b|\bWorkContractDriverPolicy\b|\bExecutionModeSelection\b|\bselectExecutionMode\b|\bmodeInput\b/,
+    'Forge must not model engineering execution modes, work modes, execution paths, drivers, or mode selection',
+  );
+  forbid(
+    path,
+    /['"](?:direct_control|goal_workloop|handoff_only)['"]/,
+    'retired engineering mode tokens must not return as typed Forge vocabulary',
+  );
+  forbid(
+    path,
+    /\bdirect_edit\b\s*\|\s*['"]bounded_work['"]|['"]bounded_work['"]\s*\|\s*['"]quick_agent['"]|['"]quick_agent['"]\s*\|\s*['"]issue_task['"]/,
+    'retired work-mode vocabulary must not return',
+  );
+}
+forbid(
+  'packages/kernel/work/domain/types.ts',
+  /\bmode:\s*ExecutionMode\b|\bdriver:\s*WorkContractDriverPolicy\b|routeDecision/,
+  'WorkContract must persist no engineering-mode, driver, or route-decision authority',
+);
+for (const path of [...sourceFiles('src'), ...sourceFiles('adapters')]) {
+  forbid(
+    path,
+    /\bisSmallScopedTask\b|\bsmallScopedTask\b|\bdurableWorkRequired\b|\bcoordinationRequired\b|\bexplicitParallelMode\b|\bexpectedFiles\b|\bexpectedChangedLines\b|\brequiresInvestigation\b|\brequiresLongRunningChecks\b|\brequiresParallelism\b|\bindependentTaskCount\b|\bagentRequested\b|\broutingKey\(|\bproviderOrder\(|\bKIND_RANK\b/,
+    'Forge must not infer engineering method, worker choice, or Work topology from task size, complexity, path classification, or semantic intent',
+  );
+}
+forbid(
+  'src/runtime/plugins/store.ts',
+  /acceptSubmittedWorkContract|localSystemActionRequiresWork/,
+  'plugin capability execution must not manufacture semantic Work from action risk',
+);
+forbid(
+  'src/runtime/control-plane/facade/goal-workloop.ts',
+  /repositoryChangeIntent|directEditWithinBoundary|maxChangedFiles\s*<|maxChangedLines\s*</,
+  'Work-kind classification must not be inferred from predicted scope size or a task-size threshold',
+);
+forbid(
+  'src/runtime/control-plane/facade/goal-workloop.ts',
+  /linkedEngineeringBlockerWorkId|work-linked-engineering-blocker-/,
+  'continuation must not manufacture child Work; an unrelated blocker names an explicitly created owning Work',
+);
+requireText('src/runtime/control-plane/facade/goal-workloop.ts', 'ENGINEERING_BLOCKER_LINKED_WORK_REQUIRED');
+for (const path of [...sourceFiles('src'), ...sourceFiles('adapters')]) {
+  forbid(path, /operation:\s*['"](?:plan_approve|plan_accept_step|plan_supersede)['"]/, 'retired Plan approval/acceptance/supersession operations must not be advertised or suggested');
+}
+forbid(
+  'src/runtime/control-plane/facade/rh-work-operation-contract.ts',
+  /plan_approve|plan_accept_step|plan_supersede/,
+  'retired Plan lifecycle operations must not remain accepted rh_work ABI operations',
+);
+for (const path of [
+  'src/runtime/control-plane/facade/goal-workloop.ts',
+  'src/runtime/control-plane/facade/goal-workloop-access.ts',
+  'src/cli/local-bridge/facade-api.ts',
+  'src/cli/local-bridge/server.ts',
+]) {
+  forbid(path, /force_mode|forceMode/, 'retired mode-override tokens must not return as caller-visible input');
+}
+requireText('src/runtime/plugins/capability-authorization-grants.ts', 'migrateLegacyPluginCapabilityGrants');
+requireText('src/runtime/plugins/capability-authorization-grants.ts', 'findActiveCanonicalGrant');
+requireText('src/runtime/plugins/capability-authorization-grants.ts', 'legacyPluginGrantMigrationMarkerPath');
+forbid(
+  'src/runtime/plugins/capability-authorization-grants.ts',
+  /saveStore\(|writeJsonAtomic\(\s*pluginCapabilityAuthorizationGrantStorePath|writeFileSync/,
+  'the legacy plugin capability authorization file is migration input only; the canonical Grant authority is the single writer',
+);
+for (const path of [
+  ...sourceFiles('src/runtime/control-plane'),
+  ...sourceFiles('adapters/mcp'),
+]) {
+  forbid(path, /directEditWithinBoundary|DirectEditBoundary/, 'task-size authorization shortcuts must not be reintroduced');
+}
 requireText('src/runtime/control-plane/execution/work-verification-service.ts', 'runPersistedCheckViaProcessRuntime({');
 requireText('src/runtime/control-plane/execution/work-verification-service.ts', 'interactiveWaitMs: input.interactiveWaitMs ?? 0');
 requireText('src/runtime/control-plane/execution/work-verification-service.ts', 'checkContentRevision');
 requireText('src/runtime/control-plane/execution/work-verification-service.ts', 'observedGitHead');
-requireText('src/runtime/gateway/mcp/runtime-tools.ts', 'executeWorkVerification({');
+forbid('adapters/mcp/runtime-gateway/work-adapter.ts', /executeWorkVerification|recordWorkCheckEvidence/, 'rh_work must not execute or attribute repository checks');
 requireText('src/cli/local-bridge/facade-api.ts', 'executeWorkVerification({');
 forbid(
   'src/cli/local-bridge/facade-api.ts',
@@ -263,7 +904,7 @@ forbid(
   'Local Bridge Work verification must use the canonical persisted Work verification service',
 );
 forbid(
-  'src/runtime/gateway/mcp/runtime-tools.ts',
+  'adapters/mcp/runtime-gateway/runtime-tools.ts',
   /function\s+classifyTerminalCheckEvidence\s*\(/,
   'terminal Check evidence classification belongs to Process Runtime, not the Gateway transport',
 );
@@ -272,20 +913,83 @@ forbid(
   /runControllerCheck\s*\(/,
   'route Work verification through persisted Process Runtime instead of synchronous check execution',
 );
-for (const adapter of [
-  'src/cli/controller/work-mode.ts',
-  'src/runtime/control-plane/facade/types.ts',
+
+
+// Thin Work authority: semantic state is open/completed/cancelled. Review and
+// verification may exist as evidence/capabilities, never as generic Work/Git
+// admission authority. The old delivery/finalizer modules are intentionally gone.
+requireText('packages/kernel/work/domain/types.ts', "export const SEMANTIC_WORK_STATES = ['open', 'completed', 'cancelled'] as const;");
+requireText('packages/kernel/work/domain/types.ts', 'export type SemanticWorkState = (typeof SEMANTIC_WORK_STATES)[number];');
+requireText('packages/kernel/work/api/index.ts', "export * from '../application/work-service'");
+requireText('src/cli/repositories/selected-path-actions.ts', 'beforeCommitGuard');
+requireMissing('src/runtime/control-plane/execution/direct-edit-work-completion.ts');
+requireMissing('src/runtime/control-plane/execution/content-equivalent-commit-authority.ts');
+requireMissing('src/runtime/control-plane/execution/work-finalization-service.ts');
+forbid('adapters/mcp/runtime-gateway/work-adapter.ts', /ImplementationReview|executeWorkVerification|work_finalize/, 'rh_work must not regain review, verification, or finalization behavior authority');
+forbid('src/cli/repositories/selected-path-actions.ts', /ImplementationReview|workRequiresImplementationReview|requestWorkImplementationReview/, 'repository Git safety must not depend on Work review methodology');
+
+// The model-facing rh_work surface is the thin semantic ABI: the schema enum must
+// come from the single operation registry, that registry's model list must not
+// re-advertise legacy engineering lifecycle verbs, and the schema must not
+// hand-write lifecycle-only inputs. Legacy verbs stay reachable only through the
+// bounded server-side compatibility carrier, never as advertised model surface.
+requireText('adapters/mcp/runtime-gateway/runtime-tool-definitions.ts', '[...RH_WORK_MODEL_OPERATIONS]');
+forbid(
+  'adapters/mcp/runtime-gateway/runtime-tool-definitions.ts',
+  /review_decision|implementation_review_findings|review_rationale|requiredPlanStepId/,
+  'the model-facing rh_work schema must not hand-write legacy lifecycle review inputs',
+);
+const rhWorkOperationContract = text('src/runtime/control-plane/facade/rh-work-operation-contract.ts');
+const rhWorkModelOperations = (rhWorkOperationContract.match(/RH_WORK_MODEL_OPERATIONS = \[([\s\S]*?)\] as const/) ?? [])[1] ?? '';
+if (!rhWorkModelOperations.trim()) {
+  failures.push('rh_work operation contract must define RH_WORK_MODEL_OPERATIONS as the thin model-facing ABI');
+}
+for (const legacyModelVerb of [
+  'continue', 'verify', 'review', 'finalize', 'stop', 'delegate',
+  'controller_claim', 'controller_release', 'controller_disposition', 'controller_get_owner',
 ]) {
-  requireText(adapter, '@deprecated Compatibility adapter');
-  requireText(adapter, 'decideRoute(');
-  forbid(adapter, /expectedFiles\s*>|expectedChangedLines\s*>|KIND_RANK|providerOrder\s*\(/, 'delegate all routing thresholds and provider selection to Route Policy');
+  if (new RegExp(`['"]${legacyModelVerb}['"]`).test(rhWorkModelOperations)) {
+    failures.push(`RH_WORK_MODEL_OPERATIONS must not re-advertise the legacy engineering lifecycle verb: ${legacyModelVerb}`);
+  }
 }
-let routeAuthorityCount = 0;
+requireText('packages/kernel/controller/infrastructure/controller-round-store.ts', 'readControllerRoundContextSnapshot');
+const controllerRoundTransitionPolicyPath = 'packages/kernel/controller/domain/controller-round-transition-policy.ts';
+if (existsSync(resolve(root, controllerRoundTransitionPolicyPath))) {
+  requireText(controllerRoundTransitionPolicyPath, "case 'provider_dispatch_outcome_unknown'");
+  requireText(controllerRoundTransitionPolicyPath, "blockedReason: 'provider_dispatch_outcome_unknown'");
+  forbid(
+    'packages/kernel/controller/infrastructure/controller-round-store.ts',
+    /blockedReason\s*(?:===|:)\s*['"]provider_dispatch_outcome_unknown['"]/,
+    'ControllerRound outcome-unknown lifecycle semantics must be owned by the canonical transition policy, not the store',
+  );
+} else {
+  requireText('packages/kernel/controller/infrastructure/controller-round-store.ts', "blockedReason === 'provider_dispatch_outcome_unknown'");
+  requireText('packages/kernel/controller/infrastructure/controller-round-store.ts', "blockedReason: 'provider_dispatch_outcome_unknown'");
+}
+requireText('src/runtime/control-plane/launcher/chatgpt-work-continuation.ts', 'CHATGPT_AUTOMATION_SUBMISSION_OUTCOME_UNKNOWN');
+requireMissing('adapters/chatgpt/controller-host.ts');
+requireText('packages/kernel/controller/application/continuation-service.ts', 'const outcomeUnknown =');
+requireText('packages/kernel/controller/application/continuation-service.ts', 'outcomeUnknown });');
+requireText('adapters/chatgpt/controller-round-host.ts', 'buildChatgptControllerRoundPrompt');
+requireText('adapters/chatgpt/controller-round-settlement-store.ts', 'recordChatgptControllerRoundSettlement');
+forbid('packages/kernel/controller/infrastructure/controller-round-store.ts', /browserSessionId|conversationUrl|recordControllerRoundTabSettlement|buildControllerRoundRelayPrompt|capability_id=/, 'Kernel ControllerRound must remain provider/transport neutral; ChatGPT/MCP rendering and settlement belong to adapters');
+forbid(
+  'src/runtime/control-plane/global-scheduler/maintenance.ts',
+  /beginControllerRoundProviderDispatch|runWorkChatgptContinuation|createChatgptControllerHost/,
+  'Scheduler maintenance must never become a Work-bound ChatGPT provider writer',
+);
+forbid(
+  'adapters/mcp/runtime-gateway/runtime-tools.ts',
+  /function\s+(?:assert|evaluate|derive)[A-Za-z0-9_]*ImplementationReview/,
+  'Gateway transport must not implement implementation-review policy authority',
+);
+requireMissing('src/runtime/control-plane/execution/work-finalization-service.ts');
+requireMissing('src/cli/controller/work-mode.ts');
+forbid('src/runtime/control-plane/facade/types.ts', /repeated_infrastructure_failure|codex_worker_requires_review/, 'Handoff compatibility types may represent only genuine human blockers');
 for (const path of sourceFiles('src')) {
-  routeAuthorityCount += (text(path).match(/export function decideRoute\s*\(/g) ?? []).length;
+  forbid(path, /export function decideRoute\s*\(/, 'Route Policy was deleted; Forge must not regain an execution-strategy router');
   forbid(path, /requirePlanForGoalWorkloop\s*:\s*true/, 'never restore mandatory Plan gating in production');
 }
-if (routeAuthorityCount !== 1) failures.push(`exactly one decideRoute authority is required; found ${routeAuthorityCount}`);
 forbid(
   'src/runtime/control-plane/facade/goal-workloop.ts',
   /function\s+(?:evaluateWorkCompletionEvidence|evaluateWorkImplementationEvidence|verificationRecordAppliesToCurrentWorkspace)\s*\(/,
@@ -293,14 +997,175 @@ forbid(
 );
 requireText('src/runtime/control-plane/facade/goal-workloop.ts', "from '../execution/work-evidence-policy'");
 for (const path of sourceFiles('src/runtime/control-plane')) {
-  if (path === 'src/runtime/control-plane/facade/work-contract-store.ts' || path === 'src/runtime/control-plane/execution/work-completion-authority.ts') continue;
+  if (path === 'src/runtime/control-plane/execution/work-completion-authority.ts') continue;
   forbid(
     path,
     /\brecordWorkCompletionReceipt\s*\(/,
     'route Work completion through the canonical work-completion-authority instead of writing terminal receipts directly',
   );
 }
-requireText('src/runtime/control-plane/execution/work-finalization-service.ts', 'completeWorkWithReceipt(');
+// B2 ownership fence: production code may consume only the Kernel Work API/domain,
+// never the retired facade store/state-machine or Kernel persistence implementation.
+for (const path of sourceFiles('src')) {
+  forbid(path, /(?:from\s+['"]|import\s*\(\s*['"])[^'"]*(?:work-contract-store|work-implementation-review)['"]/, 'production source must consume packages/kernel/work instead of retired Work facade authority');
+  forbid(path, /packages\/kernel\/work\/infrastructure\/work-contract-store/, 'production source must consume the Work application/API boundary, not persistence infrastructure');
+}
+for (const record of genericWorkLifecycleMutationRecords([...sourceFiles('src'), ...sourceFiles('adapters')])) {
+  failures.push(`${record.path}:${record.line} violates Work lifecycle authority: updateWorkContract patch owns ${record.fields.join(', ')}; use explicit Kernel lifecycle commands`);
+}
+forbid(
+  'adapters/mcp/runtime-gateway/runtime-tools.ts',
+  /control-plane\/facade\/work-contract-store|kernel\/work\/infrastructure/,
+  'MCP Gateway must not mutate Work through facade/persistence authority',
+);
+forbid(
+  'adapters/mcp/runtime-gateway/runtime-tools.ts',
+  /\b(?:appendWorkEvidence|recordWorkCompletionReceipt)\s*\(/,
+  'MCP Gateway must submit Work application commands instead of writing lifecycle/evidence records directly',
+);
+requireText('src/runtime/control-plane/facade/goal-workloop.ts', 'packages/kernel/work/api/index');
+requireText('packages/kernel/work/domain/types.ts', 'predecessorWorkId?: string');
+forbid('src/runtime/control-plane/facade/goal-workloop.ts', /PLAN_(?:STEP_|SUCCESSOR_|NOT_EXECUTABLE|EXECUTION_BASELINE)/, 'Work admission must not consult Plan item status, binding, dependency or approval state');
+requireText('src/runtime/control-plane/facade/goal-workloop.ts', "requestedBy ?? 'chatgpt') === 'scheduler'");
+// V2 Goal authority convergence: lifecycle enums are canonical Kernel Goal
+// domain facts and explicit Controller goal_complete is the Requirement semantic
+// acceptance boundary. PlanStep progression is retired: Plan items are authored
+// working memory that never selects, gates or progresses Work.
+requireText('packages/kernel/goal/domain/types.ts', 'export const REQUIREMENT_STATES');
+requireText('packages/kernel/goal/domain/types.ts', 'export const PLAN_CONTRACT_STATUSES');
+requireText('packages/kernel/goal/domain/types.ts', 'export const PLAN_STEP_STATUSES');
+requireText('src/runtime/control-plane/persistence/requirement-store.ts', 'packages/kernel/goal/api/index');
+requireText('src/runtime/control-plane/facade/types.ts', 'packages/kernel/goal/api/index');
+requireText('src/runtime/control-plane/persistence/requirement-store.ts', 'reviseRequirementSemantic');
+requireText('src/runtime/control-plane/facade/plan-contract-store.ts', 'revisePlanSemanticContext');
+requireText('docs/architecture/decisions/20260924-thin-semantic-working-context.md', 'only three cross-domain model-authored semantic records');
+requireText('docs/architecture/decisions/20260924-thin-semantic-working-context.md', 'semantic revision must be applied to the latest persisted aggregate inside the same storage transaction');
+forbid('src/runtime/control-plane/facade/requirement-authority.ts', /continueRequirement|acceptRequirementOutcome|completeRequirementGoal|requirement_semantic_acceptance|requirement_semantic_continue/, 'Requirement semantic state changes must use revisioned requirement_revise CAS only');
+requireText('src/runtime/control-plane/facade/plan-contract-store.ts', 'PLAN_REQUIREMENT_TERMINAL');
+forbid('adapters/mcp/runtime-gateway/work-controller-operations.ts', /completeRequirementGoal|requirementAcceptance/, 'Controller disposition must not complete or accept Requirement semantics');
+forbid('adapters/mcp/runtime-gateway/runtime-tools.ts', /\bacceptRequirementOutcome\s*\(/, 'MCP transport must never own Requirement semantic completion');
+forbid('src/runtime/control-plane/facade/rh-work-operation-contract.ts', /requirement_continue/, 'retired Requirement lifecycle compatibility operation must not remain accepted');
+requireText('adapters/mcp/tool-mapping/post-finalize-work-attribution.ts', 'semanticWorkState(work)');
+forbid('adapters/mcp/tool-mapping/post-finalize-work-attribution.ts', /isTerminalWorkContractStatus|lifecycleClosed|work\.status\s*!==?\s*['"]completed['"]/, 'post-completion readonly attribution must follow semantic Work state, not legacy lifecycle projections');
+forbid('adapters/mcp/runtime-gateway/work-controller-operations.ts', /goal_complete[^\n]{0,200}requirementId|requirementId[^\n]{0,200}goal_complete/, 'Controller goal_complete may settle continuation but must not own Requirement completion');
+// B3 ControllerSession authority and provider-neutral host boundary.
+requireText('packages/kernel/controller/domain/types.ts', 'export interface ControllerBinding');
+requireText('packages/kernel/controller/domain/types.ts', 'export interface ControllerLease');
+requireText('packages/kernel/controller/ports/controller-host.ts', 'export interface ControllerHost');
+requireText('packages/kernel/controller/ports/controller-host.ts', 'resume(binding: ControllerBinding, roundContext: ControllerRoundContext)');
+requireText('packages/kernel/controller/infrastructure/controller-session-store.ts', 'claimControllerSession');
+requireText('packages/kernel/controller/infrastructure/controller-session-store.ts', 'releaseControllerSessionWithAuthority');
+requireText('src/runtime/control-plane/facade/controller-session-store.ts', '@deprecated Kernel V2 compatibility shim');
+forbid('packages/kernel/controller/index.ts', /infrastructure\//, 'Kernel module root must expose only its public API');
+forbid('packages/kernel/controller/application/controller-service.ts', /export\s+\*\s+from\s+['"]\.\.\/infrastructure\//, 'Controller application façade must not wildcard-export infrastructure');
+// B4 Scheduler continuation authority: Schedule owns occurrence state only;
+// continuation resolves exact Work + retained ControllerSession + opaque ControllerBinding
+// and dispatches exclusively through ControllerHost.resume.
+requireText('packages/kernel/scheduler/domain/schedule.ts', 'export interface RepositorySchedule');
+requireText('packages/kernel/scheduler/domain/schedule.ts', 'export interface ScheduleOccurrence');
+requireText('packages/kernel/scheduler/infrastructure/schedule-store.ts', "'occurrences'");
+requireText('packages/kernel/scheduler/infrastructure/schedule-store.ts', 'saveScheduleDecision');
+requireText('packages/kernel/scheduler/application/schedule-service.ts', 'createSchedule');
+requireText('packages/kernel/scheduler/api/index.ts', "../application/schedule-service");
+forbid('packages/kernel/scheduler/api/index.ts', /\.\.\/infrastructure\//, 'Scheduler public API must expose application/domain surfaces, not infrastructure stores');
+requireText('packages/kernel/scheduler/application/eligibility.ts', 'evaluateScheduleTriggerEligibility');
+requireText('packages/kernel/scheduler/application/eligibility.ts', 'evaluateScheduleOccurrenceAdmission');
+requireText('packages/kernel/scheduler/application/eligibility.ts', 'scheduleTriggerWindowKey');
+requireText('packages/kernel/scheduler/application/settlement.ts', 'applyScheduleFailure');
+requireText('packages/kernel/scheduler/application/settlement.ts', 'applyScheduleRetryableFailure');
+requireText('packages/kernel/scheduler/application/settlement.ts', 'settleScheduledExecution');
+requireText('src/runtime/workflow/schedules/settlement.ts', '@deprecated Kernel V2 compatibility shim');
+requireMissing('packages/kernel/scheduler/domain/continuation.ts');
+requireMissing('packages/kernel/scheduler/application/continuation-service.ts');
+requireMissing('packages/kernel/scheduler/infrastructure/continuation-dispatch-store.ts');
+requireText('packages/kernel/controller/application/continuation-service.ts', 'resumeControllerRoundOccurrence');
+requireText('packages/kernel/controller/application/continuation-service.ts', 'getRetainedControllerSession');
+requireText('packages/kernel/controller/application/continuation-service.ts', 'getControllerWorkBinding');
+requireText('packages/kernel/controller/application/continuation-service.ts', 'beginControllerRoundProviderDispatch');
+requireText('packages/kernel/controller/application/continuation-service.ts', 'host.resume(bindingRecord.binding');
+requireText('packages/kernel/controller/infrastructure/controller-round-store.ts', 'controller-provider-dispatch-start');
+requireText('packages/kernel/controller/domain/controller-round-transition-policy.ts', "type: 'provider_dispatch_started'");
+forbid('packages/kernel/controller/application/continuation-service.ts', /scheduler_continuation_dispatch|ScheduledContinuationDispatch/, 'Controller continuation must not recreate Scheduler-owned continuation lifecycle persistence');
+requireText('src/runtime/root/controller-progression-composition.ts', 'reconcileControllerProgression');
+requireText('src/runtime/root/controller-progression-composition.ts', 'ensureWorkflowSupervisorEnrollmentForWork');
+requireText('src/runtime/control-plane/global-scheduler/autonomous-continuation.ts', 'reconcileControllerProgression');
+requireText('src/runtime/workflow/schedules/engine.ts', 'reconcileControllerProgression');
+requireText('adapters/mcp/runtime-gateway/work-controller-operations.ts', 'reconcileControllerProgression');
+forbid(
+  'src/runtime/control-plane/launcher/chatgpt-round-continuation.ts',
+  /beginControllerRoundProviderDispatch|runWorkChatgptContinuation|openChatgptControllerRoundFromSource|continueChatgptControllerRoundFromSource/,
+  'current-source compatibility may close an already-open legacy round but must never send or open a new Work-bound ChatGPT turn',
+);
+forbid(
+  'src/runtime/control-plane/launcher/chatgpt-work-continuation.ts',
+  /runWorkChatgptContinuation|prepareWorkChatgptContinuationTransport/,
+  'Work-bound ChatGPT provider delivery is Workflow Supervisor-owned; this module may expose only standalone prompt and Browser settlement primitives',
+);
+requireText('src/runtime/root/scheduled-controller-composition.ts', 'CHATGPT_CONTROLLER_HOST_SUPERVISOR_OWNED');
+requireText('src/runtime/control-plane/launcher/thin-launcher.ts', 'LAUNCHER_CHATGPT_SUPERVISOR_OWNED');
+requireMissing('adapters/scheduler/controller-binding.ts');
+requireText('adapters/controller-process/controller-host.ts', 'createProcessControllerHost');
+requireText('src/runtime/workflow/schedules/engine.ts', 'workflow_supervisor_owns_outer_turn');
+requireText('src/runtime/root/workflow-supervisor-composition.ts', 'registerWorkflowSupervisorTask');
+requireText('src/runtime/root/workflow-supervisor-composition.ts', 'reserveWorkflowSupervisorEnrollment');
+requireText('supervisor/entry.ts', 'forgeWorkflowSupervisorValidators()');
+forbid('supervisor/client.ts', /reserveWorkflowSupervisorSchedulerRecovery|reserve_scheduler_recovery/, 'Scheduler recovery is not a Supervisor RPC; reconciliation stays on the canonical effect ledger');
+forbid('supervisor/control-plane.ts', /reserveSchedulerRecovery/, 'Scheduler recovery must not regrow as a second Supervisor recovery authority');
+forbid('supervisor/server.ts', /reserve_scheduler_recovery/, 'Supervisor RPC surface must not expose retired Scheduler recovery authority');
+requireText('supervisor/forge-validators.ts', "requirement.state !== 'done'");
+requireText('supervisor/forge-validators.ts', "requirement.state === 'waiting_for_user'");
+forbid('src/runtime/root/workflow-supervisor-composition.ts', /WorkflowSupervisorStore|supervisor\.sqlite|registerTask\(|reserveEffect\(/, 'Forge composition must access Supervisor state only through daemon RPC, never open its database or become a second writer');
+requireText('src/runtime/root/workflow-supervisor-composition.ts', 'workflowSupervisorBoundaryForWork');
+requireText('src/runtime/root/workflow-supervisor-composition.ts', '`forge:${repoId}:work:${workId}`');
+requireText('src/runtime/root/workflow-supervisor-composition.ts', 'registeredTask.taskId');
+forbid('src/runtime/root/workflow-supervisor-composition.ts', /forge:\$\{repoId\}:conversation:\$\{conversationId\}/, 'Supervisor task identity must remain conversation-stable through registration, not be recomputed from the current Work conversation');
+forbid('supervisor/client.ts', /task_has_effect|taskHasAnyEffect/, 'Supervisor boundary is derived from canonical Work+conversation facts; do not add a second ownership projection RPC');
+requireText('src/runtime/workflow/schedules/engine.ts', 'evaluateScheduleTriggerEligibility');
+requireText('src/runtime/workflow/schedules/engine.ts', 'evaluateScheduleOccurrenceAdmission');
+requireText('src/runtime/workflow/schedules/engine.ts', 'controller_session_id');
+requireText('src/runtime/workflow/schedules/engine.ts', 'controller_binding_id');
+requireText('src/runtime/workflow/schedules/store.ts', '@deprecated Kernel V2 compatibility shim');
+requireText('src/runtime/workflow/schedules/store.ts', 'packages/kernel/scheduler/api/index');
+forbid('src/runtime/workflow/schedules/store.ts', /scheduler\/infrastructure\//, 'legacy Schedule shim must route through the Kernel Scheduler public API');
+requireText('src/runtime/workflow/schedules/types.ts', '@deprecated Kernel V2 compatibility shim');
+for (const path of sourceFiles('packages/kernel/scheduler')) {
+  forbid(path, /(?:from\s+['"]|import\s*\(\s*['"])[^'"]*adapters\//, 'Kernel Scheduler must not import provider adapters');
+  forbid(path, /\b(?:runWorkChatgptContinuation|launchSuperController|getChatgptWorkConversationBinding)\b|\bbrowser_session_id\b|\bconversation_url\b|\blaunch_args\b/, 'Kernel Scheduler must not own provider transport or provider binding payload fields');
+}
+forbid('src/runtime/workflow/schedules/engine.ts', /\brunWorkChatgptContinuation\b|\blaunchSuperController\b/, 'Schedule execution must dispatch Controller continuation through Kernel Scheduler + ControllerHost, never launch providers directly');
+for (const path of sourceFiles('src')) {
+  forbid(path, /(?:from\s+['"]|import\s*\(\s*['"])[^'"]*workflow\/schedules\/(?:store|types|settlement)['"]/, 'production source must consume packages/kernel/scheduler instead of retired Schedule store/types/settlement authority');
+}
+for (const path of sourceFiles('src')) {
+  forbid(path, /(?:from\s+['"]|import\s*\(\s*['"])[^'"]*controller-session-store['"]/, 'production source must consume packages/kernel/controller instead of retired ControllerSession facade authority');
+}
+const B7_KERNEL_INTERNAL_COMPATIBILITY_SHIMS = new Set([
+  'src/runtime/control-plane/facade/controller-session-store.ts',
+  'src/runtime/control-plane/facade/work-contract-store.ts',
+  'src/runtime/control-plane/facade/types.ts',
+  'src/runtime/workflow/schedules/settlement.ts',
+  'src/runtime/workflow/schedules/types.ts',
+]);
+// The compatibility-shim ledger may only shrink. A shim with no remaining
+// importer at all is migration debt, not a boundary: delete the file and its
+// entry in the same slice instead of keeping an unused authority surface alive.
+// Shims that survive only because a test still imports them are bounded debt to
+// be removed together with that test, never a reason to keep production authority.
+const shimImportRecords = staticTypeScriptImportRecords([...productionTypeScriptFiles(), ...sourceFiles('tests')]);
+for (const shim of B7_KERNEL_INTERNAL_COMPATIBILITY_SHIMS) {
+  const shimBasename = shim.slice(shim.lastIndexOf('/') + 1).replace(/\.ts$/, '');
+  const importedBy = shimImportRecords.filter((record) => record.from !== shim
+    && (record.specifier === `./${shimBasename}` || record.specifier.endsWith(`/${shimBasename}`)));
+  if (importedBy.length === 0) {
+    failures.push(`${shim} is a dead compatibility shim with no importer; delete it and remove its compatibility-shim entry`);
+  }
+}
+for (const path of sourceFiles('src')) {
+  if (B7_KERNEL_INTERNAL_COMPATIBILITY_SHIMS.has(path)) continue;
+  forbid(path, /packages\/kernel\/[^'"/]+\/(?:domain|application|infrastructure)\//, 'active legacy Runtime code must consume Kernel public api/index surfaces; direct internals are compatibility-boundary-only');
+}
+requireText('src/runtime/control-plane/facade/types.ts', 'packages/kernel/work/domain/types');
+requireText('src/runtime/control-plane/facade/types.ts', 'packages/kernel/controller/domain/types');
 forbid(
   'src/runtime/plugins/browser-handoff-host.ts',
   /browser\/sessions|saveBrowserSession|writeBrowserSession|sessionPath/,
@@ -313,25 +1178,29 @@ forbid(
 );
 requireText('src/runtime/plugins/browser-runtime.ts', 'browserActionCanReplayAfterDispatch');
 forbid(
-  'src/runtime/gateway/mcp/runtime-tools.ts',
+  'adapters/mcp/runtime-gateway/runtime-tools.ts',
   /\b(?:createRequirement|resumeRetainedCancelledWorkContract)\s*\(/,
   'keep Requirement admission and retained-cancelled Work lifecycle authority out of the MCP transport',
 );
 forbid(
-  'src/runtime/gateway/mcp/runtime-tools.ts',
+  'adapters/mcp/runtime-gateway/runtime-tools.ts',
   /\b(?:updateWorkContract|writeWorkHandle)\s*\(/,
   'keep WorkContract/WorkHandle persistence policy out of the MCP transport',
 );
 forbid(
-  'src/runtime/gateway/mcp/execution-tools.ts',
+  'adapters/mcp/runtime-gateway/execution-tools.ts',
   /\bcreateWorkContract\s*\(/,
   'route compatibility work preparation through canonical Work admission authority',
 );
 forbid(
-  'src/cli/mcp/legacy-tool-service.ts',
+  'adapters/mcp/tool-mapping/legacy-tool-service.ts',
   /\bcreateWorkContract\s*\(/,
   'keep the legacy MCP surface as translation over canonical Work admission authority',
 );
+requireMissing('src/runtime/control-plane/routing/workspace-admission.ts');
+forbid('packages/kernel/work/domain/types.ts', /requireHandoffOnAmbiguity|requireWorktree|directMainProhibited/, 'retired Work placement/handoff policy fields must not return as durable authority');
+forbid('adapters/mcp/runtime-gateway/work-adapter.ts', /require_handoff_on_ambiguity|require_worktree|direct_main_prohibited/, 'retired placement/handoff wire flags must not drive repository topology');
+forbid('src/cli/controller/execution-policy.ts', /requiresHumanAcceptance|autoRunDeclaredChecks|autoCompleteAfterSuccessfulRun|requiresScopedPaths|requiresDiffEvidence|requiresAnyVerificationEvidence|requiresAcceptanceEvidence|READ_ONLY_INTENT|DESTRUCTIVE_INTENT|SENSITIVE_PATH_PATTERNS/, 'task risk/text/path classification must not decide workflow, placement, verification, scope, or acceptance authority');
 requireMissing('src/runtime/control-plane/daemon-entry.ts');
 requireMissing('scripts/smoke-runtime-control-plane.ts');
 requireMissing('src/cli/controller/lifecycle.ts');
@@ -356,6 +1225,55 @@ requireMissing('src/runtime/bootstrap/runtime-authority.ts');
 requireMissing('src/runtime/bootstrap/activation-transaction.ts');
 requireMissing('src/runtime/bootstrap/stable-bootstrap.ts');
 requireMissing('src/runtime/supervisor');
+requireText('supervisor/store.ts', 'BEGIN IMMEDIATE');
+requireText('supervisor/store.ts', 'completions_one_per_source_effect');
+requireText('supervisor/store.ts', 'WORKFLOW_SUPERVISOR_SOURCE_EFFECT_COMPLETION_CONFLICT');
+requireText('supervisor/paths.ts', 'resolveControllerHome');
+requireText('supervisor/paths.ts', "join(resolveWorkflowSupervisorForgeHome(controllerHome), 'supervisor')");
+forbid('supervisor/paths.ts', /control-plane\/persistence\/sqlite-store|workflow-run-store|packages\/kernel\/(?:work|controller)/, 'Workflow Supervisor path authority may share the canonical Controller Home root but must not depend on lower lifecycle persistence or Kernel authorities');
+forbid('supervisor/store.ts', /resolveControllerHome|FORGE_CONTROLLER_HOME|control-plane\/persistence\/sqlite-store|workflow-run-store|packages\/kernel\/(?:work|controller)/, 'Workflow Supervisor persistence must resolve its root only through supervisor/paths and remain a separate database authority');
+requireMissing('supervisor/service.ts');
+requireText('src/runtime/root/runtime.ts', 'startWorkflowSupervisorRuntime');
+requireText('src/runtime/root/runtime.ts', 'WORKFLOW_SUPERVISOR_STOPPED');
+requireText('src/runtime/root/workflow-supervisor-runtime.ts', 'startWorkflowSupervisorRuntime(controllerHome: string)');
+requireText('src/runtime/root/workflow-supervisor-runtime.ts', 'new WorkflowSupervisorStore(forgeHome, {');
+requireText('src/runtime/root/workflow-supervisor-runtime.ts', 'activeReleaseId: () => getRuntimeWriteClaim()?.releaseId');
+requireText('src/runtime/root/workflow-supervisor-runtime.ts', 'createWorkflowSupervisorServer');
+requireText('src/runtime/root/workflow-supervisor-runtime.ts', 'startWorkflowSupervisorNativeBrowserAdapter');
+requireText('supervisor/native-browser-adapter.ts', 'targetPort: ComputerChatgptConversationTargetPort;');
+forbid('supervisor/native-browser-adapter.ts', /MacOs|AppleEvents|browser-macos-bridge|\bwindowId\b|\btabId\b|window\.name/, 'Workflow Supervisor browser consumer must depend only on the provider-neutral Computer ChatGPT target port');
+forbid('supervisor/native-browser-adapter.ts', /supervisor\/store|sqlite|scheduler|packages\/kernel\/(?:work|controller)|control-plane\/persistence/, 'Native Supervisor browser adapter is transport-only and must not own durable lifecycle, Scheduler, Work, Controller, or persistence authority');
+requireText('src/runtime/root/workflow-supervisor-composition.ts', 'resolveWorkflowSupervisorForgeHome(options.controllerHome)');
+forbid('src/runtime/root/workflow-supervisor-runtime.ts', /createPlatformServiceManagerHost|launchd|systemd|startDetached/, 'Workflow Supervisor reuses the Canonical Runtime process lifecycle and must not own a second OS service');
+requireText('supervisor/entry.ts', "argument('--controller-home')");
+forbid('supervisor/entry.ts', /FORGE_HOME|--forge-home/, 'Workflow Supervisor foreground entry must use the canonical Controller Home authority rather than a second Forge-home root');
+requireText('supervisor/control-plane.ts', 'await validator(task, parsed.proposal)');
+requireText('supervisor/protocol.ts', 'SUPERVISOR_BLOCK_END');
+requireText('supervisor/server.ts', 'createWorkflowSupervisorServer');
+forbid('supervisor/server.ts', /from ['"]\.\/store['"]|supervisor\.sqlite|BEGIN IMMEDIATE/, 'Supervisor transport must relay typed commands through the control plane and never own persistence');
+requireText('adapters/computer/chrome-extension/manifest.json', 'nativeMessaging');
+requireText('adapters/computer/chrome-extension/background.js', 'computer_extension_claim');
+requireText('adapters/computer/chrome-extension/background.js', 'computer_extension_complete');
+requireText('adapters/computer/chrome-extension/background.js', 'chrome.runtime.connectNative');
+forbid('adapters/computer/chrome-extension/background.js', /browser_begin_effect|browser_observe_effect|browser_poll|browser_tasks|browser_observe_assistant|task_register|reserve_enrollment/, 'Computer Chrome provider must not consume or mutate Workflow Supervisor effect authority; it executes only typed Computer target commands');
+requireText('adapters/computer/chrome-extension/content.js', 'ForgeComputerChatgptCore');
+requireMissing('supervisor/chrome-extension');
+requireText('src/runtime/plugins/browser-adapter.ts', "browserMode: browserMode(raw.browserMode) ?? 'managed_persistent'");
+requireText('src/runtime/plugins/browser-adapter.ts', "nativeAttachMode: browserNativeAttachMode(raw.nativeAttachMode) ?? 'disabled'");
+requireText('supervisor/native-messaging/host.ts', 'ALLOWED_BROWSER_METHODS');
+requireText('supervisor/native-messaging/host.ts', 'computer_extension_claim');
+forbid('supervisor/native-messaging/host.ts', /['"](?:browser_tasks|browser_poll|browser_begin_effect|browser_observe_effect|browser_observe_dispatch_failure|browser_observe_provider_turn|browser_observe_assistant|bootstrap_poll|bootstrap_project_url|bootstrap_begin_effect|bootstrap_observe_effect|bootstrap_bind_conversation)['"]/, 'Chrome Native Messaging transport must not expose Workflow Supervisor effect RPCs; extension traffic terminates at Computer target commands');
+requireText('supervisor/store.ts', 'recordEffectNotAppliedProof');
+requireText('supervisor/store.ts', '`effect-dispatch:${effectId}:${generation}`');
+requireText('supervisor/control-plane.ts', 'PERSISTED_BROWSER_EVIDENCE_KEYS');
+requireText('supervisor/control-plane.ts', "reason: 'not_applied_proof_incomplete'");
+requireText('supervisor/server.ts', "if (!['applied','unknown'].includes(outcome))");
+forbid('adapters/computer/chrome-extension/background.js', /chrome\.storage|supervisor\.sqlite|BEGIN IMMEDIATE/, 'Computer Chrome provider must reconstruct provider bindings from live inventory and Computer target authority rather than browser shadow persistence');
+forbid('adapters/computer/chrome-extension/content.js', /chrome\.storage|supervisor\.sqlite|BEGIN IMMEDIATE/, 'Computer Chrome content script must remain a page capability surface rather than durable authority');
+forbid('supervisor/native-messaging/host.ts', /task_register|reserve_enrollment|supervisor\.sqlite|BEGIN IMMEDIATE|bun:sqlite|node:sqlite|from ['"][^'"]*(?:store|control-plane)['"]/, 'Chrome Native Messaging host must remain a stateless browser-method relay and never own Supervisor persistence/lifecycle');
+forbid('adapters/computer/chrome-extension/background.js', /task_register|reserve_enrollment|supervisor\.sqlite|BEGIN IMMEDIATE|chrome\.storage/, 'Computer Chrome provider must never become durable workflow authority');
+forbid('adapters/computer/chrome-extension/content.js', /task_register|reserve_enrollment|supervisor\.sqlite|BEGIN IMMEDIATE|chrome\.storage/, 'Computer Chrome content script must observe/execute one exact page only and never own durable workflow state');
+
 requireMissing('docs/architecture/current/stable-external-runtime-supervisor.md');
 requireMissing('docs/architecture/modules/controller-runtime/stable-supervisor.md');
 requireMissing('docs/operations/stable-external-runtime-supervisor.md');
@@ -368,10 +1286,10 @@ requireMissing('docs/architecture/transactional-adoption-planner.md');
 requireMissing('docs/architecture/global-hook-runtime.md');
 requireMissing('docs/architecture/ios-semantic-automation-provider-v2.md');
 requireMissing('docs/architecture/chatgpt-handoff-facade.md');
-requireText('docs/architecture/history/global-hook-runtime.md', 'Status: **Historical Evidence — Not Runtime Authority**');
-requireText('docs/architecture/history/ios-semantic-automation-provider-v2.md', 'Status: **Historical Design Evidence — Not Runtime Authority**');
-requireText('docs/architecture/history/chatgpt-handoff-facade.md', 'Status: **Historical Design Rationale — Not Runtime Authority**');
-requireText('docs/architecture/history/README.md', 'Status: **Historical Evidence — Not Runtime Authority**');
+requireMissing('docs/architecture/history/global-hook-runtime.md');
+requireMissing('docs/architecture/history/ios-semantic-automation-provider-v2.md');
+requireMissing('docs/architecture/history/chatgpt-handoff-facade.md');
+requireMissing('docs/architecture/history/README.md');
 requireMissing('docs/operations/20260802-requirement-portfolio-migration.md');
 requireMissing('docs/runbooks/RELIABILITY-SESSION-PROTOCOL.md');
 requireMissing('docs/architecture/decisions/20260718-mcp-session-lifecycle-and-ingress-isolation.md');
@@ -535,7 +1453,7 @@ forbid(
 requireText('scripts/smoke-schedule-engine.ts', 'listHandoffItems');
 requireText('scripts/smoke-schedule-engine.ts', 'listExecutionJobs');
 requireText('scripts/smoke-schedule-engine.ts', "operation: 'runtime_maintenance_apply'");
-const server = text('src/cli/mcp/server.ts');
+const server = text('adapters/mcp/server.ts');
 const runtimeCall = server.indexOf('callRuntimeTool(ctx, name, args)');
 const durableCall = server.indexOf('routeDurableMcpCall(ctx, name, args)');
 const legacyCall = server.indexOf('callMultiRepositoryTool(ctx, name, args)');
@@ -556,28 +1474,26 @@ if (executionRegion.includes('forceDurable: true') && executionRegion.includes('
   failures.push('Public MCP Work mutations must not force the retired durable ExecutionJob path');
 }
 forbid(
-  'src/runtime/gateway/mcp/router.ts',
+  'adapters/mcp/runtime-gateway/router.ts',
   /\bcreateExecutionJob\b|\bgetExecutionJob\b/,
   'Gateway Router must not retain dormant ExecutionJob creation or lookup paths',
 );
-requireText('src/runtime/gateway/mcp/router.ts', 'executionJobCreationRetired');
-requireText('src/runtime/gateway/mcp/router.ts', "'EXECUTION_JOB_RETIRED'");
-requireText('src/runtime/gateway/mcp/execution-tools.ts', 'isDurableWorkOperation');
-requireText('src/runtime/gateway/mcp/execution-tools.ts', "'work_execute'");
-requireText('src/runtime/gateway/mcp/execution-tools.ts', "'work_validate'");
-requireText('src/runtime/gateway/mcp/execution-tools.ts', "'work_finalize'");
+requireText('adapters/mcp/runtime-gateway/router.ts', 'executionJobCreationRetired');
+requireText('adapters/mcp/runtime-gateway/router.ts', "'EXECUTION_JOB_RETIRED'");
+requireText('adapters/mcp/runtime-gateway/execution-tools.ts', 'isDurableWorkOperation');
+requireText('adapters/mcp/runtime-gateway/execution-tools.ts', "'work_execute'");
+requireText('adapters/mcp/runtime-gateway/execution-tools.ts', "'work_validate'");
+forbid('adapters/mcp/runtime-gateway/execution-tools.ts', /work_finalize/, 'execution tools must not restore a Work finalization operation');
 requireText('src/runtime/execution/workers/executor.ts', 'executeWork(runtimeContext');
 requireText('src/runtime/execution/workers/executor.ts', 'validateWork(runtimeContext');
-requireText('src/runtime/execution/workers/executor.ts', 'finalizeWork(runtimeContext');
 forbid(
   'src/runtime/execution/workers/executor.ts',
   /gateway\/mcp\/execution-tools|callExecutionTool\s*\(/,
   'Execution Worker must invoke control-plane Work application services directly, never MCP transport',
 );
 requireText('src/runtime/execution/workers/executor.ts', '__from_durable_worker');
-requireText('src/runtime/gateway/mcp/runtime-tools.ts', 'managedProcessOperationDigest');
 forbid(
-  'src/runtime/gateway/mcp/runtime-tools.ts',
+  'adapters/mcp/runtime-gateway/runtime-tools.ts',
   /\bcreateExecutionJob\b/,
   'Runtime MCP tools must not retain dormant ExecutionJob creation paths',
 );
@@ -592,12 +1508,12 @@ forbid(
   'Local Bridge HTTP creation routes must return retirement handoffs without dormant Job submission or dispatch code',
 );
 forbid(
-  'src/cli/mcp/repository-tools.ts',
+  'adapters/mcp/tool-mapping/repository-tools.ts',
   /\bsubmitLocalBridgeJob\b|\bexecuteLocalBridgeJob\b|\bwaitForRepositoryCommandHandoff\b/,
   'Repository command MCP fallback must use Process Runtime or an external-Controller handoff, never Local Bridge Jobs',
 );
 forbid(
-  'src/cli/mcp/legacy-tool-service.ts',
+  'adapters/mcp/tool-mapping/legacy-tool-service.ts',
   /\bsubmitLocalBridgeJob\b|\bexecuteLocalBridgeJob\b|\bacceptTaskJob\b|\bdispatchAcceptedTaskJob\b|\bstartTaskJob\b|\blegacy_agent_run\b/,
   'Legacy MCP compatibility may read or cancel historical Jobs and Runs but must not create or dispatch new ones',
 );
@@ -638,24 +1554,23 @@ forbid(
   'Local Bridge HTTP must not call Agent Run create/start/retry write boundaries',
 );
 forbid(
-  'src/cli/mcp/legacy-tool-service.ts',
+  'adapters/mcp/tool-mapping/legacy-tool-service.ts',
   /\bretryAgentJob\b/,
   'Legacy MCP must not call Agent Run retry',
 );
-forbid('src/runtime/gateway/mcp/router.ts', /Use process_get \/ process_wait \/ process_logs/, 'Gateway follow-up instructions must use an always-exposed neutral Work facade');
+forbid('adapters/mcp/runtime-gateway/router.ts', /Use process_get \/ process_wait \/ process_logs/, 'Gateway follow-up instructions must use an always-exposed neutral Work facade');
 requireMatch(
-  'src/runtime/gateway/mcp/router.ts',
+  'adapters/mcp/runtime-gateway/routing-policy.ts',
   /const DIRECT_REPOSITORY_TOOLS = new Set\(\[[\s\S]*?'repository_list'[\s\S]*?'repository_get'[\s\S]*?'repository_workbench'[\s\S]*?\]\);/,
   'declare DIRECT_REPOSITORY_TOOLS with repository_list, repository_get, and repository_workbench',
 );
-requireText('src/runtime/gateway/mcp/runtime-tools.ts', "case 'controller_context'");
-requireText('src/runtime/gateway/mcp/runtime-tools.ts', "case 'local_bridge_status'");
-requireText('src/runtime/gateway/mcp/runtime-tools.ts', 'readAgentExecutableReadinessSnapshot');
-requireText('src/runtime/gateway/mcp/runtime-tools.ts', 'connectorExposedTools');
-requireText('src/runtime/gateway/mcp/runtime-tools.ts', 'currentCallableTools');
-forbid('src/runtime/gateway/mcp/runtime-tools.ts', /inspectAgentExecutableReadiness|resolveAgentExecutable|writeAgentExecutableReadinessSnapshot/, 'Gateway readiness must only read the Daemon-produced Agent executable snapshot');
+requireText('adapters/mcp/runtime-gateway/runtime-observation-adapter.ts', "case 'controller_context'");
+requireText('adapters/mcp/runtime-gateway/runtime-observation-adapter.ts', "case 'local_bridge_status'");
+requireText('adapters/mcp/runtime-gateway/runtime-tools.ts', 'connectorExposedTools');
+requireText('adapters/mcp/runtime-gateway/runtime-tools.ts', 'currentCallableTools');
+forbid('adapters/mcp/runtime-gateway/runtime-observation-adapter.ts', /inspectAgentExecutableReadiness|resolveAgentExecutable|writeAgentExecutableReadinessSnapshot/, 'Runtime observation adapter must not perform Agent executable discovery or mutate readiness snapshots');
 forbidBetween(
-  'src/runtime/gateway/mcp/runtime-tools.ts',
+  'adapters/mcp/runtime-gateway/runtime-observation-adapter.ts',
   "case 'repository_runtime_snapshot':",
   "case 'runtime_performance_diagnostics':",
   /rebuildRepositoryProjection\s*\(/,
@@ -669,9 +1584,9 @@ forbid(
 );
 requireText('src/runtime/projections/controller-context.ts', 'controllerContextProjectionPayloadMatchesSourceIdentity');
 requireText('src/runtime/projections/controller-context.ts', 'sourceIdentityMatches');
-requireText('src/runtime/gateway/mcp/runtime-tools.ts', 'CONTEXT_PROJECTION_SOURCE_MISMATCH');
-forbid('src/runtime/gateway/mcp/router.ts', /const DIRECT_HOT_READ_TOOLS = new Set\([\s\S]*?['"]controller_context['"][\s\S]*?\);/, 'controller_context must use a materialized projection or Durable Job, never the legacy Gateway path');
-forbid('src/runtime/gateway/mcp/router.ts', /const DIRECT_HOT_READ_TOOLS = new Set\([\s\S]*?['"](?:local_bridge_status|get_local_job|get_local_job_output)['"][\s\S]*?\);/, 'Local Bridge observations must use bounded snapshots, never reconciliation in the Gateway');
+requireText('adapters/mcp/runtime-gateway/runtime-observation-adapter.ts', 'CONTEXT_PROJECTION_SOURCE_MISMATCH');
+forbid('adapters/mcp/runtime-gateway/router.ts', /const DIRECT_HOT_READ_TOOLS = new Set\([\s\S]*?['"]controller_context['"][\s\S]*?\);/, 'controller_context must use a materialized projection or Durable Job, never the legacy Gateway path');
+forbid('adapters/mcp/runtime-gateway/router.ts', /const DIRECT_HOT_READ_TOOLS = new Set\([\s\S]*?['"](?:local_bridge_status|get_local_job|get_local_job_output)['"][\s\S]*?\);/, 'Local Bridge observations must use bounded snapshots, never reconciliation in the Gateway');
 requireText('src/runtime/execution/jobs/types.ts', 'requestId: string');
 requireText('src/runtime/execution/jobs/types.ts', 'semanticKey: string');
 requireText('src/runtime/execution/jobs/types.ts', 'admissionTimeoutMs: number');
@@ -683,7 +1598,7 @@ requireText('src/runtime/control-plane/facade/operation-digest.ts', 'operationId
 requireText('src/runtime/control-plane/facade/operation-digest.ts', 'resultRef');
 requireText('src/runtime/control-plane/facade/operation-digest.ts', 'nextActions');
 requireText('src/runtime/control-plane/facade/operation-digest.ts', 'admissionTimeoutMs');
-forbid('src/runtime/gateway/mcp/router.ts', /Math\.min\(\s*typeof args\.timeout_ms[\s\S]{0,140}?,\s*120_000\s*\)/, 'Agent parent timeout must never silently truncate timeout_ms to 120 seconds');
+forbid('adapters/mcp/runtime-gateway/router.ts', /Math\.min\(\s*typeof args\.timeout_ms[\s\S]{0,140}?,\s*120_000\s*\)/, 'Agent parent timeout must never silently truncate timeout_ms to 120 seconds');
 requireText('src/runtime/execution/jobs/store.ts', "'active.json'");
 requireText('src/runtime/execution/jobs/store.ts', "'recent.json'");
 requireText('src/runtime/execution/jobs/store.ts', "'requests'");
@@ -754,13 +1669,13 @@ forbidBetween(
   /rebuildRepositoryProjection\s*\(/,
   'Projection rebuild must happen outside the Repo Actor mailbox lock',
 );
-requireText('src/runtime/workflow/schedules/store.ts', "'occurrences.json'");
+requireText('packages/kernel/scheduler/infrastructure/schedule-store.ts', "'occurrences'");
 requireText('src/runtime/projections/git-status-sampler.ts', 'writeRepositoryGitStatusSample');
 requireText('src/runtime/projections/git-status-sampler.ts', 'readRepositoryGitStatusSample');
-requireText('src/cli/mcp/repository-tools.ts', 'readRepositoryGitStatusSample');
-requireText('src/cli/mcp/repository-tools.ts', 'args.refresh === true');
+requireText('adapters/mcp/tool-mapping/repository-tools.ts', 'readRepositoryGitStatusSample');
+requireText('adapters/mcp/tool-mapping/repository-tools.ts', 'args.refresh === true');
 forbidBetween(
-  'src/cli/mcp/repository-tools.ts',
+  'adapters/mcp/tool-mapping/repository-tools.ts',
   "case 'repository_git_status':",
   "case 'repository_git_diff':",
   /repositoryGitStatus\s*\(/,
@@ -769,83 +1684,684 @@ forbidBetween(
 requireText('src/runtime/control-plane/execution/session-store.ts', 'lastValidatedAt: now');
 requireText('src/runtime/control-plane/execution/validation.ts', 'warnings.push');
 requireText('src/runtime/control-plane/execution/work-handle-store.ts', "failed: ['validating', 'editing', 'committed', 'merged', 'cleaned', 'failed_terminal_cleanup']");
-requireText('src/runtime/gateway/mcp/execution-tools.ts', "from '../../control-plane/execution/work-finalization-service'");
-requireText('src/runtime/gateway/mcp/execution-tools.ts', "from '../../control-plane/execution/work-preparation-service'");
-requireText('src/runtime/gateway/mcp/execution-tools.ts', "from '../../control-plane/execution/work-operation-service'");
-requireText('src/runtime/gateway/mcp/execution-tools.ts', 'Compatibility exports: implementation authority lives in control-plane execution.');
-requireText('src/runtime/gateway/mcp/execution-tools.ts', 'resetFinalizationStagesForRequest,');
-requireText('src/runtime/gateway/mcp/execution-tools.ts', 'selectDefaultWorkValidationChecks');
-requireText('src/runtime/gateway/mcp/runtime-tools.ts', "callExecutionTool(ctx, 'work_finalize'");
+requireText('adapters/mcp/runtime-gateway/execution-tools.ts', "from '../../../src/runtime/control-plane/execution/work-preparation-service'");
+requireText('adapters/mcp/runtime-gateway/execution-tools.ts', "from '../../../src/runtime/control-plane/execution/work-operation-service'");
+requireText('adapters/mcp/runtime-gateway/execution-tools.ts', 'selectDefaultWorkValidationChecks');
 forbid(
-  'src/runtime/gateway/mcp/runtime-tools.ts',
+  'adapters/mcp/runtime-gateway/runtime-tools.ts',
   /repositoryGit(?:Commit|FinishWorkflow|MergeBranch|DeleteBranch|RebaseOnto)\s*\(/,
   'rh_work facade finalization must delegate to the canonical Work finalization application service instead of performing Git delivery itself',
 );
 forbid(
-  'src/runtime/gateway/mcp/execution-tools.ts',
+  'adapters/mcp/runtime-gateway/execution-tools.ts',
   /function\s+finalizeWork\s*\(/,
   'MCP execution transport must delegate Work finalization to the control-plane application service',
 );
 forbid(
-  'src/runtime/gateway/mcp/execution-tools.ts',
-  /function\s+(?:prepareWork|adoptExistingWorkHead)\s*\(/,
-  'MCP execution transport must delegate Work preparation/adoption to the control-plane application service',
+  'adapters/mcp/runtime-gateway/execution-tools.ts',
+  /function\s+prepareWork\s*\(/,
+  'MCP execution transport must delegate Work preparation to the control-plane application service',
 );
 forbid(
-  'src/runtime/gateway/mcp/execution-tools.ts',
+  'adapters/mcp/runtime-gateway/execution-tools.ts',
   /function\s+(?:executeWork|validateWork)\s*\(/,
   'MCP execution transport must delegate Work execute/validate operations to the control-plane application service',
 );
 forbid(
-  'src/runtime/gateway/mcp/execution-tools.ts',
+  'adapters/mcp/runtime-gateway/execution-tools.ts',
   /(?:ensureManagedWorkspace|admitPreparedRepositoryWorkContract)\s*\(/,
   'MCP execution transport must not own managed-workspace or WorkContract preparation admission',
 );
 requireText('src/runtime/control-plane/execution/work-preparation-service.ts', 'export function prepareWork(');
-requireText('src/runtime/control-plane/execution/work-preparation-service.ts', 'function adoptExistingWorkHead(');
+requireText('src/runtime/control-plane/execution/work-preparation-service.ts', "const useWorktree = isolation !== 'reuse';");
+forbid(
+  'src/runtime/control-plane/execution/work-preparation-service.ts',
+  /adoptExistingWorkHead|WORK_HEAD_ADOPTION_/,
+  'Work preparation must keep the start revision frozen; changed source HEADs are never adopted during implementation',
+);
+forbid(
+  'src/runtime/control-plane/execution/work-handle-authority.ts',
+  /alignRepositoryMutationBase|WORK_DIRECT_PRE_MUTATION_RECONCILIATION_/,
+  'Repository mutation authority must not advance a Work baseline to follow target-branch movement',
+);
+requireMissing('src/runtime/control-plane/execution/direct-canonical-work-reconciliation.ts');
 requireText('src/runtime/control-plane/execution/work-operation-service.ts', 'export async function executeWork(');
 requireText('src/runtime/control-plane/execution/work-operation-service.ts', 'export async function validateWork(');
-requireText('src/runtime/control-plane/execution/work-finalization-service.ts', 'resetFinalizationStagesForRequest');
-requireText('src/runtime/control-plane/execution/work-finalization-service.ts', 'finalizationComplete');
-forbidBetween(
-  'src/runtime/control-plane/execution/work-finalization-service.ts',
-  'export async function finalizeWork(',
-  '// WORK_FINALIZATION_SERVICE_END',
-  /withControllerLock\([\s\S]{0,900}?(?:repositoryGitCommit|repositoryGitFinishWorkflow|runCleanup|repositoryGitDeleteBranch)/,
-  'Work finalization must not hold the controller lock while committing, merging, deleting branches, or removing worktrees',
-);
-requireText('src/runtime/workflow/schedules/types.ts', "'repository-event'");
-requireText('src/runtime/workflow/schedules/types.ts', "'dependency-checkpoint'");
-requireText('src/runtime/workflow/schedules/store.ts', 'saveScheduleDecision');
-requireText('src/runtime/workflow/schedules/settlement.ts', 'backoffMinutes');
+requireMissing('src/runtime/control-plane/execution/work-finalization-service.ts');
+requireText('packages/kernel/scheduler/domain/schedule.ts', "'repository-event'");
+requireText('packages/kernel/scheduler/domain/schedule.ts', "'dependency-checkpoint'");
+requireText('packages/kernel/scheduler/infrastructure/schedule-store.ts', 'saveScheduleDecision');
+requireText('packages/kernel/scheduler/application/settlement.ts', 'backoffMinutes');
 requireText('src/runtime/release/release-gate.ts', 'releaseReady');
-requireText('src/cli/mcp/transports/http.ts', "'/ready'");
-requireText('src/cli/mcp/transports/http.ts', "'/repos/:repoId/health'");
+requireText('adapters/mcp/transports/http-observation.ts', "'/ready'");
+requireText('adapters/mcp/transports/http-observation.ts', "'/repos/:repoId/health'");
 requireText('src/runtime/control-plane/governance/external-effects.ts', 'EXTERNAL_EFFECT_AUTHORIZATION_REQUIRED');
 requireText('src/runtime/control-plane/governance/external-effects.ts', 'AUTOMATED_REQUIREMENT_REQUIRES_CANDIDATE');
-requireText('src/cli/mcp/tools.ts', "export * from './legacy-tool-service'");
+requireText('adapters/mcp/tool-mapping/tools.ts', "export * from './legacy-tool-service'");
+requireText('src/cli/mcp/tools.ts', '@deprecated Kernel V2 compatibility shim');
 
 for (const path of [
-  'src/runtime/gateway/mcp/router.ts',
-  'src/runtime/gateway/mcp/runtime-tools.ts',
+  'adapters/mcp/runtime-gateway/router.ts',
+  'adapters/mcp/runtime-gateway/runtime-tools.ts',
+  'adapters/mcp/runtime-gateway/work-adapter.ts',
   'src/runtime/control-plane/global-scheduler/scheduler.ts',
   'src/runtime/control-plane/repo-actor/actor.ts',
   'src/runtime/workflow/schedules/engine.ts',
   'src/runtime/workflow/schedules/work-continuation.ts',
-  'src/cli/mcp/transports/http.ts',
+  'adapters/mcp/transports/http.ts',
 ]) {
   forbid(path, /\b(?:spawnSync|execSync|execFileSync)\s*\(/, 'the non-blocking Gateway/Controller hot-path rule');
 }
 
 requireText('scripts/run-governed-gate.ts', "label: 'source duplication'");
 requireText('scripts/run-governed-gate.ts', "args: ['scripts/check-source-duplication.mjs']");
-requireText('scripts/run-governed-gate.ts', "label: 'controller UI bundle'");
-requireText('scripts/run-governed-gate.ts', "args: ['run', 'check:controller-ui']");
 requireText('docs/architecture/CURRENT.md', '## State ownership');
 requireText('docs/architecture/CURRENT.md', '## Runtime and MCP boundary');
 requireText('docs/architecture/CURRENT.md', '## Testing and verification');
 requireText('plans/README.md', 'not the runtime execution queue');
-if (text('src/cli/mcp/tools.ts').split(/\r?\n/).length > 40) failures.push('src/cli/mcp/tools.ts must remain a thin compatibility facade');
+// Compatibility-facade thinness is enforced by ownership/consumer boundaries, not source line counts.
+const b7ProductionFiles = productionTypeScriptFiles();
+const b7ProductionImports = staticTypeScriptImportRecords(b7ProductionFiles);
+const b7ProductionGraph = staticTypeScriptDependencyGraph(b7ProductionFiles);
+for (const { from, specifier } of b7ProductionImports) {
+  if (from.startsWith('packages/kernel/') && specifier.startsWith('@modelcontextprotocol/')) {
+    failures.push(`Kernel modules must remain independent of MCP SDK transport contracts: ${from} -> ${specifier}`);
+  }
+  if (from.startsWith('packages/kernel/')
+      && ['adapters/mcp', 'src/cli/mcp', 'runtime/gateway/mcp'].some((segment) => specifier.includes(segment))) {
+    failures.push(`Kernel modules must never depend on MCP adapters or retired MCP gateway paths: ${from} -> ${specifier}`);
+  }
+  if (from.startsWith('packages/plugin-runtime/')
+      && ['adapters/', 'src/runtime/'].some((segment) => specifier.includes(segment))) {
+    failures.push(`Plugin Runtime provider dispatch must not depend on concrete adapters or Runtime implementations: ${from} -> ${specifier}`);
+  }
+  if (from.startsWith('adapters/computer/') && specifier.includes('src/runtime/')) {
+    failures.push(`Computer adapters must consume provider-neutral ports and contracts rather than depend on Runtime implementations: ${from} -> ${specifier}`);
+  }
+  if (from.startsWith('packages/plugin-runtime/computer/')
+      && (['controller-home', 'external-registration'].some((segment) => specifier.includes(segment))
+        || ['node:fs', 'fs', 'node:path', 'path'].includes(specifier))) {
+    failures.push(`Computer provider runtime must remain independent of Controller Home and filesystem-backed provider discovery: ${from} -> ${specifier}`);
+  }
+  if (from !== 'src/runtime/plugins/macos-capability-broker.ts' && specifier.includes('macos-capability-broker')) {
+    failures.push(`Deprecated macOS capability broker is compatibility/test-only and must have no production consumers: ${from} -> ${specifier}`);
+  }
+}
+for (const edge of dependencyEdges(b7ProductionGraph)) {
+  const { from, to } = edgeParts(edge);
+  if (from.startsWith('packages/kernel/') && to.startsWith('packages/kernel/')) {
+    const fromModule = architectureRoot(from);
+    const toModule = architectureRoot(to);
+    if (fromModule !== toModule && !to.startsWith(`${toModule}/api/`) && to !== `${toModule}/index.ts`) {
+      failures.push(`Kernel sibling modules must use public API boundaries: ${edge}`);
+    }
+  }
+  if (from.startsWith('adapters/') && to.startsWith('adapters/') && architectureRoot(from) !== architectureRoot(to)) {
+    failures.push(`adapter sibling wiring belongs in a composition root, not another adapter: ${edge}`);
+  }
+  if (from.startsWith('adapters/') && to.startsWith('packages/kernel/')) {
+    const kernelModule = architectureRoot(to);
+    if (!to.startsWith(`${kernelModule}/api/`) && to !== `${kernelModule}/index.ts`) {
+      failures.push(`adapters must consume Kernel public APIs, not internal implementation: ${edge}`);
+    }
+  }
+  if (from.startsWith('packages/kernel/')
+      && (to.startsWith('adapters/mcp/') || to.startsWith('src/cli/mcp/') || to.startsWith('src/runtime/gateway/mcp/'))) {
+    failures.push(`Kernel modules must never depend on MCP adapters or retired MCP gateway paths: ${edge}`);
+  }
+  if (/^packages\/kernel\/[^/]+\/(?:domain|application)\//.test(from) && to.startsWith('src/')) {
+    failures.push(`Kernel domain/application must depend only on Kernel/protocol ports, never legacy src mechanisms: ${edge}`);
+  }
+  if (from.startsWith('packages/plugin-runtime/') && (to.startsWith('adapters/') || to.startsWith('src/runtime/'))) {
+    failures.push(`Plugin Runtime provider dispatch must not depend on concrete adapters or Runtime implementations: ${edge}`);
+  }
+  if (from.startsWith('packages/plugin-runtime/computer/')
+      && (to.includes('/controller-home') || to.endsWith('/external-registration.ts'))) {
+    failures.push(`Computer provider runtime must remain independent of Controller Home and provider discovery implementations: ${edge}`);
+  }
+  if (to === 'src/runtime/plugins/macos-capability-broker.ts' && from !== to) {
+    failures.push(`Deprecated macOS capability broker is compatibility/test-only and must have no production consumers: ${edge}`);
+  }
+}
+for (const compositionPath of [
+  'src/runtime/root/scheduled-controller-composition.ts',
+  'src/runtime/root/controller-round-composition.ts',
+]) requireText(compositionPath, 'Kernel V2 composition root');
+
+// Exact legacy edges are frozen below after a read-only graph inventory; new debt is never accepted.
+// The V2 baseline lineage is immutable; this gate must not require rebasing onto unrelated main work.
+const b7KernelLegacyEdges = edgeSet(b7ProductionGraph, (edge) => {
+  const { from, to } = edgeParts(edge);
+  return from.startsWith('packages/kernel/') && to.startsWith('src/');
+});
+const B7_ALLOWED_KERNEL_LEGACY_EDGES = new Set([
+  'packages/kernel/work/infrastructure/work-contract-store.ts -> src/cli/repositories/controller-home.ts',
+  'packages/kernel/work/infrastructure/work-contract-store.ts -> src/cli/repositories/locks.ts',
+  'packages/kernel/work/infrastructure/work-contract-store.ts -> src/runtime/shared/json-files.ts',
+  'packages/kernel/work/infrastructure/work-contract-store.ts -> src/runtime/control-plane/persistence/sqlite-store.ts',
+  'packages/kernel/controller/infrastructure/controller-session-store.ts -> src/cli/repositories/controller-home.ts',
+  'packages/kernel/controller/infrastructure/controller-session-store.ts -> src/cli/repositories/locks.ts',
+  'packages/kernel/controller/infrastructure/controller-session-store.ts -> src/runtime/control-plane/execution/session-store.ts',
+  'packages/kernel/controller/infrastructure/controller-session-store.ts -> src/runtime/shared/json-files.ts',
+  'packages/kernel/controller/infrastructure/controller-session-store.ts -> src/runtime/control-plane/persistence/sqlite-store.ts',
+  'packages/kernel/controller/infrastructure/controller-round-store.ts -> src/cli/repositories/locks.ts',
+  'packages/kernel/controller/infrastructure/controller-round-store.ts -> src/runtime/control-plane/persistence/requirement-store.ts',
+  'packages/kernel/controller/infrastructure/controller-round-store.ts -> src/runtime/control-plane/persistence/sqlite-store.ts',
+  'packages/kernel/controller/infrastructure/controller-round-store.ts -> src/runtime/execution/work-activity.ts',
+  'packages/kernel/controller/infrastructure/controller-round-store.ts -> src/runtime/control-plane/facade/handoff-inbox-store.ts',
+  'packages/kernel/controller/infrastructure/controller-binding-store.ts -> src/cli/repositories/locks.ts',
+  'packages/kernel/controller/infrastructure/controller-binding-store.ts -> src/runtime/control-plane/persistence/sqlite-store.ts',
+  'packages/kernel/scheduler/infrastructure/schedule-store.ts -> src/cli/repositories/controller-home.ts',
+  'packages/kernel/scheduler/infrastructure/schedule-store.ts -> src/cli/repositories/locks.ts',
+  'packages/kernel/scheduler/infrastructure/schedule-store.ts -> src/runtime/control-plane/facade/handoff-inbox-store.ts',
+  'packages/kernel/scheduler/infrastructure/schedule-store.ts -> src/runtime/shared/json-files.ts',
+  'packages/kernel/scheduler/infrastructure/schedule-store.ts -> src/runtime/evidence/event-ledger.ts',
+]);
+requireExactShrinkingDebt('Kernel -> legacy src dependency debt', b7KernelLegacyEdges, B7_ALLOWED_KERNEL_LEGACY_EDGES);
+const b7ProductionEdges = new Set(dependencyEdges(b7ProductionGraph));
+for (const requiredEdge of [
+  'packages/kernel/work/domain/types.ts -> packages/kernel/identity/api/index.ts',
+  'packages/kernel/scheduler/domain/schedule.ts -> packages/kernel/identity/api/index.ts',
+]) {
+  if (!b7ProductionEdges.has(requiredEdge)) failures.push(`Portable semantic identity contract must be consumed through the Kernel Identity boundary: ${requiredEdge}`);
+}
+
+const b7LifecycleOwnerMarkers = new Map([
+  ['WorkContract transition authority', ['packages/kernel/work/domain/state-machine.ts']],
+  ['ControllerSession claim authority', ['packages/kernel/controller/infrastructure/controller-session-store.ts']],
+  ['ControllerRound relay authority', ['packages/kernel/controller/infrastructure/controller-round-store.ts']],
+  ['Schedule occurrence authority', ['packages/kernel/scheduler/infrastructure/schedule-store.ts']],
+  ['Forge instance identity authority', ['packages/kernel/identity/infrastructure/identity-store.ts']],
+]);
+for (const [label, owners] of b7LifecycleOwnerMarkers) {
+  for (const owner of owners) text(owner);
+  if (new Set(owners).size !== 1) failures.push(`${label} must have exactly one declared durable owner`);
+}
+const b7UniqueMutationSymbols = new Map([
+  ['transitionWorkContractPhase', 'Work lifecycle mutation'],
+  ['claimControllerSession', 'ControllerSession claim mutation'],
+  ['beginInitialControllerRoundDispatch', 'ControllerRound dispatch mutation'],
+  ['ensureForgeInstanceIdentity', 'Forge instance identity creation'],
+]);
+for (const [symbol, label] of b7UniqueMutationSymbols) {
+  let count = 0;
+  for (const path of productionTypeScriptFiles()) {
+    count += (text(path).match(new RegExp(`export\\s+(?:async\\s+)?function\\s+${symbol}\\s*\\(`, 'g')) ?? []).length;
+  }
+  if (count !== 1) failures.push(`${label} must have exactly one exported production owner; found ${count} for ${symbol}`);
+}
+// Thin Plan authority: Plan items are authored working memory. Work execution,
+// Plan admission and Plan revision must never re-acquire PlanStep execution
+// writers, Plan approval/acceptance gates or Plan-derived Work progression.
+const retiredPlanExecutionSymbols = [
+  'claimPlanStepForWork',
+  'completePlanStepForWork',
+  'acceptPlanStepEvidence',
+  'repairPlanStepForTechnicalRetry',
+  'repairDanglingPlanStepWorkBinding',
+  'replanActivePlanBoundWorkScope',
+  'retireTerminalPlanBoundWorkAuthorities',
+  'getPlanExecutionBaselineRevision',
+  'updatePlanContractWithExecutionBaseline',
+  'refreshPlanBoundWorkRevision',
+  'retirePlanBoundWorkContract',
+  'rebindPlanBoundWorkContract',
+];
+for (const path of productionTypeScriptFiles()) {
+  const source = text(path);
+  for (const symbol of retiredPlanExecutionSymbols) {
+    if (new RegExp(`\\b${symbol}\\b`).test(source)) failures.push(`${path} must not reintroduce retired PlanStep execution writer ${symbol}`);
+  }
+}
+const retiredPlanGateCodes = /PLAN_STEP_(?:SEMANTIC_ACCEPTANCE_REQUIRED|TERMINAL_WORK_RECONCILIATION_REQUIRED|DEPENDENCIES_PENDING|ALREADY_ACTIVE|ALREADY_COMPLETED|MULTIPLE_PRIMARY_WORKS|BOUND_WORK_MISSING|REUSES_ACTIVE_WORK|WORK_CONTRACT_MISMATCH)|PLAN_NOT_EXECUTABLE|PLAN_EXECUTION_BASELINE_LOCKED|PLAN_OBLIGATION_CONTINUITY_REQUIRED|PLAN_STEP_SEMANTIC_ACCEPTANCE/;
+for (const path of [
+  'src/runtime/control-plane/facade/goal-workloop.ts',
+  'src/runtime/control-plane/facade/plan-contract-store.ts',
+  'src/runtime/control-plane/facade/requirement-authority.ts',
+  'src/runtime/control-plane/global-scheduler/autonomous-continuation.ts',
+  'adapters/mcp/runtime-gateway/work-plan-operations.ts',
+  'adapters/mcp/runtime-gateway/work-repair-adapter.ts',
+]) {
+  if (retiredPlanGateCodes.test(text(path))) failures.push(`${path} must not reintroduce a PlanStep execution gate`);
+}
+for (const path of ['packages/kernel/progression/api/index.ts']) requireMissing(path);
+for (const path of productionTypeScriptFiles()) {
+  if (/packages\/kernel\/progression/.test(text(path))) failures.push(`${path} must not depend on the retired PlanStep progression engine`);
+}
+for (const retiredPath of [
+  'src/runtime/control-plane/execution/work-finalization-service.ts',
+  'src/runtime/control-plane/execution/direct-edit-work-completion.ts',
+  'src/runtime/control-plane/execution/content-equivalent-commit-authority.ts',
+  'adapters/mcp/controller-round-compatibility.ts',
+  'adapters/mcp/frozen-client-semantic-compatibility.ts',
+  'adapters/mcp/runtime-gateway/work-controller-recovery-operations.ts',
+  'adapters/mcp/runtime-gateway/work-plan-repair-operations.ts',
+]) requireMissing(retiredPath);
+for (const path of [...sourceFiles('src'), ...sourceFiles('adapters')]) {
+  forbid(path, /tool:\s*['"]rh_work['"][\s\S]{0,180}?operation:\s*['"](?:continue|verify|review|finalize|stop|plan_approve|plan_accept_step|controller_claim|controller_release|controller_disposition)['"]/, 'retired Work lifecycle operations must not return as current rh_work behavioral authority');
+}
+// Thin semantic Work lifecycle: Work is open/completed/cancelled and
+// work.complete is a mechanical durable close. Review findings are durable
+// observations, never a completion gate.
+requireText('packages/kernel/work/domain/types.ts', "export const SEMANTIC_WORK_STATES = ['open', 'completed', 'cancelled'] as const;");
+requireText('packages/kernel/work/domain/types.ts', 'export type SemanticWorkState = (typeof SEMANTIC_WORK_STATES)[number];');
+requireText('adapters/mcp/runtime-gateway/work-semantic-operations.ts', "const RH_WORK_SEMANTIC_OPERATIONS = new Set(['start', 'get', 'revise', 'complete']);");
+for (const path of [
+  'packages/kernel/work/domain/state-machine.ts',
+  'src/runtime/control-plane/execution/work-evidence-policy.ts',
+  'src/runtime/control-plane/facade/goal-workloop.ts',
+]) {
+  forbid(path, /READ_ONLY_REVIEW_CLEAN_SCOPE|cleanReadOnlyReviewEvidence|READ_ONLY_REVIEW_FINDINGS_BLOCK/, 'read-only review findings must not gate terminal completion');
+}
+// Work lifecycle collapse: semantic Work completion is one durable
+// expected_revision CAS close. Verify/review/finalize/delivery/cleanup are
+// mechanical facts owned elsewhere; they must never be wired back into the
+// semantic close path as a gate.
+for (const path of [
+  'adapters/mcp/runtime-gateway/work-semantic-operations.ts',
+]) {
+  forbid(path, /transitionWorkContractPhase|requestWorkImplementationReview|recordWorkImplementationReview|finalizeGoalWorkloop|verifyGoalWorkloop|reviewGoalWorkloop/, 'semantic Work completion must not invoke a mechanical lifecycle transition');
+  forbid(path, /implementationReview|completionReceipt|dispatchState|evidenceState|ControllerRound|controllerRound/, 'semantic Work completion must not read mechanical lifecycle or controller authority');
+}
+forbidBetween(
+  'packages/kernel/work/infrastructure/work-contract-store.ts',
+  'export function reviseWorkSemanticContext(',
+  'export function getWorkContract(',
+  /WORK_IMPLEMENTATION_REVIEW|WORK_COMPLETION_RECEIPT|WORK_VERIFICATION|WORK_CLEANUP|WORK_DELIVERY|WORK_FINALIZE/,
+  'the semantic close must not require review, verification, delivery, cleanup or finalize',
+);
+requireText('packages/kernel/work/infrastructure/work-contract-store.ts', 'WORK_REVISION_CONFLICT:');
+forbidBetween(
+  'packages/kernel/work/infrastructure/work-contract-store.ts',
+  'export function semanticWorkState(',
+  'export function workSemanticView(',
+  /'failed'|'ready'|'blocked'|'running'/,
+  'semantic Work state must expose only open/completed/cancelled; execution vocabulary is not a semantic state',
+);
+// Controller de-authority: ordinary Work/capability execution is fenced by
+// semantic CAS plus concrete target/resource/effect owners, never by a
+// Work-wide ControllerSession lease. Explicit autonomous-continuation round
+// operations retain their narrow dispatch/effect authority until Slice 4.
+forbid(
+  'packages/kernel/work/domain/state-machine.ts',
+  /WORK_PHASE_EVIDENCE_|WORK_COMPLETION_PHASE_/,
+  'legacy phase evidence must not regain semantic Work authority',
+);
+for (const path of [
+  'adapters/mcp/runtime-gateway/work-workflow-operations.ts',
+  'src/runtime/workflows/runtime.ts',
+]) {
+  forbid(path, /assertFacadeControllerRoundAuthority|getControllerSession|getControllerRoundRelay|controllerSessionAuthorityMatches|WORKFLOW_CONTROLLER_AUTHORITY|WORKFLOW_CONTROLLER_NOT_OWNER/, 'ordinary Workflow execution must not depend on Work-wide Controller authority');
+}
+forbid(
+  'adapters/mcp/runtime-gateway/work-adapter.ts',
+  /claimNewFacadeWork|mintControllerSessionAuthority|resumeControllerSession|bindFacadeControllerOwnership|currentFacadeTerminalizationAuthority|currentTerminalCleanupAuthority|withControllerSessionTerminalizationFence/,
+  'ordinary Work start/continue/review/stop/finalize must not mint or require Work-wide Controller authority',
+);
+for (const path of [
+  'packages/kernel/work/domain/types.ts',
+  'packages/kernel/work/domain/execution-concurrency.ts',
+  'src/runtime/control-plane/concurrency/work-execution-concurrency.ts',
+  'src/runtime/execution/process-runtime/types.ts',
+]) {
+  forbid(path, /controller_release/, 'Work/Process concurrency must wake on concrete Work/resource/scheduler facts, not Controller ownership release');
+}
+for (const path of [
+  'src/runtime/control-plane/execution/work-execution-support.ts',
+  'src/runtime/control-plane/execution/work-operation-service.ts',
+  'src/runtime/control-plane/execution/work-terminal-cleanup.ts',
+  'src/runtime/control-plane/execution/work-preparation-service.ts',
+]) {
+  forbid(path, /assertWorkControllerOwnership|releasePreparedWorkOwnership|claimPreparedWorkOwnership|claimHeadAdoptionOwnership|withControllerSessionTerminalizationFence|getControllerSession|claimControllerSession|resumeControllerSession|releaseControllerSessionWithAuthority|releaseObservedControllerSession|controllerClaimed/, 'ordinary Work preparation/execution/finalization/cleanup must not use ControllerSession as authority');
+}
+forbid(
+  'src/runtime/recovery/maintenance-executor.ts',
+  /withControllerSessionTerminalizationFence|listControllerSessions|getControllerSession|controllerWorkIds|controller_session/,
+  'stale Work maintenance must re-check concrete Work/source/resource facts instead of using ControllerSession as lifecycle authority',
+);
+requireText('src/runtime/control-plane/facade/handoff-inbox-store.ts', 'migrateLegacyHandoffInbox');
+requireText('src/runtime/control-plane/facade/handoff-inbox-store.ts', 'HANDOFF_LEGACY_STORE_READ_ONLY');
+requireText('src/runtime/control-plane/facade/handoff-inbox-store.ts', 'UserRequest owns the durable write');
+forbid('src/runtime/control-plane/facade/handoff-inbox-store.ts', /writeLegacyHandoffInboxStore|export function writeHandoffInboxStore/, 'legacy Handoff store must never remain a writable second authority');
+forbid('src/runtime/plugins/store.ts', /status:\s*terminalRemoteEffect\s*\?\s*['\"]completed['\"]/, 'plugin/effect delivery results must never claim semantic Work completion');
+requireText('src/runtime/plugins/store.ts', "semanticState: 'open' as const");
+for (const path of sourceFiles('src')) {
+  forbid(path, /\bcancelWorkContract\s*\(/, 'runtime/maintenance code must never auto-cancel semantic Work; cancellation belongs to explicit semantic CAS');
+}
+requireText('src/runtime/control-plane/facade/goal-workloop.ts', "state: 'cancelled'");
+requireText('src/runtime/recovery/maintenance-executor.ts', "result: 'work_semantic_completion_required'");
+requireText('src/runtime/control-plane/execution/work-authority-reconciler.ts', "'semantic_work_open_ownerless'");
+forbid(
+  'packages/kernel/scheduler/infrastructure/schedule-store.ts',
+  /repeated_infrastructure_failure|activeScheduleFailureHandoff|stableScheduleFailureHandoffId|resolveRecoveredScheduleFailureHandoffs/,
+  'mechanical Scheduler failures must remain runtime/backoff facts and must not create human-request authority',
+);
+{
+  const workStoreSource = text('packages/kernel/work/infrastructure/work-contract-store.ts');
+  const receiptWriterStart = workStoreSource.indexOf('export function recordWorkCompletionReceipt(');
+  const receiptWriterEnd = workStoreSource.indexOf('\nexport interface AcceptSubmittedWorkInput', receiptWriterStart);
+  const receiptWriter = receiptWriterStart >= 0 && receiptWriterEnd > receiptWriterStart
+    ? workStoreSource.slice(receiptWriterStart, receiptWriterEnd)
+    : '';
+  if (!receiptWriter) fail('recordWorkCompletionReceipt writer not found');
+  if (/status:\s*['"]completed['"]|dispatchState:\s*['"]terminal['"]|phase:\s*['"]cleanup['"]|WORK_IMPLEMENTATION_REVIEW_REQUIRED|transitionWorkContractPhase|requestWorkImplementationReview/.test(receiptWriter)) {
+    fail('delivery/effect receipt recording must not terminalize Work or reintroduce review/lifecycle gates');
+  }
+}
+forbid(
+  'src/runtime/control-plane/execution/work-completion-authority.ts',
+  /completeRequirementFromWork|projectRequirementDeliveryFromCompletedWork|completeWorkWithReceipt/,
+  'delivery evidence must not auto-complete Work or Requirement',
+);
+for (const path of [
+  'adapters/mcp/runtime-gateway/work-adapter.ts',
+  'adapters/mcp/runtime-gateway/repository-compat-adapter.ts',
+  'src/runtime/control-plane/facade/goal-workloop.ts',
+]) {
+  forbid(path, /lifecycleClosed|finalStatus:\s*['"]completed['"]|directEditWorkCompletion/, 'mechanical delivery/finalize responses must not masquerade as semantic Work completion');
+}
+// Temporary migration assertion on automatic dispatch admission. Explicit
+// operator repair may reconstruct a historical dispatch-owner pre-click proof;
+// unknown observation reasons must never be automatic retry authority. Remove
+// this string fence when the existing effect admission contract is AST-fenced.
+forbidBetween(
+  'supervisor/store.ts',
+  'nextBrowserEffect(',
+  'effectDispatchBudget(',
+  /composer_missing|send_button_missing|latestRetryEvidenceEventId/,
+  'dispatch generation may advance only from canonical effect_not_applied proof; effect_unknown never authorizes replay',
+);
+requireText('packages/kernel/controller/domain/controller-round-transition-policy.ts', "Pick<ControllerRoundRelayRecord, 'relayScopeId' | 'originWorkId' | 'roundCount'>");
+forbid(
+  'packages/kernel/controller/domain/controller-round-transition-policy.ts',
+  /controllerRoundProviderEffectId[\s\S]{0,400}authorityId/,
+  'canonical continuation/provider effect identity must survive Controller authority rotation',
+);
+requireText('src/runtime/root/workflow-supervisor-composition.ts', 'reserveWorkflowSupervisorEnrollment(forgeHome, registeredTask.taskId, lowerLayer.providerEffectId)');
+requireText('src/runtime/root/workflow-supervisor-composition.ts', 'providerDispatchEffectId: effect.effectId');
+requireText('supervisor/protocol.ts', '(?:fx|crpe)_');
+// Cognitive Plane stays one advisory application path: all Controller tools expose the
+// same optional settlement metadata, the MCP server settles it after the primary
+// outcome, and Supervisor/external launchers consume Cognition-only projections.
+requireText('adapters/mcp/toolset.ts', 'injectCognitionSettlementFields(injectAutomationEnvelopeFields(injectDurableCommandFields(definition)))');
+requireText('adapters/mcp/server.ts', 'settleCognitionAfterTool(ctx, name, args, localResult)');
+forbid('adapters/mcp/runtime-gateway/runtime-tools.ts', /settleCognitionEnvelope/, 'cognition settlement belongs to the canonical all-tool MCP boundary, not the rh_* facade only');
+requireText('src/runtime/root/workflow-supervisor-composition.ts', 'renderCognitiveAttentionForWork');
+requireText('src/runtime/control-plane/launcher/thin-launcher.ts', 'renderCognitiveAttentionForWork');
+forbid('src/runtime/root/workflow-supervisor-composition.ts', /renderAssistantWorkContext/, 'Supervisor prompts may receive bounded Cognition, not the legacy lower-layer AssistantWorkContext blob');
+forbid('src/runtime/control-plane/launcher/thin-launcher.ts', /renderAssistantWorkContext/, 'external controller prompts may receive bounded Cognition, not the legacy lower-layer AssistantWorkContext blob');
+requireText('packages/kernel/cognition/application/activation-service.ts', 'structuredConceptAliasCueScore');
+requireText('packages/kernel/cognition/application/activation-service.ts', 'fairScopedRead');
+requireText('packages/kernel/cognition/application/activation-service.ts', 'seenFamilies');
+
+for (const path of [
+  'adapters/mcp/runtime-gateway/work-learning-operations.ts',
+  'src/runtime/control-plane/persistence/experience-store.ts',
+]) {
+  forbid(path, /assertFacadeControllerRoundAuthority|controllerSessionAuthorityMatches|getControllerSession|EXPERIENCE_CONTROLLER_NOT_OWNER|EXPERIENCE_ROUND_AUTHORITY_MISMATCH|EXPERIENCE_CLAIM_AUTHORITY_MISMATCH/, 'advisory learning writes must use Work provenance and evidence, not Controller ownership');
+}
+forbid(
+  'src/cli/commands/brain-assistant.ts',
+  /authority-env|BRAIN_CONTROLLER_AUTHORITY_REQUIRED|BRAIN_AUTHORITY_ENV_INVALID/,
+  'advisory experience CLI must not require a Controller capability',
+);
+for (const path of [
+  'src/runtime/gateway/mcp/execution-tools.ts',
+  'src/runtime/gateway/mcp/legacy-ios-tool-adapter.ts',
+  'src/runtime/gateway/mcp/persisted-check-process.ts',
+  'src/runtime/gateway/mcp/process-tools.ts',
+  'src/runtime/gateway/mcp/router.ts',
+  'src/runtime/gateway/mcp/runtime-tool-definitions.ts',
+  'src/runtime/gateway/mcp/runtime-tools.ts',
+  'src/runtime/gateway/mcp/work-validation-reconciler.ts',
+]) requireText(path, '@deprecated Kernel V2 compatibility shim');
+for (const path of [
+  'src/cli/mcp/access-tools.ts',
+  'src/cli/mcp/legacy-context.ts',
+  'src/cli/mcp/legacy-tool-service.ts',
+  'src/cli/mcp/multi-repository.ts',
+  'src/cli/mcp/repository-tools.ts',
+  'src/cli/mcp/server.ts',
+  'src/cli/mcp/tools.ts',
+  'src/cli/mcp/toolset.ts',
+]) requireText(path, '@deprecated Kernel V2 compatibility shim');
+requireText('src/runtime/control-plane/execution/work-execution-support.ts', 'packages/protocols/mcp/execution-context');
+requireText('src/runtime/control-plane/execution/work-preparation-service.ts', 'packages/protocols/mcp/execution-context');
+requireText('src/runtime/control-plane/execution/work-operation-service.ts', 'packages/protocols/mcp/execution-context');
+for (const path of [
+  'adapters/mcp/transports/http.ts',
+  'adapters/mcp/transports/session-registry.ts',
+  'adapters/mcp/transports/stdio.ts',
+]) forbid(path, /recordWorkCompletionReceipt|transitionWorkContractPhase|releaseControllerSessionWithAuthority|recordWorkImplementationReview/, 'MCP transport/session lifecycle must never terminalize Work or Controller authority');
+
+// Kernel V2 B6: semantic Forge identity is independent of Runtime processes,
+// transport sessions, OAuth credentials, tunnel ids, and endpoint rotation.
+for (const path of [
+  'packages/kernel/identity/domain/types.ts',
+  'packages/kernel/identity/application/identity-service.ts',
+  'packages/kernel/identity/infrastructure/identity-store.ts',
+  'packages/kernel/identity/api/index.ts',
+]) text(path);
+for (const symbol of ['ForgeInstanceIdentity', 'Principal', 'CredentialReference', 'CapabilityGrant', 'ConnectionIdentity']) {
+  requireText('packages/kernel/identity/domain/types.ts', `interface ${symbol}`);
+}
+requireText('packages/kernel/identity/application/identity-service.ts', 'export function connectionIdentity');
+requireText('packages/kernel/identity/infrastructure/identity-store.ts', "'identity', 'forge-instance.json'");
+requireText('packages/kernel/identity/infrastructure/identity-store.ts', 'linkSync(temporary, path)');
+forbid(
+  'packages/kernel/identity/domain/types.ts',
+  /\b(?:tunnelId|mcpServerUrl|endpointUrl|runtimeApiKey|accessToken|refreshToken|oauthToken|bearerToken)\b/,
+  'Kernel identity contracts must contain semantic ids or credential references, never transport endpoint/tunnel/token material',
+);
+forbidBetween(
+  'packages/kernel/identity/application/identity-service.ts',
+  'const semanticKey = [',
+  "].join('\\u0000')",
+  /\b(?:endpoint|url|tunnel|pid|process|session)\b/i,
+  'ConnectionIdentity semantic key must remain independent of endpoint, tunnel, process, and session identity',
+);
+forbidBetween(
+  'packages/kernel/identity/infrastructure/identity-store.ts',
+  'const identity: ForgeInstanceIdentity = {',
+  '};',
+  /\b(?:pid|process|endpoint|url|tunnel|token)\b/i,
+  'ForgeInstanceIdentity creation must remain independent of process and adapter transport/auth metadata',
+);
+for (const path of [
+  'src/cli/mcp/auth.ts',
+  'src/cli/mcp/setup.ts',
+  'src/cli/mcp/openai-secure-tunnel.ts',
+]) {
+  requireText(path, '@deprecated Kernel V2 compatibility shim');
+}
+requireText('adapters/mcp/auth.ts', 'forgeInstanceId?: string');
+forbid('adapters/mcp/auth.ts', /server:\s*\{[\s\S]{0,512}?instanceId\??:\s*string/, 'MCP server process identity must not share semantic Forge instanceId naming');
+requireText('adapters/mcp/setup.ts', 'ensureForgeInstanceIdentity');
+requireText('adapters/mcp/setup.ts', 'MCP_FORGE_INSTANCE_ID_MISMATCH');
+requireText('src/runtime/root/types.ts', 'forgeInstanceId: string');
+requireText('src/runtime/root/types.ts', 'runtimeInstanceId: string');
+requireText('src/runtime/root/runtime.ts', 'readonly forgeInstanceId: string');
+requireText('src/runtime/root/runtime.ts', 'ensureForgeInstanceIdentity');
+requireText('src/runtime/root/entry.ts', 'forgeInstanceId: runtime.forgeInstanceId');
+requireText('adapters/mcp/transports/http.ts', 'forgeInstanceId: forgeInstance.instanceId');
+requireText('adapters/mcp/transports/http-observation.ts', 'controllerInstanceId: process.env.FORGE_MCP_INSTANCE_ID');
+forbid('adapters/mcp/transports/http.ts', /\{\s*instanceId:\s*process\.env\.FORGE_MCP_INSTANCE_ID/, 'MCP process identity must not be exposed as semantic Forge instanceId');
+requireText('adapters/mcp/transports/http.ts', "adapterId: 'mcp-http'");
+requireText('adapters/mcp/transports/session-registry.ts', 'connectionId: string');
+requireText('adapters/mcp/transports/session-registry.ts', 'reservation.connectionId !== input.connectionId');
+requireText('adapters/mcp/tunnels/openai-secure-tunnel.ts', 'tunnelMatches: boolean');
+requireText('adapters/mcp/tunnels/openai-secure-tunnel.ts', 'credentialReference(config.runtimeApiKeyRef');
+forbid('adapters/mcp/tunnels/openai-secure-tunnel.ts', /\bidentityMatches\b/, 'tunnel binding match must not masquerade as Forge semantic identity');
+
+// C0 Computer capability boundary: Browser and Desktop remain separate providers.
+// Controller-scoped plugins are owned by the serving ForgeInstance. A synthetic
+// RepositoryRecord must not reappear as a canonical execution or manifest path.
+const controllerRepoCallPattern = new RegExp(['controllerPlugin', 'Repository\\s*\\('].join(''));
+const legacyControllerRepoPattern = new RegExp(['CONTROLLER_SCOPE_REPO_ID|__controller__|controllerPlugin', 'Repository'].join(''));
+for (const path of productionTypeScriptFiles()) {
+  forbid(path, controllerRepoCallPattern, 'production controller-plugin paths must not recreate a fake controller RepositoryRecord');
+}
+requireText('src/runtime/plugins/store.ts', 'const CONTROLLER_PLUGIN_SCOPE_KEY = FORGE_INSTANCE_SCOPE_KEY');
+forbidBetween(
+  'src/runtime/plugins/store.ts',
+  'function controllerPluginActionScope',
+  'function pluginActionExecutionFields',
+  legacyControllerRepoPattern,
+  'the canonical controller action scope must use the ForgeInstance scope, not the legacy controller repository sentinel',
+);
+for (const [start, end, description] of [
+  ['export function listControllerPluginManifests(', 'function getControllerPluginManifestForExecution', 'controller manifest listing'],
+  ['export function getControllerPluginManifest(', 'function writeControllerRegistry', 'controller manifest lookup'],
+  ['export function submitControllerPluginAction(', 'async function executePluginActionInScope', 'controller action submission'],
+  ['export function executeControllerScopedPluginAction(', 'export function executeAssistantPluginAction', 'controller action execution'],
+]) {
+  forbidBetween(
+    'src/runtime/plugins/store.ts',
+    start,
+    end,
+    legacyControllerRepoPattern,
+    `${description} must not depend on the legacy controller repository sentinel`,
+  );
+}
+// Legacy controller coordinates remain read-only migration/compatibility inputs
+// or explicit rejection paths; they are not allowed to become new write paths.
+requireText('src/runtime/plugins/store.ts', 'One-way read compatibility for pre-cutover controller receipts only.');
+requireText('adapters/mcp/runtime-gateway/plugin-adapter.ts', 'PLUGIN_CONTROLLER_REPOSITORY_SENTINEL_RETIRED');
+requireText('src/runtime/plugins/app-store-connect-adapter.ts', 'APP_STORE_CONNECT_LEGACY_CONTROLLER_SCOPE_WRITE_RETIRED');
+requireText('packages/protocols/computer/contract.ts', 'COMPUTER_BROWSER_AUTOMATION_CAPABILITY');
+requireText('packages/protocols/computer/contract.ts', 'ComputerRuntimeProviderCapabilityId');
+requireText('packages/plugin-runtime/computer/provider.ts', 'ComputerRuntimeProviderCapabilityId');
+requireText('packages/plugin-runtime/computer/provider-registry.ts', 'COMPUTER_PROVIDER_AMBIGUOUS');
+requireText('packages/plugin-runtime/computer/provider-registry.ts', 'COMPUTER_PROVIDER_DUPLICATE_ID');
+forbid('packages/plugin-runtime/computer/provider-registry.ts', /throw new Error\(/, 'Computer provider resolution must expose typed provider errors rather than raw order-dependent failures');
+
+requireText('packages/protocols/computer/contract.ts', 'COMPUTER_CAPABILITY_PROTOCOL_VERSION');
+requireText('packages/protocols/computer/contract.ts', 'COMPUTER_CAPABILITY_EXECUTION_METHOD');
+requireText('packages/protocols/computer/contract.ts', 'export interface ComputerCapabilityAdvertisement');
+forbid('adapters/computer/desktop-operator-negotiation.ts', /interface\s+ComputerCapabilityAdvertisement/, 'Desktop Operator negotiation must consume the provider-neutral Computer capability advertisement contract instead of redefining it');
+requireText('packages/plugin-runtime/computer/provider.ts', 'export interface ComputerProvider');
+requireText('packages/plugin-runtime/computer/provider-registry.ts', 'export class ComputerProviderRegistry');
+requireText('adapters/computer/desktop-operator-contract.ts', 'DESKTOP_OPERATOR_PROVIDER_PLUGIN_ID');
+requireText('adapters/computer/desktop-operator-negotiation.ts', 'negotiateDesktopOperatorComputerHandshake');
+requireText('adapters/computer/desktop-operator-negotiation.ts', 'buildDesktopOperatorComputerInvocation');
+requireText('adapters/computer/desktop-operator-provider.ts', 'createDesktopOperatorComputerProvider');
+requireText('adapters/computer/desktop-operator-discovery.ts', 'ComputerProviderRegistrationLookup');
+requireText('adapters/computer/desktop-operator-discovery.ts', "source: 'registration'");
+requireText('adapters/computer/desktop-operator-discovery.ts', "PLUGIN_COMPUTER_PROVIDER_REGISTRATION_REQUIRED");
+forbid('adapters/computer/desktop-operator-discovery.ts', /legacy_fallback|DesktopOperatorLegacyFallbackMode|unregistered_v0_2/, 'Computer provider discovery must not bypass canonical Desktop Operator registration with a legacy socket fallback');
+forbid('src/runtime/root/computer-composition.ts', /legacyFallback|unregistered_v0_2/, 'Computer Runtime composition must not enable an unregistered Desktop Operator compatibility provider');
+requireText('src/cli/commands/computer.ts', "new Command('computer')");
+requireText('src/cli/commands/computer.ts', 'installOfficialPlugin(COMPUTER_PROVIDER_PLUGIN_ID');
+requireText('src/cli/commands/computer.ts', 'provider release: independent');
+requireText('src/cli/commands/computer.ts', 'COMPUTER_PROVIDER_UNINSTALLER_MISSING');
+requireText('src/cli/commands/computer.ts', 'readControllerStoredPluginManifest');
+requireText('src/cli/commands/computer.ts', 'syncControllerPluginManifest');
+requireText('src/cli/commands/computer.ts', 'removeControllerPluginManifestProjection');
+requireText('src/cli/commands/computer.ts', 'withOfficialPluginLifecycleLock');
+forbid('src/cli/commands/computer.ts', new RegExp(`${controllerRepoCallPattern.source}|syncAssistantPluginRegistry|getAssistantPluginManifest\\s*\\(`), 'Computer status/doctor must use Controller-scoped stored/targeted provider APIs rather than a fake repository or global execution-style manifest lookup');
+requireText('src/cli/commands/plugin.ts', 'external-plugin:${pluginId}');
+requireText('src/runtime/plugins/store.ts', 'export function readControllerStoredPluginManifest');
+requireText('src/runtime/plugins/store.ts', 'export function syncControllerPluginManifest');
+requireText('src/runtime/plugins/store.ts', 'export function removeControllerPluginManifestProjection');
+requireText('src/runtime/plugins/store.ts', 'export function readStoredAssistantPluginManifest');
+requireText('src/runtime/plugins/store.ts', 'export function syncAssistantPluginManifest');
+requireText('src/runtime/plugins/store.ts', 'export function removeAssistantPluginManifestProjection');
+requireText('src/cli/index.ts', 'buildComputerCommand');
+requireText('src/cli/index.ts', "'computer'");
+
+forbid('adapters/computer/desktop-operator-provider.ts', /getExternalPluginRegistration|controller-home|computerCapabilities|internalCapabilities|browserAutomationProtocolVersion|browserAutomationActions|macos_browser_automation|computer_execute/, 'Desktop Operator provider transport must consume discovery and negotiation results rather than own Controller lookup or wire negotiation');
+forbid('adapters/computer/desktop-operator-negotiation.ts', /getExternalPluginRegistration|controller-home|desktop-operator-discovery/, 'Desktop Operator negotiation must depend on protocol/contract facts, not endpoint discovery');
+forbid('adapters/computer/desktop-operator-discovery.ts', /macos_browser_automation|LEGACY_BROWSER_AUTOMATION/, 'Desktop Operator discovery must own endpoint resolution only, not compatibility protocol negotiation');
+forbid('adapters/computer/desktop-operator-provider.ts', /getExternalPluginAdapter|AssistantPluginActionExecutionInput|desktop_session_open|NATIVE_BROWSER_BUNDLE_IDS|activateDesktopOperatorBrowserApplication/, 'Desktop Operator Computer transport adapter must not own Runtime plugin-action application activation glue');
+for (const path of sourceFiles('adapters/computer')) {
+  forbid(path, /AssistantPluginError/, 'Computer adapters must expose provider errors through plugin-runtime rather than depend on Runtime plugin error types');
+}
+requireText('src/runtime/root/computer-composition.ts', 'lookupRegistration: (providerPluginId) =>');
+requireText('src/runtime/root/computer-composition.ts', 'computerProviderRegistrationSnapshot(registration)');
+requireText('src/runtime/root/computer-composition.ts', 'getExternalPluginAdapter(input.controllerHome, DESKTOP_OPERATOR_PROVIDER_PLUGIN_ID)');
+requireText('src/runtime/plugins/browser-automation-service.ts', 'executeRuntimeComputerBrowserAutomation');
+requireText('src/runtime/plugins/browser-adapter.ts', 'activateRuntimeComputerBrowserApplication');
+forbid('src/runtime/plugins/browser-automation-service.ts', /desktop_operator|macos-capability-broker|desktop-operator\.sock|macos_browser_automation/, 'Browser automation must depend on the provider-neutral Computer boundary, not Desktop Operator transport details');
+forbid('src/runtime/plugins/browser-adapter.ts', /desktop_operator|Desktop Operator|getExternalPluginAdapter|desktop_session_open/, 'Browser adapter must not know the concrete Desktop Operator application provider');
+for (const path of sourceFiles('src/runtime/plugins').filter((entry) => /\/browser-(?!registration\.ts)[^/]+\.ts$/.test(entry))) {
+  forbid(path, /desktop_operator|Desktop Operator|desktop-operator\.sock|macos_browser_automation/, 'Browser modules must depend on Computer capabilities rather than concrete Desktop Operator transport identity');
+}
+requireText('src/runtime/plugins/macos-capability-broker.ts', '@deprecated C0 compatibility shim');
+requireText('src/runtime/plugins/macos-capability-broker.ts', 'executeRuntimeComputerBrowserAutomation');
+forbid('src/runtime/plugins/macos-capability-broker.ts', /callDesktopOperatorComputerBrowserAutomation/, 'Deprecated macOS broker execution must delegate to Runtime Computer composition rather than call the concrete provider directly');
+requireText('src/runtime/control-plane/facade/types.ts', 'semanticCapabilities?: string[]');
+forbid('src/runtime/control-plane/facade/capability-registry.ts', /plugin\.desktop_operator/, 'Control Plane capability discovery must rank provider-declared semantic capabilities rather than concrete Desktop Operator plugin identity');
+requireText('src/runtime/plugins/external-provider-policy.ts', 'resolveExternalProviderPolicy');
+requireText('src/runtime/plugins/desktop-operator-external-policy.ts', 'verifyExactForegroundDesktopSession');
+forbid('src/runtime/plugins/external-adapter.ts', /desktop_operator|desktopOperator|DESKTOP_|['\"]desktop_[a-z_]|desktop-operator-external-policy/, 'Generic external plugin adapter must delegate provider-specific Desktop policy through ExternalProviderPolicy');
+requireText('src/runtime/plugins/desktop-operator-registration.ts', 'COMPUTER_OBSERVE_CAPABILITY');
+requireText('src/runtime/plugins/desktop-operator-registration.ts', 'COMPUTER_INPUT_CAPABILITY');
+requireText('src/runtime/plugins/desktop-operator-registration.ts', 'COMPUTER_CAPTURE_CAPABILITY');
+requireText('src/runtime/plugins/desktop-operator-registration.ts', 'pluginVersion: options.pluginVersion');
+forbid('src/runtime/plugins/desktop-operator-registration.ts', /pluginVersion:\s*options\.pluginVersion\s*\?\?|pluginVersion:\s*['"]0\./, 'Forge must not invent the Desktop Operator provider release version');
+requireText('packages/plugin-runtime/external/unix-jsonl-transport.ts', 'EXTERNAL_RPC_METHOD_PATTERN');
+requireText('src/runtime/plugins/external-unix-socket.ts', 'callExternalUnixJsonl');
+forbid('src/runtime/plugins/external-unix-socket.ts', /createConnection|EXTERNAL_RPC_METHOD_PATTERN|packages\/protocols\/computer|computer_execute|macos_browser_automation/, 'Runtime external Unix socket compatibility layer must delegate async transport and must not own Computer/Desktop provider method identities');
+forbid('adapters/computer/desktop-operator-provider.ts', /src\/runtime\/plugins\/external-unix-socket|callExternalUnixSocket/, 'Computer provider adapters must consume provider-neutral plugin-runtime transport rather than Runtime socket implementation');
+
+// C0 Browser runtime authority: contracts and provider selection belong to plugin-runtime/protocols.
+requireText('packages/plugin-runtime/browser/runtime-contract.ts', 'export interface BrowserTransaction');
+requireText('packages/plugin-runtime/browser/provider-registry.ts', 'export class BrowserProviderRegistry');
+requireText('packages/plugin-runtime/browser/provider-registry.ts', 'export class BrowserProviderSelectionError');
+forbid('packages/plugin-runtime/browser/provider-registry.ts', /AssistantPluginError|src\/runtime|adapters\//, 'Browser provider selection must remain provider-neutral inside plugin-runtime');
+requireText('packages/protocols/browser/session.ts', 'export interface BrowserSessionState');
+for (const path of [
+  'src/runtime/plugins/browser-runtime-contract.ts',
+  'src/runtime/plugins/browser-provider-registry.ts',
+  'src/runtime/plugins/browser-session-types.ts',
+]) {
+  requireText(path, '@deprecated C0 compatibility shim');
+}
+for (const path of sourceFiles('src/runtime/plugins')) {
+  if (['src/runtime/plugins/browser-runtime-contract.ts', 'src/runtime/plugins/browser-provider-registry.ts', 'src/runtime/plugins/browser-session-types.ts'].includes(path)) continue;
+  forbid(path, /from\s+['"]\.\/browser-(?:runtime-contract|provider-registry|session-types)['"]/, 'active Browser runtime code must consume plugin-runtime/protocol Browser contracts, not retired local owners');
+}
+// Computer SurfaceTarget is the only durable interaction-target authority. Browser
+// compatibility may retain old type/API names, but it must not recreate a Browser
+// or Desktop authority/persistence owner alongside Computer.
+requireMissing('adapters/browser/session-authority.ts');
+requireMissing('adapters/browser/sqlite-session-authority.ts');
+requireMissing('packages/plugin-runtime/browser/session-persistence.ts');
+requireMissing('src/runtime/root/browser-session-persistence.ts');
+forbid('packages/plugin-runtime/browser/session-authority.ts', /\bBrowserSession(?:Authority|Persistence)Port\b/, 'Browser compatibility contracts must not expose a second durable authority or persistence port');
+requireText('src/runtime/plugins/browser-session-authority.ts', 'findComputerBackedBrowserSession');
+requireText('src/runtime/plugins/browser-session-authority.ts', 'saveComputerBackedBrowserSession');
+forbid('src/runtime/plugins/browser-session-authority.ts', /\b(?:writeControlPlaneRecord|deleteControlPlaneRecord|withControlPlaneTransaction|createBrowserSessionAuthority|runtimeBrowserSessionAuthority)\b/, 'Browser compatibility facade must delegate semantic identity to Computer and cannot persist its own authority');
+requireText('src/runtime/plugins/browser-session-legacy-migration.ts', 'readLegacyBrowserSessionMigrationEntries');
+requireText('src/runtime/plugins/browser-session-store.ts', 'PLUGIN_BROWSER_SESSION_CONTEXT_REQUIRED');
+forbid('src/runtime/plugins/browser-session-store.ts', /writeJsonAtomic\(sessionPath|readLegacyBrowserSessionJson|rmSync\(sessionPath/, 'steady-state Browser session identity must never fall back to repository-local JSON outside Computer target authority');
+forbid('src/runtime/plugins/browser-session-legacy-migration.ts', /\b(?:writeControlPlaneRecord|deleteControlPlaneRecord|withControlPlaneTransaction|createBrowserSessionAuthority|runtimeBrowserSessionAuthority)\b/, 'legacy Browser migration may read retired state but cannot mutate or recreate Browser durable authority');
+requireText('src/runtime/root/browser-session-composition.ts', 'BrowserSessionExecutionContext');
+forbid('src/runtime/root/browser-session-composition.ts', /\b(?:createBrowserSessionAuthority|runtimeBrowserSessionAuthority|createRuntimeBrowserSessionPersistence)\b/, 'Browser Runtime composition may carry execution context but cannot compose a second durable interaction authority');
+for (const path of [
+  ...sourceFiles('adapters/browser'),
+  ...sourceFiles('packages/plugin-runtime/browser'),
+  ...sourceFiles('src/runtime/plugins'),
+  ...sourceFiles('src/runtime/root'),
+]) {
+  if (path === 'src/runtime/plugins/browser-session-legacy-migration.ts') continue;
+  forbid(path, LEGACY_INTERACTION_AUTHORITY_OWNER_DECLARATION, 'Browser/Desktop durable interaction authority must live only in Computer target authority');
+}
+// Workflow Asset authority: editable content stays in files; machine registry stays metadata-only.
+requireText('packages/workflow-runtime/domain/workflow-asset.ts', 'export interface WorkflowAssetDefinition');
+requireText('packages/workflow-runtime/domain/workflow-asset.ts', 'workflowAssetContentDigest');
+requireText('src/runtime/control-plane/persistence/workflow-content-store.ts', 'ensureControllerWorkflowContentRoot');
+requireText('src/runtime/control-plane/persistence/workflow-registry-store.ts', "WORKFLOW_REGISTRY_NAMESPACE = 'workflow_registry'");
+requireText('src/runtime/control-plane/persistence/workflow-registry-store.ts', 'WORKFLOW_REGISTRY_CONTENT_IDENTITY_CHANGED');
+forbid('src/runtime/control-plane/persistence/workflow-registry-store.ts', /\b(?:prompts|scripts|templates|selectors|resources)\s*:/, 'Workflow machine registry must not persist editable prompt/script/template/selector/resource bodies');
+for (const path of sourceFiles('packages/workflow-runtime')) {
+  forbid(path, /xiaohongshu|douyin|instagram|reddit|facebook/i, 'generic Workflow Runtime contracts must not own site/business choreography');
+  forbid(path, /from\s+['"][^'"]*(?:src\/runtime|adapters)\//, 'Workflow Runtime package contracts must remain independent from Runtime/adapters implementation authority');
+}
+requireText('src/runtime/plugins/browser-registration.ts', 'export const browserPluginAdapter');
+requireText('src/runtime/plugins/first-party-registry.ts', "from './browser-registration'");
+forbid('src/runtime/plugins/first-party-registry.ts', /from\s+['"]\.\/browser-adapter['"]/, 'first-party registry must depend on the thin Browser registration entrypoint, not the action implementation');
+forbid('src/runtime/plugins/browser-adapter.ts', /export\s+const\s+browserPluginAdapter/, 'Browser action implementation must not also own first-party plugin registration');
 
 if (failures.length) {
   console.error('[runtime-architecture] FAILED');