prizmkit 1.1.120 → 1.1.122

package/bundled/dev-pipeline/tests/test_python_runner_parity.py

@@ -904,7 +904,20 @@ def _install_runner_session_fakes(monkeypatch, runners, *, statuses=("success",)
 
     def fake_update(family, invocation, item_id, session_status, session_id, project_root, **metadata):
         updates.append((session_status, session_id, metadata))
-        return SimpleNamespace(ok=True, text="", data={"new_status": update_status})
+        current_update_status = update_status
+        if session_status in {"context_overflow", "infra_error", "crashed", "timed_out", "failed"} and len(status_queue) > 0:
+            current_update_status = "in_progress"
+        return SimpleNamespace(
+            ok=True,
+            text="",
+            data={
+                "new_status": current_update_status,
+                "retry_count": sum(status in {"crashed", "timed_out", "failed"} for status, *_ in updates),
+                "infra_error_count": sum(status == "infra_error" for status, *_ in updates),
+                "continuation_count": len(updates),
+                "context_overflow_count": sum(status == "context_overflow" for status, *_ in updates),
+            },
+        )
 
     def fake_cleanup(runtime, *, delete_branch=True):
         cleanup_calls.append((runtime, delete_branch))
@@ -1096,8 +1109,8 @@ def test_explicit_worktree_materializes_ignored_support_assets_before_prompt_and
     (project / ".prizmkit" / "prizm-docs" / "root.prizm").write_text("PRIZM_VERSION: 1\n", encoding="utf-8")
     (project / ".prizmkit" / "dev-pipeline" / "scripts").mkdir(parents=True)
     (project / ".prizmkit" / "dev-pipeline" / "scripts" / "init-change-artifact.py").write_text("# init", encoding="utf-8")
-    (project / ".prizmkit" / "config.json").write_text("{}", encoding="utf-8")
-    (project / ".prizmkit" / "manifest.json").write_text("{}", encoding="utf-8")
+    (project / ".prizmkit" / "config.json").write_text(json.dumps({"completion_notes": ["Completed durable workflow"]}), encoding="utf-8")
+    (project / ".prizmkit" / "manifest.json").write_text(json.dumps({"completion_notes": ["Completed durable workflow"]}), encoding="utf-8")
 
     paths = resolve_runtime_paths(pipeline_root=PIPELINE_ROOT, project_root=project)
     family = family_for("feature", paths)
@@ -1225,7 +1238,7 @@ def test_has_branch_completion_evidence_requires_task_branch_ahead_of_base(tmp_p
     subprocess.run(["git", "config", "user.name", "Test"], cwd=tmp_path, check=True)
     artifact_dir = tmp_path / ".prizmkit" / "specs" / "001-done"
     artifact_dir.mkdir(parents=True)
-    (artifact_dir / "completion-summary.json").write_text("{}", encoding="utf-8")
+    (artifact_dir / "completion-summary.json").write_text(json.dumps({"completion_notes": ["Completed durable workflow"]}), encoding="utf-8")
     (tmp_path / "base.txt").write_text("base", encoding="utf-8")
     subprocess.run(["git", "add", "base.txt"], cwd=tmp_path, check=True)
     subprocess.run(["git", "commit", "-m", "base"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
@@ -1405,7 +1418,7 @@ def test_default_branch_names_keep_timestamp_for_each_runner_family(monkeypatch,
         ("refactor", "R-001", "refactor/R-001-20260707010203"),
     ],
 )
-def test_no_worktree_failure_stays_on_task_branch_without_merge_for_all_families(monkeypatch, tmp_path, kind, item_id, branch):
+def test_no_worktree_exhausted_failure_stays_on_task_branch_without_merge_for_all_families(monkeypatch, tmp_path, kind, item_id, branch):
     from prizmkit_runtime import runners
     from prizmkit_runtime.runner_models import family_for, parse_invocation
 
@@ -1415,7 +1428,7 @@ def test_no_worktree_failure_stays_on_task_branch_without_merge_for_all_families
     invocation = parse_invocation(family, "run", ())
     plan_path = {"feature": paths.feature_plan, "bugfix": paths.bugfix_plan, "refactor": paths.refactor_plan}[kind]
     invocation = invocation.__class__(**{**invocation.__dict__, "list_path": plan_path})
-    _install_runner_session_fakes(monkeypatch, runners, statuses=("crashed",), update_status="pending")
+    _install_runner_session_fakes(monkeypatch, runners, statuses=("crashed",), update_status="failed")
     events = []
     final_commits = []
     wip_commits = []
@@ -1431,12 +1444,12 @@ def test_no_worktree_failure_stays_on_task_branch_without_merge_for_all_families
 
     status = runners._process_item(family, invocation, item_id, paths, initial_metadata={})
 
-    assert status == "pending"
+    assert status == "failed"
     assert events[0] == "branch_create"
     assert "branch_merge" not in events
     assert events[-1] == ("return", "main", branch)
-    assert final_commits == [(paths.project_root, item_id, "pending")]
-    assert wip_commits == [(paths.project_root, item_id, "pending")]
+    assert final_commits == [(paths.project_root, item_id, "failed")]
+    assert wip_commits == [(paths.project_root, item_id, "failed")]
 
 
 def test_no_worktree_runner_ignores_recovery_side_effect_branch(monkeypatch, tmp_path):
@@ -1845,7 +1858,7 @@ def test_bookkeeping_commits_only_runner_owned_paths(tmp_path):
     item_state.mkdir(parents=True)
     plan = plans / "feature-list.json"
     plan.write_text('{"features": []}', encoding="utf-8")
-    (item_state / "status.json").write_text("{}", encoding="utf-8")
+    (item_state / "status.json").write_text(json.dumps({"completion_notes": ["Completed durable workflow"]}), encoding="utf-8")
     source = tmp_path / "src.txt"
     source.write_text("base", encoding="utf-8")
     subprocess.run(["git", "add", ".prizmkit/plans/feature-list.json", ".prizmkit/state/features/F-001/status.json", "src.txt"], cwd=tmp_path, check=True)
@@ -1899,6 +1912,8 @@ def test_context_overflow_reuses_worktree_and_skips_cleanup_until_terminal_outco
     invocation = parse_invocation(family, "run", ())
     invocation = invocation.__class__(**{**invocation.__dict__, "list_path": paths.feature_plan})
     observed = _install_runner_session_fakes(monkeypatch, runners, statuses=("context_overflow", "success"))
+    sleep_calls = []
+    monkeypatch.setattr(runners.time, "sleep", lambda seconds: sleep_calls.append(seconds))
     setup_calls = []
     monkeypatch.setattr(runners, "ensure_linked_worktree", lambda runtime: (setup_calls.append(runtime) or SimpleNamespace(ok=True, runtime=runtime, reason="")), raising=False)
 
@@ -1911,6 +1926,7 @@ def test_context_overflow_reuses_worktree_and_skips_cleanup_until_terminal_outco
     assert observed.prompt_calls[0].get("continuation") is None
     assert observed.prompt_calls[1]["continuation"]["previous_session_id"] == "F-001-session-1"
     assert observed.updates[0][0] == "context_overflow"
+    assert sleep_calls == [5]
     assert len(observed.cleanup_calls) == 1
     assert observed.cleanup_calls[0][1] is True
 
@@ -1959,7 +1975,7 @@ def test_classification_accepts_late_infra_error_with_completed_checkpoint_and_c
     assert classification.reason == "completed_checkpoint_with_late_runtime_error"
 
 
-def test_classification_rejects_late_infra_when_head_diff_has_no_commit_range(tmp_path):
+def test_classification_accepts_late_infra_with_completion_artifact_without_new_commit(tmp_path):
     from prizmkit_runtime.runner_classification import classify_session
     from prizmkit_runtime.runner_models import PromptGenerationResult
     from prizmkit_runtime.sessions import AISessionCommand, AISessionResult
@@ -1983,7 +1999,7 @@ def test_classification_rejects_late_infra_when_head_diff_has_no_commit_range(tm
     subprocess.run(["git", "checkout", "side"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
     artifact_dir = tmp_path / ".prizmkit" / "specs" / "001-done"
     artifact_dir.mkdir(parents=True)
-    (artifact_dir / "completion-summary.json").write_text("{}", encoding="utf-8")
+    (artifact_dir / "completion-summary.json").write_text(json.dumps({"completion_notes": ["Completed durable workflow"]}), encoding="utf-8")
     log = tmp_path / "session.log"
     log.write_text("quota exceeded", encoding="utf-8")
     raw = AISessionResult(
@@ -2004,7 +2020,8 @@ def test_classification_rejects_late_infra_when_head_diff_has_no_commit_range(tm
 
     classification = classify_session(raw, project_root=tmp_path, base_head=side_head, prompt=prompt)
 
-    assert classification.session_status == "infra_error"
+    assert classification.session_status == "success"
+    assert classification.reason == "completed_checkpoint_with_late_runtime_error"
 
 
 def test_classification_keeps_pre_completion_provider_error_as_infra_error(tmp_path):
@@ -2060,7 +2077,7 @@ def test_classification_accepts_terminal_success_with_completed_checkpoint_witho
     artifact_dir.mkdir(parents=True)
     checkpoint = artifact_dir / "workflow-checkpoint.json"
     checkpoint.write_text(json.dumps({"steps": [{"id": "S01", "skill": "done", "name": "Done", "status": "completed"}]}), encoding="utf-8")
-    (artifact_dir / "completion-summary.json").write_text("{}", encoding="utf-8")
+    (artifact_dir / "completion-summary.json").write_text(json.dumps({"completion_notes": ["Completed durable workflow"]}), encoding="utf-8")
     log = tmp_path / "session.log"
     log.write_text("terminal success", encoding="utf-8")
     raw = AISessionResult(
@@ -2122,8 +2139,8 @@ def test_classification_preserves_success_before_context_overflow(tmp_path):
     )
 
     classification = classify_session(raw, project_root=tmp_path, base_head=base_head)
-    assert classification.session_status == "success"
-    assert classification.reason == "commit_since_base"
+    assert classification.session_status == "context_overflow"
+    assert classification.reason == "context_overflow"
 
 
 def test_classification_crash_with_commit_since_base_does_not_become_success(tmp_path):
@@ -2256,7 +2273,7 @@ def _write_family_case(paths, kind, item_id=""):
         state_dir = paths.refactor_state_dir
         plan = paths.refactor_plan
     state_dir.mkdir(parents=True, exist_ok=True)
-    (state_dir / "pipeline.json").write_text("{}", encoding="utf-8")
+    (state_dir / "pipeline.json").write_text(json.dumps({"completion_notes": ["Completed durable workflow"]}), encoding="utf-8")
     item_state = state_dir / item_id
     item_state.mkdir(parents=True, exist_ok=True)
     (item_state / "status.json").write_text(
@@ -2517,7 +2534,7 @@ def test_invalid_existing_checkpoint_blocks_terminal_success_with_completion_sum
     artifact_dir.mkdir(parents=True)
     checkpoint = artifact_dir / "workflow-checkpoint.json"
     checkpoint.write_text(json.dumps({"steps": [{"id": "S01", "skill": "done", "name": "Done", "status": "not-valid"}]}), encoding="utf-8")
-    (artifact_dir / "completion-summary.json").write_text("{}", encoding="utf-8")
+    (artifact_dir / "completion-summary.json").write_text(json.dumps({"completion_notes": ["Completed durable workflow"]}), encoding="utf-8")
     prompt = PromptGenerationResult(output_path=tmp_path / "prompt.md", checkpoint_path=checkpoint, artifact_path=artifact_dir)
 
     classification = classify_session(_terminal_success_result(tmp_path), project_root=tmp_path, base_head=base_head, prompt=prompt)
@@ -2597,3 +2614,190 @@ def test_invalid_existing_checkpoint_blocks_workspace_auto_commit_success(tmp_pa
 
     assert classification.session_status == "crashed"
     assert classification.reason == "invalid_workflow_checkpoint:empty_steps"
+
+
+@pytest.mark.parametrize(
+    ("kind", "item_id", "branch"),
+    [
+        ("feature", "F-001", "dev/F-001-ai-retry"),
+        ("bugfix", "B-001", "bugfix/B-001-ai-retry"),
+        ("refactor", "R-001", "refactor/R-001-ai-retry"),
+    ],
+)
+@pytest.mark.parametrize("retry_status", ["infra_error", "crashed", "timed_out"])
+def test_retryable_ai_errors_continue_in_process_for_all_families(monkeypatch, tmp_path, kind, item_id, branch, retry_status):
+    from prizmkit_runtime import runners
+    from prizmkit_runtime.runner_models import family_for, parse_invocation
+
+    monkeypatch.setenv("DEV_BRANCH", branch)
+    paths = _make_paths(tmp_path / kind / retry_status)
+    family = family_for(kind, paths)
+    invocation = parse_invocation(family, "run", ())
+    plan_path = {"feature": paths.feature_plan, "bugfix": paths.bugfix_plan, "refactor": paths.refactor_plan}[kind]
+    invocation = invocation.__class__(**{**invocation.__dict__, "list_path": plan_path})
+    observed = _install_runner_session_fakes(monkeypatch, runners, statuses=(retry_status, "success"))
+    sleep_calls = []
+    branch_plans = []
+    monkeypatch.setattr(runners.time, "sleep", lambda seconds: sleep_calls.append(seconds))
+    monkeypatch.setattr(
+        runners,
+        "run_git_plan",
+        lambda project_root, plan: (branch_plans.append(plan.name) or SimpleNamespace(ok=True, plan=plan, results=())),
+    )
+
+    status = runners._process_item(family, invocation, item_id, paths, initial_metadata={})
+
+    assert status == "completed"
+    assert sleep_calls == [5]
+    assert len(observed.launch_cwds) == 2
+    assert observed.launch_cwds[0] == observed.launch_cwds[1]
+    assert branch_plans.count("branch_create") == 1
+    assert observed.updates[0][0] == retry_status
+    continuation = observed.prompt_calls[1]["continuation"]
+    assert continuation["previous_session_id"].endswith("session-1")
+    assert continuation["failure_classification"] == retry_status
+    assert continuation["active_dev_branch"] == branch
+
+
+def test_unique_session_ids_do_not_collide_when_wall_clock_second_is_frozen(monkeypatch):
+    from prizmkit_runtime import runners
+
+    monkeypatch.setattr(runners.time, "strftime", lambda _fmt: "20260711030000")
+    values = iter((101, 102))
+    monkeypatch.setattr(runners.time, "time_ns", lambda: next(values))
+
+    first = runners._session_id("F-001")
+    second = runners._session_id("F-001")
+
+    assert first != second
+    assert first.endswith("-101")
+    assert second.endswith("-102")
+
+
+@pytest.mark.parametrize("summary_text", ["{}", "{not-json", '{"completion_notes": []}', '{"completion_notes": [""]}'])
+def test_invalid_completion_summary_does_not_prove_late_runtime_success(tmp_path, summary_text):
+    from prizmkit_runtime.runner_classification import classify_session
+    from prizmkit_runtime.runner_models import PromptGenerationResult
+    from prizmkit_runtime.sessions import AISessionCommand, AISessionResult
+    from prizmkit_runtime.status import ProgressSummary
+
+    subprocess.run(["git", "init", "-b", "main"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    subprocess.run(["git", "config", "user.email", "test@example.com"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "config", "user.name", "Test"], cwd=tmp_path, check=True)
+    (tmp_path / "base.txt").write_text("base", encoding="utf-8")
+    subprocess.run(["git", "add", "base.txt"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "commit", "-m", "base"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    base_head = subprocess.run(["git", "rev-parse", "HEAD"], cwd=tmp_path, check=True, stdout=subprocess.PIPE, text=True).stdout.strip()
+    artifact_dir = tmp_path / ".prizmkit" / "specs" / "001-invalid"
+    artifact_dir.mkdir(parents=True)
+    (artifact_dir / "completion-summary.json").write_text(summary_text, encoding="utf-8")
+    log = tmp_path / "session.log"
+    log.write_text("quota exceeded", encoding="utf-8")
+    result = AISessionResult(
+        command=AISessionCommand(("fake",), None, "codebuddy", "stdin"),
+        exit_code=1,
+        timed_out=False,
+        termination_reason=None,
+        stale_marker=None,
+        fatal_error_code="api_error",
+        progress_summary=ProgressSummary(terminal_result_text="quota exceeded"),
+        session_log=log,
+        backup_log=tmp_path / "backup.log",
+        log_recovery=None,
+        started_epoch=0,
+        ended_epoch=1,
+    )
+
+    classification = classify_session(
+        result,
+        project_root=tmp_path,
+        base_head=base_head,
+        prompt=PromptGenerationResult(output_path=tmp_path / "prompt.md", artifact_path=artifact_dir),
+    )
+
+    assert classification.session_status == "infra_error"
+
+
+def test_non_utf8_completion_summary_does_not_abort_classification(tmp_path):
+    from prizmkit_runtime.runner_classification import classify_session
+    from prizmkit_runtime.runner_models import PromptGenerationResult
+    from prizmkit_runtime.sessions import AISessionCommand, AISessionResult
+    from prizmkit_runtime.status import ProgressSummary
+
+    subprocess.run(["git", "init", "-b", "main"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    subprocess.run(["git", "config", "user.email", "test@example.com"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "config", "user.name", "Test"], cwd=tmp_path, check=True)
+    (tmp_path / "base.txt").write_text("base", encoding="utf-8")
+    subprocess.run(["git", "add", "base.txt"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "commit", "-m", "base"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    base_head = subprocess.run(["git", "rev-parse", "HEAD"], cwd=tmp_path, check=True, stdout=subprocess.PIPE, text=True).stdout.strip()
+    artifact_dir = tmp_path / ".prizmkit" / "specs" / "001-corrupt"
+    artifact_dir.mkdir(parents=True)
+    (artifact_dir / "completion-summary.json").write_bytes(b"\xff\xfe")
+    log = tmp_path / "session.log"
+    log.write_text("quota exceeded", encoding="utf-8")
+    result = AISessionResult(
+        command=AISessionCommand(("fake",), None, "codebuddy", "stdin"),
+        exit_code=1,
+        timed_out=False,
+        termination_reason=None,
+        stale_marker=None,
+        fatal_error_code="api_error",
+        progress_summary=ProgressSummary(terminal_result_text="quota exceeded"),
+        session_log=log,
+        backup_log=tmp_path / "backup.log",
+        log_recovery=None,
+        started_epoch=0,
+        ended_epoch=1,
+    )
+
+    classification = classify_session(
+        result,
+        project_root=tmp_path,
+        base_head=base_head,
+        prompt=PromptGenerationResult(output_path=tmp_path / "prompt.md", artifact_path=artifact_dir),
+    )
+
+    assert classification.session_status == "infra_error"
+
+
+@pytest.mark.parametrize(
+    ("timed_out", "termination_reason", "expected_status", "expected_reason"),
+    [
+        (True, "timeout", "timed_out", "timeout"),
+        (False, "stale_session", "crashed", "stale_session"),
+    ],
+)
+def test_timeout_and_stale_termination_override_provider_error_markers(tmp_path, timed_out, termination_reason, expected_status, expected_reason):
+    from prizmkit_runtime.runner_classification import classify_session
+    from prizmkit_runtime.sessions import AISessionCommand, AISessionResult
+    from prizmkit_runtime.status import ProgressSummary
+
+    subprocess.run(["git", "init", "-b", "main"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    subprocess.run(["git", "config", "user.email", "test@example.com"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "config", "user.name", "Test"], cwd=tmp_path, check=True)
+    (tmp_path / "base.txt").write_text("base", encoding="utf-8")
+    subprocess.run(["git", "add", "base.txt"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "commit", "-m", "base"], cwd=tmp_path, check=True, stdout=subprocess.DEVNULL)
+    base_head = subprocess.run(["git", "rev-parse", "HEAD"], cwd=tmp_path, check=True, stdout=subprocess.PIPE, text=True).stdout.strip()
+    log = tmp_path / "session.log"
+    log.write_text("gateway API error", encoding="utf-8")
+    result = AISessionResult(
+        command=AISessionCommand(("fake",), None, "codebuddy", "stdin"),
+        exit_code=1,
+        timed_out=timed_out,
+        termination_reason=termination_reason,
+        stale_marker=None,
+        fatal_error_code="api_error",
+        progress_summary=ProgressSummary(terminal_result_text="provider gateway error"),
+        session_log=log,
+        backup_log=tmp_path / "backup.log",
+        log_recovery=None,
+        started_epoch=0,
+        ended_epoch=1,
+    )
+
+    classification = classify_session(result, project_root=tmp_path, base_head=base_head)
+
+    assert classification.session_status == expected_status
+    assert classification.reason == expected_reason

package/bundled/dev-pipeline/tests/test_unified_cli.py

@@ -30,10 +30,11 @@ if str(PIPELINE_ROOT) not in sys.path:
     sys.path.insert(0, str(PIPELINE_ROOT))
 
 
-def run_cli(*args):
+def run_cli(*args, env=None):
     return subprocess.run(
         [PYTHON_310_PLUS, str(CLI_PATH), *args],
         cwd=REPO_ROOT,
+        env=env,
         text=True,
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE,
@@ -72,6 +73,14 @@ def test_cli_help_exposes_python_runtime_command_groups():
     assert "Traceback" not in result.stderr
 
 
+def test_cli_help_preserves_runtime_identity_at_narrow_terminal_width():
+    result = run_cli("--help", env={**os.environ, "COLUMNS": "24"})
+
+    assert result.returncode == 0
+    assert "canonical Python runtime CLI" in result.stdout
+    assert "without shell wrappers" in result.stdout
+
+
 def test_module_entrypoint_help_exposes_same_cli():
     env = {**os.environ, "PYTHONPATH": str(PIPELINE_ROOT)}
     result = subprocess.run(
@@ -802,7 +811,7 @@ def test_session_preamble_writes_redacted_start_command_for_all_launch_profiles(
             assert str(prompt) not in "\n".join(lines[:6])
 
 
-def test_headless_subagent_prompt_guidance_keeps_no_worktree_boundary_visible():
+def test_headless_review_guidance_uses_workspace_equivalence_protocol():
     guidance_files = [
         REPO_ROOT / "dev-pipeline" / "templates" / "sections" / "phase-review-full.md",
         REPO_ROOT / "dev-pipeline" / "templates" / "bootstrap-tier3.md",
@@ -811,15 +820,19 @@ def test_headless_subagent_prompt_guidance_keeps_no_worktree_boundary_visible():
 
     for path in guidance_files:
         text = path.read_text(encoding="utf-8")
-        assert (
-            "default/no worktree" in text
-            or "current-workspace / active-checkout / no-worktree" in text
-            or "current workspace / active checkout / no worktree" in text
-        ), path
-        assert "do not request or create" in text.lower() or "do not request worktree isolation" in text.lower(), path
-        assert ".claude/worktrees/..." in text, path
-        assert ".prizmkit/state/worktrees/..." in text, path
-        assert "USE_WORKTREE" in text, path
+        assert "platform-supported" in text, path
+        assert "snapshot" in text and "equivalent" in text, path
+        assert "Main-Agent self-review" in text, path
+        assert "current-workspace / active-checkout / no-worktree" not in text, path
+        assert ".claude/worktrees/..." not in text, path
+        assert ".prizmkit/state/worktrees/..." not in text, path
+        assert "USE_WORKTREE" not in text, path
+        assert "isolation:" not in text, path
+
+    skill_text = guidance_files[-1].read_text(encoding="utf-8")
+    assert "reviewer-workspace-protocol.md" in skill_text
+    assert "staged, unstaged, untracked, deleted, and renamed" in skill_text
+    assert "WORKSPACE_MISMATCH" in skill_text
 
     for path in guidance_files[:-1]:
         text = path.read_text(encoding="utf-8")

package/bundled/skills/_metadata.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.1.120",
+  "version": "1.1.122",
   "skills": {
     "prizmkit": {
       "description": "Full-lifecycle dev toolkit. Covers spec-driven development, Prizm context docs, code quality, debugging, deployment, and knowledge management.",
@@ -65,11 +65,11 @@
       "hasScripts": false
     },
     "prizmkit-test": {
-      "description": "Full-stack test generation and orchestration. Detects architecture, discovers/runs existing tests, analyzes coverage gaps, generates missing tests (unit/integration/E2E), outputs unified report.",
+      "description": "Auditable project-native test evidence with request-driven execution, runner-generated receipts, differential proof, replay, and deterministic validation.",
       "tier": "1",
       "category": "prizmkit-skill",
-      "hasAssets": false,
-      "hasScripts": false
+      "hasAssets": true,
+      "hasScripts": true
     },
     "feature-workflow": {
       "description": "One-stop entry point for feature development. Orchestrates feature-planner → feature-pipeline-launcher → background execution. Handles multi-feature batch development from a single request.",