@xenonbyte/da-vinci-workflow 0.2.4 → 0.2.6

package/lib/cli.js

@@ -4,6 +4,7 @@ const {
   installPlatforms,
   uninstallPlatforms,
   getStatus,
+  verifyInstall,
   validateAssets
 } = require("./install");
 const { auditProject, formatAuditReport } = require("./audit");
@@ -78,7 +79,9 @@ const {
 } = require("./verify");
 const { diffSpec, formatDiffSpecReport } = require("./diff-spec");
 const { scaffoldFromBindings, formatScaffoldReport } = require("./scaffold");
-const { writeExecutionSignal } = require("./execution-signals");
+const { emitOrThrowOnStatus, persistExecutionSignal } = require("./cli/helpers");
+const { handleVerifyFamilyCommand } = require("./cli/verify-family");
+const { handleLintFamilyCommand } = require("./cli/lint-family");
 const {
   writeTaskExecutionEnvelope,
   formatTaskExecutionReport
@@ -92,6 +95,10 @@ const {
   formatWorktreePreflightReport
 } = require("./worktree-preflight");
 const { formatTuiHelp, launchTui } = require("../tui");
+const {
+  runMaintainerReadinessCheck,
+  formatMaintainerReadinessReport
+} = require("./maintainer-readiness");
 
 const DEFAULT_MAX_PREFLIGHT_STDIN_BYTES = 1024 * 1024;
 const DEFAULT_MAX_STDIN_TRANSIENT_RETRIES = 2000;
@@ -187,7 +194,10 @@ const HELP_OPTION_SPECS = [
   { flag: "--stage <value>", description: "task-review stage: spec or quality" },
   { flag: "--summary <text>", description: "task-execution/task-review summary text" },
   { flag: "--task-group <id>", description: "task group identifier for task-execution/task-review" },
-  { flag: "--changed-files <csv>", description: "comma-separated changed files for task-execution" },
+  {
+    flag: "--changed-files <csv>",
+    description: "comma-separated changed files for verify-implementation/verify-structure/verify-coverage/task-execution"
+  },
   { flag: "--test-evidence <csv>", description: "comma-separated test evidence commands for task-execution" },
   { flag: "--concerns <csv>", description: "comma-separated concern text for task-execution" },
   { flag: "--blockers <csv>", description: "comma-separated blocker text for task-execution" },
@@ -379,17 +389,6 @@ function shouldContinueOnError(args) {
   return Array.isArray(args) && args.includes("--continue-on-error");
 }
 
-function emitOrThrowOnStatus(status, blockedStatuses, output, continueOnError) {
-  if (!Array.isArray(blockedStatuses) || !blockedStatuses.includes(status)) {
-    return false;
-  }
-  if (continueOnError) {
-    console.log(output);
-    return true;
-  }
-  throw new Error(output);
-}
-
 function getIntegerOption(args, name, options = {}) {
   const raw = getOption(args, name);
   if (raw === undefined) {
@@ -465,6 +464,60 @@ function formatStatus(status) {
   return lines.join("\n");
 }
 
+function formatVerifyInstallReport(result) {
+  const scopeLabel = result.scope && result.scope.known
+    ? result.scope.selectedPlatforms.join(", ")
+    : "unknown";
+  const lines = [
+    "Da Vinci verify-install",
+    `Status: ${result.status}`,
+    `Home: ${result.homeDir}`,
+    "Surface: install verification (bootstrap-adjacent), not full repository readiness",
+    `Selected platform scope: ${scopeLabel}`,
+    "Platform coverage:"
+  ];
+
+  for (const platform of result.scope.supportedPlatforms || []) {
+    const coverage = result.platformCoverage && result.platformCoverage[platform];
+    if (!coverage) {
+      continue;
+    }
+    const checkSummary = Object.entries(coverage.checks || {})
+      .map(([name, ok]) => `${name}=${ok ? "yes" : "no"}`)
+      .join(" ");
+    lines.push(
+      `- ${platform}: scope=${coverage.scope} healthy=${coverage.healthy ? "yes" : "no"}${checkSummary ? ` ${checkSummary}` : ""}`
+    );
+  }
+
+  if (Array.isArray(result.failures) && result.failures.length > 0) {
+    lines.push("Failures:");
+    for (const message of result.failures) {
+      lines.push(`- ${message}`);
+    }
+  }
+  if (Array.isArray(result.warnings) && result.warnings.length > 0) {
+    lines.push("Warnings:");
+    for (const message of result.warnings) {
+      lines.push(`- ${message}`);
+    }
+  }
+  if (Array.isArray(result.notes) && result.notes.length > 0) {
+    lines.push("Notes:");
+    for (const message of result.notes) {
+      lines.push(`- ${message}`);
+    }
+  }
+  if (Array.isArray(result.nextSteps) && result.nextSteps.length > 0) {
+    lines.push("Next steps:");
+    for (const step of result.nextSteps) {
+      lines.push(`- ${step}`);
+    }
+  }
+
+  return lines.join("\n");
+}
+
 function appendStatusIssues(lines, label, missing = [], mismatched = [], unreadable = []) {
   if (missing.length > 0) {
     lines.push(`  ${label} missing: ${missing.join(", ")}`);
@@ -477,32 +530,6 @@ function appendStatusIssues(lines, label, missing = [], mismatched = [], unreada
   }
 }
 
-function persistExecutionSignal(projectPath, changeId, surface, result, strict = false) {
-  try {
-    writeExecutionSignal(projectPath, {
-      changeId: changeId || "global",
-      surface,
-      status: result.status,
-      advisory: strict ? false : true,
-      strict,
-      failures: result.failures || [],
-      warnings: result.warnings || [],
-      notes: result.notes || []
-    });
-  } catch (error) {
-    // Signals are advisory metadata and should not break command execution.
-    const code = error && error.code ? String(error.code).toUpperCase() : "";
-    if (code === "EACCES" || code === "ENOSPC") {
-      return;
-    }
-
-    const message = error && error.message ? error.message : String(error);
-    console.error(
-      `Warning: failed to persist execution signal (${surface}) for change ${changeId || "global"}: ${message}`
-    );
-  }
-}
-
 function printHelp() {
   const optionLines = HELP_OPTION_SPECS.map((optionSpec) => {
     const paddedFlag = optionSpec.flag.padEnd(30, " ");
@@ -517,6 +544,10 @@ function printHelp() {
       "  da-vinci install --platform codex,claude,gemini",
       "  da-vinci uninstall --platform codex,claude,gemini",
       "  da-vinci status",
+      "  da-vinci verify-install [--platform <value>] [--json]",
+      "    (bootstrap-adjacent install verification for selected maintainer platforms)",
+      "  da-vinci maintainer-readiness [--platform <value>] [--project <path>] [--json]",
+      "    (canonical repository maintainer diagnosis/readiness; not downstream bootstrap)",
       "  da-vinci tui [--project <path>] [--change <id>] [--lang en|zh] [--strict] [--json] [--continue-on-error] [--tui-width <cols>] [--alt-screen|--no-alt-screen]",
       "  da-vinci workflow-status [--project <path>] [--change <id>] [--json]",
       "  da-vinci next-step [--project <path>] [--change <id>] [--json]",
@@ -526,9 +557,9 @@ function printHelp() {
       "  da-vinci lint-bindings [--project <path>] [--change <id>] [--strict] [--json]",
       "  da-vinci generate-sidecars [--project <path>] [--change <id>] [--json]",
       "  da-vinci verify-bindings [--project <path>] [--change <id>] [--strict] [--json]",
-      "  da-vinci verify-implementation [--project <path>] [--change <id>] [--strict] [--json]",
-      "  da-vinci verify-structure [--project <path>] [--change <id>] [--strict] [--json]",
-      "  da-vinci verify-coverage [--project <path>] [--change <id>] [--strict] [--json]",
+      "  da-vinci verify-implementation [--project <path>] [--change <id>] [--changed-files <csv>] [--strict] [--json]",
+      "  da-vinci verify-structure [--project <path>] [--change <id>] [--changed-files <csv>] [--strict] [--json]",
+      "  da-vinci verify-coverage [--project <path>] [--change <id>] [--changed-files <csv>] [--strict] [--json]",
       "  da-vinci task-execution --project <path> --change <id> --task-group <id> --status <DONE|DONE_WITH_CONCERNS|NEEDS_CONTEXT|BLOCKED> --summary <text> [--changed-files <csv>] [--test-evidence <csv>] [--concerns <csv>] [--blockers <csv>] [--json]",
       "  da-vinci task-review --project <path> --change <id> --task-group <id> --stage <spec|quality> --status <PASS|WARN|BLOCK> --summary <text> [--issues <csv>] [--reviewer <name>] [--write-verification] [--json]",
       "  da-vinci worktree-preflight --project <path> [--change <id>] [--json]",
@@ -987,6 +1018,40 @@ async function runCli(argv) {
     return;
   }
 
+  if (command === "verify-install") {
+    const platformValue = getOption(argv, "--platform") || "";
+    const result = verifyInstall({
+      homeDir,
+      platforms: platformValue
+    });
+    const output = argv.includes("--json")
+      ? JSON.stringify(result, null, 2)
+      : formatVerifyInstallReport(result);
+    if (emitOrThrowOnStatus(result.status, ["BLOCK"], output, continueOnError)) {
+      return;
+    }
+    console.log(output);
+    return;
+  }
+
+  if (command === "maintainer-readiness") {
+    const platformValue = getOption(argv, "--platform") || "";
+    const repoRoot = getOption(argv, "--project") || process.cwd();
+    const result = runMaintainerReadinessCheck({
+      repoRoot,
+      homeDir,
+      platforms: platformValue
+    });
+    const output = argv.includes("--json")
+      ? JSON.stringify(result, null, 2)
+      : formatMaintainerReadinessReport(result);
+    if (emitOrThrowOnStatus(result.status, ["BLOCK"], output, continueOnError)) {
+      return;
+    }
+    console.log(output);
+    return;
+  }
+
   if (command === "tui") {
     const projectPath = getOption(argv, "--project") || positionalArgs[0] || process.cwd();
     const changeId = getOption(argv, "--change");
@@ -1040,6 +1105,7 @@ async function runCli(argv) {
             stage: result.stage,
             checkpointState: result.checkpointState,
             nextStep: result.nextStep || null,
+            blockingGate: result.blockingGate || null,
             discipline: result.discipline || null,
             executionProfile: result.executionProfile || null,
             worktreePreflight: result.worktreePreflight || null,
@@ -1056,71 +1122,24 @@ async function runCli(argv) {
     return;
   }
 
-  if (command === "lint-spec") {
-    const projectPath = getOption(argv, "--project") || positionalArgs[0] || process.cwd();
-    const changeId = getOption(argv, "--change");
-    const strict = argv.includes("--strict");
-    const result = lintRuntimeSpecs(projectPath, { changeId, strict });
-    persistExecutionSignal(projectPath, result.changeId || changeId, "lint-spec", result, strict);
-    const useJson = argv.includes("--json");
-    const output = useJson ? JSON.stringify(result, null, 2) : formatLintSpecReport(result);
-
-    if (emitOrThrowOnStatus(result.status, ["BLOCK"], output, continueOnError)) {
-      return;
-    }
-
-    console.log(output);
-    return;
-  }
-
-  if (command === "scope-check") {
-    const projectPath = getOption(argv, "--project") || positionalArgs[0] || process.cwd();
-    const changeId = getOption(argv, "--change");
-    const strict = argv.includes("--strict");
-    const result = runScopeCheck(projectPath, { changeId, strict });
-    persistExecutionSignal(projectPath, result.changeId || changeId, "scope-check", result, strict);
-    const useJson = argv.includes("--json");
-    const output = useJson ? JSON.stringify(result, null, 2) : formatScopeCheckReport(result);
-
-    if (emitOrThrowOnStatus(result.status, ["BLOCK"], output, continueOnError)) {
-      return;
-    }
-
-    console.log(output);
-    return;
-  }
-
-  if (command === "lint-tasks") {
-    const projectPath = getOption(argv, "--project") || positionalArgs[0] || process.cwd();
-    const changeId = getOption(argv, "--change");
-    const strict = argv.includes("--strict");
-    const result = lintTasks(projectPath, { changeId, strict });
-    persistExecutionSignal(projectPath, result.changeId || changeId, "lint-tasks", result, strict);
-    const useJson = argv.includes("--json");
-    const output = useJson ? JSON.stringify(result, null, 2) : formatLintTasksReport(result);
-
-    if (emitOrThrowOnStatus(result.status, ["BLOCK"], output, continueOnError)) {
-      return;
-    }
-
-    console.log(output);
-    return;
-  }
-
-  if (command === "lint-bindings") {
-    const projectPath = getOption(argv, "--project") || positionalArgs[0] || process.cwd();
-    const changeId = getOption(argv, "--change");
-    const strict = argv.includes("--strict");
-    const result = lintBindings(projectPath, { changeId, strict });
-    persistExecutionSignal(projectPath, result.changeId || changeId, "lint-bindings", result, strict);
-    const useJson = argv.includes("--json");
-    const output = useJson ? JSON.stringify(result, null, 2) : formatLintBindingsReport(result);
-
-    if (emitOrThrowOnStatus(result.status, ["BLOCK"], output, continueOnError)) {
-      return;
-    }
-
-    console.log(output);
+  if (
+    handleLintFamilyCommand(command, {
+      argv,
+      positionalArgs,
+      continueOnError,
+      getOption,
+      lintRuntimeSpecs,
+      formatLintSpecReport,
+      runScopeCheck,
+      formatScopeCheckReport,
+      lintTasks,
+      formatLintTasksReport,
+      lintBindings,
+      formatLintBindingsReport,
+      emitOrThrowOnStatus,
+      persistExecutionSignal
+    })
+  ) {
     return;
   }
 
@@ -1140,71 +1159,23 @@ async function runCli(argv) {
     return;
   }
 
-  if (command === "verify-bindings") {
-    const projectPath = getOption(argv, "--project") || positionalArgs[0] || process.cwd();
-    const changeId = getOption(argv, "--change");
-    const strict = argv.includes("--strict");
-    const result = verifyBindings(projectPath, { changeId, strict });
-    persistExecutionSignal(projectPath, result.changeId || changeId, "verify-bindings", result, strict);
-    const useJson = argv.includes("--json");
-    const output = useJson
-      ? JSON.stringify(result, null, 2)
-      : formatVerifyReport(result, "Da Vinci verify-bindings");
-    if (emitOrThrowOnStatus(result.status, ["BLOCK"], output, continueOnError)) {
-      return;
-    }
-    console.log(output);
-    return;
-  }
-
-  if (command === "verify-implementation") {
-    const projectPath = getOption(argv, "--project") || positionalArgs[0] || process.cwd();
-    const changeId = getOption(argv, "--change");
-    const strict = argv.includes("--strict");
-    const result = verifyImplementation(projectPath, { changeId, strict });
-    persistExecutionSignal(projectPath, result.changeId || changeId, "verify-implementation", result, strict);
-    const useJson = argv.includes("--json");
-    const output = useJson
-      ? JSON.stringify(result, null, 2)
-      : formatVerifyReport(result, "Da Vinci verify-implementation");
-    if (emitOrThrowOnStatus(result.status, ["BLOCK"], output, continueOnError)) {
-      return;
-    }
-    console.log(output);
-    return;
-  }
-
-  if (command === "verify-structure") {
-    const projectPath = getOption(argv, "--project") || positionalArgs[0] || process.cwd();
-    const changeId = getOption(argv, "--change");
-    const strict = argv.includes("--strict");
-    const result = verifyStructure(projectPath, { changeId, strict });
-    persistExecutionSignal(projectPath, result.changeId || changeId, "verify-structure", result, strict);
-    const useJson = argv.includes("--json");
-    const output = useJson
-      ? JSON.stringify(result, null, 2)
-      : formatVerifyReport(result, "Da Vinci verify-structure");
-    if (emitOrThrowOnStatus(result.status, ["BLOCK"], output, continueOnError)) {
-      return;
-    }
-    console.log(output);
-    return;
-  }
-
-  if (command === "verify-coverage") {
-    const projectPath = getOption(argv, "--project") || positionalArgs[0] || process.cwd();
-    const changeId = getOption(argv, "--change");
-    const strict = argv.includes("--strict");
-    const result = verifyCoverage(projectPath, { changeId, strict });
-    persistExecutionSignal(projectPath, result.changeId || changeId, "verify-coverage", result, strict);
-    const useJson = argv.includes("--json");
-    const output = useJson
-      ? JSON.stringify(result, null, 2)
-      : formatVerifyReport(result, "Da Vinci verify-coverage");
-    if (emitOrThrowOnStatus(result.status, ["BLOCK"], output, continueOnError)) {
-      return;
-    }
-    console.log(output);
+  if (
+    handleVerifyFamilyCommand(command, {
+      argv,
+      positionalArgs,
+      continueOnError,
+      getOption,
+      getCommaSeparatedOptionValues,
+      collectOptionEntries,
+      verifyBindings,
+      verifyImplementation,
+      verifyStructure,
+      verifyCoverage,
+      formatVerifyReport,
+      emitOrThrowOnStatus,
+      persistExecutionSignal
+    })
+  ) {
     return;
   }
 

package/lib/gate-utils.js

@@ -0,0 +1,56 @@
+const { STATUS } = require("./workflow-contract");
+const { unique } = require("./planning-parsers");
+
+function dedupe(values) {
+  return unique(values);
+}
+
+function buildGateEnvelope(id, options = {}) {
+  const gate = {
+    id,
+    status: STATUS.PASS,
+    blocking: [],
+    advisory: [],
+    compatibility: [],
+    evidence: []
+  };
+  if (options.includeBounded) {
+    gate.bounded = [];
+  }
+  return gate;
+}
+
+function finalizeGateEnvelope(gate, options = {}) {
+  const strict = options.strict === true;
+  const includeBounded = options.includeBounded === true;
+  const warnOnBounded = options.warnOnBounded === true;
+  const warnOnCompatibility = options.warnOnCompatibility !== false;
+  const normalized = {
+    ...gate,
+    blocking: dedupe(gate && gate.blocking),
+    advisory: dedupe(gate && gate.advisory),
+    compatibility: dedupe(gate && gate.compatibility),
+    evidence: dedupe(gate && gate.evidence)
+  };
+  if (includeBounded || Array.isArray(gate && gate.bounded)) {
+    normalized.bounded = dedupe(gate && gate.bounded);
+  }
+
+  if (normalized.blocking.length > 0) {
+    normalized.status = strict ? STATUS.BLOCK : STATUS.WARN;
+    return normalized;
+  }
+
+  const hasWarnLevelFindings =
+    normalized.advisory.length > 0 ||
+    (warnOnCompatibility && normalized.compatibility.length > 0) ||
+    (warnOnBounded && Array.isArray(normalized.bounded) && normalized.bounded.length > 0);
+  normalized.status = hasWarnLevelFindings ? STATUS.WARN : STATUS.PASS;
+  return normalized;
+}
+
+module.exports = {
+  dedupe,
+  buildGateEnvelope,
+  finalizeGateEnvelope
+};

package/lib/install.js

@@ -18,6 +18,7 @@ const REQUIRED_FILES = [
   ...listFiles(path.join(REPO_ROOT, "docs")).map((filePath) => path.relative(REPO_ROOT, filePath)),
   ...listFiles(path.join(REPO_ROOT, "examples")).map((filePath) => path.relative(REPO_ROOT, filePath))
 ];
+const SUPPORTED_PLATFORMS = ["codex", "claude", "gemini"];
 
 const CODEX_PROMPT_TARGET_PAIRS = listFiles(path.join(REPO_ROOT, "commands", "codex", "prompts")).map(
   (filePath) => ({
@@ -90,7 +91,7 @@ function resolveHome(homeDir) {
 
 function parsePlatforms(raw) {
   if (!raw || raw === "all") {
-    return ["codex", "claude", "gemini"];
+    return SUPPORTED_PLATFORMS.slice();
   }
 
   const platforms = raw
@@ -99,7 +100,7 @@ function parsePlatforms(raw) {
     .filter(Boolean);
 
   const unique = [...new Set(platforms)];
-  const invalid = unique.filter((value) => !["codex", "claude", "gemini"].includes(value));
+  const invalid = unique.filter((value) => !SUPPORTED_PLATFORMS.includes(value));
 
   if (invalid.length > 0) {
     throw new Error(`Unsupported platform value: ${invalid.join(", ")}`);
@@ -108,6 +109,129 @@ function parsePlatforms(raw) {
   return unique;
 }
 
+function summarizePlatformInstallConfidence(statusPayload) {
+  const status = statusPayload && typeof statusPayload === "object" ? statusPayload : {};
+  const codex = status.codex && typeof status.codex === "object" ? status.codex : {};
+  const claude = status.claude && typeof status.claude === "object" ? status.claude : {};
+  const gemini = status.gemini && typeof status.gemini === "object" ? status.gemini : {};
+
+  return {
+    codex: {
+      checks: {
+        prompt: codex.prompt === true,
+        skill: codex.skill === true
+      },
+      missing: [...(codex.promptMissing || []), ...(codex.skillMissing || [])],
+      mismatched: [...(codex.promptMismatched || []), ...(codex.skillMismatched || [])],
+      unreadable: [...(codex.promptUnreadable || []), ...(codex.skillUnreadable || [])]
+    },
+    claude: {
+      checks: {
+        command: claude.command === true,
+        actionSet: claude.actionSet === true
+      },
+      missing: [...(claude.commandMissing || []), ...(claude.actionSetMissing || [])],
+      mismatched: [...(claude.commandMismatched || []), ...(claude.actionSetMismatched || [])],
+      unreadable: [...(claude.commandUnreadable || []), ...(claude.actionSetUnreadable || [])]
+    },
+    gemini: {
+      checks: {
+        command: gemini.command === true,
+        actionSet: gemini.actionSet === true
+      },
+      missing: [...(gemini.commandMissing || []), ...(gemini.actionSetMissing || [])],
+      mismatched: [...(gemini.commandMismatched || []), ...(gemini.actionSetMismatched || [])],
+      unreadable: [...(gemini.commandUnreadable || []), ...(gemini.actionSetUnreadable || [])]
+    }
+  };
+}
+
+function verifyInstall(options = {}) {
+  const homeDir = resolveHome(options.homeDir);
+  const explicitScopeRaw = String(options.platforms || "").trim();
+  const scopeKnown = explicitScopeRaw.length > 0;
+  const selectedPlatforms = scopeKnown ? parsePlatforms(explicitScopeRaw) : [];
+  const status = getStatus({ homeDir });
+  const confidence = summarizePlatformInstallConfidence(status);
+  const platformCoverage = {};
+  const failures = [];
+  const warnings = [];
+  const notes = [];
+
+  for (const platform of SUPPORTED_PLATFORMS) {
+    const selected = selectedPlatforms.includes(platform);
+    const scope = scopeKnown ? (selected ? "selected" : "out_of_scope") : "unknown";
+    const platformConfidence = confidence[platform];
+    const failedChecks = Object.keys(platformConfidence.checks).filter(
+      (checkKey) => platformConfidence.checks[checkKey] !== true
+    );
+    const healthy = failedChecks.length === 0;
+    platformCoverage[platform] = {
+      scope,
+      healthy,
+      checks: platformConfidence.checks,
+      missing: platformConfidence.missing,
+      mismatched: platformConfidence.mismatched,
+      unreadable: platformConfidence.unreadable
+    };
+
+    if (scope === "selected" && !healthy) {
+      failures.push(
+        `${platform} install verification failed for selected scope (${failedChecks.join(
+          ", "
+        )}). Run \`da-vinci install --platform ${platform}\` and re-run verify-install.`
+      );
+    }
+    if (scope === "unknown" && !healthy) {
+      warnings.push(
+        `${platform} install verification is incomplete, but selected platform scope is unknown.`
+      );
+    }
+    if (scope === "out_of_scope" && !healthy) {
+      notes.push(
+        `${platform} is out-of-scope for this verify-install run and is reported as degraded coverage.`
+      );
+    }
+  }
+
+  if (!scopeKnown) {
+    warnings.push(
+      "Selected platform scope is unknown; pass `--platform <value>` so verify-install can evaluate selected targets explicitly."
+    );
+  }
+
+  const statusToken = failures.length > 0 ? "BLOCK" : warnings.length > 0 ? "WARN" : "PASS";
+  const nextSteps = [];
+  if (failures.length > 0) {
+    nextSteps.push("Fix selected-platform install failures, then rerun `da-vinci verify-install`.");
+  }
+  if (!scopeKnown) {
+    nextSteps.push(
+      "Rerun with explicit scope, for example `da-vinci verify-install --platform codex`, to avoid unknown-scope coverage."
+    );
+  }
+  if (statusToken === "PASS") {
+    nextSteps.push(
+      "Continue with repository readiness checks (for example `da-vinci maintainer-readiness`)."
+    );
+  }
+
+  return {
+    status: statusToken,
+    homeDir,
+    scope: {
+      known: scopeKnown,
+      selectedPlatforms,
+      supportedPlatforms: SUPPORTED_PLATFORMS.slice()
+    },
+    platformCoverage,
+    failures: failures,
+    warnings: warnings,
+    notes: notes,
+    nextSteps
+  };
+}
+
 function ensureDir(targetPath) {
   fs.mkdirSync(targetPath, { recursive: true });
 }
@@ -407,25 +531,29 @@ function getStatus(options = {}) {
   };
 }
 
-function validateAssets() {
+function validateAssets(options = {}) {
+  const repoRoot = options.repoRoot ? path.resolve(String(options.repoRoot)) : REPO_ROOT;
   const missing = REQUIRED_FILES.filter((relativePath) => {
-    return !fs.existsSync(path.join(REPO_ROOT, relativePath));
+    return !fs.existsSync(path.join(repoRoot, relativePath));
   });
 
   if (missing.length > 0) {
-    throw new Error(`Missing required assets:\n${missing.join("\n")}`);
+    throw new Error(`Missing required assets under ${repoRoot}:\n${missing.join("\n")}`);
   }
 
   return {
     version: VERSION,
-    requiredAssets: REQUIRED_FILES.length
+    requiredAssets: REQUIRED_FILES.length,
+    repoRoot
   };
 }
 
 module.exports = {
   VERSION,
+  SUPPORTED_PLATFORMS,
   installPlatforms,
   uninstallPlatforms,
   getStatus,
+  verifyInstall,
   validateAssets
 };