import { assert, codedError, hashValue, sleep } from '../assertions/core.mjs';
import { isNonEmptyString } from '../assertions/runtime.mjs';
import {
  createHash,
  fs,
  fsConstants,
  path,
  randomUUID,
  spawn,
  watchFileSystem,
} from '../dependencies.mjs';
import {
  appRoot,
  BlockedError,
  configFileName,
  contextCompactionAppDataSentinelFileName,
  contextCompactionAppDataSentinelSchema,
  goalAppDataSentinelFileName,
  goalAppDataSentinelSchema,
  linuxPidfdHelperSource,
  localConfigFileName,
  mainAgentId,
  mcpAppDataSentinelFileName,
  mcpAppDataSentinelSchema,
  parallelReadAppDataSentinelFileName,
  parallelReadAppDataSentinelSchema,
  projectSkillAppDataSentinelFileName,
  projectSkillAppDataSentinelSchema,
  projectSupervisorAgentId,
  responseStreamAppDataSentinelFileName,
  responseStreamAppDataSentinelSchema,
  runnerEndpointFileName,
  scopedAgentsAppDataSentinelFileName,
  scopedAgentsAppDataSentinelSchema,
  state,
  steerRunnerKillAppDataSentinelFileName,
  steerRunnerKillAppDataSentinelSchema,
  supervisorAutonomousPlayableAppDataSentinelFileName,
  supervisorAutonomousPlayableAppDataSentinelSchema,
  supervisorSwarmAppDataSentinelFileName,
  supervisorSwarmAppDataSentinelSchema,
  supervisorSwarmAutonomousChatAppDataSentinelFileName,
  supervisorSwarmAutonomousChatAppDataSentinelSchema,
  supervisorSwarmCollaborationPolicyAppDataSentinelFileName,
  supervisorSwarmCollaborationPolicyAppDataSentinelSchema,
  supervisorSwarmFinalReplyTransientRetryAppDataSentinelFileName,
  supervisorSwarmFinalReplyTransientRetryAppDataSentinelSchema,
  supervisorSwarmRequiredAgentIds,
  supervisorSwarmStaticIsolatedAutonomousChatAppDataSentinelFileName,
  supervisorSwarmStaticIsolatedAutonomousChatAppDataSentinelSchema,
  supervisorSwarmToolPlanHandoffRunnerKillAppDataSentinelFileName,
  supervisorSwarmToolPlanHandoffRunnerKillAppDataSentinelSchema,
  supervisorSwarmTransientRetryAppDataSentinelFileName,
  supervisorSwarmTransientRetryAppDataSentinelSchema,
  supervisorSwarmTransientRetryTargetAgentId,
  userInputAppDataSentinelFileName,
  userInputAppDataSentinelSchema,
  webSearchAppDataSentinelFileName,
  webSearchAppDataSentinelSchema,
} from '../runtime-state.mjs';
import { isContextCompactionSuite } from '../suites/context-compaction.mjs';
import { isGoalRuntimeSuite } from '../suites/goal.mjs';
import { isMcpRuntimeSuite } from '../suites/mcp.mjs';
import { isParallelReadSuite } from '../suites/parallel-read.mjs';
import { isProjectSkillSuite } from '../suites/project-skill.mjs';
import { isResponseStreamSuite } from '../suites/response-stream.mjs';
import { isScopedAgentsSuite } from '../suites/scoped-agents.mjs';
import { isSteerRunnerKillSuite } from '../suites/steer-runner-kill.mjs';
import { isSupervisorAutonomousPlayableLaneDefenseSuite } from '../suites/supervisor-autonomous-playable.mjs';
import {
  isSupervisorSwarmAutonomousChatSuite,
  isSupervisorSwarmCollaborationPolicyMixedRecoverySuite,
  isSupervisorSwarmFinalReplyTransientRetrySuite,
  isSupervisorSwarmInitialTransientRetrySuite,
  isSupervisorSwarmInteractiveChatSuite,
  isSupervisorSwarmMixedHarnessSuite,
  isSupervisorSwarmStaticIsolatedAutonomousChatSuite,
  isSupervisorSwarmSuite,
  isSupervisorSwarmToolPlanHandoffRunnerKillSuite,
  isSupervisorSwarmTransientRetrySuite,
  rebuildSupervisorSwarmTranscriptScanner,
} from '../suites/supervisor-swarm.mjs';
import { isUserInputRuntimeSuite } from '../suites/user-input.mjs';
import {
  isWebSearchSuite,
  sameEffectiveAgentLlmWithoutWebSearch,
} from '../suites/web-search.mjs';
import {
  effectiveAgentLlmConfig,
  isPlainObject,
  loadConfig,
  mergeConfigPatch,
  safeEffectiveAgentLlmPolicy,
  sameEffectiveAgentLlm,
  sameEffectiveAgentLlmWithoutStream,
} from './config.mjs';
import { collectApiKeys, isPathInside, readJson } from './io.mjs';
import { appendBounded, runProcess } from './process.mjs';
import { decodeUtf8Fatal, isIsolatedRunnerSuite } from './reporting.mjs';
import { killRunnerOnce, readRunnerStatus, runnerBootId } from './runtime.mjs';

export function isolatedSuiteProtectsSourceAppData() {
  return (
    isSupervisorSwarmTransientRetrySuite() ||
    isSupervisorSwarmToolPlanHandoffRunnerKillSuite() ||
    isSupervisorAutonomousPlayableLaneDefenseSuite() ||
    isSupervisorSwarmInteractiveChatSuite()
  );
}

export function isolatedSuiteUsesSiblingAppData() {
  return isWebSearchSuite() || isolatedSuiteProtectsSourceAppData();
}

