@moretea-labs/forge 1.8.0 → 1.8.2

package/packages/kernel/scheduler/application/continuation-service.ts

@@ -1,212 +0,0 @@
-import {
-  beginInitialControllerRoundDispatch,
-  bindLegacyControllerRoundOccurrence,
-  controllerSessionPrincipalId,
-  finishControllerRoundRelayDispatch,
-  getControllerRoundRelay,
-  readControllerRoundSemanticStateFingerprint,
-  getControllerWorkBinding,
-  getRetainedControllerSession,
-  type ControllerHost,
-} from '../../controller/api/index';
-import { getWorkContract, isTerminalWorkContractStatus } from '../../work/api/index';
-import type { ScheduledControllerContinuationInput, ScheduledContinuationDispatch } from '../domain/continuation';
-import {
-  getScheduledContinuationDispatch,
-  updateScheduledContinuationDispatch,
-  type SchedulerContinuationStoreOptions,
-} from '../infrastructure/continuation-dispatch-store';
-
-export interface ScheduledControllerContinuationResult {
-  dispatch: ScheduledContinuationDispatch;
-  reused: boolean;
-}
-
-/**
- * Canonical Scheduler continuation path:
- * Schedule occurrence -> exact Work -> Work-scoped durable ControllerBinding -> current Controller delivery session -> ControllerHost.resume.
- * The occurrence record fences external replay independently of transport/provider behavior; ControllerSession ids are observation, not semantic continuation identity.
- */
-export async function resumeScheduledControllerContinuation(
-  options: SchedulerContinuationStoreOptions,
-  input: ScheduledControllerContinuationInput,
-  host: ControllerHost,
-): Promise<ScheduledControllerContinuationResult> {
-  const previous = getScheduledContinuationDispatch(options, input.occurrenceId);
-  if (previous) {
-    if (
-      previous.scheduleId !== input.scheduleId
-      || previous.workId !== input.workId
-      || previous.controllerBindingId !== input.controllerBindingId
-    ) throw new Error(`SCHEDULE_CONTINUATION_OCCURRENCE_IDENTITY_CONFLICT: ${input.occurrenceId}`);
-    if (previous.status === 'dispatched' || previous.status === 'wait_for_user' || previous.status === 'semantic_wait' || previous.status === 'rejected') return { dispatch: previous, reused: true };
-    if (previous.status === 'outcome_unknown') throw new Error(`SCHEDULE_CONTINUATION_OUTCOME_UNKNOWN: ${input.occurrenceId}`);
-    if (previous.status === 'dispatching') throw new Error(`SCHEDULE_CONTINUATION_ALREADY_DISPATCHING: ${input.occurrenceId}`);
-  }
-
-  const work = getWorkContract(options, input.workId);
-  if (!work) throw new Error(`WORK_NOT_FOUND: ${input.workId}`);
-  if (isTerminalWorkContractStatus(work.status)) throw new Error(`WORK_ALREADY_TERMINAL: ${work.workId}:${work.status}`);
-
-  const session = getRetainedControllerSession(options, work.workId);
-  if (!session) throw new Error(`CONTROLLER_SESSION_NOT_RETAINED: ${work.workId}`);
-  const bindingRecord = getControllerWorkBinding(options, work.workId);
-  if (!bindingRecord) throw new Error(`CONTROLLER_WORK_BINDING_NOT_FOUND: ${work.workId}`);
-  if (bindingRecord.binding.bindingId !== input.controllerBindingId) {
-    throw new Error(`SCHEDULE_CONTINUATION_BINDING_DRIFT: ${work.workId}:expected=${input.controllerBindingId}:actual=${bindingRecord.binding.bindingId}`);
-  }
-  if (bindingRecord.binding.hostKind !== session.controllerType) {
-    throw new Error(`SCHEDULE_CONTINUATION_HOST_KIND_MISMATCH: ${work.workId}`);
-  }
-
-  const requestedRelayScopeId = input.relayScopeId?.trim() || undefined;
-  const canonicalRelayScopeId = requestedRelayScopeId
-    ?? (work.requirementId ? `requirement:${work.requirementId}` : `goal:${work.workId}`);
-
-  // A semantic `wait` is quiescent, not a request to periodically reread the same
-  // state. Suppress unchanged schedule/manual wakes before a provider host is even
-  // selected. A new occurrence may proceed only after Kernel semantic state changes.
-  const waitingRelay = getControllerRoundRelay(options, work.workId);
-  if (waitingRelay?.status === 'waiting' && waitingRelay.relayScopeId === canonicalRelayScopeId) {
-    const currentFingerprint = readControllerRoundSemanticStateFingerprint(options, work.workId);
-    if (currentFingerprint && currentFingerprint === waitingRelay.stateFingerprint) {
-      const quiesced = updateScheduledContinuationDispatch(options, input.occurrenceId, 'scheduler_continuation_semantic_wait', (current, at) => current ?? ({
-        schemaVersion: 1, repoId: options.repoId, scheduleId: input.scheduleId, occurrenceId: input.occurrenceId,
-        workId: work.workId, controllerSessionId: session.sessionId, controllerBindingId: bindingRecord.binding.bindingId,
-        relayScopeId: canonicalRelayScopeId, status: 'semantic_wait',
-        reason: `Controller semantic wait remains unchanged for ${canonicalRelayScopeId}; provider dispatch suppressed.`,
-        createdAt: at, updatedAt: at,
-      }));
-      return { dispatch: quiesced, reused: Boolean(previous) };
-    }
-  }
-
-  // Reserve the exact occurrence before creating a ControllerRound. If Forge dies
-  // after the round write but before the authority is copied back here, the next
-  // attempt can safely adopt only the exact still-dispatching round for this
-  // retained session/binding instead of minting or replaying another wake.
-  let prepared = updateScheduledContinuationDispatch(options, input.occurrenceId, 'scheduler_continuation_prepare', (current, at) => current ?? ({
-    schemaVersion: 1, repoId: options.repoId, scheduleId: input.scheduleId, occurrenceId: input.occurrenceId,
-    workId: work.workId, controllerSessionId: session.sessionId, controllerBindingId: bindingRecord.binding.bindingId,
-    relayScopeId: canonicalRelayScopeId, status: 'prepared', createdAt: at, updatedAt: at,
-  }));
-  if (prepared.status === 'dispatched' || prepared.status === 'wait_for_user' || prepared.status === 'semantic_wait' || prepared.status === 'rejected') return { dispatch: prepared, reused: true };
-  if (prepared.status === 'outcome_unknown') throw new Error(`SCHEDULE_CONTINUATION_OUTCOME_UNKNOWN: ${input.occurrenceId}`);
-  if (prepared.status === 'dispatching') throw new Error(`SCHEDULE_CONTINUATION_ALREADY_DISPATCHING: ${input.occurrenceId}`);
-
-  const currentControllerPrincipalId = controllerSessionPrincipalId(session);
-  const roundMatchesReservedOccurrence = (candidate: ReturnType<typeof getControllerRoundRelay>): boolean => Boolean(
-    candidate
-    && candidate.status === 'dispatching'
-    && candidate.relayScopeId === prepared.relayScopeId
-    && candidate.occurrenceId === prepared.occurrenceId
-    && candidate.controllerId === session.controllerId
-    && candidate.controllerType === session.controllerType
-    && candidate.authorityId,
-  );
-  const bindRecoveredLegacyOccurrence = (candidate: ReturnType<typeof getControllerRoundRelay>) => {
-    if (!candidate
-      || candidate.status !== 'dispatching'
-      || candidate.occurrenceId
-      || candidate.relayScopeId !== prepared.relayScopeId
-      || candidate.controllerId !== session.controllerId
-      || candidate.controllerType !== session.controllerType
-      || (candidate.principalId?.trim() || candidate.controllerId) !== currentControllerPrincipalId
-      || !candidate.authorityId
-      || (candidate.providerRecoveryEpoch ?? 0) < 1
-      || !candidate.providerRecoveryEvidenceId) return candidate;
-    return bindLegacyControllerRoundOccurrence(options, {
-      workId: work.workId,
-      relayScopeId: prepared.relayScopeId,
-      occurrenceId: prepared.occurrenceId,
-      authorityId: candidate.authorityId,
-      expectedUpdatedAt: candidate.updatedAt,
-      identity: { controllerId: session.controllerId, controllerType: session.controllerType, principalId: currentControllerPrincipalId },
-    });
-  };
-
-  let relay = previous ? getControllerRoundRelay(options, work.workId) : undefined;
-  if (relay && !roundMatchesReservedOccurrence(relay)) {
-    relay = bindRecoveredLegacyOccurrence(relay);
-    if (!roundMatchesReservedOccurrence(relay)) {
-      throw new Error(`SCHEDULE_CONTINUATION_ROUND_ALREADY_OPEN: ${input.occurrenceId}:${relay?.relayScopeId ?? canonicalRelayScopeId}`);
-    }
-  }
-  if (!relay) {
-    try {
-      relay = beginInitialControllerRoundDispatch(options, {
-        workId: work.workId,
-        relayScopeId: requestedRelayScopeId,
-        requirementId: work.requirementId,
-        bindingId: bindingRecord.binding.bindingId,
-        occurrenceId: input.occurrenceId,
-        identity: {
-          controllerId: session.controllerId,
-          controllerType: session.controllerType,
-          principalId: controllerSessionPrincipalId(session),
-          controllerInstanceId: session.controllerInstanceId?.trim() || session.controllerId,
-          sessionId: session.sessionId,
-        },
-      });
-    } catch (error) {
-      if (error instanceof Error && error.message.startsWith('CONTROLLER_RELAY_ROUND_ALREADY_OPEN:')) {
-        let existing = getControllerRoundRelay(options, work.workId);
-        if (!roundMatchesReservedOccurrence(existing)) existing = bindRecoveredLegacyOccurrence(existing);
-        if (roundMatchesReservedOccurrence(existing)) relay = existing;
-        else throw new Error(`SCHEDULE_CONTINUATION_ROUND_ALREADY_OPEN: ${input.occurrenceId}:${canonicalRelayScopeId}`);
-      } else {
-        throw error;
-      }
-    }
-  }
-  if (!relay) throw new Error(`SCHEDULE_CONTINUATION_ROUND_MISSING: ${input.occurrenceId}`);
-  if (relay.status === 'blocked') throw new Error(`CONTROLLER_RELAY_LAUNCH_BLOCKED: ${relay.blockedReason ?? relay.relayScopeId}`);
-  if (!relay.authorityId) throw new Error(`CONTROLLER_ROUND_AUTHORITY_REQUIRED: ${relay.relayScopeId}`);
-
-  prepared = updateScheduledContinuationDispatch(options, input.occurrenceId, 'scheduler_continuation_bind_round', (current, at) => ({
-    ...(current ?? prepared), relayScopeId: relay.relayScopeId, controllerAuthorityId: relay.authorityId, status: 'prepared', updatedAt: at,
-  }));
-
-  updateScheduledContinuationDispatch(options, input.occurrenceId, 'scheduler_continuation_dispatch_begin', (current, at) => ({
-    ...(current ?? prepared), status: 'dispatching', updatedAt: at,
-  }));
-  try {
-    const result = await host.resume(bindingRecord.binding, {
-      workId: work.workId,
-      relayScopeId: relay.relayScopeId,
-      roundNumber: relay.roundCount,
-      authorityId: relay.authorityId,
-      occurrenceId: input.occurrenceId,
-      exactOriginWork: true,
-      continuationHint: input.continuationHint?.trim() || undefined,
-    });
-    if (!result.accepted) {
-      const reason = result.reason ?? 'CONTROLLER_HOST_RESUME_REJECTED';
-      if (result.waitForUser) {
-        finishControllerRoundRelayDispatch(options, { workId: work.workId, ok: false, waitForUser: true, handoffId: result.handoffId, error: reason });
-        const waiting = updateScheduledContinuationDispatch(options, input.occurrenceId, 'scheduler_continuation_wait_for_user', (current, at) => ({
-          ...(current ?? prepared), status: 'wait_for_user', reason, ...(result.handoffId ? { handoffId: result.handoffId } : {}), updatedAt: at,
-        }));
-        return { dispatch: waiting, reused: false };
-      }
-      finishControllerRoundRelayDispatch(options, { workId: work.workId, ok: false, error: reason });
-      const rejected = updateScheduledContinuationDispatch(options, input.occurrenceId, 'scheduler_continuation_rejected', (current, at) => ({
-        ...(current ?? prepared), status: 'rejected', reason, updatedAt: at,
-      }));
-      return { dispatch: rejected, reused: false };
-    }
-    finishControllerRoundRelayDispatch(options, { workId: work.workId, ok: true, bindingId: bindingRecord.binding.bindingId, providerDispatchReceiptId: result.dispatchId });
-    const dispatched = updateScheduledContinuationDispatch(options, input.occurrenceId, 'scheduler_continuation_dispatched', (current, at) => ({
-      ...(current ?? prepared), status: 'dispatched', ...(result.dispatchId ? { hostDispatchId: result.dispatchId } : {}), updatedAt: at,
-    }));
-    return { dispatch: dispatched, reused: false };
-  } catch (error) {
-    const reason = error instanceof Error ? error.message : String(error);
-    const providerDispatchOutcomeUnknown = /CONTROLLER_HOST_PROVIDER_DISPATCH_OUTCOME_UNKNOWN|CHATGPT_AUTOMATION_SUBMISSION_OUTCOME_UNKNOWN/i.test(reason);
-    try { finishControllerRoundRelayDispatch(options, { workId: work.workId, ok: false, error: reason, outcomeUnknown: providerDispatchOutcomeUnknown }); } catch {}
-    updateScheduledContinuationDispatch(options, input.occurrenceId, 'scheduler_continuation_outcome_unknown', (current, at) => ({
-      ...(current ?? prepared), status: 'outcome_unknown', reason, updatedAt: at,
-    }));
-    throw error;
-  }
-}

