@moretea-labs/forge 1.8.0 → 1.8.2

package/src/runtime/context/codegraph-sidecar.cjs

@@ -1,248 +0,0 @@
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const readline = require('readline');
-const { performance } = require('perf_hooks');
-
-const SCHEMA_VERSION = 1;
-const ALLOWED_OPERATIONS = new Set(['status', 'search', 'context', 'impact', 'file_dependencies']);
-
-function clamp(value, fallback, min, max) {
-  if (typeof value !== 'number' || !Number.isFinite(value)) return fallback;
-  return Math.min(Math.max(Math.trunc(value), min), max);
-}
-
-function failure(operation, code, message) {
-  return {
-    schemaVersion: SCHEMA_VERSION,
-    ok: false,
-    operation,
-    error: { code, message: String(message).slice(0, 1000) },
-  };
-}
-
-function writeResponse(response, options = {}) {
-  process.stdout.write(`${JSON.stringify(response)}${options.newline ? '\n' : ''}`);
-  if (options.failExit && response.ok === false) process.exitCode = 1;
-}
-
-function nodeSummary(node) {
-  return {
-    id: node.id,
-    kind: node.kind,
-    name: node.name,
-    qualifiedName: node.qualifiedName,
-    filePath: node.filePath,
-    language: node.language,
-    startLine: node.startLine,
-    endLine: node.endLine,
-    ...(node.signature ? { signature: String(node.signature).slice(0, 1000) } : {}),
-  };
-}
-
-function edgeSummary(edge) {
-  return {
-    source: edge.source,
-    target: edge.target,
-    kind: edge.kind,
-    ...(typeof edge.line === 'number' ? { line: edge.line } : {}),
-    ...(edge.provenance ? { provenance: edge.provenance } : {}),
-  };
-}
-
-function subgraphSummary(subgraph, maxNodes) {
-  const nodes = Array.from(subgraph.nodes.values()).slice(0, maxNodes);
-  const nodeIds = new Set(nodes.map((node) => node.id));
-  const edges = subgraph.edges
-    .filter((edge) => nodeIds.has(edge.source) && nodeIds.has(edge.target))
-    .slice(0, maxNodes * 3);
-  const byId = new Map(nodes.map((node) => [node.id, node]));
-  return {
-    nodes: nodes.map(nodeSummary),
-    edges: edges.map(edgeSummary),
-    roots: subgraph.roots.filter((id) => nodeIds.has(id)).slice(0, 20),
-    entryPoints: subgraph.roots.map((id) => byId.get(id)).filter(Boolean).slice(0, 12).map(nodeSummary),
-    relatedFiles: Array.from(new Set(nodes.map((node) => node.filePath).filter(Boolean))).slice(0, 80),
-    ...(subgraph.confidence ? { confidence: subgraph.confidence } : {}),
-    truncated: subgraph.nodes.size > nodes.length || subgraph.edges.length > edges.length,
-  };
-}
-
-function metadata(graph) {
-  const changed = graph.getChangedFiles();
-  const build = graph.getIndexBuildInfo();
-  const stats = graph.getStats();
-  return {
-    initialized: true,
-    lastIndexedAt: graph.getLastIndexedAt(),
-    buildVersion: build.version,
-    extractionVersion: build.extractionVersion,
-    staleEngine: graph.isIndexStale(),
-    changedFiles: {
-      added: changed.added.slice(0, 50),
-      modified: changed.modified.slice(0, 50),
-      removed: changed.removed.slice(0, 50),
-    },
-    stats: {
-      nodeCount: stats.nodeCount,
-      edgeCount: stats.edgeCount,
-      fileCount: stats.fileCount,
-      dbSizeBytes: stats.dbSizeBytes,
-      lastUpdated: stats.lastUpdated,
-    },
-    backend: String(graph.getBackend()),
-    journalMode: String(graph.getJournalMode()),
-  };
-}
-
-let CodeGraph;
-
-function loadCodeGraph(operation) {
-  if (CodeGraph) return { ok: true, CodeGraph };
-  try {
-    const configuredLibrary = process.env.FORGE_CODEGRAPH_LIBRARY_PATH;
-    const library = require(configuredLibrary || '@colbymchenry/codegraph');
-    if (typeof library.setLogger === 'function' && library.silentLogger) library.setLogger(library.silentLogger);
-    CodeGraph = library.CodeGraph || library.default;
-  } catch (error) {
-    return { ok: false, response: failure(operation, 'CODEGRAPH_LIBRARY_UNAVAILABLE', error instanceof Error ? error.message : error) };
-  }
-  if (!CodeGraph || typeof CodeGraph.open !== 'function') {
-    return { ok: false, response: failure(operation, 'CODEGRAPH_LIBRARY_UNAVAILABLE', 'CodeGraph SDK entry point is unavailable.') };
-  }
-  return { ok: true, CodeGraph };
-}
-
-async function handleRequest(request) {
-  const operation = request && request.operation;
-  if (!request || request.schemaVersion !== SCHEMA_VERSION || !ALLOWED_OPERATIONS.has(operation)) {
-    return failure(operation, 'CODEGRAPH_OPERATION_NOT_ALLOWED', `Unsupported read operation: ${String(operation)}`);
-  }
-  if (typeof request.projectRoot !== 'string' || !path.isAbsolute(request.projectRoot)) {
-    return failure(operation, 'CODEGRAPH_PROJECT_ROOT_INVALID', 'projectRoot must be an absolute path selected by Forge.');
-  }
-
-  const loaded = loadCodeGraph(operation);
-  if (!loaded.ok) return loaded.response;
-  if (!loaded.CodeGraph.isInitialized(request.projectRoot)) {
-    return {
-      schemaVersion: SCHEMA_VERSION,
-      ok: true,
-      operation,
-      metadata: {
-        initialized: false,
-        lastIndexedAt: null,
-        buildVersion: null,
-        extractionVersion: null,
-        staleEngine: false,
-        changedFiles: { added: [], modified: [], removed: [] },
-      },
-      result: {},
-      timingsMs: { open: 0, query: 0 },
-    };
-  }
-
-  let graph;
-  const openStartedAt = performance.now();
-  const refreshIfStale = request.refresh === 'if_stale';
-  try {
-    // Structural refresh mutates only the Forge-owned derived CodeGraph cache.
-    // Ordinary/auto reads stay strictly read-only so they never acquire hidden
-    // lifecycle authority or pay an indexing latency tax.
-    graph = await loaded.CodeGraph.open(request.projectRoot, {
-      sync: refreshIfStale,
-      readOnly: !refreshIfStale,
-    });
-  } catch (error) {
-    return failure(operation, 'CODEGRAPH_OPEN_FAILED', error instanceof Error ? error.message : error);
-  }
-  const openMs = Math.round((performance.now() - openStartedAt) * 100) / 100;
-
-  try {
-    const queryStartedAt = performance.now();
-    const limit = clamp(request.limit, 12, 1, 40);
-    const maxNodes = clamp(request.maxNodes, 40, 1, 80);
-    const maxDepth = clamp(request.maxDepth, 2, 1, 5);
-    let result = {};
-    if (operation === 'search') {
-      if (typeof request.query !== 'string' || !request.query.trim()) throw new Error('CODEGRAPH_QUERY_REQUIRED');
-      result = {
-        results: graph.searchNodes(request.query.trim(), { limit }).map((entry) => ({
-          node: nodeSummary(entry.node),
-          score: entry.score,
-          highlights: Array.isArray(entry.highlights) ? entry.highlights.slice(0, 8).map((value) => String(value).slice(0, 500)) : [],
-        })),
-      };
-    } else if (operation === 'context') {
-      if (typeof request.query !== 'string' || !request.query.trim()) throw new Error('CODEGRAPH_QUERY_REQUIRED');
-      const subgraph = await graph.findRelevantContext(request.query.trim(), {
-        searchLimit: Math.min(limit, 12),
-        traversalDepth: Math.min(maxDepth, 3),
-        maxNodes,
-      });
-      result = subgraphSummary(subgraph, maxNodes);
-    } else if (operation === 'impact') {
-      if (typeof request.nodeId !== 'string' || !request.nodeId.trim()) throw new Error('CODEGRAPH_NODE_ID_REQUIRED');
-      result = subgraphSummary(graph.getImpactRadius(request.nodeId.trim(), maxDepth), maxNodes);
-    } else if (operation === 'file_dependencies') {
-      if (typeof request.filePath !== 'string' || !request.filePath.trim()) throw new Error('CODEGRAPH_FILE_PATH_REQUIRED');
-      result = {
-        filePath: request.filePath.trim(),
-        dependencies: graph.getFileDependencies(request.filePath.trim()).slice(0, 100),
-        dependents: graph.getFileDependents(request.filePath.trim()).slice(0, 100),
-      };
-    }
-    const queryMs = Math.round((performance.now() - queryStartedAt) * 100) / 100;
-    return {
-      schemaVersion: SCHEMA_VERSION,
-      ok: true,
-      operation,
-      metadata: metadata(graph),
-      result,
-      timingsMs: { open: openMs, query: queryMs },
-    };
-  } catch (error) {
-    return failure(operation, 'CODEGRAPH_QUERY_FAILED', error instanceof Error ? error.message : error);
-  } finally {
-    try { graph.close(); } catch (_) { /* no-op */ }
-  }
-}
-
-async function runOneShot() {
-  let request;
-  try {
-    request = JSON.parse(fs.readFileSync(0, 'utf8'));
-  } catch (error) {
-    writeResponse(failure(undefined, 'CODEGRAPH_REQUEST_INVALID', error instanceof Error ? error.message : error), { failExit: true });
-    return;
-  }
-  writeResponse(await handleRequest(request), { failExit: true });
-}
-
-async function runPersistent() {
-  const lines = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
-  for await (const line of lines) {
-    if (!line.trim()) continue;
-    let request;
-    try {
-      request = JSON.parse(line);
-    } catch (error) {
-      writeResponse(failure(undefined, 'CODEGRAPH_REQUEST_INVALID', error instanceof Error ? error.message : error), { newline: true });
-      continue;
-    }
-    try {
-      writeResponse(await handleRequest(request), { newline: true });
-    } catch (error) {
-      writeResponse(failure(request?.operation, 'CODEGRAPH_SIDECAR_UNHANDLED', error instanceof Error ? error.message : error), { newline: true });
-    }
-  }
-}
-
-const run = process.env.FORGE_CODEGRAPH_PERSISTENT === '1' ? runPersistent : runOneShot;
-run().catch((error) => {
-  writeResponse(failure(undefined, 'CODEGRAPH_SIDECAR_UNHANDLED', error instanceof Error ? error.message : error), {
-    newline: process.env.FORGE_CODEGRAPH_PERSISTENT === '1',
-    failExit: process.env.FORGE_CODEGRAPH_PERSISTENT !== '1',
-  });
-});