export function isolatedSuiteAppDataProfile() {
  if (isSteerRunnerKillSuite()) {
    return {
      prefix: '.agent-runtime-real-e2e-steer-runner-kill-',
      sentinelName: steerRunnerKillAppDataSentinelFileName,
      sentinelSchema: steerRunnerKillAppDataSentinelSchema,
      codePrefix: 'steer-runner-kill-appdata',
    };
  }
  if (isGoalRuntimeSuite()) {
    return {
      prefix: '.agent-runtime-real-e2e-goal-',
      sentinelName: goalAppDataSentinelFileName,
      sentinelSchema: goalAppDataSentinelSchema,
      codePrefix: 'goal-appdata',
    };
  }
  if (isWebSearchSuite()) {
    return {
      prefix: '.agent-runtime-real-e2e-web-search-',
      sentinelName: webSearchAppDataSentinelFileName,
      sentinelSchema: webSearchAppDataSentinelSchema,
      codePrefix: 'web-search-appdata',
    };
  }
  if (isContextCompactionSuite()) {
    return {
      prefix: '.agent-runtime-real-e2e-context-compaction-',
      sentinelName: contextCompactionAppDataSentinelFileName,
      sentinelSchema: contextCompactionAppDataSentinelSchema,
      codePrefix: 'context-compaction-appdata',
    };
  }
  if (isMcpRuntimeSuite()) {
    return {
      prefix: '.agent-runtime-real-e2e-mcp-',
      sentinelName: mcpAppDataSentinelFileName,
      sentinelSchema: mcpAppDataSentinelSchema,
      codePrefix: 'mcp-appdata',
    };
  }
  if (isUserInputRuntimeSuite()) {
    return {
      prefix: '.agent-runtime-real-e2e-user-input-',
      sentinelName: userInputAppDataSentinelFileName,
      sentinelSchema: userInputAppDataSentinelSchema,
      codePrefix: 'user-input-appdata',
    };
  }
  if (isScopedAgentsSuite()) {
    return {
      prefix: '.agent-runtime-real-e2e-scoped-agents-',
      sentinelName: scopedAgentsAppDataSentinelFileName,
      sentinelSchema: scopedAgentsAppDataSentinelSchema,
      codePrefix: 'scoped-agents-appdata',
    };
  }
  if (isProjectSkillSuite()) {
    return {
      prefix: '.agent-runtime-real-e2e-project-skill-',
      sentinelName: projectSkillAppDataSentinelFileName,
      sentinelSchema: projectSkillAppDataSentinelSchema,
      codePrefix: 'project-skill-appdata',
    };
  }
  if (isParallelReadSuite()) {
    return {
      prefix: '.agent-runtime-real-e2e-parallel-read-',
      sentinelName: parallelReadAppDataSentinelFileName,
      sentinelSchema: parallelReadAppDataSentinelSchema,
      codePrefix: 'parallel-read-appdata',
    };
  }
  if (isSupervisorSwarmFinalReplyTransientRetrySuite()) {
    return {
      prefix:
        '.agent-runtime-real-e2e-supervisor-swarm-final-reply-transient-retry-',
      sentinelName:
        supervisorSwarmFinalReplyTransientRetryAppDataSentinelFileName,
      sentinelSchema:
        supervisorSwarmFinalReplyTransientRetryAppDataSentinelSchema,
      codePrefix: 'supervisor-swarm-final-reply-transient-retry-appdata',
    };
  }
  if (isSupervisorSwarmToolPlanHandoffRunnerKillSuite()) {
    return {
      prefix:
        '.agent-runtime-real-e2e-supervisor-swarm-tool-plan-handoff-runner-kill-',
      sentinelName:
        supervisorSwarmToolPlanHandoffRunnerKillAppDataSentinelFileName,
      sentinelSchema:
        supervisorSwarmToolPlanHandoffRunnerKillAppDataSentinelSchema,
      codePrefix: 'supervisor-swarm-tool-plan-handoff-runner-kill-appdata',
    };
  }
  if (isSupervisorSwarmInitialTransientRetrySuite()) {
    return {
      prefix: '.agent-runtime-real-e2e-supervisor-swarm-transient-retry-',
      sentinelName: supervisorSwarmTransientRetryAppDataSentinelFileName,
      sentinelSchema: supervisorSwarmTransientRetryAppDataSentinelSchema,
      codePrefix: 'supervisor-swarm-transient-retry-appdata',
    };
  }
  if (isSupervisorAutonomousPlayableLaneDefenseSuite()) {
    return {
      prefix: '.agent-runtime-real-e2e-supervisor-autonomous-playable-',
      sentinelName: supervisorAutonomousPlayableAppDataSentinelFileName,
      sentinelSchema: supervisorAutonomousPlayableAppDataSentinelSchema,
      codePrefix: 'supervisor-autonomous-playable-appdata',
    };
  }
  if (isSupervisorSwarmAutonomousChatSuite()) {
    return {
      prefix: '.agent-runtime-real-e2e-supervisor-swarm-autonomous-chat-',
      sentinelName: supervisorSwarmAutonomousChatAppDataSentinelFileName,
      sentinelSchema: supervisorSwarmAutonomousChatAppDataSentinelSchema,
      codePrefix: 'supervisor-swarm-autonomous-chat-appdata',
    };
  }
  if (isSupervisorSwarmStaticIsolatedAutonomousChatSuite()) {
    return {
      prefix:
        '.agent-runtime-real-e2e-supervisor-swarm-static-isolated-autonomous-chat-',
      sentinelName:
        supervisorSwarmStaticIsolatedAutonomousChatAppDataSentinelFileName,
      sentinelSchema:
        supervisorSwarmStaticIsolatedAutonomousChatAppDataSentinelSchema,
      codePrefix: 'supervisor-swarm-static-isolated-autonomous-chat-appdata',
    };
  }
  if (isSupervisorSwarmCollaborationPolicyMixedRecoverySuite()) {
    return {
      prefix: '.agent-runtime-real-e2e-supervisor-swarm-collaboration-policy-',
      sentinelName: supervisorSwarmCollaborationPolicyAppDataSentinelFileName,
      sentinelSchema: supervisorSwarmCollaborationPolicyAppDataSentinelSchema,
      codePrefix: 'supervisor-swarm-collaboration-policy-appdata',
    };
  }
  if (isSupervisorSwarmSuite()) {
    return {
      prefix: '.agent-runtime-real-e2e-supervisor-swarm-',
      sentinelName: supervisorSwarmAppDataSentinelFileName,
      sentinelSchema: supervisorSwarmAppDataSentinelSchema,
      codePrefix: 'supervisor-swarm-appdata',
    };
  }
  assert(
    isResponseStreamSuite(),
    'isolated-appdata-used-outside-isolated-suite',
  );
  return {
    prefix: '.agent-runtime-real-e2e-response-stream-',
    sentinelName: responseStreamAppDataSentinelFileName,
    sentinelSchema: responseStreamAppDataSentinelSchema,
    codePrefix: 'response-stream-appdata',
  };
}

export async function createSentinelOwnedTempDirectory({
  prefix,
  sentinelName,
  sentinel,
  codePrefix,
}) {
  const directory = await fs.mkdtemp(prefix);
  try {
    if (process.platform !== 'win32') await fs.chmod(directory, 0o700);
    await fs.writeFile(
      path.join(directory, sentinelName),
      `${JSON.stringify(sentinel)}\n`,
      { flag: 'wx', mode: 0o600 },
    );
    return directory;
  } catch (error) {
    try {
      await fs.rm(directory, { recursive: true, force: true });
    } catch (cleanupError) {
      throw codedError(
        `${codePrefix}-sentinel-create-cleanup-failed`,
        cleanupError,
      );
    }
    throw codedError(`${codePrefix}-sentinel-create-failed`, error);
  }
}

export async function captureSourceRunnerEndpointSnapshot(sourceConfigDir) {
  const endpointPath = path.join(sourceConfigDir, runnerEndpointFileName);
  const metadata = await fs.lstat(endpointPath).catch((error) => {
    if (error?.code === 'ENOENT') return null;
    throw error;
  });
  if (!metadata) return { exists: false, fingerprint: null };
  assert(
    metadata.isFile() && !metadata.isSymbolicLink(),
    'source-runner-endpoint-not-regular-file',
  );
  const endpoint = await readJson(endpointPath);
  const stableEndpoint = { ...endpoint };
  delete stableEndpoint.heartbeatAt;
  return {
    exists: true,
    fingerprint: hashValue(JSON.stringify(stableEndpoint)),
  };
}

export async function verifySourceRunnerEndpointUnchanged() {
  const sourceConfigDir = await fs.realpath(state.options.configDir);
  const current = await captureSourceRunnerEndpointSnapshot(sourceConfigDir);
  assert(
    JSON.stringify(current) ===
      JSON.stringify(state.isolatedRunner.sourceEndpointSnapshot),
    'source-runner-endpoint-changed-during-isolated-suite',
  );
  state.isolatedRunner.sourceRunnerEndpointUnchanged = true;
}