package/packages/kernel/scheduler/domain/continuation.ts

@@ -1,38 +0,0 @@
-export type ScheduledContinuationDispatchStatus =
-  | 'prepared'
-  | 'dispatching'
-  | 'dispatched'
-  | 'wait_for_user'
-  | 'semantic_wait'
-  | 'rejected'
-  | 'outcome_unknown';
-
-export interface ScheduledContinuationDispatch {
-  schemaVersion: 1;
-  repoId: string;
-  scheduleId: string;
-  occurrenceId: string;
-  workId: string;
-  /** Observed transport/session at initial dispatch; never part of semantic occurrence identity. */
-  controllerSessionId: string;
-  controllerBindingId: string;
-  relayScopeId: string;
-  controllerAuthorityId?: string;
-  status: ScheduledContinuationDispatchStatus;
-  /** Projection of ControllerRound.providerDispatchReceiptId for occurrence replay diagnostics. */
-  hostDispatchId?: string;
-  handoffId?: string;
-  reason?: string;
-  createdAt: string;
-  updatedAt: string;
-}
-
-export interface ScheduledControllerContinuationInput {
-  scheduleId: string;
-  occurrenceId: string;
-  workId: string;
-  /** Observed transport/session at initial dispatch; never part of semantic occurrence identity. */
-  controllerBindingId: string;
-  relayScopeId?: string;
-  continuationHint?: string;
-}

