@design-ai/cli 4.55.0 → 4.57.0

package/tools/audit/registry-smoke.py

@@ -39,6 +39,8 @@ from smoke_assertions import (
     EXPECTED_HELP_ALIASES,
     EXPECTED_NUMERIC_VALUE_SMOKES,
     EXPECTED_PACK_MAX_BYTES,
+    EXPECTED_RANKED_SEARCH_LIMIT,
+    EXPECTED_RANKED_SEARCH_NOT_BUILT_NOTICE,
     EXPECTED_REPOSITORY_URL,
     EXPECTED_ROUTE_BRIEF,
     EXPECTED_ROUTE_ID,
@@ -55,11 +57,15 @@ from smoke_assertions import (
     assert_check_examples_json_component_spec,
     assert_check_stdin_json_component_spec,
     assert_command_alias_output,
+    assert_design_ai_mcp_protocol_responses,
     assert_examples_human_output,
     assert_examples_json_route_hit,
     assert_force_overwrite_replaced,
     assert_functional_alias_smokes,
     assert_help_topic_output,
+    assert_index_build_json,
+    assert_index_status_json,
+    assert_index_verify_json,
     assert_install_doctor_lifecycle_output,
     assert_list_catalog_output,
     assert_list_catalog_json,
@@ -71,6 +77,8 @@ from smoke_assertions import (
     assert_pack_json_component_spec,
     assert_pack_markdown_body_component_spec,
     assert_pack_markdown_component_spec,
+    assert_ranked_search_determinism,
+    assert_ranked_search_json,
     assert_site_repair_apply_report_payload,
     assert_site_repair_guidance_report_contract,
     assert_site_repair_preview_report_payload,
@@ -127,9 +135,14 @@ from smoke_assertions import (
     format_cmd,
     help_alias_script,
     help_topic_script,
+    mcp_smoke_input,
     parse_help_topics,
     passing_doctor_report_json,
     passing_check_artifact_content,
+    passing_index_build_json,
+    passing_index_status_json,
+    passing_index_verify_json,
+    passing_ranked_search_json,
     passing_site_json,
     passing_site_mcp_check_json,
     passing_site_mcp_check_probes_human,
@@ -154,6 +167,104 @@ from smoke_assertions import (
 ROOT = Path(__file__).resolve().parents[2]
 PACKAGE = json.loads((ROOT / "package.json").read_text(encoding="utf-8"))
 DEFAULT_PACKAGE_SPEC = f"{PACKAGE['name']}@{PACKAGE['version']}"
+EXPECTED_SITE_MCP_PROBE_COUNTS = {"count": 4, "pass": 4, "warn": 0, "fail": 0}
+EXPECTED_SITE_BUNDLE_MCP_PROBES_KEYS = [
+    "enabled",
+    "mode",
+    "externalCalls",
+    "status",
+    "count",
+    "pass",
+    "warn",
+    "fail",
+    "items",
+]
+EXPECTED_SITE_BUNDLE_MCP_PROBE_ITEM_KEYS = [
+    "id",
+    "key",
+    "label",
+    "requestedStatus",
+    "level",
+    "passed",
+    "message",
+    "evidence",
+    "actions",
+]
+EXPECTED_SITE_BUNDLE_MCP_PROBE_IDS = [
+    "github-repo-reference",
+    "figma-url-reference",
+    "browser-smoke-target",
+    "deploy-provider-reference",
+]
+
+
+def assert_site_mcp_probe_counts(
+    actual: object,
+    *,
+    context: str,
+    label: str,
+) -> None:
+    if actual != EXPECTED_SITE_MCP_PROBE_COUNTS:
+        raise SystemExit(f"{label} after {context} MCP probe counts changed: {actual!r}")
+
+
+def assert_smoke_json_keys(
+    payload: object,
+    expected_keys: list[str],
+    *,
+    label: str,
+    context: str,
+    command_label: str,
+) -> dict:
+    if not isinstance(payload, dict):
+        raise SystemExit(f"{command_label} after {context} {label} must be an object")
+    keys = list(payload.keys())
+    if keys != expected_keys:
+        raise SystemExit(f"{command_label} after {context} {label} keys changed: {keys!r}")
+    return payload
+
+
+def assert_site_bundle_mcp_probes_payload(payload: object, *, context: str) -> None:
+    checked = assert_smoke_json_keys(
+        payload,
+        EXPECTED_SITE_BUNDLE_MCP_PROBES_KEYS,
+        label="mcp-probes.json",
+        context=context,
+        command_label="site bundle",
+    )
+    if checked.get("enabled") is not True or checked.get("mode") != "read-only-local":
+        raise SystemExit(f"site bundle after {context} mcp-probes.json mode changed")
+    if checked.get("externalCalls") is not False:
+        raise SystemExit(f"site bundle after {context} mcp-probes.json must remain read-only")
+    if checked.get("status") != "pass":
+        raise SystemExit(f"site bundle after {context} mcp-probes.json status changed")
+    assert_site_mcp_probe_counts(
+        {key: checked.get(key) for key in ("count", "pass", "warn", "fail")},
+        context=context,
+        label="site bundle mcp-probes.json",
+    )
+
+    items = checked.get("items")
+    if not isinstance(items, list) or len(items) != len(EXPECTED_SITE_BUNDLE_MCP_PROBE_IDS):
+        raise SystemExit(f"site bundle after {context} mcp-probes.json item count changed")
+    checked_ids = []
+    for item in items:
+        checked_item = assert_smoke_json_keys(
+            item,
+            EXPECTED_SITE_BUNDLE_MCP_PROBE_ITEM_KEYS,
+            label="mcp-probes.json item",
+            context=context,
+            command_label="site bundle",
+        )
+        checked_ids.append(checked_item.get("id"))
+        if checked_item.get("level") != "pass" or checked_item.get("passed") is not True:
+            raise SystemExit(f"site bundle after {context} mcp-probes.json item should pass: {checked_item.get('id')}")
+        if not isinstance(checked_item.get("evidence"), list) or not checked_item.get("evidence"):
+            raise SystemExit(f"site bundle after {context} mcp-probes.json item evidence missing")
+        if not isinstance(checked_item.get("actions"), list):
+            raise SystemExit(f"site bundle after {context} mcp-probes.json item actions must be an array")
+    if checked_ids != EXPECTED_SITE_BUNDLE_MCP_PROBE_IDS:
+        raise SystemExit(f"site bundle after {context} mcp-probes.json item order changed")
 
 
 def npm_exec_cmd(package_spec: str, *args: str) -> list[str]:
@@ -169,6 +280,18 @@ def npm_exec_cmd(package_spec: str, *args: str) -> list[str]:
     ]
 
 
+def npm_exec_mcp_cmd(package_spec: str) -> list[str]:
+    return [
+        "npm",
+        "exec",
+        "--yes",
+        "--package",
+        package_spec,
+        "--",
+        "design-ai-mcp",
+    ]
+
+
 def npm_exec_shell_cmd(package_spec: str, script: str) -> list[str]:
     return [
         "npm",
@@ -2093,6 +2216,102 @@ def assert_learning_redact_smoke(
     )
 
 
+def assert_learning_recall_json(
+    raw: str,
+    *,
+    context: str,
+    cmd: list[str],
+) -> None:
+    assert_no_ansi(raw, cmd)
+    try:
+        payload = json.loads(raw)
+    except json.JSONDecodeError as error:
+        raise SystemExit(f"{context}: failed to parse learn recall JSON") from error
+
+    require_registry_smoke(
+        isinstance(payload, dict) and payload.get("query") == "korean mobile",
+        context=context,
+        cmd=cmd,
+        message="learn recall JSON must echo the query",
+    )
+    corpus = payload.get("corpus")
+    require_registry_smoke(
+        isinstance(corpus, dict)
+        and isinstance(corpus.get("candidateCount"), int)
+        and corpus.get("candidateCount") > 0
+        and isinstance(corpus.get("selectedCount"), int)
+        and isinstance(corpus.get("selected"), list),
+        context=context,
+        cmd=cmd,
+        message="learn recall corpus block shape changed",
+    )
+    learning = payload.get("learning")
+    require_registry_smoke(
+        isinstance(learning, dict)
+        and learning.get("mode") == "brief-relevance"
+        and learning.get("candidateCount") == 3
+        and isinstance(learning.get("selected"), list),
+        context=context,
+        cmd=cmd,
+        message="learn recall learning block shape changed",
+    )
+    selected = learning.get("selected")
+    require_registry_smoke(
+        len(selected) >= 1
+        and isinstance(selected[0], dict)
+        and selected[0].get("id") == "registry-korean"
+        and selected[0].get("category") == "korean"
+        and isinstance(selected[0].get("matchedTokens"), list),
+        context=context,
+        cmd=cmd,
+        message="learn recall should rank the Korean learning entry for a Korean query",
+    )
+
+
+def assert_learning_recall_smoke(
+    command_factory,
+    profile_path: Path,
+    *,
+    env: dict[str, str],
+    cwd: Path | None = None,
+    context: str,
+) -> None:
+    write_learning_stats_fixture(profile_path)
+
+    json_cmd = command_factory(
+        "learn",
+        "--recall",
+        "korean mobile",
+        "--file",
+        str(profile_path),
+        "--json",
+    )
+    json_result = run_plain(json_cmd, cwd=cwd, env=env)
+    assert_learning_recall_json(json_result.stdout, context=f"{context} JSON", cmd=json_cmd)
+
+    # Read-only: the profile file is unchanged after recall.
+    before = write_learning_stats_fixture_snapshot(profile_path)
+    human_cmd = command_factory("learn", "--recall", "korean mobile", "--file", str(profile_path))
+    human_result = run_plain(human_cmd, cwd=cwd, env=env)
+    require_registry_smoke(
+        "Recall (read-only)" in human_result.stdout
+        and "Privacy: recall is read-only" in human_result.stdout,
+        context=f"{context} human",
+        cmd=human_cmd,
+        message="learn recall human output missing read-only markers",
+    )
+    require_registry_smoke(
+        profile_path.read_text(encoding="utf-8") == before,
+        context=f"{context} read-only",
+        cmd=human_cmd,
+        message="learn recall must not mutate the learning profile",
+    )
+
+
+def write_learning_stats_fixture_snapshot(profile_path: Path) -> str:
+    return profile_path.read_text(encoding="utf-8")
+
+
 def assert_learning_stats_json(
     raw: str,
     *,
@@ -2621,6 +2840,45 @@ def assert_version_json_smoke(cmd: list[str], *, env: dict[str, str], cwd: Path
     assert_version_json(result.stdout, context=context, cmd=cmd)
 
 
+def assert_design_ai_mcp_protocol_smoke(
+    cmd: list[str],
+    *,
+    env: dict[str, str],
+    cwd: Path | None,
+    context: str,
+) -> None:
+    print(f"$ {format_cmd(cmd)} < MCP smoke", flush=True)
+    result = subprocess.run(
+        cmd,
+        cwd=cwd,
+        env=env,
+        input=mcp_smoke_input(),
+        text=True,
+        capture_output=True,
+        timeout=15,
+    )
+    if result.stdout:
+        print(result.stdout, end="")
+    if result.stderr:
+        print(result.stderr, end="", file=sys.stderr)
+
+    if result.returncode != 0:
+        raise SystemExit(f"command failed with exit code {result.returncode}: {format_cmd(cmd)}")
+
+    output = f"{result.stdout}\n{result.stderr}"
+    assert_no_ansi(output, cmd)
+
+    responses = []
+    for line in result.stdout.splitlines():
+        if not line.strip():
+            continue
+        try:
+            responses.append(json.loads(line))
+        except json.JSONDecodeError as error:
+            raise SystemExit(f"{context}: MCP stdout line is not JSON: {error}") from error
+    assert_design_ai_mcp_protocol_responses(responses, context=context, cmd=cmd)
+
+
 def assert_workspace_json_smoke(cmd: list[str], *, env: dict[str, str], cwd: Path | None = None, context: str) -> None:
     result = run_plain(cmd, cwd=cwd, env=env)
     assert_workspace_json(result.stdout, context=context, cmd=cmd)
@@ -3031,6 +3289,7 @@ def assert_site_bundle_smoke(
         "summary.json",
         "website-workspace.tasks.json",
         "mcp-check.json",
+        "mcp-probes.json",
         "mcp-action-plan.md",
         "website-handoff.md",
         "website-prompts.md",
@@ -3046,8 +3305,26 @@ def assert_site_bundle_smoke(
         raise SystemExit(f"site bundle after {context} summary status changed: {summary.get('status')!r}")
     if summary.get("taskGeneration", {}).get("totalTasks") != 3:
         raise SystemExit(f"site bundle after {context} expected 3 generated/retained tasks")
+    evidence_counts = summary.get("implementationEvidence")
+    if (
+        not isinstance(evidence_counts, dict)
+        or evidence_counts.get("executedWork") != 0
+        or evidence_counts.get("verificationResults") != 0
+        or evidence_counts.get("remainingRisks") != 3
+        or evidence_counts.get("nextActions") != 0
+    ):
+        raise SystemExit(f"site bundle after {context} implementation evidence counts changed")
     if summary.get("files") != expected_files:
         raise SystemExit(f"site bundle after {context} file manifest changed")
+    execution_checklist = summary.get("handoff", {}).get("executionChecklist")
+    if not isinstance(execution_checklist, list) or [item.get("id") for item in execution_checklist] != [
+        "confirm-target-repo",
+        "inspect-architecture",
+        "apply-focused-task",
+        "verify-quality-gates",
+        "record-handoff-evidence",
+    ]:
+        raise SystemExit(f"site bundle after {context} handoff execution checklist changed")
     checksums = summary.get("checksums", {})
     checksum_files = checksums.get("files", {})
     if checksums.get("algorithm") != "sha256":
@@ -3066,9 +3343,14 @@ def assert_site_bundle_smoke(
     task_ids = [task.get("id") for task in tasks.get("refactorTasks", [])]
     if task_ids != ["task-homepage-cta", "task-accessibility", "task-content-quality"]:
         raise SystemExit(f"site bundle after {context} task ids changed: {task_ids!r}")
+    evidence = tasks.get("implementationEvidence")
+    if not isinstance(evidence, dict) or len(evidence.get("remainingRisks", [])) != 3:
+        raise SystemExit(f"site bundle after {context} did not preserve implementationEvidence in workspace JSON")
 
     mcp_check = json.loads((out_dir / "mcp-check.json").read_text(encoding="utf-8"))
     assert_site_mcp_check_json(json.dumps(mcp_check), context=context, cmd=cmd)
+    mcp_probes = json.loads((out_dir / "mcp-probes.json").read_text(encoding="utf-8"))
+    assert_site_bundle_mcp_probes_payload(mcp_probes, context=context)
     assert_site_mcp_plan_markdown((out_dir / "mcp-action-plan.md").read_text(encoding="utf-8"), context=context, cmd=cmd)
     implementation_prompt = (out_dir / "codex-implementation.md").read_text(encoding="utf-8")
     assert_no_ansi(implementation_prompt, cmd)
@@ -3083,6 +3365,8 @@ def assert_site_bundle_smoke(
     readme = (out_dir / "README.md").read_text(encoding="utf-8")
     if "Website improvement handoff bundle" not in readme or "does not call external MCPs" not in readme:
         raise SystemExit(f"site bundle after {context} README missing bundle boundary guidance")
+    if "Target Repo Execution Checklist" not in readme or "Run target repo quality gates" not in readme:
+        raise SystemExit(f"site bundle after {context} README missing target repo execution checklist")
 
 
 def assert_site_warning_bundle_smoke(
@@ -3141,22 +3425,82 @@ def assert_site_bundle_check_json_smoke(
     env: dict[str, str],
     cwd: Path | None = None,
     context: str,
+    expected_evidence_counts: dict[str, int] | None = None,
 ) -> None:
+    if expected_evidence_counts is None:
+        expected_evidence_counts = {
+            "executedWork": 0,
+            "verificationResults": 0,
+            "remainingRisks": 3,
+            "nextActions": 0,
+        }
     result = run_plain(cmd, cwd=cwd, env=env)
     assert_no_ansi(result.stdout, cmd)
     payload = json.loads(result.stdout)
     if payload.get("status") != "pass" or payload.get("valid") is not True:
         raise SystemExit(f"site bundle check after {context} expected pass/valid output")
-    if payload.get("counts", {}).get("presentFiles") != 8:
-        raise SystemExit(f"site bundle check after {context} expected 8 present files")
-    if payload.get("counts", {}).get("verifiedChecksumFiles") != 7:
-        raise SystemExit(f"site bundle check after {context} expected 7 verified checksum files")
+    if payload.get("externalCalls") is not False or payload.get("targetRepoMutation") is not False:
+        raise SystemExit(f"site bundle check after {context} boundary flags changed")
+    boundaries = payload.get("boundaries")
+    if (
+        not isinstance(boundaries, list)
+        or "deterministic-local" not in boundaries
+        or "no-external-mcp-calls" not in boundaries
+        or "no-target-repo-mutation" not in boundaries
+    ):
+        raise SystemExit(f"site bundle check after {context} boundary list changed: {boundaries!r}")
+    if payload.get("counts", {}).get("presentFiles") != 9:
+        raise SystemExit(f"site bundle check after {context} expected 9 present files")
+    if payload.get("counts", {}).get("verifiedChecksumFiles") != 8:
+        raise SystemExit(f"site bundle check after {context} expected 8 verified checksum files")
     if payload.get("counts", {}).get("checksumFailures") != 0:
         raise SystemExit(f"site bundle check after {context} expected no checksum failures")
+    if payload.get("counts", {}).get("verifiedGeneratedFiles") != 8:
+        raise SystemExit(f"site bundle check after {context} expected 8 current-contract generated files")
+    if payload.get("counts", {}).get("generatedFailures") != 0:
+        raise SystemExit(f"site bundle check after {context} expected no generated bundle contract failures")
+    generated_contract = payload.get("generatedContract")
+    if not isinstance(generated_contract, dict) or generated_contract.get("available") is not True:
+        raise SystemExit(f"site bundle check after {context} generated contract diagnostics missing")
+    if generated_contract.get("expectedFiles") != 8 or generated_contract.get("verifiedFiles") != 8:
+        raise SystemExit(f"site bundle check after {context} generated contract file counts changed")
+    if generated_contract.get("driftFiles") != []:
+        raise SystemExit(f"site bundle check after {context} expected no generated contract drift files")
+    generated_files = generated_contract.get("files")
+    if not isinstance(generated_files, list) or len(generated_files) != 8:
+        raise SystemExit(f"site bundle check after {context} expected 8 generated contract file diagnostics")
+    for item in generated_files:
+        if item.get("present") is not True or item.get("matches") is not True:
+            raise SystemExit(f"site bundle check after {context} generated contract file did not match: {item!r}")
+        for key in ("expectedDigest", "actualDigest"):
+            digest = item.get(key)
+            if not isinstance(digest, str) or len(digest) != 64 or any(char not in "0123456789abcdef" for char in digest):
+                raise SystemExit(f"site bundle check after {context} generated contract {key} is not a SHA-256 hex digest")
+    repair_guidance = payload.get("repairGuidance")
+    if not isinstance(repair_guidance, dict) or repair_guidance.get("available") is not True:
+        raise SystemExit(f"site bundle check after {context} repair guidance missing")
+    if repair_guidance.get("targetRepoMutation") is not False or repair_guidance.get("externalCalls") is not False:
+        raise SystemExit(f"site bundle check after {context} repair guidance boundary flags changed")
+    repair_command = repair_guidance.get("command")
+    verify_command = repair_guidance.get("verifyCommand")
+    if (
+        not isinstance(repair_command, str)
+        or "website-workspace.tasks.json --bundle --out " not in repair_command
+        or " --force" not in repair_command
+    ):
+        raise SystemExit(f"site bundle check after {context} repair command changed: {repair_command!r}")
+    if not isinstance(verify_command, str) or "--bundle-check --strict --json" not in verify_command:
+        raise SystemExit(f"site bundle check after {context} repair verify command changed: {verify_command!r}")
     if payload.get("summary", {}).get("totalTasks") != 3:
         raise SystemExit(f"site bundle check after {context} expected 3 tasks")
     if payload.get("summary", {}).get("siteName") != "Korean SaaS marketing site":
         raise SystemExit(f"site bundle check after {context} site name changed")
+    evidence_counts = payload.get("summary", {}).get("implementationEvidence")
+    if not isinstance(evidence_counts, dict):
+        raise SystemExit(f"site bundle check after {context} implementationEvidence counts missing")
+    for key, expected in expected_evidence_counts.items():
+        if evidence_counts.get(key) != expected:
+            raise SystemExit(f"site bundle check after {context} evidence count {key} changed: {evidence_counts.get(key)!r}")
     if payload.get("summary", {}).get("checksumAlgorithm") != "sha256":
         raise SystemExit(f"site bundle check after {context} checksum algorithm changed")
     bundle_digest = payload.get("summary", {}).get("checksumBundleDigest")
@@ -3164,6 +3508,18 @@ def assert_site_bundle_check_json_smoke(
         raise SystemExit(f"site bundle check after {context} bundle digest changed")
     if payload.get("mcpStatus") != "pass":
         raise SystemExit(f"site bundle check after {context} MCP status changed")
+    if payload.get("mcpProbeStatus") != "pass":
+        raise SystemExit(f"site bundle check after {context} MCP probe status changed")
+    assert_site_mcp_probe_counts(
+        payload.get("mcpProbeCounts"),
+        context=context,
+        label="site bundle check",
+    )
+    assert_site_mcp_probe_counts(
+        payload.get("summary", {}).get("mcpProbeCounts"),
+        context=context,
+        label="site bundle check summary",
+    )
     issue_ids = [issue.get("id") for issue in payload.get("issues", [])]
     if issue_ids != ["bundle-ready"]:
         raise SystemExit(f"site bundle check after {context} expected bundle-ready only, got {issue_ids!r}")
@@ -3175,7 +3531,15 @@ def assert_site_bundle_compare_json_smoke(
     env: dict[str, str],
     cwd: Path | None = None,
     context: str,
+    expected_evidence_counts: dict[str, int] | None = None,
 ) -> None:
+    if expected_evidence_counts is None:
+        expected_evidence_counts = {
+            "executedWork": 0,
+            "verificationResults": 0,
+            "remainingRisks": 3,
+            "nextActions": 0,
+        }
     result = run_plain(cmd, cwd=cwd, env=env)
     assert_no_ansi(result.stdout, cmd)
     payload = json.loads(result.stdout)
@@ -3191,6 +3555,21 @@ def assert_site_bundle_compare_json_smoke(
             raise SystemExit(f"site bundle compare after {context} {side} bundle digest changed")
         if payload.get(side, {}).get("siteName") != "Korean SaaS marketing site":
             raise SystemExit(f"site bundle compare after {context} {side} site name changed")
+        assert_site_mcp_probe_counts(
+            payload.get(side, {}).get("mcpProbeCounts"),
+            context=context,
+            label=f"site bundle compare {side}",
+        )
+        if payload.get(side, {}).get("verifiedGeneratedFiles") != 8 or payload.get(side, {}).get("generatedFailures") != 0:
+            raise SystemExit(f"site bundle compare after {context} {side} generated bundle contract verification changed")
+        if payload.get(side, {}).get("generatedDriftFiles") != []:
+            raise SystemExit(f"site bundle compare after {context} {side} generated bundle contract drift changed")
+        evidence_counts = payload.get(side, {}).get("implementationEvidence")
+        if not isinstance(evidence_counts, dict):
+            raise SystemExit(f"site bundle compare after {context} {side} implementationEvidence counts missing")
+        for key, expected in expected_evidence_counts.items():
+            if evidence_counts.get(key) != expected:
+                raise SystemExit(f"site bundle compare after {context} {side} evidence count {key} changed: {evidence_counts.get(key)!r}")
     issue_ids = [issue.get("id") for issue in payload.get("issues", [])]
     if issue_ids != ["bundle-compare-identical"]:
         raise SystemExit(f"site bundle compare after {context} expected bundle-compare-identical only, got {issue_ids!r}")
@@ -3202,17 +3581,72 @@ def assert_site_bundle_handoff_json_smoke(
     env: dict[str, str],
     cwd: Path | None = None,
     context: str,
+    expected_evidence_counts: dict[str, int] | None = None,
 ) -> None:
+    if expected_evidence_counts is None:
+        expected_evidence_counts = {
+            "executedWork": 0,
+            "verificationResults": 0,
+            "remainingRisks": 3,
+            "nextActions": 0,
+        }
     result = run_plain(cmd, cwd=cwd, env=env)
     assert_no_ansi(result.stdout, cmd)
     payload = json.loads(result.stdout)
     if payload.get("status") != "pass" or payload.get("valid") is not True:
         raise SystemExit(f"site bundle handoff after {context} expected pass/valid output")
+    expected_boundaries = [
+        "deterministic-local",
+        "no-external-mcp-calls",
+        "no-target-repo-mutation",
+        "no-lighthouse-axe-visual-diff",
+        "target-repo-work-after-handoff",
+    ]
+    if payload.get("boundaries") != expected_boundaries:
+        raise SystemExit(f"site bundle handoff after {context} boundary list changed: {payload.get('boundaries')!r}")
+    if payload.get("externalCalls") is not False or payload.get("targetRepoMutation") is not False:
+        raise SystemExit(f"site bundle handoff after {context} boundary flags changed")
     bundle = payload.get("bundle", {})
+    source_bundle = payload.get("sourceBundle")
+    if not isinstance(source_bundle, dict):
+        raise SystemExit(f"site bundle handoff after {context} source bundle provenance missing")
+    if bundle.get("sourceBundle") != source_bundle:
+        raise SystemExit(f"site bundle handoff after {context} source bundle provenance is not mirrored under bundle")
+    if (
+        source_bundle.get("status") != "pass"
+        or source_bundle.get("valid") is not True
+        or source_bundle.get("sourceWorkspace") != "stdin"
+        or source_bundle.get("siteName") != "Korean SaaS marketing site"
+    ):
+        raise SystemExit(f"site bundle handoff after {context} source bundle provenance summary changed: {source_bundle!r}")
+    if (
+        source_bundle.get("verifiedGeneratedFiles") != 8
+        or source_bundle.get("expectedGeneratedFiles") != 8
+        or source_bundle.get("verifiedChecksumFiles") != 8
+        or source_bundle.get("expectedChecksumFiles") != 8
+    ):
+        raise SystemExit(f"site bundle handoff after {context} source bundle provenance verification counts changed: {source_bundle!r}")
     if bundle.get("siteName") != "Korean SaaS marketing site":
         raise SystemExit(f"site bundle handoff after {context} site name changed")
-    if bundle.get("verifiedChecksumFiles") != 7 or bundle.get("checksumFailures") != 0:
+    if bundle.get("boundaries") != expected_boundaries:
+        raise SystemExit(f"site bundle handoff after {context} bundle boundary list changed: {bundle.get('boundaries')!r}")
+    if bundle.get("externalCalls") is not False or bundle.get("targetRepoMutation") is not False:
+        raise SystemExit(f"site bundle handoff after {context} bundle boundary flags changed")
+    if bundle.get("verifiedChecksumFiles") != 8 or bundle.get("checksumFailures") != 0:
         raise SystemExit(f"site bundle handoff after {context} checksum verification changed")
+    if bundle.get("verifiedGeneratedFiles") != 8 or bundle.get("generatedFailures") != 0:
+        raise SystemExit(f"site bundle handoff after {context} generated bundle contract verification changed")
+    assert_site_mcp_probe_counts(
+        bundle.get("mcpProbeCounts"),
+        context=context,
+        label="site bundle handoff",
+    )
+    evidence_counts = bundle.get("implementationEvidence")
+    if not isinstance(evidence_counts, dict):
+        raise SystemExit(f"site bundle handoff after {context} implementationEvidence counts missing")
+    for key, expected in expected_evidence_counts.items():
+        if evidence_counts.get(key) != expected:
+            raise SystemExit(f"site bundle handoff after {context} evidence count {key} changed: {evidence_counts.get(key)!r}")
     digest = bundle.get("checksumBundleDigest")
     if not isinstance(digest, str) or len(digest) != 64:
         raise SystemExit(f"site bundle handoff after {context} bundle digest changed")
@@ -3221,9 +3655,9 @@ def assert_site_bundle_handoff_json_smoke(
         raise SystemExit(f"site bundle handoff after {context} prompt missing")
     for fragment in (
         "Website improvement target-repo handoff prompt",
-        "Bundle digest:",
-        "Run `design-ai site",
-        "Work inside the target website repository, not inside the design-ai repository.",
+        "SHA-256 bundle digest:",
+        "Source bundle strict check command: `design-ai site",
+        "You are Codex working in the target website repository, not in the design-ai repository.",
         "# Codex implementation prompt",
     ):
         if fragment not in prompt:
@@ -4085,6 +4519,56 @@ def assert_pack_stdin_smoke(
     )
 
 
+def assert_recall_context(payload: dict[str, object], *, context: str, cmd: list[str]) -> None:
+    recall = payload.get("recall")
+    require_registry_smoke(
+        isinstance(recall, dict),
+        context=context,
+        cmd=cmd,
+        message="recall should be present when --with-recall is used",
+    )
+    require_registry_smoke(
+        recall.get("mode") == "lexical",
+        context=context,
+        cmd=cmd,
+        message="recall should use the deterministic lexical scorer",
+    )
+    selected_count = recall.get("selectedCount")
+    require_registry_smoke(
+        isinstance(selected_count, int) and selected_count >= 1,
+        context=context,
+        cmd=cmd,
+        message="recall should select at least one corpus file for the Button brief",
+    )
+    selected = recall.get("selected")
+    require_registry_smoke(
+        isinstance(selected, list) and len(selected) == selected_count and len(selected) >= 1,
+        context=context,
+        cmd=cmd,
+        message="recall selected list should match the reported selected count",
+    )
+    top = selected[0]
+    require_registry_smoke(
+        isinstance(top, dict) and isinstance(top.get("id"), str) and top.get("id"),
+        context=context,
+        cmd=cmd,
+        message="recall selection should cite the corpus relPath as its id",
+    )
+    require_registry_smoke(
+        type(top.get("score")) in (int, float) and top.get("score") > 0,
+        context=context,
+        cmd=cmd,
+        message="recall selection should include a positive relevance score",
+    )
+    markdown = recall.get("markdown")
+    require_registry_smoke(
+        isinstance(markdown, str) and "## Recalled design knowledge" in markdown and top.get("id") in markdown,
+        context=context,
+        cmd=cmd,
+        message="recall markdown should carry the Recalled design knowledge section and cite the top file",
+    )
+
+
 def assert_learning_relevance_context(payload: dict[str, object], *, context: str, cmd: list[str]) -> None:
     learning_context = payload.get("learningContext")
     require_registry_smoke(
@@ -4502,7 +4986,7 @@ def assert_learning_signals_report_smoke(
     cwd: Path | None = None,
     context: str,
 ) -> None:
-    seed_force_overwrite_target(output_path, context=context, cmd=["design-ai", "learn", "--signals", "--report"])
+    seed_force_overwrite_target(output_path, context=context, cmd=["design-ai", "learn", "--signals", "--report", "--force"])
     cmd = command_factory(
         "learn",
         "--signals",
@@ -4536,7 +5020,7 @@ def assert_learning_agent_backlog_report_smoke(
     cwd: Path | None = None,
     context: str,
 ) -> None:
-    seed_force_overwrite_target(output_path, context=context, cmd=["design-ai", "learn", "--agent-backlog", "--report"])
+    seed_force_overwrite_target(output_path, context=context, cmd=["design-ai", "learn", "--agent-backlog", "--report", "--force"])
     cmd = command_factory(
         "learn",
         "--agent-backlog",
@@ -4662,6 +5146,49 @@ def assert_learning_relevance_smoke(
     require_registry_smoke(isinstance(plan, dict), context=f"{context} pack", cmd=pack_cmd, message="pack plan missing")
     assert_learning_relevance_context(plan, context=f"{context} pack plan", cmd=pack_cmd)
 
+    recall_prompt_cmd = command_factory(
+        "prompt",
+        EXPECTED_ROUTE_BRIEF,
+        "--route",
+        EXPECTED_ROUTE_ID,
+        "--with-recall",
+        "--recall-limit",
+        "3",
+        "--json",
+    )
+    recall_prompt_result = run_plain(recall_prompt_cmd, cwd=cwd, env=relevance_env)
+    try:
+        recall_prompt_payload = json.loads(recall_prompt_result.stdout)
+    except json.JSONDecodeError as error:
+        raise SystemExit(f"{context}: failed to parse prompt recall JSON") from error
+    assert_recall_context(recall_prompt_payload, context=f"{context} prompt recall", cmd=recall_prompt_cmd)
+
+    recall_pack_cmd = command_factory(
+        "pack",
+        EXPECTED_ROUTE_BRIEF,
+        "--route",
+        EXPECTED_ROUTE_ID,
+        "--with-recall",
+        "--recall-limit",
+        "3",
+        "--max-bytes",
+        str(EXPECTED_PACK_MAX_BYTES),
+        "--json",
+    )
+    recall_pack_result = run_plain(recall_pack_cmd, cwd=cwd, env=relevance_env)
+    try:
+        recall_pack_payload = json.loads(recall_pack_result.stdout)
+    except json.JSONDecodeError as error:
+        raise SystemExit(f"{context}: failed to parse pack recall JSON") from error
+    recall_plan = recall_pack_payload.get("plan")
+    require_registry_smoke(
+        isinstance(recall_plan, dict),
+        context=f"{context} pack recall",
+        cmd=recall_pack_cmd,
+        message="pack recall plan missing",
+    )
+    assert_recall_context(recall_plan, context=f"{context} pack recall plan", cmd=recall_pack_cmd)
+
     eval_template_path = profile_path.with_name(f"{profile_path.stem}-eval-template.json")
     eval_template_path.write_text("stale eval template output\n", encoding="utf-8")
     eval_template_cmd = command_factory(
@@ -4728,6 +5255,166 @@ def assert_learning_relevance_smoke(
     )
 
 
+def assert_index_roundtrip_smoke(
+    command_factory,
+    index_dir: Path,
+    profile_path: Path,
+    *,
+    env: dict[str, str],
+    cwd: Path | None = None,
+    context: str,
+) -> None:
+    """`index --build` -> `index --status` -> `index --verify` round-trip against a
+    temp index dir and learning profile, isolated from the ambient environment."""
+    index_dir.mkdir(parents=True, exist_ok=True)
+    write_learning_relevance_fixture(profile_path)
+    index_env = env.copy()
+    index_env["DESIGN_AI_INDEX_DIR"] = str(index_dir)
+    index_env["DESIGN_AI_LEARNING_FILE"] = str(profile_path)
+
+    build_cmd = command_factory("index", "--build", "--json")
+    build_result = run_plain(build_cmd, cwd=cwd, env=index_env)
+    assert_index_build_json(
+        build_result.stdout,
+        index_dir=str(index_dir),
+        context=f"{context} build",
+        cmd=build_cmd,
+    )
+
+    status_cmd = command_factory("index", "--status", "--json")
+    status_result = run_plain(status_cmd, cwd=cwd, env=index_env)
+    assert_index_status_json(
+        status_result.stdout,
+        index_dir=str(index_dir),
+        context=f"{context} status",
+        cmd=status_cmd,
+    )
+
+    verify_cmd = command_factory("index", "--verify", "--json")
+    verify_result = run_plain(verify_cmd, cwd=cwd, env=index_env)
+    assert_index_verify_json(
+        verify_result.stdout,
+        index_dir=str(index_dir),
+        context=f"{context} verify",
+        cmd=verify_cmd,
+    )
+
+
+def assert_ranked_search_determinism_smoke(
+    command_factory,
+    index_dir: Path,
+    *,
+    env: dict[str, str],
+    cwd: Path | None = None,
+    context: str,
+) -> None:
+    """Two identical `search --ranked --json` runs must produce byte-identical output."""
+    index_dir.mkdir(parents=True, exist_ok=True)
+    ranked_env = env.copy()
+    ranked_env["DESIGN_AI_INDEX_DIR"] = str(index_dir)
+
+    ranked_cmd = command_factory(
+        "search",
+        EXPECTED_CORPUS_SEARCH_QUERY,
+        "--dir",
+        "knowledge",
+        "--limit",
+        str(EXPECTED_RANKED_SEARCH_LIMIT),
+        "--ranked",
+        "--json",
+    )
+    first_result = run_plain(ranked_cmd, cwd=cwd, env=ranked_env)
+    second_result = run_plain(ranked_cmd, cwd=cwd, env=ranked_env)
+    assert_ranked_search_json(
+        first_result.stdout,
+        context=f"{context} payload",
+        cmd=ranked_cmd,
+        expected_notice=EXPECTED_RANKED_SEARCH_NOT_BUILT_NOTICE,
+    )
+    assert_ranked_search_determinism(
+        first_result.stdout,
+        second_result.stdout,
+        context=context,
+        cmd=ranked_cmd,
+    )
+
+
+def assert_embeddings_off_by_default_smoke(
+    command_factory,
+    index_dir: Path,
+    profile_path: Path,
+    *,
+    env: dict[str, str],
+    cwd: Path | None = None,
+    context: str,
+) -> None:
+    """Phase B is opt-in: a plain `index --build` never touches embeddings, and
+    `index --status` reports `embeddings: null` (the feature is simply unused)."""
+    index_dir.mkdir(parents=True, exist_ok=True)
+    write_learning_relevance_fixture(profile_path)
+    index_env = env.copy()
+    index_env["DESIGN_AI_INDEX_DIR"] = str(index_dir)
+    index_env["DESIGN_AI_LEARNING_FILE"] = str(profile_path)
+    # Point at a config file that is guaranteed not to exist, rather than relying on
+    # the ambient environment lacking DESIGN_AI_CONFIG_FILE — a real ~/.design-ai/
+    # config.json on the machine running this smoke must not leak into the test.
+    index_env["DESIGN_AI_CONFIG_FILE"] = str(index_dir.parent / "no-config-here" / "config.json")
+
+    build_cmd = command_factory("index", "--build", "--json")
+    build_result = run_plain(build_cmd, cwd=cwd, env=index_env)
+    build_payload = json.loads(build_result.stdout)
+    if "embeddings" in build_payload:
+        raise SystemExit(f"index build JSON after {context} unexpectedly ran provider execution with plain --build")
+
+    status_cmd = command_factory("index", "--status", "--json")
+    status_result = run_plain(status_cmd, cwd=cwd, env=index_env)
+    assert_index_status_json(
+        status_result.stdout,
+        index_dir=str(index_dir),
+        context=f"{context} status",
+        cmd=status_cmd,
+        expect_embeddings=False,
+    )
+
+
+def assert_search_embeddings_no_provider_fallback_smoke(
+    command_factory,
+    *,
+    env: dict[str, str],
+    cwd: Path | None = None,
+    context: str,
+    config_file: Path,
+) -> None:
+    """`search --ranked --embeddings` with no provider configured (flag or config)
+    degrades to the lexical backend with a notice and exit code 0."""
+    fallback_env = env.copy()
+    # Same isolation rationale as assert_embeddings_off_by_default_smoke: point at a
+    # config path guaranteed not to exist rather than trusting the ambient environment.
+    fallback_env["DESIGN_AI_CONFIG_FILE"] = str(config_file)
+
+    search_cmd = command_factory(
+        "search",
+        EXPECTED_CORPUS_SEARCH_QUERY,
+        "--dir",
+        "knowledge",
+        "--limit",
+        str(EXPECTED_RANKED_SEARCH_LIMIT),
+        "--ranked",
+        "--embeddings",
+        "--json",
+    )
+    result = run_plain(search_cmd, cwd=cwd, env=fallback_env)
+    assert_ranked_search_json(
+        result.stdout,
+        context=f"{context} payload",
+        cmd=search_cmd,
+        expected_backend="lexical",
+    )
+    payload = json.loads(result.stdout)
+    if "embedding provider" not in payload.get("notice", "") and "no embedding provider configured" not in payload.get("notice", ""):
+        raise SystemExit(f"search ranked JSON after {context} fallback notice does not mention the missing provider")
+
+
 def wait_for_registry_package(
     package_spec: str,
     *,
@@ -4800,6 +5487,12 @@ def smoke_registry_package(package_spec: str, *, retries: int, delay: float) ->
             env=env,
             context="registry smoke npm exec version JSON",
         )
+        assert_design_ai_mcp_protocol_smoke(
+            npm_exec_mcp_cmd(package_spec),
+            cwd=npx_root,
+            env=env,
+            context="registry smoke npm exec design-ai-mcp protocol",
+        )
         assert_workspace_json_smoke(
             npm_exec_cmd(package_spec, "workspace", "--json"),
             cwd=npx_root,
@@ -5753,6 +6446,13 @@ def smoke_registry_package(package_spec: str, *, retries: int, delay: float) ->
             env=env,
             context="registry smoke npm exec learn stats",
         )
+        assert_learning_recall_smoke(
+            lambda *args: npm_exec_cmd(package_spec, *args),
+            npx_root / "registry-recall-learning.json",
+            cwd=npx_root,
+            env=env,
+            context="registry smoke npm exec learn recall",
+        )
         assert_learning_audit_cleanup_smoke(
             lambda *args: npm_exec_cmd(package_spec, *args),
             npx_root / "registry-audit-learning.json",
@@ -5767,6 +6467,36 @@ def smoke_registry_package(package_spec: str, *, retries: int, delay: float) ->
             env=env,
             context="registry smoke npm exec learning relevance",
         )
+        assert_index_roundtrip_smoke(
+            lambda *args: npm_exec_cmd(package_spec, *args),
+            npx_root / "registry-index",
+            npx_root / "registry-index-learning.json",
+            cwd=npx_root,
+            env=env,
+            context="registry smoke npm exec index roundtrip",
+        )
+        assert_ranked_search_determinism_smoke(
+            lambda *args: npm_exec_cmd(package_spec, *args),
+            npx_root / "registry-ranked-search-index",
+            cwd=npx_root,
+            env=env,
+            context="registry smoke npm exec ranked search determinism",
+        )
+        assert_embeddings_off_by_default_smoke(
+            lambda *args: npm_exec_cmd(package_spec, *args),
+            npx_root / "registry-embeddings-off-index",
+            npx_root / "registry-embeddings-off-learning.json",
+            cwd=npx_root,
+            env=env,
+            context="registry smoke npm exec embeddings off by default",
+        )
+        assert_search_embeddings_no_provider_fallback_smoke(
+            lambda *args: npm_exec_cmd(package_spec, *args),
+            cwd=npx_root,
+            env=env,
+            context="registry smoke npm exec search embeddings no provider fallback",
+            config_file=npx_root / "registry-no-config-here" / "config.json",
+        )
         assert_update_dry_run_smoke(
             npm_exec_cmd(package_spec, "update", "--dry-run"),
             cwd=npx_root,
@@ -6192,6 +6922,41 @@ def run_self_test() -> None:
             expected="without external calls",
             scope="registry smoke",
         )
+        mcp_protocol_cmd = ["design-ai-mcp"]
+        assert_design_ai_mcp_protocol_responses(
+            [
+                {"jsonrpc": "2.0", "id": 1, "result": {"serverInfo": {"name": "design-ai"}}},
+                {"jsonrpc": "2.0", "id": 2, "result": {"tools": [{"name": "design_ai_route"}, {"name": "design_ai_search"}]}},
+                {
+                    "jsonrpc": "2.0",
+                    "id": 3,
+                    "error": {"code": -32602, "message": "design_ai_search.limit must be an integer"},
+                },
+            ],
+            context="registry smoke self-test design-ai MCP protocol",
+            cmd=mcp_protocol_cmd,
+        )
+        expect_self_test_failure(
+            lambda: assert_design_ai_mcp_protocol_responses(
+                [
+                    {"jsonrpc": "2.0", "id": 1, "result": {"serverInfo": {"name": "design-ai"}}},
+                    {
+                        "jsonrpc": "2.0",
+                        "id": 2,
+                        "result": {"tools": [{"name": "design_ai_route"}, {"name": "design_ai_search"}]},
+                    },
+                    {
+                        "jsonrpc": "2.0",
+                        "id": 3,
+                        "error": {"code": -32602, "message": "wrong validation message"},
+                    },
+                ],
+                context="registry smoke self-test design-ai MCP protocol",
+                cmd=mcp_protocol_cmd,
+            ),
+            expected="MCP invalid argument response did not preserve invalid params validation",
+            scope="registry smoke",
+        )
         assert_site_mcp_plan_markdown(
             passing_site_mcp_plan_markdown(),
             context="registry smoke self-test site mcp-plan",
@@ -7929,6 +8694,38 @@ def run_self_test() -> None:
             scope="registry smoke",
         )
 
+        recall_payload = {
+            "recall": {
+                "query": EXPECTED_ROUTE_BRIEF,
+                "mode": "lexical",
+                "candidateCount": 42,
+                "selectedCount": 1,
+                "selected": [
+                    {
+                        "id": "knowledge/components/INDEX.md",
+                        "score": 9.5,
+                        "matchedTokens": ["button", "component"],
+                    },
+                ],
+                "markdown": (
+                    "## Recalled design knowledge\n\n"
+                    "- knowledge/components/INDEX.md\n"
+                    "  - Component index"
+                ),
+            },
+        }
+        recall_cmd = ["design-ai", "prompt", EXPECTED_ROUTE_BRIEF, "--with-recall", "--json"]
+        assert_recall_context(recall_payload, context="registry smoke self-test", cmd=recall_cmd)
+        expect_self_test_failure(
+            lambda: assert_recall_context(
+                {**recall_payload, "recall": {**recall_payload["recall"], "selectedCount": 0, "selected": []}},
+                context="registry smoke self-test",
+                cmd=recall_cmd,
+            ),
+            expected="recall should select at least one corpus file",
+            scope="registry smoke",
+        )
+
         learning_audit_path = tmp_root / "learning-audit.json"
         duplicate_command_args = [
             "design-ai",
@@ -8135,6 +8932,111 @@ def run_self_test() -> None:
             scope="registry smoke",
         )
 
+        index_dir = str(tmp_root / "registry-index-self-test")
+        index_build_cmd = ["design-ai", "index", "--build", "--json"]
+        assert_index_build_json(
+            passing_index_build_json(index_dir),
+            index_dir=index_dir,
+            context="registry smoke self-test",
+            cmd=index_build_cmd,
+        )
+        expect_self_test_failure(
+            lambda: assert_index_build_json(
+                "{",
+                index_dir=index_dir,
+                context="registry smoke self-test",
+                cmd=index_build_cmd,
+            ),
+            expected="failed to parse index build JSON",
+            scope="registry smoke",
+        )
+
+        index_status_cmd = ["design-ai", "index", "--status", "--json"]
+        assert_index_status_json(
+            passing_index_status_json(index_dir),
+            index_dir=index_dir,
+            context="registry smoke self-test",
+            cmd=index_status_cmd,
+        )
+        assert_index_status_json(
+            passing_index_status_json(index_dir, with_embeddings=True),
+            index_dir=index_dir,
+            context="registry smoke self-test embeddings",
+            cmd=index_status_cmd,
+            expect_embeddings=True,
+        )
+        expect_self_test_failure(
+            lambda: assert_index_status_json(
+                passing_index_status_json(index_dir, with_embeddings=True),
+                index_dir=index_dir,
+                context="registry smoke self-test embeddings unexpected",
+                cmd=index_status_cmd,
+                expect_embeddings=False,
+            ),
+            expected="embeddings is not null when embeddings were not built",
+            scope="registry smoke",
+        )
+
+        index_verify_cmd = ["design-ai", "index", "--verify", "--json"]
+        assert_index_verify_json(
+            passing_index_verify_json(index_dir),
+            index_dir=index_dir,
+            context="registry smoke self-test",
+            cmd=index_verify_cmd,
+        )
+        expect_self_test_failure(
+            lambda: assert_index_verify_json(
+                json.dumps({**json.loads(passing_index_verify_json(index_dir)), "ok": False}),
+                index_dir=index_dir,
+                context="registry smoke self-test",
+                cmd=index_verify_cmd,
+            ),
+            expected="ok is not true",
+            scope="registry smoke",
+        )
+
+        ranked_search_cmd = ["design-ai", "search", EXPECTED_CORPUS_SEARCH_QUERY, "--ranked", "--json"]
+        ranked_search_json = passing_ranked_search_json()
+        assert_ranked_search_json(
+            ranked_search_json,
+            context="registry smoke self-test",
+            cmd=ranked_search_cmd,
+        )
+        assert_ranked_search_determinism(
+            ranked_search_json,
+            ranked_search_json,
+            context="registry smoke self-test",
+            cmd=ranked_search_cmd,
+        )
+        expect_self_test_failure(
+            lambda: assert_ranked_search_determinism(
+                ranked_search_json,
+                passing_ranked_search_json(backend="lexical"),
+                context="registry smoke self-test",
+                cmd=ranked_search_cmd,
+            ),
+            expected="differs between identical runs",
+            scope="registry smoke",
+        )
+
+        ranked_search_fallback_json = passing_ranked_search_json(backend="lexical")
+        assert_ranked_search_json(
+            ranked_search_fallback_json,
+            context="registry smoke self-test fallback",
+            cmd=ranked_search_cmd,
+            expected_backend="lexical",
+        )
+        expect_self_test_failure(
+            lambda: assert_ranked_search_json(
+                passing_ranked_search_json(backend="embeddings"),
+                context="registry smoke self-test fallback mismatch",
+                cmd=ranked_search_cmd,
+                expected_backend="lexical",
+            ),
+            expected="backend differs from expected backend",
+            scope="registry smoke",
+        )
+
     expect_self_test_failure(
         lambda: smoke_registry_package("self-test-package", retries=0, delay=0),
         expected="--retries must be at least 1",