package/src/runtime/control-plane/codegraph-cache-retention.ts

@@ -1,164 +0,0 @@
-import { existsSync, lstatSync, readdirSync, rmSync } from 'fs';
-import { join, relative, resolve } from 'path';
-import { codegraphCacheIdentity, codegraphCacheRoot } from '../context/codegraph-cache-boundary';
-import { measureReclaimablePath } from './lifecycle-retention-metrics';
-
-export const CODEGRAPH_CACHE_RETENTION_POLICY_VERSION = 'codegraph-cache-retention-v2';
-export const DEFAULT_CODEGRAPH_CACHE_RETENTION_MS = 7 * 24 * 60 * 60_000;
-export const DEFAULT_CODEGRAPH_CACHE_MAX_REPOSITORY_BYTES = 512 * 1024 * 1024;
-export const DEFAULT_CODEGRAPH_CACHE_MAX_TOTAL_BYTES = 2 * 1024 * 1024 * 1024;
-const DEFAULT_CODEGRAPH_CACHE_SCAN_BUDGET = 512;
-const DEFAULT_CODEGRAPH_CACHE_REMOVAL_BUDGET = 16;
-
-export interface CodegraphCacheRetentionOptions {
-  nowMs?: number;
-  retentionMs?: number;
-  maxRepositoryBytes?: number;
-  maxTotalBytes?: number;
-  maxEntries?: number;
-  maxRemovals?: number;
-  /** Repository roots with a live process-scoped locator. */
-  protectedRepositoryRoots?: readonly string[];
-}
-
-export interface CodegraphCacheRetentionReport {
-  policyVersion: typeof CODEGRAPH_CACHE_RETENTION_POLICY_VERSION;
-  inspected: number;
-  eligible: number;
-  attempted: number;
-  removedPaths: string[];
-  reclaimedBytes: number;
-  unknownReclaimedByteCount: number;
-  observedBytes: number;
-  unknownObservedByteCount: number;
-  retained: number;
-  protected: number;
-  protectedOverCapacity: number;
-  skippedByReason: Record<string, number>;
-  errors: string[];
-  truncated: boolean;
-  budgetExhausted: boolean;
-}
-
-function increment(counts: Record<string, number>, reason: string): void {
-  counts[reason] = (counts[reason] ?? 0) + 1;
-}
-
-/**
- * Reclaim only Forge-owned, rebuildable CodeGraph caches. LRU recency is the
- * cache-root mtime touched when a process-scoped locator is acquired/released.
- * A live locator fences deletion. Inactive caches are eligible when old, over
- * the per-repository cap, or when the Controller Home aggregate is over cap.
- */
-export function cleanupCodegraphCaches(
-  controllerHome: string,
-  options: CodegraphCacheRetentionOptions = {},
-): CodegraphCacheRetentionReport {
-  const root = codegraphCacheRoot(controllerHome);
-  const nowMs = options.nowMs ?? Date.now();
-  const retentionMs = Math.max(60_000, Math.floor(options.retentionMs ?? DEFAULT_CODEGRAPH_CACHE_RETENTION_MS));
-  const maxRepositoryBytes = Math.max(1, Math.floor(options.maxRepositoryBytes ?? DEFAULT_CODEGRAPH_CACHE_MAX_REPOSITORY_BYTES));
-  const maxTotalBytes = Math.max(1, Math.floor(options.maxTotalBytes ?? DEFAULT_CODEGRAPH_CACHE_MAX_TOTAL_BYTES));
-  const maxEntries = Math.max(1, Math.floor(options.maxEntries ?? DEFAULT_CODEGRAPH_CACHE_SCAN_BUDGET));
-  const maxRemovals = Math.max(0, Math.floor(options.maxRemovals ?? DEFAULT_CODEGRAPH_CACHE_REMOVAL_BUDGET));
-  const protectedIds = new Set((options.protectedRepositoryRoots ?? []).map(codegraphCacheIdentity));
-  const report: CodegraphCacheRetentionReport = {
-    policyVersion: CODEGRAPH_CACHE_RETENTION_POLICY_VERSION,
-    inspected: 0,
-    eligible: 0,
-    attempted: 0,
-    removedPaths: [],
-    reclaimedBytes: 0,
-    unknownReclaimedByteCount: 0,
-    observedBytes: 0,
-    unknownObservedByteCount: 0,
-    retained: 0,
-    protected: 0,
-    protectedOverCapacity: 0,
-    skippedByReason: {},
-    errors: [],
-    truncated: false,
-    budgetExhausted: false,
-  };
-  if (!existsSync(root)) return report;
-
-  let entries: Array<{ name: string; path: string; mtimeMs: number; bytes: number; sizeKnown: boolean }> = [];
-  try {
-    for (const entry of readdirSync(root, { withFileTypes: true })) {
-      const path = join(root, String(entry.name));
-      try {
-        const stat = lstatSync(path);
-        if (!entry.isDirectory() || stat.isSymbolicLink() || !/^[a-f0-9]{24}$/.test(String(entry.name))) {
-          increment(report.skippedByReason, 'ownership_unproven');
-          report.retained += 1;
-          continue;
-        }
-        const measurement = measureReclaimablePath(path);
-        if (measurement.complete) report.observedBytes += measurement.bytes;
-        else report.unknownObservedByteCount += 1;
-        entries.push({ name: String(entry.name), path, mtimeMs: stat.mtimeMs, bytes: measurement.bytes, sizeKnown: measurement.complete });
-      } catch (error) {
-        report.errors.push(`${String(entry.name)}: ${error instanceof Error ? error.message : String(error)}`);
-      }
-    }
-  } catch (error) {
-    report.errors.push(`codegraph cache root: ${error instanceof Error ? error.message : String(error)}`);
-    return report;
-  }
-
-  // Oldest first is LRU because locator acquire/release touches the cache root.
-  entries.sort((left, right) => left.mtimeMs - right.mtimeMs || left.name.localeCompare(right.name));
-  if (entries.length > maxEntries) report.truncated = true;
-  entries = entries.slice(0, maxEntries);
-  let knownRetainedBytes = report.observedBytes;
-  if (report.unknownObservedByteCount > 0) increment(report.skippedByReason, 'capacity_unknown_size');
-
-  for (const entry of entries) {
-    report.inspected += 1;
-    const expired = nowMs - entry.mtimeMs >= retentionMs;
-    const overRepositoryCap = entry.sizeKnown && entry.bytes > maxRepositoryBytes;
-    const overTotalCap = knownRetainedBytes > maxTotalBytes;
-    const capacityPressure = overRepositoryCap || overTotalCap;
-
-    if (protectedIds.has(entry.name)) {
-      report.protected += 1;
-      report.retained += 1;
-      increment(report.skippedByReason, 'active_locator');
-      if (capacityPressure) {
-        report.protectedOverCapacity += 1;
-        increment(report.skippedByReason, 'active_cache_over_capacity');
-      }
-      continue;
-    }
-    if (!expired && !capacityPressure) {
-      report.retained += 1;
-      increment(report.skippedByReason, 'retention_grace');
-      continue;
-    }
-
-    report.eligible += 1;
-    if (report.attempted >= maxRemovals) {
-      report.retained += 1;
-      report.budgetExhausted = true;
-      increment(report.skippedByReason, 'cleanup_budget_exhausted');
-      continue;
-    }
-    report.attempted += 1;
-    try {
-      rmSync(entry.path, { recursive: true, force: true });
-      report.removedPaths.push(relative(resolve(controllerHome), entry.path).replace(/\\/g, '/'));
-      if (entry.sizeKnown) {
-        report.reclaimedBytes += entry.bytes;
-        knownRetainedBytes = Math.max(0, knownRetainedBytes - entry.bytes);
-      } else {
-        report.unknownReclaimedByteCount += 1;
-      }
-    } catch (error) {
-      report.errors.push(`${entry.name}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-  if (knownRetainedBytes > maxTotalBytes) increment(report.skippedByReason, 'total_capacity_not_yet_converged');
-  report.removedPaths.sort();
-  report.errors.sort();
-  return report;
-}

package/src/runtime/control-plane/execution/content-equivalent-commit-authority.ts

@@ -1,169 +0,0 @@
-import { createHash } from 'crypto';
-import type { RepositoryRecord } from '../../../cli/repositories/types';
-import {
-  authoritativeImplementationReviewVerificationEvidence,
-  deriveImplementationReviewAcrossCommit,
-  getWorkContract,
-  implementationReviewChangedPathDigest,
-  implementationReviewEvidenceDigest,
-  latestImplementationReview,
-  recordContentEquivalentCommitAuthorityTransfer,
-  type ImplementationReviewCandidateIdentity,
-  type WorkContract,
-  type WorkImplementationReviewRecord,
-} from '../../../../packages/kernel/work/api/index';
-import { planWorkVerificationAcrossContentEquivalentCommit } from './work-verification-service';
-
-export interface ReviewedContentEquivalentCommitTransferInput {
-  controllerHome: string;
-  repository: RepositoryRecord;
-  workId: string;
-  preCommitCandidate: ImplementationReviewCandidateIdentity;
-  preCommitDirtyPaths: readonly string[];
-  committedPaths: readonly string[];
-  preCommitContentDigest: string;
-  postCommitSourceRevision: string;
-  postCommitContentDigest: string;
-  postCommitVerificationWorkspaceFingerprint: string;
-  postCommitChangedPaths: readonly string[];
-  recordedAt?: string;
-}
-
-export interface ReviewedContentEquivalentCommitTransferResult {
-  transferred: boolean;
-  reusedExistingTransfer: boolean;
-  reusableCheckIds: string[];
-  invalidatedCheckIds: string[];
-  derivedReview?: WorkImplementationReviewRecord;
-  contract?: WorkContract;
-  recordedAt: string;
-}
-
-function existingTransferMatches(input: ReviewedContentEquivalentCommitTransferInput, work: WorkContract): WorkImplementationReviewRecord | undefined {
-  const review = latestImplementationReview(work.implementationReviews);
-  if (!review || review.derivation !== 'content_equivalent_commit' || review.decision !== 'approved') return undefined;
-  if (review.sourceRevision !== input.postCommitSourceRevision
-    || review.workspaceFingerprint !== input.postCommitContentDigest
-    || review.verificationWorkspaceFingerprint !== input.postCommitVerificationWorkspaceFingerprint
-    || review.changedPathDigest !== implementationReviewChangedPathDigest(input.postCommitChangedPaths)
-    || implementationReviewEvidenceDigest(review.architectureEvidence) !== implementationReviewEvidenceDigest(input.preCommitCandidate.architectureEvidence ?? [])) {
-    return undefined;
-  }
-  const verification = authoritativeImplementationReviewVerificationEvidence({
-    repoId: work.repoId,
-    workId: work.workId,
-    requiredCheckIds: work.checks,
-    records: work.checkRefs,
-    sourceRevision: input.postCommitSourceRevision,
-    workspaceFingerprint: input.postCommitVerificationWorkspaceFingerprint,
-  });
-  if (verification.missingCheckIds.length > 0
-    || implementationReviewEvidenceDigest(verification.evidence) !== implementationReviewEvidenceDigest(review.verificationEvidence)) {
-    return undefined;
-  }
-  return review;
-}
-
-/**
- * The single control-plane owner for representation-only commit authority
- * transfer. Planning is side-effect free; persistence happens only after the
- * exact post-commit verification and review derivation proof both succeed.
- */
-export function transferReviewedWorkAuthorityAcrossContentEquivalentCommit(
-  input: ReviewedContentEquivalentCommitTransferInput,
-): ReviewedContentEquivalentCommitTransferResult {
-  const recordedAt = input.recordedAt ?? new Date().toISOString();
-  const current = getWorkContract({ controllerHome: input.controllerHome, repoId: input.repository.repoId }, input.workId);
-  if (!current || current.completionReceipt) throw new Error(`WORK_IMPLEMENTATION_REVIEW_CONTRACT_REQUIRED: ${input.workId}`);
-
-  const existing = existingTransferMatches(input, current);
-  if (existing) {
-    return {
-      transferred: true,
-      reusedExistingTransfer: true,
-      reusableCheckIds: [...current.checks],
-      invalidatedCheckIds: [],
-      derivedReview: existing,
-      contract: current,
-      recordedAt,
-    };
-  }
-
-  const verificationPlan = planWorkVerificationAcrossContentEquivalentCommit({
-    controllerHome: input.controllerHome,
-    repository: input.repository,
-    workId: input.workId,
-    preCommitSourceRevision: input.preCommitCandidate.sourceRevision,
-    preCommitWorkspaceFingerprint: input.preCommitCandidate.verificationWorkspaceFingerprint,
-    postCommitSourceRevision: input.postCommitSourceRevision,
-    postCommitWorkspaceFingerprint: input.postCommitVerificationWorkspaceFingerprint,
-    recordedAt,
-  });
-  if (verificationPlan.invalidatedCheckIds.length > 0) {
-    return {
-      transferred: false,
-      reusedExistingTransfer: false,
-      reusableCheckIds: verificationPlan.reusableCheckIds,
-      invalidatedCheckIds: verificationPlan.invalidatedCheckIds,
-      recordedAt,
-    };
-  }
-
-  const plannedRecords = [...verificationPlan.transferredRecords, ...current.checkRefs];
-  const postVerification = authoritativeImplementationReviewVerificationEvidence({
-    repoId: current.repoId,
-    workId: current.workId,
-    requiredCheckIds: current.checks,
-    records: plannedRecords,
-    sourceRevision: input.postCommitSourceRevision,
-    workspaceFingerprint: input.postCommitVerificationWorkspaceFingerprint,
-  });
-  if (postVerification.missingCheckIds.length > 0) {
-    throw new Error(`WORK_IMPLEMENTATION_REVIEW_TRANSFER_VERIFICATION_REQUIRED: ${postVerification.missingCheckIds.join(', ')}`);
-  }
-  const postCandidate: ImplementationReviewCandidateIdentity = {
-    sourceRevision: input.postCommitSourceRevision,
-    workspaceFingerprint: input.postCommitContentDigest,
-    verificationWorkspaceFingerprint: input.postCommitVerificationWorkspaceFingerprint,
-    changedPaths: input.postCommitChangedPaths,
-    verificationEvidence: postVerification.evidence,
-    architectureEvidence: input.preCommitCandidate.architectureEvidence ?? [],
-  };
-  const derivedReview = deriveImplementationReviewAcrossCommit({
-    workId: current.workId,
-    reviews: current.implementationReviews,
-    proof: {
-      preCommitCandidate: input.preCommitCandidate,
-      postCommitCandidate: postCandidate,
-      preCommitDirtyPaths: input.preCommitDirtyPaths,
-      committedPaths: input.committedPaths,
-      preCommitContentDigest: input.preCommitContentDigest,
-      postCommitContentDigest: input.postCommitContentDigest,
-      postCommitVerificationAuthority: {
-        repoId: current.repoId,
-        workId: current.workId,
-        requiredCheckIds: current.checks,
-        records: plannedRecords,
-      },
-    },
-    derivedReviewId: `REV-commit-${createHash('sha256').update(`${current.workId}\0${input.postCommitSourceRevision}\0${input.postCommitContentDigest}`).digest('hex').slice(0, 20)}`,
-    recordedAt,
-  });
-  const contract = recordContentEquivalentCommitAuthorityTransfer(
-    { controllerHome: input.controllerHome, repoId: input.repository.repoId },
-    input.workId,
-    {
-      transferredVerificationRecords: verificationPlan.transferredRecords,
-      derivedReview,
-    },
-  );
-  return {
-    transferred: true,
-    reusedExistingTransfer: false,
-    reusableCheckIds: verificationPlan.reusableCheckIds,
-    invalidatedCheckIds: [],
-    derivedReview,
-    contract,
-    recordedAt,
-  };
-}

package/src/runtime/control-plane/execution/direct-canonical-work-reconciliation.ts

@@ -1,85 +0,0 @@
-import { spawnSync } from 'child_process';
-import { realpathSync } from 'fs';
-import type { RepositoryGitStatusSnapshot } from '../../../cli/repositories/structured-git';
-import type { WorkHandleState } from './work-handle-store';
-
-export function gitIsAncestor(root: string, ancestor: string, descendant: string): boolean {
-  const result = spawnSync('git', ['-C', root, 'merge-base', '--is-ancestor', ancestor, descendant], {
-    encoding: 'utf-8', stdio: ['ignore', 'pipe', 'pipe'], timeout: 10_000,
-  });
-  if (result.error || (result.status !== 0 && result.status !== 1)) {
-    throw new Error(`WORK_TARGET_ADVANCE_ANCESTRY_UNAVAILABLE: ${ancestor} -> ${descendant}`);
-  }
-  return result.status === 0;
-}
-
-export type DirectCanonicalPreMutationReason =
-  | 'not_prepared'
-  | 'not_direct_target'
-  | 'path_mismatch'
-  | 'branch_mismatch'
-  | 'workspace_dirty'
-  | 'revision_unavailable'
-  | 'delivery_identity_not_pristine'
-  | 'no_target_advance'
-  | 'target_history_rewritten'
-  | 'alignable';
-
-export interface DirectCanonicalPreMutationInspection {
-  alignable: boolean;
-  reason: DirectCanonicalPreMutationReason;
-  previousDeliveryBase?: string;
-  targetHead?: string;
-}
-
-/**
- * Decide whether a Direct canonical Work may cross its first repository-mutation
- * boundary. Before that boundary the shared checkout must still be clean, so any
- * linear target advancement is unambiguously target-owned rather than Work-owned.
- * The caller persists the accepted base movement and the prepared -> editing
- * transition together before allowing repository bytes to change.
- */
-export function inspectDirectCanonicalPreMutationReconciliation(input: {
-  handle: WorkHandleState;
-  root: string;
-  targetBranch: string;
-  status: RepositoryGitStatusSnapshot;
-  freshlyMaterialized: boolean;
-}): DirectCanonicalPreMutationInspection {
-  const empty = (reason: DirectCanonicalPreMutationReason): DirectCanonicalPreMutationInspection => ({
-    alignable: false,
-    reason,
-  });
-  if (input.handle.state !== 'prepared') return empty('not_prepared');
-  if (input.handle.managedWorktree || input.handle.branch !== input.targetBranch) return empty('not_direct_target');
-  try {
-    if (realpathSync(input.root) !== realpathSync(input.handle.worktreePath)) return empty('path_mismatch');
-  } catch {
-    return empty('path_mismatch');
-  }
-  if (input.status.branch !== input.targetBranch) return empty('branch_mismatch');
-  if (!input.status.clean) return empty('workspace_dirty');
-
-  const previousDeliveryBase = input.handle.deliveryBaseCommit ?? input.handle.baseCommit;
-  const expectedHead = input.handle.expectedHead;
-  const targetHead = input.status.head ?? undefined;
-  if (!previousDeliveryBase || !expectedHead || !targetHead) return empty('revision_unavailable');
-  if (
-    expectedHead !== previousDeliveryBase
-    && !(input.freshlyMaterialized && expectedHead === targetHead)
-  ) {
-    return { ...empty('delivery_identity_not_pristine'), previousDeliveryBase, targetHead };
-  }
-  if (targetHead === previousDeliveryBase) {
-    return { ...empty('no_target_advance'), previousDeliveryBase, targetHead };
-  }
-  if (!gitIsAncestor(input.root, previousDeliveryBase, targetHead)) {
-    return { ...empty('target_history_rewritten'), previousDeliveryBase, targetHead };
-  }
-  return {
-    alignable: true,
-    reason: 'alignable',
-    previousDeliveryBase,
-    targetHead,
-  };
-}