package/packages/kernel/scheduler/infrastructure/continuation-dispatch-store.ts

@@ -1,38 +0,0 @@
-import { withControllerLock } from '../../../../src/cli/repositories/locks';
-import { readControlPlaneRecord, writeControlPlaneRecord } from '../../../../src/runtime/control-plane/persistence/sqlite-store';
-import type { ScheduledContinuationDispatch } from '../domain/continuation';
-
-const NAMESPACE = 'scheduler_continuation_dispatch';
-
-export interface SchedulerContinuationStoreOptions {
-  controllerHome: string;
-  repoId: string;
-  now?: () => string;
-}
-
-export function getScheduledContinuationDispatch(
-  options: SchedulerContinuationStoreOptions,
-  occurrenceId: string,
-): ScheduledContinuationDispatch | undefined {
-  return readControlPlaneRecord<ScheduledContinuationDispatch>(
-    options.controllerHome, NAMESPACE, options.repoId, occurrenceId,
-  )?.value;
-}
-
-export function updateScheduledContinuationDispatch(
-  options: SchedulerContinuationStoreOptions,
-  occurrenceId: string,
-  actor: string,
-  update: (current: ScheduledContinuationDispatch | undefined, now: string) => ScheduledContinuationDispatch,
-): ScheduledContinuationDispatch {
-  return withControllerLock(options.controllerHome, { scope: 'task', repoId: options.repoId, taskId: `schedule-continuation-${occurrenceId}` }, actor, () => {
-    const current = readControlPlaneRecord<ScheduledContinuationDispatch>(options.controllerHome, NAMESPACE, options.repoId, occurrenceId);
-    const at = options.now?.() ?? new Date().toISOString();
-    const value = update(current?.value, at);
-    writeControlPlaneRecord(options.controllerHome, {
-      namespace: NAMESPACE, scope: options.repoId, key: occurrenceId, schemaVersion: 1, value,
-      action: actor, expectedRevision: current?.revision ?? null,
-    });
-    return value;
-  });
-}