export function closeSourceAppDataDirectoryGuard() {
  const watcher = state.isolatedRunner.sourceAppDataDirectoryWatcher;
  if (!watcher) return;
  watcher.close();
  state.isolatedRunner.sourceAppDataDirectoryWatcher = null;
}

export function sourceAppDataDirectoryEventIsViolation(
  fileName,
  profilePrefix,
  sourceEndpointSnapshot,
) {
  const name = Buffer.isBuffer(fileName)
    ? fileName.toString('utf8')
    : String(fileName ?? '');
  return (
    name.startsWith(profilePrefix) ||
    (sourceEndpointSnapshot?.exists === false &&
      name === runnerEndpointFileName)
  );
}

export function startSourceAppDataDirectoryGuard(sourceConfigDir, profile) {
  if (!isolatedSuiteProtectsSourceAppData()) return;
  assert(
    !state.isolatedRunner.sourceAppDataDirectoryWatcher,
    'source-appdata-directory-guard-already-started',
  );
  const watcher = watchFileSystem(
    sourceConfigDir,
    { persistent: false },
    (_eventType, fileName) => {
      if (
        sourceAppDataDirectoryEventIsViolation(
          fileName,
          profile.prefix,
          state.isolatedRunner.sourceEndpointSnapshot,
        )
      ) {
        state.isolatedRunner.sourceAppDataDirectoryViolationCount += 1;
      }
    },
  );
  watcher.on('error', () => {
    state.isolatedRunner.sourceAppDataDirectoryViolationCount += 1;
  });
  state.isolatedRunner.sourceAppDataDirectoryWatcher = watcher;
}

export async function verifySourceAppDataDirectoryUntouched() {
  if (!isolatedSuiteProtectsSourceAppData()) return;
  closeSourceAppDataDirectoryGuard();
  const sourceConfigDir = await fs.realpath(state.options.configDir);
  const profile = isolatedSuiteAppDataProfile();
  const entries = await fs.readdir(sourceConfigDir);
  assert(
    state.isolatedRunner.sourceAppDataDirectoryViolationCount === 0 &&
      !entries.some((name) => name.startsWith(profile.prefix)),
    'source-appdata-directory-touched-by-suite',
  );
  state.isolatedRunner.sourceAppDataDirectoryUntouched = true;
}

