@moretea-labs/forge 1.6.0 → 1.7.1

package/src/runtime/control-plane/execution/work-verification-service.ts

@@ -0,0 +1,388 @@
+import { readLatestControllerCheckEvidence } from '../../../cli/controller/check-runner';
+import { repositoryGitStatus } from '../../../cli/repositories/structured-git';
+import type { RepositoryRecord } from '../../../cli/repositories/types';
+import {
+  DEFAULT_WORK_CHECK_LEASE_WAIT_MS,
+  checkRequiresDurableWorkflow,
+  getProcessRecord,
+  processCheckCompletionReceipt,
+  readPersistedCheckResultReceipt,
+  runPersistedCheckViaProcessRuntime,
+} from '../../execution/process-runtime';
+import { classifyPersistedCheckTerminalEvidence } from '../../execution/process-runtime/check-result';
+import { buildFacadeResult } from '../facade/facade-result';
+import { classifyVerificationOutcome, normalizeCheckIds } from '../facade/check-normalization';
+import { verifyGoalWorkloop } from '../facade/goal-workloop';
+import type { FacadeResult, WorkContract } from '../facade/types';
+import { executionIdentityForRepository } from './execution-identity';
+import { commandFingerprint, verificationInputFingerprint, workspaceValidationFingerprint } from './verification-evidence';
+import { resolveWorkVerificationContext } from './work-verification-context';
+
+export interface ExecuteWorkVerificationInput {
+  controllerHome: string;
+  repository: RepositoryRecord;
+  workId?: string;
+  checkId?: string;
+  requestId?: string;
+  timeoutMs?: number;
+  interactiveWaitMs?: number;
+  leaseWaitMs?: number;
+  simulate?: {
+    infrastructureFailed?: boolean;
+    checkFailed?: boolean;
+    skipped?: boolean;
+  };
+  /** Caller-supplied exact ownership proof for durable-class checks. */
+  allowDurableCheckExecution?: (input: { work: WorkContract; checkId: string }) => boolean;
+}
+
+export interface ExecuteWorkVerificationResult {
+  facade: FacadeResult;
+  isError: boolean;
+}
+
+function result(facade: FacadeResult, isError = false): ExecuteWorkVerificationResult {
+  return { facade, isError };
+}
+
+/**
+ * Canonical Work verification application service.
+ *
+ * Transports supply authenticated ownership proof when they want to execute a
+ * durable-class check, but they never choose the Work checkout, check registry,
+ * Process evidence identity, or acceptance/infrastructure classification.
+ */
+export async function executeWorkVerification(input: ExecuteWorkVerificationInput): Promise<ExecuteWorkVerificationResult> {
+  const workId = input.workId?.trim() ?? '';
+  const checkId = input.checkId?.trim() ?? '';
+  const resolvedVerification = resolveWorkVerificationContext({
+    controllerHome: input.controllerHome,
+    repository: input.repository,
+    workId,
+  });
+  if (!resolvedVerification.ok) {
+    return result(buildFacadeResult({
+      status: 'blocked',
+      summary: `${resolvedVerification.code}: ${resolvedVerification.detail}`,
+      data: {
+        verification: {
+          checkId: checkId || undefined,
+          outcome: 'infrastructure_failure',
+          isAcceptanceFailure: false,
+          isInfrastructureIssue: true,
+          doesNotRequestTaskChanges: true,
+        },
+      },
+      warnings: ['Work verification never falls back to the canonical/main check registry when the Work-bound checkout is unavailable.'],
+    }), true);
+  }
+
+  const { store, workContract, repository: verificationRepository, checks } = resolvedVerification.context;
+  if (!checkId) {
+    return result(buildFacadeResult({
+      status: 'blocked',
+      summary: 'Work verification requires a registered check_id.',
+      data: {
+        verification: {
+          outcome: 'check_id_required',
+          isAcceptanceFailure: false,
+          isInfrastructureIssue: true,
+          doesNotRequestTaskChanges: true,
+        },
+        registeredCheckCount: checks.length,
+      },
+      warnings: ['CHECK_ID_REQUIRED: pass check_id for one registered repository check.'],
+      suggestedNextActions: normalizeCheckIds(checks.slice(0, 3).map((check) => check.id), checks).suggestedNextActions,
+    }), true);
+  }
+
+  const workloopCtx = {
+    workStore: store,
+    handoffStore: store,
+    repoId: input.repository.repoId,
+    availableChecks: checks,
+  };
+  if (workId && (!workContract || workContract.status === 'completed' || workContract.status === 'cancelled' || workContract.status === 'failed')) {
+    const facade = verifyGoalWorkloop(workloopCtx, { workId, checkId });
+    return result(facade, facade.status === 'failed');
+  }
+
+  const classified = classifyVerificationOutcome({ checkId, available: checks });
+  if (classified.outcome === 'invalid_check_id') {
+    if (workId) return result(verifyGoalWorkloop(workloopCtx, { workId, checkId }));
+    return result(buildFacadeResult({
+      status: 'ok',
+      summary: classified.summary,
+      data: {
+        verification: {
+          checkId,
+          outcome: 'invalid_check_id',
+          isAcceptanceFailure: false,
+          isInfrastructureIssue: true,
+          doesNotRequestTaskChanges: true,
+        },
+        registeredCheckCount: checks.length,
+      },
+      warnings: classified.warnings,
+      suggestedNextActions: normalizeCheckIds(checks.slice(0, 3).map((check) => check.id), checks).suggestedNextActions,
+    }));
+  }
+
+  if (input.simulate) {
+    if (!workId) {
+      return result(buildFacadeResult({
+        status: input.simulate.checkFailed ? 'failed' : 'ok',
+        summary: 'Simulated verification without WorkContract.',
+        data: {
+          verification: {
+            checkId: classified.normalizedCheckId,
+            outcome: input.simulate.skipped ? 'skipped' : input.simulate.infrastructureFailed ? 'infrastructure_failure' : input.simulate.checkFailed ? 'valid_fail' : 'valid_pass',
+            isAcceptanceFailure: input.simulate.checkFailed === true,
+            simulated: true,
+          },
+        },
+      }), input.simulate.checkFailed === true);
+    }
+    const facade = verifyGoalWorkloop(workloopCtx, {
+      workId,
+      checkId: classified.normalizedCheckId ?? checkId,
+      infrastructureFailed: input.simulate.infrastructureFailed === true,
+      checkFailed: input.simulate.checkFailed === true,
+      skipped: input.simulate.skipped === true,
+    });
+    return result(facade, facade.status === 'failed');
+  }
+
+  try {
+    const normalizedCheckId = classified.normalizedCheckId!;
+    const verificationStatus = repositoryGitStatus(verificationRepository);
+    const observedGitHead = verificationStatus.head;
+    const workspaceFingerprint = workspaceValidationFingerprint(verificationRepository.canonicalRoot, verificationStatus);
+    const requestedChecks = workContract?.checks.length ? workContract.checks : [normalizedCheckId];
+    const verificationRequestFingerprint = observedGitHead ? verificationInputFingerprint({
+      sourceRevision: observedGitHead,
+      workspaceFingerprint,
+      checkId: normalizedCheckId,
+      requestedChecks,
+    }) : undefined;
+    const registeredCheck = checks.find((entry) => entry.id === normalizedCheckId);
+    const durableClassCheck = checkRequiresDurableWorkflow(normalizedCheckId, registeredCheck);
+    const allowDurableCheckExecution = Boolean(
+      durableClassCheck
+      && workContract
+      && workContract.checks.includes(normalizedCheckId)
+      && !workContract.completionReceipt
+      && workContract.status === 'running'
+      && input.allowDurableCheckExecution?.({ work: workContract, checkId: normalizedCheckId }),
+    );
+
+    const executed = await runPersistedCheckViaProcessRuntime({
+      controllerHome: input.controllerHome,
+      repoId: verificationRepository.repoId,
+      checkoutId: verificationRepository.activeCheckoutId,
+      repoRoot: verificationRepository.canonicalRoot,
+      executionIdentity: executionIdentityForRepository(verificationRepository, workId ? { workId } : {}),
+      checkId: normalizedCheckId,
+      timeoutMs: input.timeoutMs,
+      interactiveWaitMs: input.interactiveWaitMs ?? 0,
+      leaseWaitMs: input.leaseWaitMs ?? (workId ? DEFAULT_WORK_CHECK_LEASE_WAIT_MS : undefined),
+      requestId: input.requestId,
+      requestSemanticFingerprint: verificationRequestFingerprint,
+      workId: workId || undefined,
+      commandId: input.requestId,
+      verificationSnapshot: workContract ? {
+        workId: workContract.workId,
+        allowedPaths: workContract.allowedPaths,
+        forbiddenPaths: workContract.forbiddenPaths,
+      } : undefined,
+      allowDurableCheckExecution,
+    });
+
+    if (executed.mode === 'durable') {
+      return result(buildFacadeResult({
+        status: 'blocked',
+        summary: `Check ${normalizedCheckId} requires an explicit durable workflow; no acceptance result was recorded.`,
+        data: {
+          verification: {
+            checkId: normalizedCheckId,
+            outcome: 'deferred',
+            isAcceptanceFailure: false,
+            isInfrastructureIssue: false,
+            durable: executed.durable,
+            observedGitHead,
+          },
+        },
+        suggestedNextActions: workId ? [{
+          label: 'Continue Work with the durable check requirement',
+          tool: 'rh_work',
+          operation: 'continue',
+          payload: { work_id: workId },
+          risk: 'workspace_write',
+          confidence: 'high',
+        }] : [],
+      }), true);
+    }
+
+    const handle = executed.process;
+    if (!handle) throw new Error(`PROCESS_CHECK_HANDLE_MISSING: ${normalizedCheckId}`);
+    const record = getProcessRecord(input.controllerHome, verificationRepository.repoId, handle.processId);
+    const checkContentRevision = record?.checkExecution?.revision;
+    if (!handle.completed) {
+      return result(buildFacadeResult({
+        status: 'ok',
+        summary: `Check ${normalizedCheckId} is running through Process Runtime; continue other work and reattach to ${handle.processId}.`,
+        data: {
+          verification: {
+            checkId: normalizedCheckId,
+            outcome: 'running',
+            isAcceptanceFailure: false,
+            isInfrastructureIssue: false,
+            executed: true,
+            completed: false,
+            processId: handle.processId,
+            processStatus: handle.status,
+            deduplicated: handle.deduplicated === true,
+            semanticDeduplicated: handle.semanticDeduplicated === true,
+            checkContentRevision,
+            observedGitHead,
+            verificationIsolation: workContract ? 'work_snapshot' : 'shared_checkout',
+            revisionSemantics: 'checkContentRevision is a content-bound Check identity; observedGitHead is Git HEAD and is not interchangeable.',
+          },
+        },
+        rawAvailable: false,
+      }));
+    }
+
+    if (!record) throw new Error(`PROCESS_CHECK_RECORD_MISSING: ${handle.processId}`);
+    const receipt = processCheckCompletionReceipt(record, {
+      repoId: verificationRepository.repoId,
+      checkId: normalizedCheckId,
+      processId: handle.processId,
+      ...(record.checkExecution ? {
+        checkoutId: verificationRepository.activeCheckoutId,
+        workId: workId || undefined,
+        requestId: input.requestId,
+        checkExecution: {
+          cacheKey: record.checkExecution.cacheKey,
+          revision: record.checkExecution.revision,
+          definitionDigest: record.checkExecution.definitionDigest,
+          environmentFingerprint: record.checkExecution.environmentFingerprint,
+          timeoutMs: record.checkExecution.timeoutMs,
+          scopeKey: record.checkExecution.scopeKey,
+        },
+      } : {}),
+    });
+    const structuredCheckResult = readPersistedCheckResultReceipt(record.origin?.checkResultReceiptPath);
+    const legacyEvidence = record.origin?.checkResultReceiptPath
+      ? undefined
+      : readLatestControllerCheckEvidence(verificationRepository.canonicalRoot, normalizedCheckId);
+    const evidenceState = classifyPersistedCheckTerminalEvidence(record, normalizedCheckId, { legacyEvidence });
+    const failureClass = evidenceState.failureClass;
+    const infrastructureFailed = receipt.timedOut
+      || receipt.cancelled
+      || evidenceState.state !== 'matched'
+      || (!receipt.ok && failureClass !== 'acceptance_failure');
+    const checkFailed = !receipt.ok && !infrastructureFailed;
+    const commonVerification = {
+      checkId: normalizedCheckId,
+      outcome: infrastructureFailed ? 'infrastructure_failure' : receipt.ok ? 'valid_pass' : 'valid_fail',
+      isAcceptanceFailure: checkFailed,
+      isInfrastructureIssue: infrastructureFailed,
+      executed: true,
+      completed: true,
+      processId: receipt.processId,
+      processStatus: receipt.runtimeStatus,
+      ok: receipt.ok,
+      timedOut: receipt.timedOut,
+      cancelled: receipt.cancelled,
+      failureClass: infrastructureFailed ? 'infrastructure_failure' : failureClass,
+      deduplicated: handle.deduplicated === true,
+      semanticDeduplicated: handle.semanticDeduplicated === true,
+      checkContentRevision: receipt.checkRevision,
+      observedGitHead,
+      revisionSemantics: 'checkContentRevision is a content-bound Check identity; observedGitHead is Git HEAD and is not interchangeable.',
+      evidenceArtifactPath: record.origin?.workVerificationSnapshot ? undefined : receipt.artifactPath,
+      evidenceReceiptId: receipt.receiptId,
+      checkResultReceiptId: structuredCheckResult?.receiptId,
+      verificationIsolation: record.origin?.workVerificationSnapshot ? 'work_snapshot' : 'shared_checkout',
+      boundedStatus: receipt.ok ? 'pass' : infrastructureFailed ? 'infrastructure_failure' : 'fail',
+      evidenceState: evidenceState.state,
+      ...(evidenceState.infrastructureReason ? { infrastructureReason: evidenceState.infrastructureReason } : {}),
+      ...(record.error?.code ? { processErrorCode: record.error.code } : {}),
+    };
+
+    if (workId) {
+      const sourceRevision = observedGitHead ?? undefined;
+      const facade = verifyGoalWorkloop(workloopCtx, {
+        workId,
+        checkId: normalizedCheckId,
+        sourceRevision,
+        workspaceFingerprint,
+        verificationInputFingerprint: sourceRevision ? verificationRequestFingerprint : undefined,
+        commandFingerprint: commandFingerprint(normalizedCheckId, receipt.commandId),
+        receipt,
+        infrastructureFailed,
+        checkFailed,
+      });
+      return result({
+        ...facade,
+        data: {
+          ...(facade.data as Record<string, unknown>),
+          verification: {
+            ...(typeof facade.data.verification === 'object' && facade.data.verification ? facade.data.verification as Record<string, unknown> : {}),
+            ...commonVerification,
+          },
+        },
+        warnings: infrastructureFailed
+          ? [...facade.warnings, evidenceState.warning ?? 'infrastructure_failure is distinct from acceptance failure']
+          : facade.warnings,
+      }, facade.status === 'failed');
+    }
+
+    return result(buildFacadeResult({
+      status: checkFailed ? 'failed' : 'ok',
+      summary: infrastructureFailed
+        ? `Infrastructure failure while running ${normalizedCheckId}; not an acceptance failure.`
+        : receipt.ok
+          ? `Check ${normalizedCheckId} passed with persisted Process evidence.`
+          : `Check ${normalizedCheckId} failed acceptance.`,
+      data: { verification: commonVerification },
+      warnings: infrastructureFailed ? [evidenceState.warning ?? 'infrastructure_failure is distinct from acceptance failure'] : [],
+      rawAvailable: false,
+    }), checkFailed);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (workId) {
+      const facade = verifyGoalWorkloop(workloopCtx, {
+        workId,
+        checkId: classified.normalizedCheckId ?? checkId,
+        infrastructureFailed: true,
+      });
+      return result({
+        ...facade,
+        warnings: [...facade.warnings, `check_runner_error: ${message.slice(0, 200)}`],
+        data: { ...(facade.data as Record<string, unknown>), isAcceptanceFailure: false },
+      });
+    }
+    return result(buildFacadeResult({
+      status: 'ok',
+      summary: `Infrastructure failure invoking Process Runtime for ${classified.normalizedCheckId}; not acceptance failure.`,
+      data: {
+        verification: {
+          checkId: classified.normalizedCheckId,
+          outcome: 'infrastructure_failure',
+          isAcceptanceFailure: false,
+          isInfrastructureIssue: true,
+        },
+      },
+      warnings: [`check_runner_error: ${message.slice(0, 200)}`],
+      suggestedNextActions: [{
+        label: 'Diagnose runtime (dry-run)',
+        tool: 'rh_work',
+        operation: 'repair',
+        payload: { repair_operation: 'diagnose', dry_run: true },
+        risk: 'readonly',
+      }],
+    }));
+  }
+}

