release-skill 0.9.3 → 0.9.5

package/src/commands/post-release-local.mjs

@@ -1,4 +1,4 @@
-import { access } from 'node:fs/promises';
+import { access, readFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join, relative } from 'node:path';
 
@@ -12,6 +12,8 @@ import {
 import { getPlatform } from '../platforms/registry.mjs';
 import { resolveCodeBuddyMarketplace } from '../platforms/codebuddy.mjs';
 import { verifyInstalledMarketplacePayload } from '../adapters/plugin-marketplace.mjs';
+import { normalizePostPublishView, postPublishActionId } from '../core/postpublish.mjs';
+import { loadRun, validateRunLineage } from '../core/run.mjs';
 
 const HOSTS_BY_ACTION = Object.freeze({
   'claude-marketplace-install': ['claude'],
@@ -34,7 +36,18 @@ const SAFE_ENV_KEYS = Object.freeze([
   'HTTP_PROXY', 'HTTPS_PROXY', 'NO_PROXY', 'http_proxy', 'https_proxy', 'no_proxy',
   'SSL_CERT_FILE', 'SSL_CERT_DIR', 'NODE_EXTRA_CA_CERTS',
   'CLAUDE_CONFIG_DIR', 'CODEX_HOME', 'KIMI_CONFIG_DIR',
+  'CODEBUDDY_CONFIG_DIR', 'WORKBUDDY_CONFIG_DIR',
 ]);
+const CODEBUDDY_PLUGIN_LIST_ARGS = Object.freeze(['plugin', 'list', '--json']);
+const CODEBUDDY_MARKETPLACE_LIST_ARGS = Object.freeze(['plugin', 'marketplace', 'list']);
+
+function attachFoundationFailure(error, { envelope, stdout }) {
+  Object.defineProperties(error, {
+    foundationEnvelope: { value: envelope, enumerable: false },
+    foundationStdout: { value: stdout, enumerable: false },
+  });
+  return error;
+}
 
 function actionTarget(plan, action, host) {
   const parameters = action.parameters ?? {};
@@ -159,7 +172,27 @@ function assertExecutableTarget(target) {
   }
 }
 
-export function derivePostReleaseChecklist(plan) {
+function buildShipNextStep({ root, statePath, unitIds }) {
+  const argv = ['release-skill', 'ship'];
+  if (typeof root === 'string' && root.length > 0) argv.push('--root', root);
+  if (typeof statePath === 'string' && statePath.length > 0) argv.push('--state', statePath);
+  if (Array.isArray(unitIds) && unitIds.length > 0) {
+    for (const unitId of unitIds) argv.push('--unit', unitId);
+  }
+  return {
+    code: 'COMPLETE_POST_VERIFY',
+    message: 'Complete the postVerify phase with ship before running post-release.',
+    argv,
+  };
+}
+
+export function derivePostReleaseChecklist(plan, {
+  runPath,
+  root,
+  statePath,
+  unitIds,
+  postVerifyComplete = false,
+} = {}) {
   if (!plan || typeof plan !== 'object' || typeof plan.digest !== 'string') {
     throw new Error('a frozen release plan with digest is required');
   }
@@ -168,6 +201,9 @@ export function derivePostReleaseChecklist(plan) {
     !BRANCH_ACTION_INCLUDED.has(unit.productionConfig?.branchStrategy)
   ));
   const targets = pluginTargets(plan);
+  const hasPendingPostVerify = postVerifyHooks(plan).length > 0 && !postVerifyComplete && targets.length > 0;
+  const hasStatePath = typeof statePath === 'string' && statePath.length > 0;
+  const selectedUnitIds = Array.isArray(unitIds) ? unitIds : undefined;
   return {
     command: 'post-release',
     status: 'AWAITING_USER_DECISION',
@@ -183,14 +219,173 @@ export function derivePostReleaseChecklist(plan) {
       })),
     },
     localHostUpdate: {
-      promptRequired: targets.length > 0,
-      available: targets.length > 0,
+      promptRequired: targets.length > 0 && !hasPendingPostVerify,
+      available: targets.length > 0 && !hasPendingPostVerify,
+      ...(!hasPendingPostVerify && runPath ? { runPath } : {}),
+      ...(hasPendingPostVerify ? {
+        ...(hasStatePath ? { nextSteps: [buildShipNextStep({ root, statePath, unitIds: selectedUnitIds })] } : {}),
+      } : {}),
       hosts: [...new Set(targets.map((target) => target.host))].sort(),
       targets,
     },
   };
 }
 