export async function prepareIsolatedSuiteAppData({
  streamAgentId = null,
  webSearchAgentId = null,
  mcpConfigFactory = null,
  configOverlay = null,
} = {}) {
  assert(
    isIsolatedRunnerSuite(),
    'isolated-appdata-used-outside-isolated-suite',
  );
  assert(
    [streamAgentId, webSearchAgentId, mcpConfigFactory, configOverlay].filter(
      Boolean,
    ).length <= 1,
    'isolated-appdata-multiple-overlays-forbidden',
  );
  if (configOverlay) {
    assert(
      isPlainObject(configOverlay) &&
        collectApiKeys(configOverlay).length === 0,
      'isolated-appdata-config-overlay-invalid',
    );
  }
  const profile = isolatedSuiteAppDataProfile();
  const suiteSecrets = new Set(state.secrets);
  const sourceConfigDir = await fs.realpath(state.options.configDir);
  state.isolatedRunner.sourceEndpointSnapshot =
    await captureSourceRunnerEndpointSnapshot(sourceConfigDir);
  const ownerToken = randomUUID();
  const createdAt = Date.now();
  const appDataParent = isolatedSuiteUsesSiblingAppData()
    ? path.dirname(sourceConfigDir)
    : sourceConfigDir;
  const appDataDir = await createSentinelOwnedTempDirectory({
    prefix: path.join(appDataParent, profile.prefix),
    sentinelName: profile.sentinelName,
    sentinel: {
      schemaVersion: profile.sentinelSchema,
      token: ownerToken,
      ownerPid: process.pid,
      createdAt,
    },
    codePrefix: profile.codePrefix,
  });
  state.isolatedRunner.appDataDir = appDataDir;
  state.isolatedRunner.ownerToken = ownerToken;
  state.isolatedRunner.createdAt = createdAt;
  if (isolatedSuiteProtectsSourceAppData()) {
    const realAppDataDir = await fs.realpath(appDataDir);
    assert(
      !isPathInside(sourceConfigDir, realAppDataDir) &&
        path.dirname(realAppDataDir) === path.dirname(sourceConfigDir),
      `${profile.codePrefix}-source-appdata-write-boundary-invalid`,
    );
    startSourceAppDataDirectoryGuard(sourceConfigDir, profile);
  }
  const mcpOverlay = mcpConfigFactory
    ? await mcpConfigFactory(appDataDir)
    : null;
  if (mcpOverlay) {
    assert(
      isPlainObject(mcpOverlay) &&
        isPlainObject(mcpOverlay.mcpServers) &&
        Object.keys(mcpOverlay.mcpServers).length > 0 &&
        Array.isArray(mcpOverlay.secrets) &&
        mcpOverlay.secrets.every(isNonEmptyString),
      'mcp-config-overlay-invalid',
    );
    for (const secret of mcpOverlay.secrets) suiteSecrets.add(secret);
  }

  const sourceConfigs = [];
  for (const name of [configFileName, localConfigFileName]) {
    const sourcePath = path.join(sourceConfigDir, name);
    const metadata = await fs.lstat(sourcePath).catch((error) => {
      if (error?.code === 'ENOENT') return null;
      throw error;
    });
    if (!metadata) {
      assert(
        name !== configFileName,
        `${profile.codePrefix}-source-config-missing`,
      );
      continue;
    }
    assert(
      metadata.isFile() && !metadata.isSymbolicLink(),
      `${profile.codePrefix}-source-config-not-regular-file`,
    );
    const sourceContent = await fs.readFile(sourcePath);
    let sourceConfig;
    try {
      sourceConfig = JSON.parse(
        decodeUtf8Fatal(
          sourceContent,
          `${profile.codePrefix}-linked-config-invalid-utf8`,
        ),
      );
    } catch (error) {
      throw codedError(
        `${profile.codePrefix}-linked-config-json-invalid`,
        error,
      );
    }
    assert(
      isPlainObject(sourceConfig),
      `${profile.codePrefix}-linked-config-root-invalid`,
    );
    for (const secret of collectApiKeys(sourceConfig)) suiteSecrets.add(secret);
    sourceConfigs.push({
      name,
      sourcePath,
      metadata,
      sourceContent,
      config: sourceConfig,
    });
  }

  const mergedSourceConfig = {};
  for (const source of sourceConfigs) {
    mergeConfigPatch(mergedSourceConfig, source.config);
  }
  const overlayAgentId =
    streamAgentId ?? webSearchAgentId ?? (mcpOverlay ? mainAgentId : null);
  const sourceEffective = overlayAgentId
    ? effectiveAgentLlmConfig(mergedSourceConfig, overlayAgentId)
    : null;
  let activeConfigSource = null;
  if (
    overlayAgentId &&
    (mcpOverlay || webSearchAgentId || sourceEffective.stream !== true)
  ) {
    const sameEffective = mcpOverlay
      ? sameEffectiveAgentLlm
      : webSearchAgentId
        ? sameEffectiveAgentLlmWithoutWebSearch
        : sameEffectiveAgentLlmWithoutStream;
    activeConfigSource =
      sourceConfigs.find(
        (source) =>
          source.name === configFileName &&
          sameEffective(
            effectiveAgentLlmConfig(source.config, overlayAgentId),
            sourceEffective,
          ),
      ) ??
      sourceConfigs.find((source) =>
        sameEffective(
          effectiveAgentLlmConfig(source.config, overlayAgentId),
          sourceEffective,
        ),
      );
    assert(
      Boolean(activeConfigSource),
      mcpOverlay
        ? 'mcp-source-config-cannot-accept-mcp-only-overlay'
        : webSearchAgentId
          ? 'web-search-source-config-cannot-accept-search-only-overlay'
          : 'response-stream-source-config-cannot-accept-stream-only-overlay',
    );
  }

  for (const source of sourceConfigs) {
    const linkedName = configOverlay
      ? `.source-${source.name}`
      : activeConfigSource
        ? source === activeConfigSource
          ? configFileName
          : `.source-${source.name}`
        : source.name;
    const linkedPath = path.join(appDataDir, linkedName);
    const storageMode =
      isWebSearchSuite() ||
      isMcpRuntimeSuite() ||
      isScopedAgentsSuite() ||
      isProjectSkillSuite() ||
      isParallelReadSuite() ||
      isSupervisorSwarmSuite()
        ? 'private-copy'
        : 'hardlink';
    try {
      if (storageMode === 'private-copy') {
        await fs.copyFile(
          source.sourcePath,
          linkedPath,
          fsConstants.COPYFILE_EXCL | fsConstants.COPYFILE_FICLONE,
        );
        await fs.chmod(linkedPath, 0o600);
      } else {
        // Existing isolated suites share credential-bearing config inodes.
        await fs.link(source.sourcePath, linkedPath);
      }
    } catch (error) {
      throw codedError(`${profile.codePrefix}-config-replica-failed`, error);
    }
    const linkedMetadata = await fs.lstat(linkedPath);
    const privateCopyValid =
      storageMode === 'private-copy' &&
      (linkedMetadata.dev !== source.metadata.dev ||
        linkedMetadata.ino !== source.metadata.ino) &&
      (linkedMetadata.mode & 0o077) === 0;
    const hardlinkValid =
      storageMode === 'hardlink' &&
      linkedMetadata.dev === source.metadata.dev &&
      linkedMetadata.ino === source.metadata.ino;
    assert(
      linkedMetadata.isFile() &&
        !linkedMetadata.isSymbolicLink() &&
        (privateCopyValid || hardlinkValid),
      `${profile.codePrefix}-config-replica-identity-invalid`,
    );
    state.isolatedRunner.configLinks.push({
      storageMode,
      sourceName: source.name,
      linkedName,
      sourcePath: source.sourcePath,
      linkedPath,
      dev: source.metadata.dev,
      ino: source.metadata.ino,
      linkedDev: linkedMetadata.dev,
      linkedIno: linkedMetadata.ino,
      nlink: source.metadata.nlink,
      sourceMode: source.metadata.mode,
      sourceSize: source.metadata.size,
      sourceMtimeMs: source.metadata.mtimeMs,
      sourceCtimeMs: source.metadata.ctimeMs,
      sha256: createHash('sha256').update(source.sourceContent).digest('hex'),
    });
  }
  if (configOverlay) {
    const primaryConfigPath = path.join(appDataDir, configFileName);
    const localOverlayPath = path.join(appDataDir, localConfigFileName);
    await fs.writeFile(
      primaryConfigPath,
      `${JSON.stringify(mergedSourceConfig)}\n`,
      { flag: 'wx', mode: 0o600 },
    );
    await fs.writeFile(localOverlayPath, `${JSON.stringify(configOverlay)}\n`, {
      flag: 'wx',
      mode: 0o600,
    });
    const [primaryMetadata, overlayMetadata] = await Promise.all([
      fs.lstat(primaryConfigPath),
      fs.lstat(localOverlayPath),
    ]);
    assert(
      primaryMetadata.isFile() &&
        !primaryMetadata.isSymbolicLink() &&
        overlayMetadata.isFile() &&
        !overlayMetadata.isSymbolicLink() &&
        (primaryMetadata.mode & 0o077) === 0 &&
        (overlayMetadata.mode & 0o077) === 0,
      `${profile.codePrefix}-materialized-config-invalid`,
    );
    state.isolatedRunner.configOverlayCreated = true;
  } else {
    assert(
      state.isolatedRunner.configLinks.some(
        (link) => link.linkedName === configFileName,
      ),
      `${profile.codePrefix}-primary-config-link-missing`,
    );
  }

  if (activeConfigSource) {
    const overrideKey = webSearchAgentId ? 'webSearchEnabled' : 'stream';
    const overlay = mcpOverlay
      ? { mcpServers: mcpOverlay.mcpServers }
      : { agentLlm: { [overlayAgentId]: { [overrideKey]: true } } };
    if (mcpOverlay) {
      assert(
        JSON.stringify(Object.keys(overlay)) ===
          JSON.stringify(['mcpServers']) &&
          Object.keys(overlay.mcpServers).length === 2,
        'mcp-overlay-shape-invalid',
      );
    } else {
      assert(
        collectApiKeys(overlay).length === 0 &&
          JSON.stringify(Object.keys(overlay)) ===
            JSON.stringify(['agentLlm']) &&
          JSON.stringify(Object.keys(overlay.agentLlm)) ===
            JSON.stringify([overlayAgentId]) &&
          JSON.stringify(Object.keys(overlay.agentLlm[overlayAgentId])) ===
            JSON.stringify([overrideKey]),
        webSearchAgentId
          ? 'web-search-overlay-shape-invalid'
          : 'response-stream-overlay-shape-invalid',
      );
    }
    await fs.writeFile(
      path.join(appDataDir, localConfigFileName),
      `${JSON.stringify(overlay)}\n`,
      { flag: 'wx', mode: 0o600 },
    );
    if (mcpOverlay) {
      state.isolatedRunner.mcpOverrideCreated = true;
    } else if (webSearchAgentId) {
      state.isolatedRunner.webSearchOverrideCreated = true;
    } else {
      state.isolatedRunner.streamOverrideCreated = true;
    }
  }

  const previousLeakCount = state.transcriptScanner?.count ?? 0;
  state.secrets = [...suiteSecrets];
  rebuildSupervisorSwarmTranscriptScanner();
  state.transcriptScanner.count = previousLeakCount;
  const unexpectedEndpoint = await fs
    .lstat(path.join(appDataDir, runnerEndpointFileName))
    .catch((error) => {
      if (error?.code === 'ENOENT') return null;
      throw error;
    });
  assert(!unexpectedEndpoint, `${profile.codePrefix}-endpoint-preexisted`);
  state.runtimeConfigDir = appDataDir;
  if (streamAgentId) {
    const isolatedConfig = await loadConfig(appDataDir);
    const isolatedEffective = effectiveAgentLlmConfig(
      isolatedConfig.config,
      streamAgentId,
    );
    assert(
      isolatedEffective.stream === true &&
        ['apiKey', 'baseUrl', 'model'].every(
          (key) =>
            typeof isolatedEffective[key] === 'string' &&
            isolatedEffective[key].trim().length > 0,
        ),
      'response-stream-effective-llm-config-invalid',
    );
    state.responseStream.effectiveStreamEnabled = true;
  }
  if (webSearchAgentId) {
    const isolatedConfig = await loadConfig(appDataDir);
    const isolatedEffective = effectiveAgentLlmConfig(
      isolatedConfig.config,
      webSearchAgentId,
    );
    if (isolatedEffective.apiKind === 'anthropic') {
      state.webSearch.gatewayDiagnosis = 'anthropic-web-search-unsupported';
      throw new BlockedError(['web-search-anthropic-unsupported']);
    }
    assert(
      isolatedEffective.webSearchEnabled === true &&
        ['apiKey', 'baseUrl', 'model'].every(
          (key) =>
            typeof isolatedEffective[key] === 'string' &&
            isolatedEffective[key].trim().length > 0,
        ),
      'web-search-effective-llm-config-invalid',
    );
    state.webSearch.effectiveEnabled = true;
  }
  if (mcpOverlay) {
    const isolatedConfig = await loadConfig(appDataDir);
    const isolatedEffective = effectiveAgentLlmConfig(
      isolatedConfig.config,
      mainAgentId,
    );
    assert(
      Object.keys(isolatedConfig.config.mcpServers ?? {}).length === 2 &&
        ['apiKey', 'baseUrl', 'model'].every(
          (key) =>
            typeof isolatedEffective[key] === 'string' &&
            isolatedEffective[key].trim().length > 0,
        ),
      'mcp-effective-runtime-config-invalid',
    );
  }
  if (isUserInputRuntimeSuite()) {
    const isolatedConfig = await loadConfig(appDataDir);
    const isolatedEffective = effectiveAgentLlmConfig(
      isolatedConfig.config,
      projectSupervisorAgentId,
    );
    assert(
      isolatedEffective.model === 'gpt-5.5' &&
        ['apiKey', 'baseUrl', 'model'].every(
          (key) =>
            typeof isolatedEffective[key] === 'string' &&
            isolatedEffective[key].trim().length > 0,
        ),
      'user-input-effective-gpt-5-5-config-invalid',
    );
  }
  if (isScopedAgentsSuite()) {
    const isolatedConfig = await loadConfig(appDataDir);
    const isolatedEffective = effectiveAgentLlmConfig(
      isolatedConfig.config,
      mainAgentId,
    );
    assert(
      isolatedEffective.model === 'gpt-5.5' &&
        isolatedEffective.apiKind === 'openai_chat' &&
        ['apiKey', 'baseUrl', 'model'].every(
          (key) =>
            typeof isolatedEffective[key] === 'string' &&
            isolatedEffective[key].trim().length > 0,
        ),
      'scoped-agents-effective-openai-chat-gpt-5-5-config-invalid',
    );
    state.scopedAgents.effectiveModel = isolatedEffective.model;
    state.scopedAgents.effectiveApiKind = isolatedEffective.apiKind;
  }
  if (isProjectSkillSuite()) {
    const isolatedConfig = await loadConfig(appDataDir);
    const isolatedEffective = effectiveAgentLlmConfig(
      isolatedConfig.config,
      mainAgentId,
    );
    assert(
      isolatedEffective.model === 'gpt-5.5' &&
        isolatedEffective.apiKind === 'openai_chat' &&
        ['apiKey', 'baseUrl', 'model'].every(
          (key) =>
            typeof isolatedEffective[key] === 'string' &&
            isolatedEffective[key].trim().length > 0,
        ),
      'project-skill-effective-openai-chat-gpt-5-5-config-invalid',
    );
    state.projectSkill.effectiveModel = isolatedEffective.model;
    state.projectSkill.effectiveApiKind = isolatedEffective.apiKind;
  }
  if (isParallelReadSuite()) {
    const isolatedConfig = await loadConfig(appDataDir);
    const isolatedEffective = effectiveAgentLlmConfig(
      isolatedConfig.config,
      mainAgentId,
    );
    assert(
      isolatedEffective.model === 'gpt-5.5' &&
        isolatedEffective.apiKind === 'openai_chat' &&
        ['apiKey', 'baseUrl', 'model'].every(
          (key) =>
            typeof isolatedEffective[key] === 'string' &&
            isolatedEffective[key].trim().length > 0,
        ),
      'parallel-read-effective-openai-chat-gpt-5-5-config-invalid',
    );
    state.parallelRead.effectiveModel = isolatedEffective.model;
    state.parallelRead.effectiveApiKind = isolatedEffective.apiKind;
  }
  if (isSupervisorSwarmSuite()) {
    const isolatedConfig = await loadConfig(appDataDir);
    const requiredAgentIds = supervisorSwarmRequiredAgentIds;
    const requiredEffectiveConfigs = requiredAgentIds.map((agentId) => [
      agentId,
      effectiveAgentLlmConfig(isolatedConfig.config, agentId),
    ]);
    assert(
      requiredEffectiveConfigs.every(
        ([agentId, effective]) =>
          (isSupervisorSwarmToolPlanHandoffRunnerKillSuite()
            ? isNonEmptyString(effective.model)
            : effective.model === 'gpt-5.5') &&
          effective.apiKind === 'openai_chat' &&
          isNonEmptyString(effective.reasoningEffort) &&
          Number.isSafeInteger(effective.requestTimeoutMs) &&
          effective.requestTimeoutMs > 0 &&
          Number.isSafeInteger(effective.maxRetries) &&
          effective.maxRetries >=
            (isSupervisorSwarmInteractiveChatSuite() ||
            (isSupervisorSwarmTransientRetrySuite() &&
              agentId !== supervisorSwarmTransientRetryTargetAgentId)
              ? 0
              : 1) &&
          effective.maxRetries <= 3 &&
          Number.isSafeInteger(effective.retryBackoffMs) &&
          effective.retryBackoffMs > 0 &&
          ['apiKey', 'baseUrl', 'model'].every(
            (key) =>
              typeof effective[key] === 'string' &&
              effective[key].trim().length > 0,
          ),
      ),
      isSupervisorSwarmToolPlanHandoffRunnerKillSuite()
        ? 'supervisor-swarm-effective-openai-chat-configured-model-invalid'
        : 'supervisor-swarm-effective-openai-chat-gpt-5-5-config-invalid',
    );
    const globalEffective = effectiveAgentLlmConfig(
      { llm: isolatedConfig.config.llm },
      '',
    );
    if (isSupervisorSwarmMixedHarnessSuite()) {
      assert(
        globalEffective.model === 'gpt-5.5' &&
          globalEffective.apiKind === 'openai_chat' &&
          isNonEmptyString(globalEffective.reasoningEffort) &&
          Number.isSafeInteger(globalEffective.requestTimeoutMs) &&
          globalEffective.requestTimeoutMs > 0 &&
          Number.isSafeInteger(globalEffective.maxRetries) &&
          globalEffective.maxRetries >= 0 &&
          globalEffective.maxRetries <= 3 &&
          Number.isSafeInteger(globalEffective.retryBackoffMs) &&
          globalEffective.retryBackoffMs > 0 &&
          ['apiKey', 'baseUrl', 'model'].every((key) =>
            isNonEmptyString(globalEffective[key]),
          ),
        'supervisor-swarm-mixed-default-provider-policy-invalid',
      );
    }
    const configuredAgentIds = Object.keys(
      isPlainObject(isolatedConfig.config.agentLlm)
        ? isolatedConfig.config.agentLlm
        : {},
    ).filter(isNonEmptyString);
    const policyAgentIds = [
      ...new Set([...requiredAgentIds, ...configuredAgentIds]),
    ].sort();
    const effectivePolicies = policyAgentIds.map((agentId) => [
      agentId,
      effectiveAgentLlmConfig(isolatedConfig.config, agentId),
    ]);
    const supervisorEffective = requiredEffectiveConfigs.find(
      ([agentId]) => agentId === projectSupervisorAgentId,
    )[1];
    state.supervisorSwarm.effectiveModel = supervisorEffective.model;
    state.supervisorSwarm.effectiveApiKind = supervisorEffective.apiKind;
    state.supervisorSwarm.effectiveReasoningEffort =
      supervisorEffective.reasoningEffort;
    state.supervisorSwarm.effectiveRequestTimeoutMs =
      supervisorEffective.requestTimeoutMs;
    state.supervisorSwarm.effectiveMaxRetries = supervisorEffective.maxRetries;
    state.supervisorSwarm.effectiveRetryBackoffMs =
      supervisorEffective.retryBackoffMs;
    state.supervisorSwarm.effectiveDefaultPolicy =
      safeEffectiveAgentLlmPolicy(globalEffective);
    state.supervisorSwarm.effectiveAgentPolicies = Object.fromEntries(
      effectivePolicies.map(([agentId, effective]) => [
        agentId,
        safeEffectiveAgentLlmPolicy(effective),
      ]),
    );
  }
  if (isSteerRunnerKillSuite()) {
    const isolatedConfig = await loadConfig(appDataDir);
    const isolatedEffective = effectiveAgentLlmConfig(
      isolatedConfig.config,
      mainAgentId,
    );
    assert(
      isolatedEffective.model === 'gpt-5.5' &&
        isolatedEffective.apiKind === 'openai_chat' &&
        ['apiKey', 'baseUrl', 'model'].every(
          (key) =>
            typeof isolatedEffective[key] === 'string' &&
            isolatedEffective[key].trim().length > 0,
        ),
      'steer-runner-kill-effective-openai-chat-gpt-5-5-config-invalid',
    );
    state.steerRunnerKill.effectiveModel = isolatedEffective.model;
    state.steerRunnerKill.effectiveApiKind = isolatedEffective.apiKind;
  }
}