package/src/runtime/control-plane/execution/work-verification-snapshot.ts

@@ -5,7 +5,9 @@ import {
   lstatSync,
   mkdirSync,
   mkdtempSync,
+  readFileSync,
   readdirSync,
+  rmdirSync,
   rmSync,
   statSync,
   symlinkSync,
@@ -28,6 +30,8 @@ export interface WorkVerificationSnapshotScope {
 
 export interface WorkVerificationSnapshot {
   root: string;
+  /** Ephemeral Controller Home visible only to Candidate verification children. */
+  isolatedControllerHome: string;
   sourceHead: string;
   includedPaths: string[];
   excludedPaths: string[];
@@ -91,11 +95,28 @@ function cloneHead(sourceRoot: string, targetRoot: string, head: string): void {
   git(targetRoot, ['checkout', '--detach', '--quiet', head]);
 }
 
+function pruneEmptySnapshotParents(targetRoot: string, targetPath: string): void {
+  const boundary = resolve(targetRoot);
+  let current = dirname(resolve(targetPath));
+  while (current !== boundary) {
+    try {
+      if (readdirSync(current).length > 0) return;
+      rmdirSync(current);
+    } catch {
+      return;
+    }
+    current = dirname(current);
+  }
+}
+
 function overlayPath(sourceRoot: string, targetRoot: string, relativePath: string): void {
   const source = resolve(sourceRoot, relativePath);
   const target = resolve(targetRoot, relativePath);
   rmSync(target, { recursive: true, force: true });
-  if (!existsSync(source)) return;
+  if (!existsSync(source)) {
+    pruneEmptySnapshotParents(targetRoot, target);
+    return;
+  }
   mkdirSync(dirname(target), { recursive: true });
   const stat = lstatSync(source);
   if (stat.isSymbolicLink()) {
@@ -105,11 +126,69 @@ function overlayPath(sourceRoot: string, targetRoot: string, relativePath: strin
   cpSync(source, target, { recursive: stat.isDirectory(), dereference: false, force: true, preserveTimestamps: true });
 }
 
-function linkIgnoredNodeModules(sourceRoot: string, targetRoot: string): void {
-  const source = join(sourceRoot, 'node_modules');
+const DEPENDENCY_LOCK_FILES = ['bun.lock', 'bun.lockb', 'pnpm-lock.yaml', 'package-lock.json', 'yarn.lock'] as const;
+const DEPENDENCY_CONFIG_FILES = ['pnpm-workspace.yaml', 'bunfig.toml', '.npmrc', '.yarnrc.yml'] as const;
+const DEPENDENCY_METADATA_NAMES = ['package.json', ...DEPENDENCY_LOCK_FILES, ...DEPENDENCY_CONFIG_FILES] as const;
+
+function isDependencyMetadataPath(path: string): boolean {
+  const name = path.split('/').pop() ?? path;
+  return DEPENDENCY_METADATA_NAMES.some((candidate) => candidate === name);
+}
+
+function hasUntrackedDependencyMetadata(root: string): boolean {
+  return nulPaths(git(root, ['ls-files', '--others', '--exclude-standard', '-z'])).some(isDependencyMetadataPath);
+}
+
+function dependencyMetadataDigest(root: string): string | undefined {
+  if (!existsSync(join(root, 'package.json'))) return undefined;
+  const rootLock = DEPENDENCY_LOCK_FILES.find((name) => existsSync(join(root, name)));
+  if (!rootLock) return undefined;
+  const pathspecs = DEPENDENCY_METADATA_NAMES.flatMap((name) => [name, `:(glob)**/${name}`]);
+  const tracked = nulPaths(git(root, ['ls-files', '-z', '--', ...pathspecs]));
+  const files = [...new Set(tracked)].sort();
+  if (!files.includes('package.json') || !files.includes(rootLock)) return undefined;
+  const hash = createHash('sha256');
+  for (const path of files) {
+    hash.update(path);
+    hash.update('\0');
+    hash.update(readFileSync(join(root, path)));
+    hash.update('\0');
+  }
+  return hash.digest('hex');
+}
+
+function primaryWorktreeRoot(sourceRoot: string): string | undefined {
+  const commonDirValue = git(sourceRoot, ['rev-parse', '--git-common-dir']).toString('utf8').trim();
+  if (!commonDirValue) return undefined;
+  const commonDir = resolve(sourceRoot, commonDirValue);
+  const candidate = dirname(commonDir);
+  if (resolve(candidate) === resolve(sourceRoot)) return undefined;
+  if (!existsSync(join(candidate, '.git'))) return undefined;
+  return candidate;
+}
+
+function linkIgnoredNodeModules(sourceRoot: string, targetRoot: string, dirtyPaths: readonly string[]): void {
+  let source = join(sourceRoot, 'node_modules');
   const target = join(targetRoot, 'node_modules');
-  if (!existsSync(source) || existsSync(target)) return;
-  const ignored = spawnSync('git', ['-C', sourceRoot, 'check-ignore', '--quiet', '--', 'node_modules'], { stdio: 'ignore', timeout: 10_000 });
+  if (existsSync(target)) return;
+  if (!existsSync(source)) {
+    if (dirtyPaths.some(isDependencyMetadataPath)) return;
+    const primaryRoot = primaryWorktreeRoot(sourceRoot);
+    if (!primaryRoot) return;
+    const primaryNodeModules = join(primaryRoot, 'node_modules');
+    if (!existsSync(primaryNodeModules) || hasUntrackedDependencyMetadata(primaryRoot)) return;
+    const sourceDigest = dependencyMetadataDigest(sourceRoot);
+    const primaryDigest = dependencyMetadataDigest(primaryRoot);
+    if (!sourceDigest || sourceDigest !== primaryDigest) return;
+    source = primaryNodeModules;
+  }
+  // An existing managed-worktree node_modules may itself be a symlink. Git
+  // rejects child pathspecs through symlinks, while an absent node_modules
+  // needs a virtual child path so directory-only ignore rules still match.
+  const ignoreProbe = existsSync(join(sourceRoot, 'node_modules'))
+    ? 'node_modules'
+    : 'node_modules/.forge-verification-probe';
+  const ignored = spawnSync('git', ['-C', sourceRoot, 'check-ignore', '--quiet', '--', ignoreProbe], { stdio: 'ignore', timeout: 10_000 });
   if (ignored.status !== 0) return;
   try {
     symlinkSync(source, target, process.platform === 'win32' ? 'junction' : 'dir');
@@ -136,18 +215,18 @@ export function materializeWorkVerificationSnapshot(input: {
       excludedPaths.push(path);
       continue;
     }
-    if (input.scope.allowedPaths.length > 0 && matchesAny(input.scope.allowedPaths, path)) {
+    if (input.scope.allowedPaths.length === 0 || matchesAny(input.scope.allowedPaths, path)) {
       includedPaths.push(path);
       continue;
     }
-    throw new Error(`WORK_VERIFICATION_PATH_OWNERSHIP_AMBIGUOUS: ${path} is dirty but is neither allowed nor forbidden for ${input.scope.workId}`);
+    throw new Error(`WORK_VERIFICATION_PATH_OWNERSHIP_AMBIGUOUS: ${path} is dirty but is outside the allowed path fence for ${input.scope.workId}`);
   }
 
   const root = snapshotRoot(input.controllerHome, input.repoId, input.scope.workId);
   try {
     cloneHead(input.sourceRoot, root, sourceHead);
     for (const path of includedPaths) overlayPath(input.sourceRoot, root, path);
-    linkIgnoredNodeModules(input.sourceRoot, root);
+    linkIgnoredNodeModules(input.sourceRoot, root, dirtyPaths);
     const ownershipDigest = createHash('sha256').update(JSON.stringify({
       sourceHead,
       workId: input.scope.workId,
@@ -156,9 +235,11 @@ export function materializeWorkVerificationSnapshot(input: {
       allowedPaths: [...input.scope.allowedPaths].sort(),
       forbiddenPaths: [...input.scope.forbiddenPaths].sort(),
     })).digest('hex');
+    const isolatedControllerHome = join(root, '.git', 'forge-candidate-controller');
+    mkdirSync(isolatedControllerHome, { recursive: true, mode: 0o700 });
     mkdirSync(dirname(join(root, SNAPSHOT_MARKER)), { recursive: true });
     writeFileSync(join(root, SNAPSHOT_MARKER), `${JSON.stringify({ schemaVersion: 1, ...input.scope, sourceHead, includedPaths, excludedPaths, ownershipDigest }, null, 2)}\n`);
-    return { root, sourceHead, includedPaths, excludedPaths, ownershipDigest };
+    return { root, isolatedControllerHome, sourceHead, includedPaths, excludedPaths, ownershipDigest };
   } catch (error) {
     rmSync(root, { recursive: true, force: true });
     throw error;