package/packages/kernel/work/domain/admission-policy.ts

@@ -1,34 +0,0 @@
-export interface WorkAdmissionPolicy {
-  schemaVersion: 1;
-  mode: 'normal' | 'exclusive_work' | 'convergence';
-  allowedWorkId?: string;
-  allowReadOnlyDiagnostics: true;
-  reason?: string;
-  activatedAt?: string;
-  updatedAt: string;
-}
-
-export const WORK_ADMISSION_POLICY_NAMESPACE = 'runtime_policy';
-export const WORK_ADMISSION_POLICY_SCOPE = 'global';
-export const WORK_ADMISSION_POLICY_KEY = 'work_admission';
-
-export function normalWorkAdmissionPolicy(now = new Date().toISOString()): WorkAdmissionPolicy {
-  return { schemaVersion: 1, mode: 'normal', allowReadOnlyDiagnostics: true, updatedAt: now };
-}
-
-export function assertWorkAdmissionPolicyAllows(
-  policy: WorkAdmissionPolicy,
-  input: { operation: 'create' | 'continue' | 'maintenance'; workId?: string },
-): WorkAdmissionPolicy {
-  if (policy.mode === 'normal' || input.operation === 'maintenance') return policy;
-  if (policy.mode === 'convergence') {
-    if (input.operation !== 'create') return policy;
-    throw new Error('WORK_ADMISSION_BLOCKED:CONVERGENCE:operation=create');
-  }
-  if (input.workId?.trim() === policy.allowedWorkId) return policy;
-  throw new Error(`WORK_ADMISSION_BLOCKED:P0_EXCLUSIVE_WORK:operation=${input.operation}:allowed=${policy.allowedWorkId ?? 'none'}`);
-}
-
-export function schedulerDispatchPolicyAllowed(policy: WorkAdmissionPolicy): boolean {
-  return policy.mode !== 'exclusive_work';
-}