export async function readIsolatedAppDataSentinel() {
  const runner = state.isolatedRunner;
  const profile = isolatedSuiteAppDataProfile();
  assert(
    isNonEmptyString(runner.appDataDir) && isNonEmptyString(runner.ownerToken),
    'isolated-appdata-ownership-missing',
  );
  const sentinelPath = path.join(runner.appDataDir, profile.sentinelName);
  const metadata = await fs.lstat(sentinelPath);
  const sentinel = await readJson(sentinelPath);
  assert(
    metadata.isFile() &&
      !metadata.isSymbolicLink() &&
      sentinel.schemaVersion === profile.sentinelSchema &&
      sentinel.token === runner.ownerToken &&
      sentinel.ownerPid === process.pid &&
      sentinel.createdAt === runner.createdAt,
    'isolated-appdata-ownership-invalid',
  );
  return sentinel;
}

export async function inspectOwnedRunnerIdentity(status) {
  await readIsolatedAppDataSentinel();
  const runner = state.isolatedRunner;
  const pid = Number(status?.pid ?? status?.status?.pid);
  const bootId = runnerBootId(status);
  assert(
    status?.running === true &&
      Number.isSafeInteger(pid) &&
      pid > 1 &&
      pid !== process.pid &&
      isNonEmptyString(bootId),
    'isolated-owned-runner-status-invalid',
  );
  const endpointPath = path.join(runner.appDataDir, runnerEndpointFileName);
  const endpointMetadata = await fs.lstat(endpointPath);
  const endpoint = await readJson(endpointPath);
  assert(
    endpointMetadata.isFile() &&
      !endpointMetadata.isSymbolicLink() &&
      endpoint.pid === pid &&
      endpoint.bootId === bootId &&
      endpoint.protocolVersion === status.protocolVersion &&
      endpoint.port === status.port &&
      Number.isSafeInteger(endpoint.heartbeatAt) &&
      endpoint.heartbeatAt >= runner.createdAt &&
      isNonEmptyString(endpoint.token) &&
      endpoint.token.length >= 32,
    'isolated-owned-runner-endpoint-identity-invalid',
  );
  return {
    pid,
    bootId,
    protocolVersion: endpoint.protocolVersion,
    port: endpoint.port,
    processIdentity: await captureOwnedRunnerProcessIdentity(pid),
  };
}

