arkgate 3.6.1 → 3.8.0

package/bin/lib/parse-health.mjs

@@ -0,0 +1,75 @@
+/**
+ * Y03/Z02 — parse honesty over the ASTs already created by architecture-scan.
+ * Counts are transported without raw TypeScript diagnostics; Z02 maps affected
+ * governed files to a partial analysis verdict.
+ */
+
+export const PARSE_HEALTH_FILE_CAP = 12;
+
+function unavailableParseHealth(scannedFiles = 0) {
+  return {
+    advisory: true,
+    available: false,
+    status: 'unavailable',
+    scannedFiles,
+    affectedFiles: 0,
+    diagnosticCount: 0,
+    files: [],
+    truncated: 0,
+    overflow: false,
+  };
+}
+
+/** Aggregate cached/per-file parse counts into a deterministic doctor surface. */
+export function summarizeParseHealth(scanned) {
+  if (!Array.isArray(scanned)) return unavailableParseHealth();
+  const rows = scanned
+    .map(({ relFile, entry }) => ({
+      file: relFile,
+      diagnosticCount: entry?.parseDiagnosticCount,
+    }));
+  if (rows.some(({ file, diagnosticCount }) =>
+    typeof file !== 'string' || file.length === 0 ||
+    !Number.isSafeInteger(diagnosticCount) || diagnosticCount < 0
+  )) return unavailableParseHealth(rows.length);
+  const affected = rows
+    .filter(({ diagnosticCount }) => diagnosticCount > 0)
+    .sort((a, b) => (a.file < b.file ? -1 : a.file > b.file ? 1 : 0));
+  let diagnosticCount = 0;
+  for (const row of affected) {
+    if (!Number.isSafeInteger(diagnosticCount + row.diagnosticCount)) {
+      return unavailableParseHealth(rows.length);
+    }
+    diagnosticCount += row.diagnosticCount;
+  }
+  const truncated = Math.max(0, affected.length - PARSE_HEALTH_FILE_CAP);
+  return {
+    advisory: true,
+    available: true,
+    status: affected.length > 0 ? 'parse-diagnostics' : 'ok',
+    scannedFiles: rows.length,
+    affectedFiles: affected.length,
+    diagnosticCount,
+    files: affected.slice(0, PARSE_HEALTH_FILE_CAP),
+    truncated,
+    overflow: truncated > 0,
+  };
+}
+
+/** Human doctor detail; clean parse health stays quiet. */
+export function printParseHealthSection(health, io) {
+  if (!health || health.affectedFiles === 0) return;
+  console.log('');
+  console.log(io.color.bold('Parse health (analysis completeness)'));
+  io.line(
+    io.warn,
+    `${health.affectedFiles} governed file(s) carry ${health.diagnosticCount} parse diagnostic(s) across ${health.scannedFiles} scanned file(s).`
+  );
+  for (const finding of health.files ?? []) {
+    io.line(io.warn, `${finding.file} — ${finding.diagnosticCount} parse diagnostic(s)`);
+  }
+  if (health.truncated > 0) {
+    io.line(' ', io.color.dim(`…(+${health.truncated} more affected file(s); list capped)`));
+  }
+  io.line(' ', io.color.dim('analysis incomplete — plan cannot be satisfied and strict merge fails closed'));
+}

package/bin/lib/port-proof.mjs