+function postVerifyHooks(plan) {
+  if (plan?.planVersion === undefined) return [];
+  return normalizePostPublishView(plan).flatMap((declaration) => (
+    (declaration.hooks ?? [])
+      .filter((hook) => hook.phase === 'postVerify')
+      .map((hook) => ({
+        actionId: postPublishActionId({ planVersion: plan.planVersion, unitId: declaration.unitId, localId: hook.id }),
+        hook,
+        unitId: declaration.unitId,
+      }))
+  ));
+}
+
+function localFinishEvidenceError(message, { cause, root, statePath, unitIds } = {}) {
+  const error = new Error(`local host update evidence is not ready: ${message}; next step: obtain approval if required, then complete the postVerify phase with ship before rerunning post-release`);
+  error.code = 'LOCAL_FINISH_EVIDENCE_NOT_READY';
+  const hasStatePath = typeof statePath === 'string' && statePath.length > 0;
+  error.details = {
+    cause: {
+      code: cause?.code ?? 'LOCAL_FINISH_EVIDENCE_NOT_READY',
+      message: cause?.message ?? message,
+    },
+    ...(hasStatePath ? {
+      nextSteps: [buildShipNextStep({ root, statePath, unitIds })],
+    } : {}),
+  };
+  return error;
+}
+
+/**
+ * Validate the frozen run authority before allowing any local host command.
+ * This is the only exported entry that can perform local host writes.
+ */
+export async function updateLocalHostPlugins({
+  plan: _suppliedPlan,
+  planPath,
+  runPath,
+  runRecord: _suppliedRunRecord,
+  production: _suppliedProduction,
+  root = process.cwd(),
+  statePath,
+  unitIds,
+  ...options
+} = {}) {
+  if (!planPath || !runPath) {
+    throw localFinishEvidenceError(
+      'planPath and runPath are required before local host updates',
+      { root, statePath, unitIds },
+    );
+  }
+  let plan;
+  let runRecord;
+  try {
+    plan = JSON.parse(await readFile(planPath, 'utf8'));
+    runRecord = await loadRun(runPath, {
+      requireDigest: true,
+      authorityPlanPath: planPath,
+    });
+  } catch (cause) {
+    throw localFinishEvidenceError(cause.message, { cause, root, statePath, unitIds });
+  }
+  await assertLocalFinishRun({
+    plan,
+    planPath,
+    runPath,
+    runRecord,
+    production: Boolean(plan.production),
+    root,
+    statePath,
+    unitIds,
+  });
+  return updateLocalHostPluginsInternal({
+    plan,
+    root,
+    ...options,
+  });
+}
+
+/** Validate the explicit run supplied to local-finish before any host probe. */
+export async function assertLocalFinishRun({
+  plan,
+  planPath,
+  runPath,
+  runRecord,
+  production = false,
+  root,
+  statePath,
+  unitIds,
+} = {}) {
+  const hooks = postVerifyHooks(plan);
+  if (hooks.length === 0) {
+    try {
+      await validateRunLineage(runRecord, { plan, planPath, runPath, production });
+      assertVerifiedReleaseRun(plan, runRecord);
+    } catch (cause) {
+      throw localFinishEvidenceError(cause.message, { cause, root, statePath, unitIds, plan });
+    }
+    return { runPath, phase: 'verify' };
+  }
+  if (runRecord?.command !== 'postverify' || runRecord?.status !== 'DISTRIBUTED') {
+    throw localFinishEvidenceError('the plan declares postVerify hooks, so the supplied verify run cannot authorize local-finish', { root, statePath, unitIds, plan });
+  }
+  if (runRecord.planDigest !== plan?.digest) {
+    throw localFinishEvidenceError('postVerify run is not bound to the frozen plan', { root, statePath, unitIds, plan });
+  }
+  if (typeof runRecord.sourceRunPath !== 'string' || typeof runRecord.sourceRunId !== 'string' || typeof runRecord.sourceRunDigest !== 'string') {
+    throw localFinishEvidenceError('completed postVerify run has incomplete verify-run lineage', { root, statePath, unitIds, plan });
+  }
+  const checkpoints = Array.isArray(runRecord.checkpoints) ? runRecord.checkpoints : null;
+  const expectedIds = hooks.map(({ actionId }) => actionId);
+  const actualIds = checkpoints?.map((checkpoint) => checkpoint?.actionId) ?? [];
+  if (
+    !checkpoints
+    || actualIds.length !== expectedIds.length
+    || new Set(actualIds).size !== actualIds.length
+    || actualIds.some((id) => !expectedIds.includes(id))
+    || expectedIds.some((id) => !actualIds.includes(id))
+    || checkpoints.some((checkpoint) => (
+      checkpoint.actionType !== 'postpublish-hook'
+      || !['succeeded', 'NO_CHANGE'].includes(checkpoint.status)
+    ))
+  ) {
+    throw localFinishEvidenceError('postVerify checkpoints must match each declared hook exactly and be succeeded or NO_CHANGE', { root, statePath, unitIds, plan });
+  }
+  let sourceRun;
+  try {
+    sourceRun = await loadRun(runRecord.sourceRunPath, {
+      requireDigest: true,
+      authorityPlanPath: planPath,
+    });
+  } catch (cause) {
+    throw localFinishEvidenceError(cause.message, { cause, root, statePath, unitIds, plan });
+  }
+  if (
+    sourceRun.command !== 'verify'
+    || sourceRun.status !== 'VERIFIED'
+    || sourceRun.runId !== runRecord.sourceRunId
+    || sourceRun.runDigest !== runRecord.sourceRunDigest
+    || sourceRun.planDigest !== plan.digest
+  ) {
+    throw localFinishEvidenceError('postVerify lineage does not point to the same-plan VERIFIED run', { root, statePath, unitIds, plan });
+  }
+  try {
+    await validateRunLineage(sourceRun, {
+      plan,
+      planPath,
+      runPath: runRecord.sourceRunPath,
+      production,
+    });
+  } catch (cause) {
+    throw localFinishEvidenceError(cause.message, { cause, root, statePath, unitIds, plan });
+  }
+  return { runPath, sourceRunPath: runRecord.sourceRunPath, phase: 'postverify' };
+}
+
 export function unavailablePostReleaseChecklist(plan, error) {
   return {
     command: 'post-release',
@@ -222,7 +417,11 @@ function hostEnvironment(host, { kimiHome } = {}) {
   env.HOME ??= homedir();
   env.PATH ??= '/usr/bin:/bin';
   env.GIT_TERMINAL_PROMPT = '0';
-  if (host === 'workbuddy') env.CODEBUDDY_CONFIG_DIR = join(env.HOME, '.workbuddy');
+  if (host === 'codebuddy') env.CODEBUDDY_CONFIG_DIR = join(env.HOME, '.codebuddy');
+  if (host === 'workbuddy') {
+    env.CODEBUDDY_CONFIG_DIR = join(env.HOME, '.workbuddy');
+    env.WORKBUDDY_CONFIG_DIR = join(env.HOME, '.workbuddy');
+  }
   if (host === 'kimi' && kimiHome) env.KIMI_CONFIG_DIR = kimiHome;
   return env;
 }
@@ -259,7 +458,7 @@ async function defaultRun(command, args, options = {}) {
         watchdogReason: envelope.watchdogReason,
         ...(envelope.evidence?.spawnError ? { spawnError: envelope.evidence.spawnError } : {}),
       };
-      throw error;
+      throw attachFoundationFailure(error, { envelope, stdout });
     }
     return { stdout, stderr };
   }, { prefix: 'release-skill-host-command-' });