export async function claimOwnedRunner(status = null) {
  const liveStatus = status ?? (await readRunnerStatus());
  const identity = await inspectOwnedRunnerIdentity(liveStatus);
  const current = state.isolatedRunner.current;
  if (current) {
    assert(
      current.pid === identity.pid &&
        current.bootId === identity.bootId &&
        current.processIdentity.fingerprint ===
          identity.processIdentity.fingerprint &&
        current.killHandle?.closed === false,
      'isolated-owned-runner-identity-changed-after-claim',
    );
    return current;
  }

  const killHandle = await openOwnedRunnerKillHandle(identity.pid);
  try {
    const rechecked = await inspectOwnedRunnerIdentity(
      await readRunnerStatus(),
    );
    assert(
      rechecked.pid === identity.pid &&
        rechecked.bootId === identity.bootId &&
        rechecked.protocolVersion === identity.protocolVersion &&
        rechecked.port === identity.port &&
        rechecked.processIdentity.fingerprint ===
          identity.processIdentity.fingerprint,
      'isolated-owned-runner-identity-changed-during-pidfd-claim',
    );
  } catch (error) {
    await closeOwnedRunnerKillHandle(killHandle).catch(() => {});
    throw error;
  }
  state.isolatedRunner.current = { ...identity, killHandle };
  state.isolatedRunner.pidfdClaimCount += 1;
  return state.isolatedRunner.current;
}

export async function verifyOwnedRunnerForKill() {
  const claimed = state.isolatedRunner.current;
  assert(claimed, 'isolated-owned-runner-not-claimed');
  const current = await inspectOwnedRunnerIdentity(await readRunnerStatus());
  assert(
    current.pid === claimed.pid &&
      current.bootId === claimed.bootId &&
      current.protocolVersion === claimed.protocolVersion &&
      current.port === claimed.port &&
      current.processIdentity.fingerprint ===
        claimed.processIdentity.fingerprint &&
      claimed.killHandle?.pid === claimed.pid &&
      claimed.killHandle.closed === false,
    'isolated-owned-runner-identity-changed-before-kill',
  );
  return claimed;
}

export async function ensureOwnedRunnerStableKillSupport() {
  assert(
    process.platform === 'linux',
    'isolated-runner-stable-kill-handle-platform-unsupported',
  );
  const python = await findControlledLinuxPython();
  const probe =
    'import os, signal; assert hasattr(os, "pidfd_open") and hasattr(signal, "pidfd_send_signal"); fd = os.pidfd_open(os.getpid(), 0); os.close(fd)';
  try {
    await runProcess(python, ['-I', '-S', '-c', probe], {
      cwd: appRoot,
      timeoutMs: 30_000,
      env: { LANG: 'C', LC_ALL: 'C', PATH: '/usr/bin:/bin' },
    });
  } catch (error) {
    throw codedError('isolated-runner-pidfd-support-unavailable', error);
  }
}

export async function findControlledLinuxPython() {
  if (state.linuxPidfdPythonPath) return state.linuxPidfdPythonPath;
  for (const candidate of ['/usr/bin/python3', '/usr/local/bin/python3']) {
    const resolved = await fs.realpath(candidate).catch(() => null);
    const metadata = resolved
      ? await fs.stat(resolved).catch(() => null)
      : null;
    if (metadata?.isFile() && (metadata.mode & 0o111) !== 0) {
      state.linuxPidfdPythonPath = resolved;
      return resolved;
    }
  }
  throw codedError('isolated-runner-controlled-python-unavailable');
}