package/scripts/benchmark-background-check-overlap.ts

@@ -1,228 +0,0 @@
-#!/usr/bin/env bun
-
-/**
- * Executable goal-drift guard for the managed-check controller path.
- *
- * It deliberately performs useful rh_context work after run_check returns and
- * before its one final dependency join. A future change that turns this into
- * periodic process_wait polling, re-executes the check, or blocks the initial
- * handle return fails the benchmark rather than only a local Process test.
- */
-
-import { execFileSync } from 'child_process';
-import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'fs';
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { performance } from 'perf_hooks';
-import { createMcpToolContext } from '../src/cli/mcp/server';
-import { registerRepository } from '../src/cli/repositories/registry';
-import { callRuntimeTool } from '../src/runtime/gateway/mcp/runtime-tools';
-import { callProcessTool } from '../src/runtime/gateway/mcp/process-tools';
-import { routeDurableMcpCall } from '../src/runtime/gateway/mcp/router';
-import { getProcessRecord } from '../src/runtime/execution/process-runtime/store';
-import {
-  clearGitIdentityCacheForTest,
-  clearGitSnapshotCacheForTest,
-  gitSnapshotPerformanceSnapshot,
-} from '../src/cli/repository/inspector';
-
-const CHECK_DURATION_MS = 1_200;
-const MAX_INITIAL_HANDLE_LATENCY_MS = 700;
-const MAX_TERMINAL_OBSERVATION_LATENCY_MS = 1_000;
-const root = mkdtempSync(join(tmpdir(), 'forge-background-check-overlap-'));
-const controllerHome = join(root, 'controller');
-const repoRoot = join(root, 'repo');
-
-const behavioralContract = {
-  originalUserFacingGoal: 'A long focused check must run in the background while Forge continues useful independent work, then synchronize once at the true dependency boundary.',
-  invariants: {
-    backgroundCheck: 'long_check_returns_a_managed_handle_promptly',
-    noPollingWhileUsefulWorkExists: 'zero_process_wait_calls_before_independent_work_finishes',
-    dependencyDrivenJoin: 'one_final_process_wait_after_the_dependency_boundary',
-    exactlyOnce: 'one_physical_check_execution',
-    resultCorrectness: 'terminal_result_matches_the_returned_process_id',
-    noAdditionalOrchestration: 'no_execution_job_created_for_the_fast_check_route',
-    sourceRetrievalStaysFocused: 'ordinary_rh_context_search_skips_execution_preflight',
-    summaryStaysCheap: 'rh_status_summary_avoids_detail_diagnostics',
-  },
-  antiGoals: [
-    'periodic_process_wait_polling',
-    'synchronous_wait_before_independent_work',
-    'duplicate_check_execution',
-    'source_retrieval_building_unrequested_check_readiness',
-    'summary_status_triggering_detail_diagnostics',
-  ],
-  validation: 'Runs a real managed check, performs rh_context work before the sole join, and separately asserts the rh_status summary hot path.',
-};
-
-function percentile(values: number[], ratio: number): number {
-  const sorted = [...values].sort((left, right) => left - right);
-  return Math.round((sorted[Math.min(sorted.length - 1, Math.floor(sorted.length * ratio))] ?? 0) * 100) / 100;
-}
-
-try {
-  mkdirSync(join(repoRoot, 'src'), { recursive: true });
-  mkdirSync(join(repoRoot, '.forge'), { recursive: true });
-  execFileSync('git', ['init', '-q', '-b', 'main'], { cwd: repoRoot });
-  execFileSync('git', ['config', 'user.email', 'benchmark@example.test'], { cwd: repoRoot });
-  execFileSync('git', ['config', 'user.name', 'Forge Benchmark'], { cwd: repoRoot });
-  writeFileSync(join(repoRoot, 'src', 'fixture.ts'), 'export const backgroundFixture = true;\n');
-  const executionMarker = join(root, 'physical-check-executions.txt');
-  writeFileSync(join(repoRoot, '.forge', 'checks.json'), JSON.stringify({
-    version: 1,
-    checks: {
-      background: {
-        description: 'Synthetic long check for controller overlap behavior.',
-        command: [
-          process.execPath,
-          '-e',
-          [
-            `require('fs').appendFileSync(${JSON.stringify(executionMarker)}, '1');`,
-            `setTimeout(() => { process.stdout.write('BACKGROUND_CHECK_DONE\\n'); process.exit(0); }, ${CHECK_DURATION_MS});`,
-          ].join(' '),
-        ],
-        timeoutMs: 10_000,
-      },
-    },
-  }, null, 2));
-  execFileSync('git', ['add', '.'], { cwd: repoRoot });
-  execFileSync('git', ['commit', '-qm', 'fixture'], { cwd: repoRoot });
-
-  const repository = registerRepository({ path: repoRoot, controllerHome, displayName: 'background-check-overlap' });
-  const ctx = createMcpToolContext({ controllerHome, profile: 'controller', repo: repoRoot });
-
-  const startedAt = performance.now();
-  const started = await routeDurableMcpCall(ctx, 'run_check', {
-    repo_id: repository.repoId,
-    check_id: 'background',
-    interactive_wait_ms: 0,
-  });
-  const initialHandleLatencyMs = performance.now() - startedAt;
-  const startPayload = started?.structuredContent as Record<string, unknown> | undefined;
-  const processId = typeof startPayload?.processId === 'string' ? startPayload.processId : '';
-
-  const independentStartedAt = performance.now();
-  const independent = await callRuntimeTool(ctx, 'rh_context', {
-    repo_id: repository.repoId,
-    operation: 'search',
-    query: 'backgroundFixture',
-    known_paths: ['src/fixture.ts'],
-    structural_context: 'off',
-  });
-  const independentOperationLatencyMs = performance.now() - independentStartedAt;
-  const independentPayload = independent?.structuredContent as { data?: Record<string, unknown> } | undefined;
-  const independentData = independentPayload?.data;
-  const independentRetrievalPolicy = independentData?.retrievalPolicy as Record<string, unknown> | undefined;
-  const sourceRetrievalSkippedExecutionPreflight = independentData?.executionReadiness === undefined
-    && independentData?.registeredChecks === undefined
-    && independentRetrievalPolicy?.executionReadiness === 'requested_check_ids_only';
-  const processWaitCallsBeforeDependencyBoundary = 0;
-
-  const joinStartedAtMs = Date.now();
-  const joined = processId
-    ? await callProcessTool(ctx, 'process_wait', {
-      repo_id: repository.repoId,
-      process_id: processId,
-      timeout_ms: 10_000,
-    })
-    : undefined;
-  const resultObservedAtMs = Date.now();
-  const finalSynchronizationCount = processId ? 1 : 0;
-  const joinedPayload = joined?.structuredContent as { process?: { processId?: string; completed?: boolean; ok?: boolean } } | undefined;
-  const record = processId ? getProcessRecord(controllerHome, repository.repoId, processId) : undefined;
-  const finishedAtMs = record?.finishedAt ? Date.parse(record.finishedAt) : NaN;
-  const completionToObservationLatencyMs = Number.isFinite(finishedAtMs)
-    ? Math.max(0, resultObservedAtMs - finishedAtMs)
-    : undefined;
-  const physicalExecutionCount = readFileSync(executionMarker, 'utf8').length;
-
-  // Summary is a separate hot path: it must answer readiness without falling
-  // into the full Git status/diff-stat or maintenance/detail projection.
-  clearGitIdentityCacheForTest();
-  clearGitSnapshotCacheForTest();
-  const statusSummaryDurations: number[] = [];
-  let summaryPayload: Record<string, unknown> | undefined;
-  for (let iteration = 0; iteration < 7; iteration += 1) {
-    const statusStartedAt = performance.now();
-    const status = await callRuntimeTool(ctx, 'rh_status', { repo_id: repository.repoId, detail_level: 'summary' });
-    statusSummaryDurations.push(performance.now() - statusStartedAt);
-    summaryPayload = status?.structuredContent as Record<string, unknown> | undefined;
-  }
-  // Snapshot this before the intentional detail call below: detail is allowed
-  // to build the full Git projection, while summary is not.
-  const summaryGitSnapshot = gitSnapshotPerformanceSnapshot();
-  const detailStartedAt = performance.now();
-  const detail = await callRuntimeTool(ctx, 'rh_status', { repo_id: repository.repoId, detail_level: 'detail' });
-  const detailElapsedMs = performance.now() - detailStartedAt;
-  const detailPayload = detail?.structuredContent as Record<string, unknown> | undefined;
-  const detailMeta = detailPayload?.responseMeta as Record<string, unknown> | undefined;
-  const summaryData = summaryPayload?.data as Record<string, unknown> | undefined;
-  const summaryRepositoryState = summaryData?.repositoryState as Record<string, unknown> | undefined;
-  const summaryUsesCompactPayload = Boolean(summaryData)
-    && summaryData?.access === undefined
-    && summaryData?.pendingHandoffCount === undefined
-    && summaryData?.activeWorkCount === undefined
-    && summaryData?.activeProcessCount === undefined
-    && summaryRepositoryState?.status === undefined
-    && summaryRepositoryState?.diffStat === undefined;
-
-  const assertions = {
-    initialManagedHandle: Boolean(processId) && startPayload?.path === 'process_managed' && initialHandleLatencyMs <= MAX_INITIAL_HANDLE_LATENCY_MS,
-    independentUsefulOperation: independent?.isError !== true,
-    sourceRetrievalSkipsExecutionPreflight: sourceRetrievalSkippedExecutionPreflight,
-    noPollingBeforeDependencyBoundary: processWaitCallsBeforeDependencyBoundary === 0,
-    oneDependencyJoin: finalSynchronizationCount === 1,
-    exactlyOnce: physicalExecutionCount === 1,
-    terminalResultCorrect: joinedPayload?.process?.processId === processId && joinedPayload?.process?.completed === true && joinedPayload?.process?.ok === true,
-    promptResultObservation: completionToObservationLatencyMs === undefined || completionToObservationLatencyMs <= MAX_TERMINAL_OBSERVATION_LATENCY_MS,
-    statusSummaryUsesCompactProjection: Boolean(summaryPayload?.data)
-      && summaryGitSnapshot.refreshes === 0
-      && summaryGitSnapshot.subprocesses === 0
-      && summaryUsesCompactPayload,
-  };
-  const output = {
-    schemaVersion: 1,
-    behavioralContract,
-    check: {
-      configuredDurationMs: CHECK_DURATION_MS,
-      initialManagedHandleLatencyMs: Number(initialHandleLatencyMs.toFixed(2)),
-      processWaitCallsBeforeDependencyBoundary,
-      independentOperation: {
-        tool: 'rh_context.search',
-        latencyMs: Number(independentOperationLatencyMs.toFixed(2)),
-        completed: independent?.isError !== true,
-        executionPreflight: sourceRetrievalSkippedExecutionPreflight ? 'not_requested' : 'unexpected',
-      },
-      finalSynchronizationCount,
-      finalJoinDurationMs: resultObservedAtMs - joinStartedAtMs,
-      physicalExecutionCount,
-      terminalCompletionToObservationLatencyMs: completionToObservationLatencyMs,
-      processId,
-    },
-    status: {
-      summaryP50Ms: percentile(statusSummaryDurations, 0.5),
-      summaryP95Ms: percentile(statusSummaryDurations, 0.95),
-      detailElapsedMs: Number(detailElapsedMs.toFixed(2)),
-      detailServerDurationMs: detailMeta?.serverDurationMs,
-      detailPhaseTimingsMs: detailMeta?.phaseTimingsMs,
-      fullGitSnapshot: summaryGitSnapshot,
-      summaryOmissions: {
-        maintenance: true,
-        plugins: true,
-        workState: true,
-        accessPolicy: true,
-        gitStatusAndDiffStat: true,
-      },
-    },
-    thresholds: {
-      initialManagedHandleLatencyMs: MAX_INITIAL_HANDLE_LATENCY_MS,
-      terminalCompletionToObservationLatencyMs: MAX_TERMINAL_OBSERVATION_LATENCY_MS,
-    },
-    assertions,
-    passed: Object.values(assertions).every(Boolean),
-  };
-  process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
-  if (!output.passed) process.exitCode = 1;
-} finally {
-  rmSync(root, { recursive: true, force: true });
-}