@@ -276,12 +475,17 @@ async function commandAvailable(command, host, run) {
 }
 
 async function defaultDetect(host, run = defaultRun) {
-  if (host === 'codebuddy' || host === 'workbuddy') {
-    for (const command of ['codebuddy', 'cbc', CODEBUDDY_MACOS_PATH]) {
+  if (host === 'codebuddy') {
+    for (const command of ['codebuddy', 'cbc']) {
       if (await commandAvailable(command, host, run)) return { available: true, command };
     }
     return { available: false, reason: 'CodeBuddy/WorkBuddy CLI not found' };
   }
+  if (host === 'workbuddy') {
+    if (process.platform !== 'darwin') return { available: false, status: 'SKIPPED_UNSUPPORTED_PLATFORM', reason: 'WorkBuddy local update is supported only on macOS' };
+    if (await commandAvailable(CODEBUDDY_MACOS_PATH, host, run)) return { available: true, command: CODEBUDDY_MACOS_PATH };
+    return { available: false, reason: 'WorkBuddy embedded CLI not found' };
+  }
   if (host === 'kimi') {
     if (!await commandAvailable('kimi', host, run)) return { available: false, reason: 'kimi CLI not found' };
     try {
@@ -303,6 +507,96 @@ function parseJson(stdout, label) {
   }
 }
 
+function foundationEnvelopeFromError(error) {
+  return error?.foundationEnvelope ?? null;
+}
+
+function foundationStdoutFromError(error) {
+  return error?.foundationStdout ?? null;
+}
+
+function isCodeBuddyResidualEnvelope(error) {
+  const envelope = foundationEnvelopeFromError(error);
+  const evidence = envelope?.evidence;
+  const signals = evidence?.signalSequence;
+  const signal = signals?.[0];
+  return envelope?.ok === false
+    && envelope.exitStatus === 124
+    && envelope.processStatus === 'TERMINATED'
+    && envelope.terminationReason === 'child_exit'
+    && envelope.watchdogReason === 'residual_process_group'
+    && evidence?.childExitCode === 0
+    && (evidence.childSignal === null || evidence.childSignal === undefined)
+    && evidence.residualGroupCleanupCompleted === true
+    && evidence.forcedKill === false
+    && evidence.outputLimitExceeded === null
+    && Array.isArray(signals)
+    && signals.length === 1
+    && signal?.signal === 'SIGTERM'
+    && signal.requestedMode === 'process_group'
+    && signal.successfulMode === 'process_group';
+}
+
+function isCodeBuddyReadCommand(target, command, args) {
+  return target.host === 'codebuddy'
+    && (command === 'codebuddy' || command === 'cbc' || command === CODEBUDDY_MACOS_PATH)
+    && Array.isArray(args)
+    && (
+      args.every((value, index) => value === CODEBUDDY_PLUGIN_LIST_ARGS[index])
+      && args.length === CODEBUDDY_PLUGIN_LIST_ARGS.length
+      || args.every((value, index) => value === CODEBUDDY_MARKETPLACE_LIST_ARGS[index])
+      && args.length === CODEBUDDY_MARKETPLACE_LIST_ARGS.length
+    );
+}
+
+function isCodeBuddyWriteCommand(target, command, args, kind) {
+  if (target.host !== 'codebuddy' || !['codebuddy', 'cbc', CODEBUDDY_MACOS_PATH].includes(command)) return false;
+  const expected = kind === 'marketplace-update'
+    ? ['plugin', 'marketplace', 'update', target.marketplace]
+    : ['plugin', 'update', `${target.plugin}@${target.marketplace}`, '--scope', 'user'];
+  return Array.isArray(args) && args.length === expected.length && args.every((value, index) => value === expected[index]);
+}
+
+async function runCodeBuddyRead(target, command, args, label, env, run) {
+  try {
+    return { output: await run(command, [...args], { env }), recovered: false };
+  } catch (error) {
+    if (!isCodeBuddyReadCommand(target, command, args) || !isCodeBuddyResidualEnvelope(error)) throw error;
+    const residualStdout = foundationStdoutFromError(error);
+    if (typeof residualStdout !== 'string') throw error;
+    parseJson(residualStdout, label);
+    return {
+      output: { stdout: residualStdout, stderr: '' },
+      recovered: true,
+    };
+  }
+}
+
+function exactCodeBuddyMarketplaceObservation(target, stdout) {
+  const parsed = parseJson(stdout, `${target.host} marketplace list`);
+  if (!Array.isArray(parsed)) throw new Error(`${target.host} marketplace list did not return an array`);
+  const matches = parsed.filter((entry) => entry?.name === target.marketplace);
+  if (matches.length !== 1) {
+    throw new Error(`${target.host} marketplace list did not contain exactly one ${target.marketplace}`);
+  }
+  if (matches[0].type !== 'git') {
+    throw new Error(`${target.host} marketplace ${target.marketplace} is not a git marketplace`);
+  }
+  return { installed: true, exact: true, found: matches[0] };
+}
+
+async function observeCodeBuddyMarketplaceAfterResidual(target, command, env, run) {
+  const observed = await runCodeBuddyRead(
+    target,
+    command,
+    CODEBUDDY_MARKETPLACE_LIST_ARGS,
+    `${target.host} marketplace list`,
+    env,
+    run,
+  );
+  return exactCodeBuddyMarketplaceObservation(target, observed.output.stdout);
+}
+
 function exactPluginObservation(target, stdout) {
   const selector = `${target.plugin}@${target.marketplace}`;
   const parsed = parseJson(stdout, `${target.host} plugin list`);
@@ -433,7 +727,10 @@ async function runStructuredUpdate(target, detected, run, {
 }) {
   if (target.host === 'codebuddy' || target.host === 'workbuddy') {
     const env = hostEnvironment(target.host);
-    const listed = await run(detected.command, ['plugin', 'list', '--json'], { env });
+    const listedObservation = target.host === 'codebuddy'
+      ? await runCodeBuddyRead(target, detected.command, CODEBUDDY_PLUGIN_LIST_ARGS, `${target.host} plugin list`, env, run)
+      : { output: await run(detected.command, [...CODEBUDDY_PLUGIN_LIST_ARGS], { env }), recovered: false };
+    const listed = listedObservation.output;
     const observed = exactPluginObservation(target, listed.stdout);
     if (
       target.sourceForm !== 'bundled-family'
@@ -445,7 +742,13 @@ async function runStructuredUpdate(target, detected, run, {
         reason: `${target.host} source identity is not eligible for a frozen bundled-family update`,
       };
     }
-    if (observed.exact) return { status: 'ALREADY_CURRENT', version: target.version };
+    if (observed.exact) {
+      return {
+        status: 'ALREADY_CURRENT',
+        version: target.version,
+        ...(listedObservation.recovered ? { residualRecovery: true } : {}),
+      };
+    }
     if (!observed.installed) {
       return {
         status: 'MANUAL_REQUIRED',
@@ -471,14 +774,51 @@ async function runStructuredUpdate(target, detected, run, {
         reason: `${target.host} frozen tag and mutable ref do not both resolve to ${target.pluginCommit}`,
       };
     }
-    await run(detected.command, ['plugin', 'marketplace', 'update', target.marketplace], { env });
-    await run(detected.command, [
-      'plugin', 'update', `${target.plugin}@${target.marketplace}`, '--scope', 'user',
-    ], { env });
-    const afterList = await run(detected.command, ['plugin', 'list', '--json'], { env });
-    const after = exactPluginObservation(target, afterList.stdout);
+    let marketplaceRecovered = false;
+    try {
+      await run(detected.command, ['plugin', 'marketplace', 'update', target.marketplace], { env });
+    } catch (error) {
+      if (!isCodeBuddyWriteCommand(target, detected.command, ['plugin', 'marketplace', 'update', target.marketplace], 'marketplace-update')
+        || !isCodeBuddyResidualEnvelope(error)) throw error;
+      await observeCodeBuddyMarketplaceAfterResidual(target, detected.command, env, run);
+      marketplaceRecovered = true;
+    }
+    let after;
+    let pluginRecovered = false;
+    try {
+      await run(detected.command, [
+        'plugin', 'update', `${target.plugin}@${target.marketplace}`, '--scope', 'user',
+      ], { env });
+    } catch (error) {
+      if (!isCodeBuddyWriteCommand(target, detected.command, [
+        'plugin', 'update', `${target.plugin}@${target.marketplace}`, '--scope', 'user',
+      ], 'plugin-update') || !isCodeBuddyResidualEnvelope(error)) throw error;
+      const afterList = await runCodeBuddyRead(
+        target,
+        detected.command,
+        CODEBUDDY_PLUGIN_LIST_ARGS,
+        `${target.host} plugin list`,
+        env,
+        run,
+      );
+      after = exactPluginObservation(target, afterList.output.stdout);
+      pluginRecovered = true;
+    }
+    if (!pluginRecovered) {
+      const afterList = target.host === 'codebuddy'
+        ? await runCodeBuddyRead(target, detected.command, CODEBUDDY_PLUGIN_LIST_ARGS, `${target.host} plugin list`, env, run)
+        : { output: await run(detected.command, [...CODEBUDDY_PLUGIN_LIST_ARGS], { env }), recovered: false };
+      after = exactPluginObservation(target, afterList.output.stdout);
+    }
     if (!after.exact) throw new Error(`${target.host} did not update to the frozen plugin identity`);
-    return { status: 'UPDATED', version: target.version, restartRequired: true };
+    return {
+      status: 'UPDATED',
+      version: target.version,
+      restartRequired: true,
+      ...(marketplaceRecovered || listedObservation.recovered || pluginRecovered
+        ? { residualRecovery: true }
+        : {}),
+    };
   }
 
   const command = detected.command;
@@ -566,9 +906,9 @@ expect {
       timeout { exit 95 }
       eof { exit 96 }
     }
-    expect -re {> $}
+    expect -re $promptPattern
   }
-  -re {> $} {}
+  -re $promptPattern {}
   timeout { exit 93 }
   eof { exit 94 }
 }
@@ -581,8 +921,9 @@ foreach variable {RELEASE_SKILL_KIMI_COMMAND RELEASE_SKILL_KIMI_INSTALL_URL RELE
 set kimiCommand $env(RELEASE_SKILL_KIMI_COMMAND)
 set installUrl $env(RELEASE_SKILL_KIMI_INSTALL_URL)
 set removePlugin $env(RELEASE_SKILL_KIMI_REMOVE_PLUGIN)
+set promptPattern {(?:(?:^|\\r|\\n)> |(?:^|\\r|\\n)(?:\\033\\[[0-9;?]*[ -/]*[@-~])*│[ \\t]*>[ \\t]*│(?:\\033\\[[0-9;?]*[ -/]*[@-~])*)(?![^\\n]|\\n)}
 spawn $kimiCommand
-expect -re {> $}
+expect -re $promptPattern
 ${removeCommand}send -- "/plugins install $installUrl\\r"
 expect {
   -nocase -re {trust and install} {
@@ -595,9 +936,9 @@ expect {
   timeout { exit 91 }
   eof { exit 92 }
 }
-expect -re {> $}
+expect -re $promptPattern
 send -- "/reload\\r"
-expect -re {> $}
+expect -re $promptPattern
 send -- "/exit\\r"
 expect eof
 `;
@@ -730,6 +1071,12 @@ function aggregateStatus(results) {
 
 function failedHostResult(target, error) {
   const message = error?.message ?? String(error);
+  const details = error?.details;
+  const publicDetails = details && typeof details === 'object' && !Array.isArray(details)
+    ? Object.fromEntries(Object.entries(details).filter(([key]) => (
+      key !== 'foundationEnvelope' && key !== 'foundationStdout' && key !== 'foundationStderr'
+    )))
+    : details;
   return {
     host: target.host,
     unitId: target.unitId,
@@ -737,11 +1084,11 @@ function failedHostResult(target, error) {
     error: message,
     reason: typeof error?.reason === 'string' ? error.reason : message,
     ...(error?.code !== undefined ? { code: error.code } : {}),
-    ...(error?.details !== undefined ? { details: error.details } : {}),
+    ...(publicDetails !== undefined ? { details: publicDetails } : {}),
   };
 }
 
-export async function updateLocalHostPlugins({
+async function updateLocalHostPluginsInternal({
   plan,
   root = process.cwd(),
   confirmPlanDigest,
@@ -752,7 +1099,7 @@ export async function updateLocalHostPlugins({
   verifyInstalledPayload = verifyInstalledMarketplacePayload,
 } = {}) {
   const effectiveKimiHome = kimiHome ?? process.env.KIMI_CONFIG_DIR ?? join(homedir(), '.kimi-code');
-  const checklist = derivePostReleaseChecklist(plan);
+  const checklist = derivePostReleaseChecklist(plan, { postVerifyComplete: true });
   if (confirmPlanDigest !== plan.digest) {
     throw new Error('plan digest confirmation does not match the frozen release plan');
   }
@@ -770,7 +1117,7 @@ export async function updateLocalHostPlugins({
         results.push({
           host: target.host,
           unitId: target.unitId,
-          status: 'SKIPPED_NOT_INSTALLED',
+          status: detected?.status ?? 'SKIPPED_NOT_INSTALLED',
           reason: detected?.reason ?? 'host unavailable',
         });
         continue;