export async function openOwnedRunnerKillHandle(pid) {
  assert(
    process.platform === 'linux' && Number.isSafeInteger(pid) && pid > 1,
    'isolated-runner-pidfd-open-precondition-invalid',
  );
  const python = await findControlledLinuxPython();
  const child = spawn(
    python,
    ['-I', '-S', '-c', linuxPidfdHelperSource, String(pid)],
    {
      cwd: appRoot,
      env: { LANG: 'C', LC_ALL: 'C', PATH: '/usr/bin:/bin' },
      stdio: ['pipe', 'pipe', 'pipe'],
    },
  );
  const handle = {
    pid,
    child,
    stdout: Buffer.alloc(0),
    stderr: Buffer.alloc(0),
    closed: false,
  };
  child.stdout.on('data', (chunk) => {
    handle.stdout = appendBounded(handle.stdout, chunk, 4_096);
  });
  child.stderr.on('data', (chunk) => {
    handle.stderr = appendBounded(handle.stderr, chunk, 4_096);
  });
  await waitForOwnedRunnerKillHandleReady(handle);
  return handle;
}

export async function waitForOwnedRunnerKillHandleReady(handle) {
  await new Promise((resolve, reject) => {
    const timer = setTimeout(() => {
      handle.child.kill('SIGKILL');
      reject(codedError('isolated-runner-pidfd-open-timeout'));
    }, 10_000);
    const settle = (callback) => {
      clearTimeout(timer);
      handle.child.stdout.off('data', onData);
      handle.child.off('error', onError);
      handle.child.off('close', onClose);
      callback();
    };
    const onData = () => {
      if (handle.stdout.includes(Buffer.from('PIDFD_READY\n'))) {
        settle(resolve);
      }
    };
    const onError = (error) =>
      settle(() =>
        reject(codedError('isolated-runner-pidfd-helper-spawn-failed', error)),
      );
    const onClose = () =>
      settle(() => reject(codedError('isolated-runner-pidfd-open-failed')));
    handle.child.stdout.on('data', onData);
    handle.child.on('error', onError);
    handle.child.on('close', onClose);
    onData();
  });
}

export async function closeOwnedRunnerKillHandle(handle) {
  if (!handle || handle.closed) return;
  handle.closed = true;
  if (handle.child.exitCode !== null || handle.child.signalCode !== null)
    return;
  handle.child.stdin.end('CLOSE\n');
  const result = await waitForChildClose(handle.child, 10_000);
  assert(result.code === 0, 'isolated-runner-pidfd-close-failed');
}

export async function signalOwnedRunnerKillHandle(handle) {
  assert(
    handle &&
      handle.closed === false &&
      handle.child.exitCode === null &&
      handle.child.signalCode === null,
    'isolated-runner-pidfd-handle-not-live',
  );
  handle.closed = true;
  handle.child.stdin.end('KILL\n');
  const result = await waitForChildClose(handle.child, 15_000);
  assert(
    result.code === 0 && handle.stdout.includes(Buffer.from('PIDFD_EXITED\n')),
    'isolated-runner-pidfd-sigkill-failed',
  );
}

export async function waitForChildClose(child, timeoutMs) {
  if (child.exitCode !== null || child.signalCode !== null) {
    return { code: child.exitCode, signal: child.signalCode };
  }
  return new Promise((resolve, reject) => {
    const timer = setTimeout(() => {
      child.kill('SIGKILL');
      reject(codedError('isolated-runner-pidfd-helper-timeout'));
    }, timeoutMs);
    const onError = (error) => {
      clearTimeout(timer);
      child.off('close', onClose);
      reject(codedError('isolated-runner-pidfd-helper-failed', error));
    };
    const onClose = (code, signal) => {
      clearTimeout(timer);
      child.off('error', onError);
      resolve({ code, signal });
    };
    child.once('error', onError);
    child.once('close', onClose);
  });
}

export async function captureOwnedRunnerProcessIdentity(pid) {
  const expectedAppData = state.isolatedRunner.appDataDir;
  assert(
    isNonEmptyString(expectedAppData) && Boolean(state.cliBinary),
    'isolated-runner-process-identity-context-missing',
  );
  if (process.platform === 'linux') {
    const [executable, expectedExecutable, stat, commandLine] =
      await Promise.all([
        fs.realpath(`/proc/${pid}/exe`),
        fs.realpath(state.cliBinary),
        fs.readFile(`/proc/${pid}/stat`, 'utf8'),
        fs.readFile(`/proc/${pid}/cmdline`),
      ]);
    const closeParenthesis = stat.lastIndexOf(')');
    const fields = stat
      .slice(closeParenthesis + 1)
      .trim()
      .split(/\s+/u);
    const startTime = fields[19];
    const argv = commandLine.toString('utf8').split('\0').filter(Boolean);
    const configIndex = argv.indexOf('--config-dir');
    assert(
      closeParenthesis > 0 &&
        isNonEmptyString(startTime) &&
        executable === expectedExecutable &&
        argv.includes('--agent-runner') &&
        configIndex >= 0 &&
        argv[configIndex + 1] === expectedAppData,
      'isolated-runner-linux-process-identity-invalid',
    );
    return {
      kind: 'linux-proc',
      fingerprint: hashValue(JSON.stringify({ executable, startTime, argv })),
    };
  }

  if (process.platform === 'darwin') {
    const result = await runProcess(
      '/bin/ps',
      ['-p', String(pid), '-o', 'lstart=', '-o', 'command='],
      { cwd: appRoot, timeoutMs: 30_000 },
    );
    assert(
      result.stdout.includes(path.basename(state.cliBinary)) &&
        result.stdout.includes('--agent-runner') &&
        result.stdout.includes(expectedAppData),
      'isolated-runner-darwin-process-identity-invalid',
    );
    return {
      kind: 'darwin-ps',
      fingerprint: hashValue(result.stdout.trim()),
    };
  }

  if (process.platform === 'win32') {
    const script = `$process = Get-CimInstance Win32_Process -Filter "ProcessId = ${pid}"; if ($null -eq $process) { exit 3 }; $process | Select-Object ProcessId,CreationDate,ExecutablePath,CommandLine | ConvertTo-Json -Compress`;
    const result = await runProcess(
      'powershell.exe',
      ['-NoProfile', '-NonInteractive', '-Command', script],
      { cwd: appRoot, timeoutMs: 30_000 },
    );
    const value = JSON.parse(result.stdout);
    const executable = path.resolve(String(value.ExecutablePath ?? ''));
    const expectedExecutable = path.resolve(state.cliBinary);
    const commandLine = String(value.CommandLine ?? '');
    assert(
      Number(value.ProcessId) === pid &&
        executable.toLowerCase() === expectedExecutable.toLowerCase() &&
        isNonEmptyString(value.CreationDate) &&
        commandLine.includes('--agent-runner') &&
        commandLine.includes(expectedAppData),
      'isolated-runner-windows-process-identity-invalid',
    );
    return {
      kind: 'windows-cim',
      fingerprint: hashValue(
        JSON.stringify({
          pid,
          creationDate: value.CreationDate,
          executable: executable.toLowerCase(),
          commandLine,
        }),
      ),
    };
  }

  throw codedError('isolated-runner-process-identity-platform-unsupported');
}

