@dadado/agent-kit-cli 5.15.1 → 5.17.0

package/dist/chunk-STGFBAYT.js

@@ -0,0 +1,641 @@
+import {
+  CLAUDE_COMMANDS_DIR_REL,
+  CLAUDE_SETTINGS_REL,
+  GUARD_SHELL_HOOK_MARKER,
+  RESOLVE_AGENT_KIT_REL,
+  SESSION_START_HOOK_MARKER,
+  discoverInstalledCommands
+} from "./chunk-W24CMQ32.js";
+import {
+  createReadinessReport
+} from "./chunk-PNFF6OU3.js";
+import {
+  KIT_OWNED_IGNORE_PATTERNS,
+  REPOSITORY_PROFILE_REL,
+  REQUIRED_SECRET_PATTERNS,
+  detectGitDirty,
+  runScanner
+} from "./chunk-ZCTSUQRR.js";
+import {
+  CONTEXT_CONFIG_REL,
+  contextConfigPath
+} from "./chunk-NQ7IQ5XT.js";
+import {
+  ensureDir,
+  fileExists,
+  readJson,
+  writeJson
+} from "./chunk-77V75A7O.js";
+
+// src/invariants/hooks-health.ts
+import { execFile } from "child_process";
+import { constants, access, readFile, readdir, stat } from "fs/promises";
+import path from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var GIT_HOOK_CANONICAL_NAMES = ["pre-commit", "pre-push", "prepare-commit-msg"];
+var EXPECTED_EVENTS = [
+  "sessionStart",
+  "preCompact",
+  "beforeShellExecution",
+  "afterFileEdit",
+  "beforeSubmitPrompt"
+];
+async function exists(p) {
+  try {
+    await access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isExecutable(p) {
+  try {
+    await access(p, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveAgentKitCli(rootDir) {
+  const root = path.resolve(rootDir);
+  const candidates = [
+    path.join(root, "node_modules", ".bin", "agent-kit"),
+    path.join(root, "packages", "cli", "dist", "index.js")
+  ];
+  for (const c of candidates) {
+    if (await exists(c)) return c;
+  }
+  try {
+    const { stdout } = await execFileAsync("which", ["agent-kit"], { encoding: "utf8" });
+    const hit = stdout.trim().split("\n")[0]?.trim();
+    if (hit) return hit;
+  } catch {
+  }
+  return null;
+}
+function commandLooksLikeAdapter(command) {
+  const trimmed = command.trim();
+  if (!trimmed) return null;
+  const m = trimmed.match(/(\.cursor\/hooks\/agent\/[A-Za-z0-9._-]+\.sh)\b/);
+  return m?.[1] ?? null;
+}
+async function assessGitHooksInstallDrift(rootDir) {
+  const root = path.resolve(rootDir);
+  const canonicalDir = path.join(root, "git-hooks");
+  if (!await exists(canonicalDir)) return [];
+  let hooksPathCfg = "";
+  try {
+    const { stdout } = await execFileAsync(
+      "git",
+      ["-C", root, "config", "--get", "core.hooksPath"],
+      { encoding: "utf8" }
+    );
+    hooksPathCfg = stdout.trim();
+  } catch {
+  }
+  if (hooksPathCfg) {
+    const resolved = path.isAbsolute(hooksPathCfg) ? path.normalize(hooksPathCfg) : path.normalize(path.join(root, hooksPathCfg));
+    if (resolved === path.normalize(canonicalDir)) {
+      return [];
+    }
+  }
+  const gitDir = path.join(root, ".git");
+  if (!await exists(gitDir)) return [];
+  try {
+    const st = await stat(gitDir);
+    if (!st.isDirectory()) return [];
+  } catch {
+    return [];
+  }
+  const installedDir = path.join(gitDir, "hooks");
+  const advisories = [];
+  const installHint = "Install or refresh with: `cp git-hooks/<name> .git/hooks/<name> && chmod +x .git/hooks/<name>` (see git-hooks/README.md)";
+  let names = [...GIT_HOOK_CANONICAL_NAMES];
+  try {
+    const listed = await readdir(canonicalDir);
+    const fromDisk = listed.filter(
+      (n) => GIT_HOOK_CANONICAL_NAMES.includes(n)
+    );
+    if (fromDisk.length > 0) names = fromDisk;
+  } catch {
+  }
+  for (const name of names) {
+    const canonical = path.join(canonicalDir, name);
+    const installed = path.join(installedDir, name);
+    if (!await exists(canonical)) continue;
+    if (!await exists(installed)) {
+      advisories.push(
+        `git-hooks drift: \`.git/hooks/${name}\` missing (canonical \`git-hooks/${name}\` present). ${installHint}`
+      );
+      continue;
+    }
+    try {
+      const [a, b] = await Promise.all([readFile(canonical, "utf8"), readFile(installed, "utf8")]);
+      if (a !== b) {
+        advisories.push(
+          `git-hooks drift: \`.git/hooks/${name}\` differs from \`git-hooks/${name}\`. ${installHint}`
+        );
+      }
+    } catch {
+      advisories.push(
+        `git-hooks drift: could not compare \`git-hooks/${name}\` with \`.git/hooks/${name}\`. ${installHint}`
+      );
+    }
+  }
+  return advisories;
+}
+async function assessSignatureGateHook(rootDir) {
+  const root = path.resolve(rootDir);
+  if (!await exists(path.join(root, "autogit", "gitupdate.md"))) return [];
+  if (await exists(path.join(root, "git-hooks", "prepare-commit-msg"))) return [];
+  return [
+    "signature gate hook missing: `git-hooks/prepare-commit-msg` (/git-staging runs `sh git-hooks/prepare-commit-msg --check -`; a missing file exits 127 and reads as red). Run `agent-kit update` to restore it."
+  ];
+}
+async function assessClaudeCommandAdapters(rootDir) {
+  const root = path.resolve(rootDir);
+  if (!await exists(path.join(root, ".claude"))) return [];
+  const sources = await discoverInstalledCommands(root);
+  if (sources.length === 0) return [];
+  const missing = [];
+  for (const { name } of sources) {
+    if (!await exists(path.join(root, CLAUDE_COMMANDS_DIR_REL, `${name}.md`))) missing.push(name);
+  }
+  if (missing.length === 0) return [];
+  const shown = missing.slice(0, 3).map((n) => `/${n}`);
+  const more = missing.length > shown.length ? `, +${missing.length - shown.length} more` : "";
+  return [
+    `Claude Code command adapters missing: ${missing.length} of ${sources.length} installed kit commands have no \`.claude/commands/<name>.md\` (${shown.join(", ")}${more}), so they are not recognized as slash commands. Run \`agent-kit update --claude\` to generate them (writes only \`.claude/commands/*\`).`
+  ];
+}
+async function resolveGuardProbeArgv(root) {
+  const hookBin = process.env.AGENT_KIT_HOOK_BIN;
+  if (hookBin && await isExecutable(hookBin)) return [hookBin];
+  const local = path.join(root, "node_modules", ".bin", "agent-kit");
+  if (await isExecutable(local)) return [local];
+  const dist = path.join(root, "packages", "cli", "dist", "index.js");
+  if (await exists(dist)) return [process.execPath, dist];
+  try {
+    const { stdout } = await execFileAsync("which", ["agent-kit"], { encoding: "utf8" });
+    const hit = stdout.trim().split("\n")[0]?.trim();
+    if (hit) return [hit];
+  } catch {
+  }
+  return null;
+}
+async function assessClaudeGuardProbe(rootDir) {
+  const root = path.resolve(rootDir);
+  let text;
+  try {
+    text = await readFile(path.join(root, CLAUDE_SETTINGS_REL), "utf8");
+  } catch {
+    return [];
+  }
+  if (!text.includes(GUARD_SHELL_HOOK_MARKER)) {
+    return text.includes(SESSION_START_HOOK_MARKER) ? [
+      "Claude SessionStart hook is installed but the PreToolUse guard hook is absent from `.claude/settings.json`. Run `agent-kit install --claude`."
+    ] : [];
+  }
+  const stale = "Claude guard hook active but resolved CLI is too old or stale dist; update the CLI / rebuild.";
+  const argv = await resolveGuardProbeArgv(root);
+  if (!argv) return [`${stale} (agent-kit CLI not resolvable)`];
+  const [bin, ...lead] = argv;
+  try {
+    const { stdout } = await execFileAsync(
+      bin,
+      [
+        ...lead,
+        "guard",
+        "shell",
+        "--format",
+        "claude",
+        "--command",
+        "git push --force origin main"
+      ],
+      {
+        cwd: root,
+        encoding: "utf8",
+        timeout: 1e4,
+        env: { ...process.env, ALLOW_MAIN_PUSH: "" }
+      }
+    );
+    const decision = JSON.parse(stdout).hookSpecificOutput?.permissionDecision;
+    return decision === "deny" ? [] : [stale];
+  } catch {
+    return [stale];
+  }
+}
+async function assessHooksHealth(rootDir) {
+  const root = path.resolve(rootDir);
+  const hooksJsonPath = ".cursor/hooks.json";
+  const hooksJsonAbs = path.join(root, hooksJsonPath);
+  const reasons = [];
+  const wiredEvents = [];
+  const advisories = [
+    ...await assessGitHooksInstallDrift(root),
+    ...await assessSignatureGateHook(root),
+    ...await assessClaudeGuardProbe(root),
+    ...await assessClaudeCommandAdapters(root)
+  ];
+  if (!await exists(hooksJsonAbs)) {
+    return {
+      status: "missing",
+      reasons: ["`.cursor/hooks.json` not found"],
+      advisories,
+      hooksJsonPath,
+      expectedEvents: [...EXPECTED_EVENTS],
+      wiredEvents
+    };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile(hooksJsonAbs, "utf8"));
+  } catch {
+    return {
+      status: "degraded",
+      reasons: ["`.cursor/hooks.json` is not valid JSON"],
+      advisories,
+      hooksJsonPath,
+      expectedEvents: [...EXPECTED_EVENTS],
+      wiredEvents
+    };
+  }
+  const hooks = parsed.hooks ?? {};
+  const adapterRels = /* @__PURE__ */ new Set();
+  for (const event of EXPECTED_EVENTS) {
+    const list = hooks[event];
+    if (Array.isArray(list) && list.length > 0) {
+      wiredEvents.push(event);
+      for (const entry of list) {
+        if (!entry || typeof entry !== "object") continue;
+        const command = String(entry.command ?? "");
+        if (command.endsWith(".py") || command.includes("python")) {
+          reasons.push(`${event} still points at a Python script (${command})`);
+        }
+        const rel = commandLooksLikeAdapter(command);
+        if (rel) adapterRels.add(rel);
+      }
+    } else {
+      reasons.push(`missing hook event: ${event}`);
+    }
+  }
+  const resolveLib = path.join(root, RESOLVE_AGENT_KIT_REL);
+  if (!await exists(resolveLib)) {
+    reasons.push(`missing \`${RESOLVE_AGENT_KIT_REL}\` (thin adapter resolver)`);
+  } else if (!await isExecutable(resolveLib)) {
+    reasons.push(`\`${RESOLVE_AGENT_KIT_REL}\` is not executable (chmod +x)`);
+  }
+  for (const rel of adapterRels) {
+    const abs = path.join(root, rel);
+    if (!await exists(abs)) {
+      reasons.push(`missing adapter script: \`${rel}\``);
+      continue;
+    }
+    try {
+      const st = await stat(abs);
+      if (!st.isFile()) {
+        reasons.push(`adapter path is not a file: \`${rel}\``);
+        continue;
+      }
+    } catch {
+      reasons.push(`unreadable adapter script: \`${rel}\``);
+      continue;
+    }
+    if (!await isExecutable(abs)) {
+      reasons.push(`adapter not executable: \`${rel}\` (chmod +x)`);
+    }
+  }
+  const cli = await resolveAgentKitCli(root);
+  if (!cli) {
+    reasons.push(
+      "agent-kit CLI not resolvable (node_modules/.bin/agent-kit, packages/cli/dist, or PATH)"
+    );
+  }
+  if (Array.isArray(hooks.stop) && hooks.stop.length > 0) {
+    reasons.push("`stop` hook is registered (forbidden; remove it)");
+  }
+  const status = reasons.length === 0 && wiredEvents.length === EXPECTED_EVENTS.length ? "active" : "degraded";
+  return {
+    status,
+    reasons,
+    advisories,
+    hooksJsonPath,
+    expectedEvents: [...EXPECTED_EVENTS],
+    wiredEvents
+  };
+}
+
+// src/scanner/safe-fixes.ts
+import { readFile as readFile2, writeFile } from "fs/promises";
+import path2 from "path";
+var CONTEXT_CONFIG_REL_POSIX = CONTEXT_CONFIG_REL.replace(/\\/g, "/");
+var ESSENTIAL_DIRECTORIES = [
+  ".cursor",
+  ".cursor/context",
+  ".cursor/context/current",
+  ".cursor/context/backups",
+  ".cursor/plans",
+  ".cursor/memory"
+];
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergeMissing(existing, defaults) {
+  if (!isObject(existing) || !isObject(defaults)) return existing ?? defaults;
+  const merged = { ...existing };
+  for (const [key, value] of Object.entries(defaults)) {
+    merged[key] = key in existing ? mergeMissing(existing[key], value) : value;
+  }
+  return merged;
+}
+function jsonEqual(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+function relativeEvidence(relativePath, detail) {
+  return [`${relativePath}: ${detail}`];
+}
+function createProfile(scan, report, generatedAt) {
+  const git = {
+    mode: scan.git.mode,
+    workflow: scan.git.workflow,
+    remotes: scan.git.remotes,
+    remoteUrl: scan.git.remoteUrl,
+    remoteName: scan.git.remoteName,
+    currentBranch: scan.git.currentBranch,
+    defaultBranch: scan.git.defaultBranch,
+    isDirty: scan.git.isDirty,
+    hasLocalStaging: scan.git.hasLocalStaging,
+    hasRemoteStaging: scan.git.hasRemoteStaging
+  };
+  if (scan.git.providerConfidence === "high") {
+    git.provider = scan.git.provider;
+    git.providerKind = scan.git.providerKind;
+    git.providerConfidence = scan.git.providerConfidence;
+    git.providerEvidence = scan.git.providerEvidence;
+  }
+  return {
+    schemaVersion: 1,
+    contractVersion: 1,
+    purpose: scan.purpose,
+    stack: scan.stack,
+    git,
+    infra: scan.infra,
+    services: scan.services,
+    context: scan.context,
+    detection: {
+      generatedAt,
+      repositoryFingerprint: report.repositoryFingerprint,
+      providerConfidence: scan.git.providerConfidence,
+      providerEvidence: scan.git.providerEvidence
+    }
+  };
+}
+function createOnboardingState(report, generatedAt, deferredItems = report.deferredChecks) {
+  const validDeferredCheckIds = new Set(
+    deferredItems.filter((item) => item.reason.trim().length > 0).map((item) => item.checkId)
+  );
+  const unresolvedEssential = report.pillars.flatMap((pillar) => pillar.checks).some((check) => {
+    if (!check.essential || check.status === "ready") return false;
+    if (check.status === "blocked") return true;
+    if (!validDeferredCheckIds.has(check.id)) return true;
+    return check.actions.length > 0;
+  });
+  return {
+    contractVersion: 1,
+    status: unresolvedEssential ? "in_progress" : "completed",
+    updatedAt: generatedAt,
+    checks: Object.fromEntries(
+      report.pillars.flatMap((pillar) => pillar.checks).map((check) => [
+        check.id,
+        {
+          status: check.status,
+          essential: check.essential,
+          evidence: check.evidence
+        }
+      ])
+    ),
+    deferredItems
+  };
+}
+function validDeferredItems(value, fallback) {
+  if (!Array.isArray(value)) return fallback;
+  return value.filter(
+    (item) => isObject(item) && typeof item.checkId === "string" && typeof item.reason === "string" && (item.recoveryCommand === void 0 || typeof item.recoveryCommand === "string")
+  );
+}
+function reconcileOnboardingState(report, existingConfig, generatedAt) {
+  const existing = isObject(existingConfig.onboarding) ? existingConfig.onboarding : {};
+  const deferredItems = validDeferredItems(existing.deferredItems, report.deferredChecks);
+  const derived = createOnboardingState(report, generatedAt, deferredItems);
+  const candidate = {
+    ...existing,
+    ...derived
+  };
+  const { updatedAt: _candidateUpdatedAt, ...candidateState } = candidate;
+  const { updatedAt: existingUpdatedAt, ...existingState } = existing;
+  candidate.updatedAt = jsonEqual(candidateState, existingState) && typeof existingUpdatedAt === "string" ? existingUpdatedAt : generatedAt;
+  return candidate;
+}
+function preferenceDefaults(onboarding, onboarded) {
+  return {
+    onboarded: onboarded === true,
+    onboarding,
+    externalPlanReview: {
+      enabled: false,
+      backend: "claude",
+      autoRemediate: false,
+      offerOnExhausted: true,
+      mode: "paste",
+      midBatchAudits: false,
+      preflight: "off"
+    },
+    autoHandoff: false,
+    agentPersona: {
+      default: "autopilot",
+      modes: {
+        "continue-plan": "autopilot",
+        "run-plan": "night-shift",
+        "cli-run-plan": "ghost-runner"
+      }
+    }
+  };
+}
+function mergeIgnorePatterns(existing, patterns) {
+  const activeLines = new Set(
+    existing.split(/\r?\n/).map((line) => line.trim()).filter((line) => line && !line.startsWith("#"))
+  );
+  const missing = patterns.filter((pattern) => !activeLines.has(pattern));
+  if (missing.length === 0) return existing;
+  const prefix = existing.length === 0 ? "" : existing.endsWith("\n") ? existing : `${existing}
+`;
+  return `${prefix}${missing.join("\n")}
+`;
+}
+function mergeSecretIgnores(existing) {
+  return mergeIgnorePatterns(existing, REQUIRED_SECRET_PATTERNS);
+}
+function mergeKitOwnedIgnores(existing) {
+  return mergeIgnorePatterns(existing, KIT_OWNED_IGNORE_PATTERNS);
+}
+function recordChange(changes, id, relativePath, changed, dryRun, evidence) {
+  changes.push({
+    id,
+    path: relativePath,
+    status: changed ? dryRun ? "planned" : "applied" : "skipped",
+    evidence
+  });
+}
+function appliedActions(changes) {
+  return changes.filter((change) => change.status === "applied").map((change) => ({
+    id: change.id,
+    status: "ready",
+    recommendation: `Applied safe local change to ${change.path}`,
+    owner: "system"
+  }));
+}
+function withoutGeneratedAtForComparison(profile) {
+  const { generatedAt: _generatedAt, ...detection } = isObject(profile.detection) ? profile.detection : {};
+  return { ...profile, detection };
+}
+function reconcileFreshOverExisting(desired, existing) {
+  const merged = { ...existing };
+  for (const [key, value] of Object.entries(desired)) {
+    const existingValue = existing[key];
+    merged[key] = isObject(value) && isObject(existingValue) ? reconcileFreshOverExisting(value, existingValue) : value;
+  }
+  return merged;
+}
+async function refreshRepositoryProfile(rootDir, options) {
+  const generatedAt = options.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const scan = await runScanner(rootDir);
+  const report = createReadinessReport(scan, {
+    generatorVersion: options.generatorVersion,
+    generatedAt
+  });
+  const desiredProfile = createProfile(scan, report, generatedAt);
+  const profilePath = path2.join(scan.rootDir, REPOSITORY_PROFILE_REL);
+  const existingProfile = await readJson(profilePath) ?? {};
+  const reconciled = reconcileFreshOverExisting(desiredProfile, existingProfile);
+  const meaningfulChange = !jsonEqual(
+    withoutGeneratedAtForComparison(existingProfile),
+    withoutGeneratedAtForComparison(reconciled)
+  );
+  if (!meaningfulChange) {
+    return { changed: false, profile: existingProfile };
+  }
+  await writeJson(profilePath, reconciled);
+  return { changed: true, profile: reconciled };
+}
+async function executeSafeReadinessFixes(rootDir, options) {
+  const dryRun = options.dryRun ?? false;
+  const generatedAt = options.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const beforeScan = await runScanner(rootDir);
+  const before = createReadinessReport(beforeScan, {
+    generatorVersion: options.generatorVersion,
+    generatedAt
+  });
+  const changes = [];
+  for (const relativePath of ESSENTIAL_DIRECTORIES) {
+    const absolutePath = path2.join(beforeScan.rootDir, relativePath);
+    const exists2 = await fileExists(absolutePath);
+    if (!exists2 && !dryRun) await ensureDir(absolutePath);
+    recordChange(
+      changes,
+      "ensure-agent-kit-directory",
+      relativePath,
+      !exists2,
+      dryRun,
+      relativeEvidence(relativePath, exists2 ? "already exists" : "missing directory")
+    );
+  }
+  const gitignoreRelativePath = ".gitignore";
+  const gitignorePath = path2.join(beforeScan.rootDir, gitignoreRelativePath);
+  const existingGitignore = await fileExists(gitignorePath) ? await readFile2(gitignorePath, "utf8") : "";
+  const gitignoreAfterSecrets = mergeSecretIgnores(existingGitignore);
+  const secretsChanged = gitignoreAfterSecrets !== existingGitignore;
+  const mergedGitignore = mergeKitOwnedIgnores(gitignoreAfterSecrets);
+  const gitignoreChanged = mergedGitignore !== existingGitignore;
+  const kitOwnedChanged = mergedGitignore !== gitignoreAfterSecrets;
+  if (gitignoreChanged && !dryRun) await writeFile(gitignorePath, mergedGitignore, "utf8");
+  recordChange(
+    changes,
+    "merge-secret-ignores",
+    gitignoreRelativePath,
+    secretsChanged,
+    dryRun,
+    relativeEvidence(
+      gitignoreRelativePath,
+      secretsChanged ? "required secret patterns are missing" : "required patterns are present"
+    )
+  );
+  recordChange(
+    changes,
+    "merge-kit-owned-ignores",
+    gitignoreRelativePath,
+    kitOwnedChanged,
+    dryRun,
+    relativeEvidence(
+      gitignoreRelativePath,
+      kitOwnedChanged ? "kit-owned session/derived paths are missing" : "kit-owned session/derived paths are present"
+    )
+  );
+  const profilePath = path2.join(beforeScan.rootDir, REPOSITORY_PROFILE_REL);
+  const existingProfile = await readJson(profilePath) ?? {};
+  const desiredProfile = createProfile(beforeScan, before, generatedAt);
+  const mergedProfile = mergeMissing(existingProfile, desiredProfile);
+  const profileChanged = !jsonEqual(existingProfile, mergedProfile);
+  if (profileChanged && !dryRun) await writeJson(profilePath, mergedProfile);
+  recordChange(
+    changes,
+    "merge-repository-profile",
+    REPOSITORY_PROFILE_REL,
+    profileChanged,
+    dryRun,
+    relativeEvidence(
+      REPOSITORY_PROFILE_REL,
+      profileChanged ? "missing scanner-derived facts" : "existing facts preserved"
+    )
+  );
+  const evidenceScan = dryRun ? beforeScan : await runScanner(beforeScan.rootDir);
+  const evidenceReport = createReadinessReport(evidenceScan, {
+    generatorVersion: options.generatorVersion,
+    generatedAt
+  });
+  const configPath = contextConfigPath(beforeScan.rootDir);
+  const existingContextConfig = await readJson(configPath) ?? {};
+  const onboarding = reconcileOnboardingState(evidenceReport, existingContextConfig, generatedAt);
+  const defaults = preferenceDefaults(onboarding, existingContextConfig.onboarded);
+  const mergedContextConfig = mergeMissing(existingContextConfig, defaults);
+  mergedContextConfig.onboarding = onboarding;
+  const contextConfigChanged = !jsonEqual(existingContextConfig, mergedContextConfig);
+  if (contextConfigChanged && !dryRun) await writeJson(configPath, mergedContextConfig);
+  recordChange(
+    changes,
+    "merge-onboarding-state",
+    CONTEXT_CONFIG_REL_POSIX,
+    contextConfigChanged,
+    dryRun,
+    relativeEvidence(
+      CONTEXT_CONFIG_REL_POSIX,
+      contextConfigChanged ? "missing preferences or onboarding state" : "state already merged"
+    )
+  );
+  const afterScan = contextConfigChanged && !dryRun && evidenceScan.git.mode !== "none" ? {
+    ...evidenceScan,
+    git: { ...evidenceScan.git, isDirty: await detectGitDirty(evidenceScan.rootDir) }
+  } : evidenceScan;
+  const after = createReadinessReport(afterScan, {
+    generatorVersion: options.generatorVersion,
+    generatedAt
+  });
+  after.appliedSafeFixes = appliedActions(changes);
+  return { dryRun, changes, before, after };
+}
+
+export {
+  assessClaudeCommandAdapters,
+  assessHooksHealth,
+  refreshRepositoryProfile,
+  executeSafeReadinessFixes
+};