@@ -26,14 +26,14 @@ import path from 'node:path';
 /**
  * @param {object} ts typescript module
  * @param {string} source
- * @param {{ filePath?: string, importLocalName?: string, importSpecifier?: string }} [opts]
+ * @param {{ filePath?: string, importLocalName?: string, importSpecifier?: string, sourceFile?: object }} [opts]
  * @returns {{ eligible: boolean, reason?: string, bindingName?: string, methods?: string[], functionNames?: string[], specifier?: string }}
  */
 export function provePortProofInject(ts, source, opts = {}) {
   if (!ts || typeof source !== 'string') {
     return { eligible: false, reason: 'missing-ts-or-source' };
   }
-  const sf = ts.createSourceFile(
+  const sf = opts.sourceFile ?? ts.createSourceFile(
     opts.filePath || 'file.ts',
     source,
     ts.ScriptTarget.Latest,

package/bin/lib/prepare-change.mjs

@@ -1,9 +1,18 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { loadArchitectureChangeMap, loadContract, preflightChange } from './analysis-engine.mjs';
+import {
+  loadArchitectureChangeMap,
+  loadContract,
+  preflightResolvedChange,
+} from './analysis-engine.mjs';
 import { createAdapterResult } from './adapter-contract.mjs';
-import { collectGovernedFiles, isGovernableSourceFile, normalize } from './scan-files.mjs';
-import { isScanExcludedRelative, layerForRelativePath } from '../ark-shared.mjs';
+import { isGovernableSourceFile } from './scan-files.mjs';
+import {
+  canonicalizeCandidateChanges,
+  resolveCandidateFacts,
+} from './resolved-candidate-facts.mjs';
+import { effectiveAnalysisConfig } from './analysis-policy.mjs';
+import { isScanExcludedRelative } from '../ark-shared.mjs';
 
 function candidatePath(value) {
   if (typeof value !== 'string' || value.trim() === '') {
@@ -27,16 +36,21 @@ function isIncluded(relativePath, include) {
   });
 }
 
+export function isCandidateSourceInScope(config, relativePath) {
+  return (
+    isGovernableSourceFile(path.basename(relativePath)) &&
+    isIncluded(relativePath, config.include) &&
+    !isScanExcludedRelative(relativePath, config)
+  );
+}
+
 function assertGovernedSource(config, relativePath) {
   if (!isGovernableSourceFile(path.basename(relativePath))) {
     throw new Error(`Atomic preflight only accepts governed production source files: ${relativePath}`);
   }
-  if (!isIncluded(relativePath, config.include) || isScanExcludedRelative(relativePath, config)) {
+  if (!isCandidateSourceInScope(config, relativePath)) {
     throw new Error(`Change path is outside the configured source scope: ${relativePath}`);
   }
-  if (!layerForRelativePath(relativePath, config.layers)) {
-    throw new Error(`Change path is not assigned to an architecture layer: ${relativePath}`);
-  }
 }
 
 function assertInsideProject(root, relativePath) {
@@ -73,22 +87,6 @@ export function normalizeChangeSet(input) {
   });
 }
 
-function baseFilesForChange(root, config, changes) {
-  const byPath = new Map(
-    collectGovernedFiles(root, config).map((absolute) => [
-      normalize(path.relative(root, absolute)),
-      { path: normalize(path.relative(root, absolute)), content: fs.readFileSync(absolute, 'utf8') },
-    ])
-  );
-  for (const change of changes) {
-    if (byPath.has(change.path) || !isGovernableSourceFile(path.basename(change.path))) continue;
-    const absolute = path.join(root, change.path);
-    if (!fs.existsSync(absolute) || !fs.statSync(absolute).isFile()) continue;
-    byPath.set(change.path, { path: change.path, content: fs.readFileSync(absolute, 'utf8') });
-  }
-  return [...byPath.values()].sort((left, right) => left.path.localeCompare(right.path));
-}
-
 export function prepareChangeFromRoot({
   root,
   config,
@@ -96,33 +94,65 @@ export function prepareChangeFromRoot({
   changes,
   changeMap,
   changeMapSource,
-  compilerOptions,
+  ts,
+  tsconfig,
+  manifest,
+  overlayChanges,
 }) {
   const normalizedChanges = normalizeChangeSet(changes);
+  const normalizedOverlayChanges =
+    overlayChanges === undefined ? normalizedChanges : normalizeChangeSet(overlayChanges);
+  const effectiveConfig = effectiveAnalysisConfig(config, manifest);
   for (const change of normalizedChanges) {
     assertInsideProject(root, change.path);
-    assertGovernedSource(config, change.path);
   }
-  const contract = loadContract(config, configSource ?? path.join(root, 'ark.config.json'));
+  const contract = loadContract(
+    effectiveConfig,
+    configSource ?? path.join(root, 'ark.config.json')
+  );
   const loadedChangeMap =
     changeMap === undefined
       ? undefined
       : loadArchitectureChangeMap(changeMap, contract.config, changeMapSource);
-  const result = preflightChange({
-    contract,
-    files: baseFilesForChange(root, config, normalizedChanges),
+  const canonicalChanges = canonicalizeCandidateChanges({
+    root,
+    config: contract.config,
     changes: normalizedChanges,
+  });
+  for (const change of canonicalChanges) assertGovernedSource(effectiveConfig, change.path);
+  const baseFacts = resolveCandidateFacts({
+    root,
+    config: contract.config,
+    ts,
+    ...(tsconfig ? { tsconfig } : {}),
+  });
+  const candidateFacts = resolveCandidateFacts({
+    root,
+    config: contract.config,
+    ts,
+    changes: normalizedOverlayChanges,
+    ...(tsconfig ? { tsconfig } : {}),
+  });
+  const result = preflightResolvedChange({
+    contract,
+    baseFacts,
+    candidateFacts,
+    changes: canonicalChanges,
     ...(loadedChangeMap ? { changeMap: loadedChangeMap } : {}),
-    ...(compilerOptions ? { compilerOptions } : {}),
   });
-  return {
-    ...createAdapterResult({
-      valid: result.valid,
-      violations: result.violations,
-      warnings: result.warnings,
-    }),
-    ...result,
-  };
+  const completeness =
+    result.baseCompleteness === 'unavailable' || result.candidateCompleteness === 'unavailable'
+      ? 'unavailable'
+      : result.baseCompleteness === 'partial' || result.candidateCompleteness === 'partial'
+        ? 'partial'
+        : 'complete';
+  const { diagnostics } = createAdapterResult({
+    valid: result.valid,
+    completeness,
+    violations: result.violations,
+    warnings: result.warnings,
+  });
+  return { ...result, diagnostics };
 }
 
 export function renderChangePreflight(result) {

package/bin/lib/prepare-write.mjs

@@ -73,7 +73,7 @@ export function buildJudgmentBrief(violations) {
  *   placement: object,
  *   root: string,
  *   ts: object,
- *   validate: (source: string) => { valid: boolean, violations?: any[] },
+ *   validate: (source: string) => { valid: boolean, completeness?: string, violations?: any[] },
  *   resolveTargetAbs?: Function,
  * }} opts
  */
@@ -117,7 +117,13 @@ export function composePrepareWrite(opts) {
     ...(placement?.description ? { description: placement.description } : {}),
     // Q03: pass through golden pattern from ark_place (advisory; absent is normal).
     ...(placement?.goldenPattern ? { goldenPattern: placement.goldenPattern } : {}),
+    mode: gate.mode,
     valid: gate.valid,
+    lexicalValid: gate.lexicalValid,
+    ...(gate.completeness ? { completeness: gate.completeness } : {}),
+    ...(Array.isArray(gate.completenessReasons)
+      ? { completenessReasons: gate.completenessReasons }
+      : {}),
     violations: gate.violations,
     ...(gate.autoPatch ? { autoPatch: gate.autoPatch } : {}),
     ...(judgment ? { judgmentBrief: judgment } : {}),

package/bin/lib/reshape-decisions.mjs

@@ -0,0 +1,284 @@
+/**
+ * Y01 — explicit verdict memory for X04 reshape pilots.
+ *
+ * Decisions bind to a concept plus its complete, sorted anchor set. Counts,
+ * move samples, and change-map hashes are deliberately excluded: evidence may
+ * drift without overturning an adopter's verdict, while a changed physical
+ * layout makes the old record stale. Advisory only; mirror facts stay intact.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { classifyPhysical, computeReshapePilot } from './physical-cohesion.mjs';
+
+export const RESHAPE_DECISIONS_PATH = '.ark/reshape-decisions.json';
+
+const MAX_DECISION_BYTES = 64 * 1024;
+const MAX_DECISIONS = 200;
+const MAX_LIFECYCLE_ITEMS = 12;
+const MAX_ANCHOR_EVIDENCE = 20;
+const VERDICTS = new Set(['accepted', 'deferred', 'rejected']);
+
+function normalizeAnchor(raw) {
+  const portable = String(raw).trim().replace(/\\/g, '/');
+  if (portable === '.') return '.';
+  if (!portable || portable.startsWith('/') || /^[A-Za-z]:\//.test(portable) || portable.includes('\0')) {
+    return null;
+  }
+  const segments = portable.split('/');
+  if (segments.some((segment) => !segment || segment === '.' || segment === '..')) return null;
+  return segments.join('/');
+}
+
+function targetKey(concept, anchors) {
+  return JSON.stringify([concept, anchors]);
+}
+
+function compareText(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+
+function sameStrings(left, right) {
+  return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+
+function lifecycleStatus(decision, today) {
+  const reviewBy = decision.reviewBy;
+  if (reviewBy === undefined) return 'undated';
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(reviewBy)) return 'malformed';
+  const date = new Date(`${reviewBy}T00:00:00.000Z`);
+  if (Number.isNaN(date.getTime()) || date.toISOString().slice(0, 10) !== reviewBy) {
+    return 'malformed';
+  }
+  return typeof today === 'string' && reviewBy < today ? 'expired' : 'current';
+}
+
+/** Bounded, fail-loud loader. A broken file never suppresses a pilot. */
+export function loadReshapeDecisions(root) {
+  const relPath = RESHAPE_DECISIONS_PATH;
+  const abs = path.join(root, relPath);
+  let stats;
+  try {
+    stats = fs.statSync(abs);
+  } catch {
+    return { path: relPath, exists: false, decisions: [] };
+  }
+  const invalid = (error) => ({ path: relPath, exists: true, invalid: true, error, decisions: [] });
+  if (!stats.isFile()) return invalid('not a regular file');
+  if (stats.size > MAX_DECISION_BYTES) {
+    return invalid(`larger than ${MAX_DECISION_BYTES} bytes`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(fs.readFileSync(abs, 'utf8'));
+  } catch (error) {
+    return invalid(error instanceof Error ? error.message : 'unreadable JSON');
+  }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    return invalid('expected an object with decisions[]');
+  }
+  const unknownTop = Object.keys(parsed).filter((key) => !['schemaVersion', 'decisions'].includes(key));
+  if (unknownTop.length > 0) return invalid(`unknown field: ${unknownTop[0]}`);
+  if (parsed.schemaVersion !== undefined && parsed.schemaVersion !== '1') {
+    return invalid('schemaVersion must be "1" when present');
+  }
+  if (!Array.isArray(parsed.decisions)) return invalid('expected { decisions: [...] }');
+  if (parsed.decisions.length > MAX_DECISIONS) {
+    return invalid(`more than ${MAX_DECISIONS} entries`);
+  }
+
+  const decisions = [];
+  const seen = new Set();
+  for (const entry of parsed.decisions) {
+    if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+      return invalid('every decision must be an object');
+    }
+    const unknown = Object.keys(entry).filter((key) =>
+      !['concept', 'anchors', 'verdict', 'reason', 'reviewBy'].includes(key)
+    );
+    if (unknown.length > 0) return invalid(`decision has unknown field: ${unknown[0]}`);
+    const concept = typeof entry.concept === 'string' ? entry.concept.trim() : '';
+    const reason = typeof entry.reason === 'string' ? entry.reason.trim() : '';
+    if (!concept || !reason || !VERDICTS.has(entry.verdict)) {
+      return invalid('every decision needs concept, verdict (accepted/deferred/rejected), and reason');
+    }
+    if (entry.reviewBy !== undefined && typeof entry.reviewBy !== 'string') {
+      return invalid('reviewBy must be a string when present');
+    }
+    if (!Array.isArray(entry.anchors) || entry.anchors.length === 0) {
+      return invalid('every decision needs a non-empty anchors array');
+    }
+    if (entry.anchors.some((anchor) => typeof anchor !== 'string')) {
+      return invalid('every decision anchor must be a string');
+    }
+    const anchors = entry.anchors.map(normalizeAnchor);
+    if (anchors.some((anchor) => anchor === null)) {
+      return invalid('anchors must be canonical project-relative paths');
+    }
+    anchors.sort();
+    if (new Set(anchors).size !== anchors.length) return invalid('decision anchors must be unique');
+    const key = targetKey(concept, anchors);
+    if (seen.has(key)) return invalid('duplicate decision target');
+    seen.add(key);
+    decisions.push({
+      concept,
+      anchors,
+      verdict: entry.verdict,
+      reason,
+      ...(entry.reviewBy !== undefined ? { reviewBy: entry.reviewBy } : {}),
+    });
+  }
+  decisions.sort(
+    (left, right) =>
+      compareText(left.concept, right.concept) ||
+      compareText(targetKey(left.concept, left.anchors), targetKey(right.concept, right.anchors))
+  );
+  return { path: relPath, exists: true, decisions };
+}
+
+function anchorsByConcept(root, files) {
+  const result = new Map();
+  const resolvedRoot = path.resolve(root);
+  for (const file of Array.isArray(files) ? files : []) {
+    const abs = path.isAbsolute(file) ? path.resolve(file) : path.resolve(root, file);
+    const rel = path.relative(resolvedRoot, abs);
+    if (rel.startsWith('..') || path.isAbsolute(rel)) continue;
+    const classified = classifyPhysical(rel);
+    if (!classified) continue;
+    if (!result.has(classified.concept)) result.set(classified.concept, new Set());
+    result.get(classified.concept).add(classified.anchor);
+  }
+  return new Map([...result].map(([concept, anchors]) => [concept, [...anchors].sort()]));
+}
+
+/** Pure lifecycle/staleness resolution; callers inject `today` in tests. */
+export function analyzeReshapeDecisions(
+  root,
+  files,
+  state = { path: RESHAPE_DECISIONS_PATH, exists: false, decisions: [] },
+  today = null
+) {
+  const anchorSets = anchorsByConcept(root, files);
+  const current = [];
+  const expired = [];
+  const malformed = [];
+  const stale = [];
+  for (const decision of state.invalid ? [] : state.decisions ?? []) {
+    const currentAnchors = anchorSets.get(decision.concept) ?? [];
+    if (!sameStrings(decision.anchors, currentAnchors)) {
+      stale.push({
+        ...decision,
+        currentAnchorCount: currentAnchors.length,
+        currentAnchors: currentAnchors.slice(0, MAX_ANCHOR_EVIDENCE),
+      });
+      continue;
+    }
+    const status = lifecycleStatus(decision, today);
+    if (status === 'expired') expired.push(decision);
+    else if (status === 'malformed') malformed.push(decision);
+    else {
+      current.push({
+        ...decision,
+        lifecycle: status,
+        suppressesPilot: decision.verdict === 'deferred' || decision.verdict === 'rejected',
+      });
+    }
+  }
+  const summary = {
+    advisory: true,
+    explicitOnly: true,
+    neverChangesFacts: true,
+    decisionFile: {
+      path: state.path ?? RESHAPE_DECISIONS_PATH,
+      present: state.exists === true,
+      invalid: state.invalid === true,
+      ...(state.invalid ? { error: state.error ?? 'invalid' } : {}),
+    },
+    currentCount: current.length,
+    current: current.slice(0, MAX_LIFECYCLE_ITEMS),
+    lifecycle: {
+      undated: current.filter((decision) => decision.lifecycle === 'undated').length,
+      malformedCount: malformed.length,
+      malformed: malformed.slice(0, MAX_LIFECYCLE_ITEMS),
+      expiredCount: expired.length,
+      expired: expired.slice(0, MAX_LIFECYCLE_ITEMS),
+      staleCount: stale.length,
+      stale: stale.slice(0, MAX_LIFECYCLE_ITEMS),
+    },
+  };
+  return { summary, current, anchorSets };
+}
+
+/** Filesystem/clock wrapper for doctor and report callers. */
+export function computeReshapeDecisionMemory(root, files, today = new Date().toISOString().slice(0, 10)) {
+  return analyzeReshapeDecisions(root, files, loadReshapeDecisions(root), today);
+}
+
+/** Select one actionable finding while respecting explicit current verdicts. */
+export function computeDecisionAwareReshapePilot(cohesion, files, root, analysis) {
+  const findings = Array.isArray(cohesion?.findings) ? cohesion.findings : [];
+  if (findings.length === 0) return null;
+  const currentByTarget = new Map(
+    analysis.current.map((decision) => [targetKey(decision.concept, decision.anchors), decision])
+  );
+  for (const finding of findings) {
+    const anchors = analysis.anchorSets.get(finding.concept) ?? [];
+    const decision = currentByTarget.get(targetKey(finding.concept, anchors));
+    if (decision?.suppressesPilot) continue;
+    const pilot = computeReshapePilot({ ...cohesion, findings: [finding] }, files, root);
+    if (!pilot?.nextPilot) return pilot;
+    return {
+      ...pilot,
+      ...(decision ? { decision } : {}),
+      nextPilot: {
+        ...pilot.nextPilot,
+        decisionTarget: { concept: finding.concept, anchors },
+        decisionFile: RESHAPE_DECISIONS_PATH,
+      },
+    };
+  }
+  return {
+    proposed: false,
+    applied: false,
+    neverMechanicalSafe: true,
+    nextPilot: null,
+    suppressedByDecision: true,
+    note: 'Every displayed reshape target has an explicit current rejected/deferred decision; mirror facts remain visible.',
+  };
+}
+
+/** Human doctor section; lifecycle stays visible even after the sensor quiets. */
+export function printReshapeDecisionsSection(memory, io) {
+  const lifecycle = memory?.lifecycle;
+  const hasContent =
+    memory?.decisionFile?.invalid ||
+    memory?.currentCount > 0 ||
+    lifecycle?.expiredCount > 0 ||
+    lifecycle?.malformedCount > 0 ||
+    lifecycle?.staleCount > 0;
+  if (!hasContent) return;
+  console.log('');
+  console.log(io.color.bold('Reshape decisions (advisory)'));
+  if (memory.decisionFile.invalid) {
+    io.line(io.warn, `${memory.decisionFile.path} is present but invalid — decisions are ignored.`);
+  }
+  for (const decision of memory.current.slice(0, 5)) {
+    const review = decision.reviewBy ? ` · review-by ${decision.reviewBy}` : '';
+    io.line(' ', `[${decision.concept}] ${decision.verdict}${review} — ${decision.reason}`);
+  }
+  if (memory.currentCount > memory.current.slice(0, 5).length) {
+    io.line(' ', io.color.dim(`…(+${memory.currentCount - 5} more current decision(s))`));
+  }
+  if (lifecycle.expiredCount > 0) {
+    io.line(io.warn, `${lifecycle.expiredCount} reshape decision(s) expired — pilot pressure is active again.`);
+  }
+  if (lifecycle.malformedCount > 0) {
+    io.line(io.warn, `${lifecycle.malformedCount} reshape decision(s) have malformed review-by dates — ignored.`);
+  }
+  if (lifecycle.staleCount > 0) {
+    io.line(io.warn, `${lifecycle.staleCount} reshape decision(s) have a changed anchor set — stale; update or delete them.`);
+  }
+  if (lifecycle.undated > 0) {
+    io.line(' ', io.color.dim(`${lifecycle.undated} current decision(s) have no review-by date.`));
+  }
+  io.line(' ', io.color.dim('explicit verdicts affect pilot pressure only; physical facts and the gate verdict are unchanged'));
+}

package/bin/lib/resident-doctor-client.mjs

@@ -0,0 +1,55 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import {
+  RESIDENT_HOOK_PROTOCOL_VERSION,
+  requestResidentHook,
+  residentDoctorEnvironment,
+  residentHookEndpoint,
+} from './resident-hook.mjs';
+
+const arkMcpLauncher = fileURLToPath(new URL('../ark-mcp.mjs', import.meta.url));
+
+/** Try the opt-in resident doctor and let the caller continue through the cold fallback. */
+export async function tryResidentDoctor(args) {
+  if (!args.resident) return false;
+  if (!args.doctor || !args.json) throw new Error('--resident requires --doctor --json.');
+  const endpoint = residentHookEndpoint({
+    root: args.root,
+    config: args.config,
+    manifest: args.manifest,
+    tsconfig: args.tsconfig,
+    launcher: arkMcpLauncher,
+  });
+  const configuredTimeout = Number(process.env.ARK_RESIDENT_DOCTOR_TIMEOUT_MS);
+  const response = await requestResidentHook({
+    socket: endpoint.socket,
+    timeoutMs:
+      Number.isFinite(configuredTimeout) && configuredTimeout > 0 ? configuredTimeout : 500,
+    request: {
+      protocolVersion: RESIDENT_HOOK_PROTOCOL_VERSION,
+      kind: 'doctor',
+      root: path.resolve(args.root),
+      config: args.config,
+      manifest: args.manifest ?? null,
+      tsconfig: args.tsconfig ?? null,
+      environment: residentDoctorEnvironment(),
+    },
+  });
+  if (
+    !response ||
+    response.fallback === true ||
+    !Number.isInteger(response.status) ||
+    typeof response.stdout !== 'string' ||
+    typeof response.stderr !== 'string'
+  ) {
+    if (process.env.ARK_RESIDENT_DOCTOR_REQUIRED === '1') {
+      throw new Error('Resident doctor was required but unavailable.');
+    }
+    return false;
+  }
+  if (response.stdout) process.stdout.write(response.stdout);
+  if (response.stderr) process.stderr.write(response.stderr);
+  process.exitCode = response.status;
+  return true;
+}