export function isProcessAlive(pid) {
  if (!Number.isSafeInteger(pid) || pid <= 1 || pid === process.pid)
    return false;
  try {
    process.kill(pid, 0);
    return true;
  } catch (error) {
    return error?.code === 'EPERM';
  }
}

export async function killRunnerPidOnce(pid, ownedRunner) {
  if (isIsolatedRunnerSuite()) {
    assert(ownedRunner, 'isolated-runner-pid-kill-fallback-forbidden');
  }
  if (ownedRunner) {
    const claimed = state.isolatedRunner.current;
    assert(
      claimed?.pid === pid && claimed.killHandle?.pid === pid,
      'isolated-runner-pidfd-identity-missing',
    );
    await signalOwnedRunnerKillHandle(claimed.killHandle);
    state.isolatedRunner.pidfdSignalCount += 1;
    state.runnerKilled = true;
    state.isolatedRunner.current = null;
    return;
  }
  try {
    process.kill(pid, 'SIGKILL');
  } catch (error) {
    throw codedError('runner-sigkill-failed', error);
  }
  state.runnerKilled = true;
  const deadline = Date.now() + 10_000;
  while (Date.now() < deadline) {
    if (!isProcessAlive(pid)) {
      if (ownedRunner) state.isolatedRunner.current = null;
      return;
    }
    await sleep(50);
  }
  throw codedError('runner-still-alive-after-sigkill');
}

export async function stopClaimedOwnedRunnerWithoutEndpoint() {
  const claimed = state.isolatedRunner.current;
  if (!claimed) return;
  if (!isProcessAlive(claimed.pid)) {
    await closeOwnedRunnerKillHandle(claimed.killHandle);
    state.isolatedRunner.current = null;
    return;
  }
  let currentIdentity;
  try {
    currentIdentity = await captureOwnedRunnerProcessIdentity(claimed.pid);
  } catch (error) {
    if (!isProcessAlive(claimed.pid)) {
      await closeOwnedRunnerKillHandle(claimed.killHandle);
      state.isolatedRunner.current = null;
      return;
    }
    throw error;
  }
  assert(
    currentIdentity.fingerprint === claimed.processIdentity.fingerprint,
    'isolated-owned-runner-identity-changed-without-endpoint',
  );
  await killRunnerPidOnce(claimed.pid, true);
}

export async function stopOwnedIsolatedRunner() {
  await readIsolatedAppDataSentinel();
  const endpointPath = path.join(
    state.isolatedRunner.appDataDir,
    runnerEndpointFileName,
  );
  const endpointMetadata = await fs.lstat(endpointPath).catch((error) => {
    if (error?.code === 'ENOENT') return null;
    throw error;
  });
  if (!endpointMetadata) {
    assert(
      state.isolatedRunner.current || !state.isolatedRunner.launchAttempted,
      'isolated-owned-runner-endpoint-missing-before-stable-claim',
    );
    await stopClaimedOwnedRunnerWithoutEndpoint();
    return;
  }
  assert(
    endpointMetadata.isFile() && !endpointMetadata.isSymbolicLink(),
    'isolated-owned-runner-endpoint-not-regular-file',
  );
  const endpoint = await readJson(endpointPath);
  const status = await readRunnerStatus();
  if (status?.running !== true) {
    assert(
      !isProcessAlive(Number(endpoint.pid)),
      'isolated-owned-runner-live-pid-without-identity',
    );
    await closeOwnedRunnerKillHandle(state.isolatedRunner.current?.killHandle);
    state.isolatedRunner.current = null;
    return;
  }
  await claimOwnedRunner(status);
  await killRunnerOnce();
}

export async function verifyIsolatedSuiteConfigLinksUnchanged() {
  for (const link of state.isolatedRunner.configLinks) {
    const [sourceMetadata, linkedMetadata, sourceContent, linkedContent] =
      await Promise.all([
        fs.lstat(link.sourcePath),
        fs.lstat(link.linkedPath),
        fs.readFile(link.sourcePath),
        fs.readFile(link.linkedPath),
      ]);
    const sourceHash = createHash('sha256').update(sourceContent).digest('hex');
    const linkedHash = createHash('sha256').update(linkedContent).digest('hex');
    const replicaIdentityValid =
      link.storageMode === 'private-copy'
        ? linkedMetadata.dev === link.linkedDev &&
          linkedMetadata.ino === link.linkedIno &&
          (linkedMetadata.dev !== sourceMetadata.dev ||
            linkedMetadata.ino !== sourceMetadata.ino) &&
          (linkedMetadata.mode & 0o077) === 0
        : linkedMetadata.dev === link.dev && linkedMetadata.ino === link.ino;
    const sourceMetadataStable =
      sourceMetadata.mode === link.sourceMode &&
      sourceMetadata.size === link.sourceSize &&
      sourceMetadata.mtimeMs === link.sourceMtimeMs &&
      (link.storageMode !== 'private-copy' ||
        (sourceMetadata.ctimeMs === link.sourceCtimeMs &&
          sourceMetadata.nlink === link.nlink));
    assert(
      sourceMetadata.isFile() &&
        !sourceMetadata.isSymbolicLink() &&
        linkedMetadata.isFile() &&
        !linkedMetadata.isSymbolicLink() &&
        sourceMetadata.dev === link.dev &&
        sourceMetadata.ino === link.ino &&
        sourceMetadataStable &&
        replicaIdentityValid &&
        sourceHash === link.sha256 &&
        linkedHash === link.sha256,
      'isolated-source-config-changed-during-suite',
    );
  }
}

export async function verifySourceConfigLinkCountsRestored() {
  for (const link of state.isolatedRunner.configLinks) {
    const metadata = await fs.lstat(link.sourcePath);
    assert(
      metadata.isFile() &&
        !metadata.isSymbolicLink() &&
        metadata.dev === link.dev &&
        metadata.ino === link.ino &&
        metadata.nlink === link.nlink,
      'isolated-source-config-link-count-not-restored',
    );
  }
}

export async function removeIsolatedSuiteAppData() {
  await readIsolatedAppDataSentinel();
  const profile = isolatedSuiteAppDataProfile();
  const [sourceConfigDir, appDataDir] = await Promise.all([
    fs.realpath(state.options.configDir),
    fs.realpath(state.isolatedRunner.appDataDir),
  ]);
  const cleanupPathValid = isolatedSuiteUsesSiblingAppData()
    ? !isPathInside(sourceConfigDir, appDataDir) &&
      path.dirname(appDataDir) === path.dirname(sourceConfigDir)
    : isPathInside(sourceConfigDir, appDataDir);
  assert(
    cleanupPathValid && path.basename(appDataDir).startsWith(profile.prefix),
    'isolated-appdata-cleanup-path-invalid',
  );
  let ownershipError = null;
  try {
    await verifySourceAppDataDirectoryUntouched();
    await verifyIsolatedSuiteConfigLinksUnchanged();
    await verifySourceRunnerEndpointUnchanged();
  } catch (error) {
    ownershipError = error;
  }
  await fs.rm(appDataDir, { recursive: true, force: false });
  state.runtimeConfigDir = state.options.configDir;
  try {
    await verifySourceConfigLinkCountsRestored();
    state.isolatedRunner.sourceConfigLinksVerified = true;
  } catch (error) {
    ownershipError ??= error;
  }
  if (ownershipError) throw ownershipError;
  return true;
}