@prism-d1/cli 1.9.0 → 1.10.0

package/README.md

@@ -0,0 +1,48 @@
+# prism-cli
+
+The command line for [PRISM D1 Velocity](https://github.com/aws-samples/sample-prism-d1-velocity): measure, secure and review AI-assisted development from your own machine. Codewatch git hooks, a local dashboard, an MCP server for AI agents, AWS Security Agent scans, read-only AWS account checks, and the setup helpers for a team's PRISM deployment.
+
+> Sample project, not production-ready. See [SECURITY.md](https://github.com/aws-samples/sample-prism-d1-velocity/blob/main/SECURITY.md).
+
+## Install
+
+Node.js 22 or later:
+
+```bash
+npm install -g @prism-d1/cli
+prism-cli version     # installed version, newer release on npm, other copies on PATH
+```
+
+## Quick start
+
+```bash
+prism-cli enable codewatch    # in a repo: secret scan on commit, AI review on push (report only)
+prism-cli dashboard           # local page on 127.0.0.1: results, AI usage, setup checklist
+prism-cli aws check           # read-only AWS account checks; then prism-cli aws recommend
+```
+
+Send AI usage to your team's PRISM with `prism-cli enable codeburn --url <OtelCollectorUrl>` (the URL comes from your platform team). Every command takes `--help`.
+
+## Documentation
+
+- [Using PRISM locally](https://github.com/aws-samples/sample-prism-d1-velocity/blob/main/USER_GUIDE.md#using-prism-locally): what each feature does and where it shows up (VS Code family editors, Kiro Crew, Claude Code)
+- [Command reference](https://github.com/aws-samples/sample-prism-d1-velocity/blob/main/docs/CLI-REFERENCE.md): every command and flag
+- [prism-cli Overview](https://github.com/aws-samples/sample-prism-d1-velocity/blob/main/docs/PRISM-CLI-OVERVIEW.md): what each command touches in AWS, its cost and its safety defaults
+- [User Guide](https://github.com/aws-samples/sample-prism-d1-velocity/blob/main/USER_GUIDE.md): deploying PRISM, CI workflows and eval gates
+
+## Develop
+
+From `cli/` in a clone:
+
+```bash
+npm ci
+npm run build       # tsc -> dist/, plus the bundled assets
+npm test            # type-checks the tests, then the node:test suite
+npm run docs        # regenerate docs/CLI-REFERENCE.md after changing a command or flag
+```
+
+Releases are published to npm by `.github/workflows/publish.yml` when a `v*` tag is pushed.
+
+## License
+
+MIT

package/dist/assets/github-workflows/prism-eval-gate-kiro.yml

@@ -8,6 +8,8 @@
 #     .kiro/steering/code-review.md in your repo (review rules)
 #   - (Optional) PRISM_METRICS_ROLE_ARN for EventBridge metrics emission
 #   - (Optional) AWS Continuum configured for security scanning
+#   - (Optional) Review model: repository variable PRISM_REVIEW_MODEL, else
+#     eval.model in .prism/config.json on the base branch, else `auto`
 #
 # Secret scanning (gitleaks) needs no setup and no secret. It installs itself
 # and always runs, so it is the only gate that still functions on a fork PR.
@@ -226,10 +228,50 @@ jobs:
           KIRO_API_KEY: ${{ secrets.KIRO_API_KEY }}
           BASE_SHA: ${{ github.event.pull_request.base.sha }}
           HEAD_SHA: ${{ github.sha }}
+          # Repository variable (Settings > Secrets and variables > Actions > Variables).
+          PRISM_REVIEW_MODEL: ${{ vars.PRISM_REVIEW_MODEL }}
         run: |
           # Trim whitespace/newlines from API key (GitHub Secrets can add trailing chars)
           export KIRO_API_KEY=$(echo -n "${KIRO_API_KEY}" | tr -d '[:space:]')
 
+          # --- review model: start (identical in every eval-gate workflow; cli/test/eval-gate-retry.test.ts checks) ---
+          # Order: the PRISM_REVIEW_MODEL variable, then eval.model in the BASE
+          # commit's .prism/config.json, then auto. Never the PR head's config:
+          # the PR author controls it, and a PR must not pick a weaker model to
+          # pass its own review. The value reaches a CLI argument, so it is
+          # validated here and never echoed when invalid.
+          REVIEW_MODEL="${PRISM_REVIEW_MODEL:-}"
+          REVIEW_MODEL_SOURCE="the PRISM_REVIEW_MODEL variable"
+          MODEL_ERROR=""
+          if [ -z "${REVIEW_MODEL}" ]; then
+            REVIEW_MODEL_SOURCE="the default"
+            if [ -n "${BASE_SHA}" ] && git cat-file -e "${BASE_SHA}:.prism/config.json" 2>/dev/null; then
+              if ! BASE_CFG_MODEL=$(git show "${BASE_SHA}:.prism/config.json" | jq -r '.eval.model? // empty | tostring'); then
+                MODEL_ERROR="the base branch's .prism/config.json could not be read as JSON"
+              elif [ -n "${BASE_CFG_MODEL}" ]; then
+                REVIEW_MODEL="${BASE_CFG_MODEL}"
+                REVIEW_MODEL_SOURCE="eval.model in the base branch's .prism/config.json"
+              fi
+            fi
+            REVIEW_MODEL="${REVIEW_MODEL:-auto}"
+          fi
+          if [ -z "${MODEL_ERROR}" ] && ! [[ "${REVIEW_MODEL}" =~ ^[A-Za-z0-9._:/-]{1,100}$ ]]; then
+            MODEL_ERROR="the model from ${REVIEW_MODEL_SOURCE} must match ^[A-Za-z0-9._:/-]{1,100}\$"
+          fi
+          # --- review model: end ---
+
+          if [ -n "${MODEL_ERROR}" ]; then
+            # FAIL CLOSED: a misconfigured model must not fall back silently.
+            echo "::error::Invalid review model: ${MODEL_ERROR}. Failing closed."
+            echo "result=ERROR" >> "$GITHUB_OUTPUT"
+            echo "model_error=true" >> "$GITHUB_OUTPUT"
+            echo "Eval gate review: invalid review model (${MODEL_ERROR}) -- failed closed." >> "$GITHUB_STEP_SUMMARY"
+            exit 0
+          fi
+          echo "Review model: ${REVIEW_MODEL} (from ${REVIEW_MODEL_SOURCE})"
+          echo "model=${REVIEW_MODEL}" >> "$GITHUB_OUTPUT"
+          echo "Eval gate review model: \`${REVIEW_MODEL}\` (from ${REVIEW_MODEL_SOURCE})." >> "$GITHUB_STEP_SUMMARY"
+
           # Fork PRs don't receive secrets -- report neutral, never silently pass
           if [ "${HAS_KIRO_KEY}" != "true" ]; then
             echo "::warning::KIRO_API_KEY unavailable (fork PR or missing secret) -- review skipped"
@@ -273,7 +315,7 @@ jobs:
           echo "::endgroup::"
 
           echo "::group::kiro-cli smoke test"
-          echo "Say hello in JSON" | kiro-cli chat --no-interactive --model auto || echo "SMOKE TEST FAILED"
+          echo "Say hello in JSON" | kiro-cli chat --no-interactive --model "${REVIEW_MODEL}" || echo "SMOKE TEST FAILED"
           echo "::endgroup::"
 
           echo "Reviewing ${FILES}"
@@ -282,49 +324,85 @@ jobs:
           # on long content. Use a minimal CLI arg prompt and let kiro read files itself.
           git diff "${BASE_SHA}..${HEAD_SHA}" -- ${FILES} > /tmp/pr-diff.patch
 
-          REVIEW_OUTPUT=$(kiro-cli chat --no-interactive \
-            --trust-all-tools \
-            --model auto \
-            "Review /tmp/pr-diff.patch for code quality. Read it, then output ONLY JSON: {\"findings\":[{\"file\":\"path\",\"line\":1,\"severity\":\"high|medium|low\",\"category\":\"str\",\"message\":\"str\"}],\"score\":0.0,\"summary\":\"str\"}") || true
-
-          # Strip ANSI escapes, then extract the LAST JSON object that parses and
-          # has a numeric score and a findings array. kiro-cli writes reasoning
-          # notes first, and they quote code with braces, so a greedy
-          # first-brace-to-last-brace match is not the verdict.
-          CLEANED=$(echo "${REVIEW_OUTPUT}" | sed 's/\x1b\[[0-9;?]*[a-zA-Z]//g' | tr -d '\r')
-          REVIEW_JSON=$(printf '%s' "${CLEANED}" | python3 -c 'if True:
-              import json, math, sys
-              text = sys.stdin.read()
-              dec = json.JSONDecoder(strict=False)
-              pos = text.rfind("{")
-              while pos != -1:
-                  try:
-                      obj = dec.raw_decode(text, pos)[0]
-                  except ValueError:
-                      obj = None
-                  score = obj.get("score") if isinstance(obj, dict) else None
-                  if (isinstance(score, (int, float)) and not isinstance(score, bool)
-                          and math.isfinite(score) and isinstance(obj.get("findings"), list)):
-                      print(json.dumps(obj))
-                      sys.exit(0)
-                  pos = text.rfind("{", 0, pos)
-              sys.exit(1)
-          ' || true)
-
-          if [ -z "${REVIEW_JSON}" ] || ! echo "${REVIEW_JSON}" | jq -e '.score' > /dev/null 2>&1; then
-            # FAIL CLOSED: a gate that can't evaluate must not pass
-            echo "::group::Debug: raw kiro-cli output (first 2000 chars)"
+          # One retry, only when the reply cannot be parsed. Attempt 2 re-runs the
+          # same review (same model, same diff file) with one sentence added that
+          # asks for a single JSON object. It does not hand the bad reply back
+          # for "repair": a broken reply is often truncated, and repairing it
+          # would make the model invent the missing findings. Each attempt reads
+          # the diff, so any accepted verdict comes from a real review. Nothing
+          # is repaired by regex; two unparseable replies still fail closed.
+          REVIEW_PROMPT="Review /tmp/pr-diff.patch for code quality. Read it, then output ONLY JSON: {\"findings\":[{\"file\":\"path\",\"line\":1,\"severity\":\"high|medium|low\",\"category\":\"str\",\"message\":\"str\"}],\"score\":0.0,\"summary\":\"str\"}"
+          RETRY_NOTE="Your previous reply was not valid JSON. Return exactly one JSON object matching that schema and nothing else: no prose, no code fences."
+          # Per-attempt cap. The retry gets the same budget as the first attempt.
+          REVIEW_TIMEOUT_SECS=600
+          REVIEW_JSON=""
+          REVIEW_ATTEMPT=""
+          for ATTEMPT in 1 2; do
+            PROMPT="${REVIEW_PROMPT}"
+            if [ "${ATTEMPT}" = "2" ]; then PROMPT="${REVIEW_PROMPT} ${RETRY_NOTE}"; fi
+            REVIEW_OUTPUT=$(timeout "${REVIEW_TIMEOUT_SECS}" kiro-cli chat --no-interactive \
+              --trust-all-tools \
+              --model "${REVIEW_MODEL}" \
+              "${PROMPT}") || true
+
+            # Strip ANSI escapes, then extract the LAST JSON object that parses and
+            # has a numeric score and a findings array. kiro-cli writes reasoning
+            # notes first, and they quote code with braces, so a greedy
+            # first-brace-to-last-brace match is not the verdict. Same rule as
+            # extractReviewJson in cli/src/codewatch/reviewers/types.ts; the copy
+            # in each eval-gate workflow is kept identical by cli/test/eval-gate-extract.test.ts.
+            CLEANED=$(echo "${REVIEW_OUTPUT}" | sed 's/\x1b\[[0-9;?]*[a-zA-Z]//g' | tr -d '\r')
+            REVIEW_JSON=$(printf '%s' "${CLEANED}" | python3 -c 'if True:
+                import json, math, sys
+                text = sys.stdin.read()
+                dec = json.JSONDecoder(strict=False)
+                pos = text.rfind("{")
+                while pos != -1:
+                    try:
+                        obj = dec.raw_decode(text, pos)[0]
+                    except ValueError:
+                        obj = None
+                    score = obj.get("score") if isinstance(obj, dict) else None
+                    if (isinstance(score, (int, float)) and not isinstance(score, bool)
+                            and math.isfinite(score) and isinstance(obj.get("findings"), list)):
+                        print(json.dumps(obj))
+                        sys.exit(0)
+                    pos = text.rfind("{", 0, pos)
+                sys.exit(1)
+            ' || true)
+
+            if [ -n "${REVIEW_JSON}" ] && echo "${REVIEW_JSON}" | jq -e '.score' > /dev/null 2>&1; then
+              REVIEW_ATTEMPT="${ATTEMPT}"
+              break
+            fi
+            REVIEW_JSON=""
+
+            # The reply is untrusted model output. Workflow commands are paused
+            # while it is printed, so a "::" line in it is shown, not executed.
+            STOP_TOKEN=$(od -An -N16 -tx1 /dev/urandom | tr -d ' \n')
+            echo "::group::Debug: attempt ${ATTEMPT} raw kiro-cli output (first 2000 chars)"
+            echo "::stop-commands::${STOP_TOKEN}"
             echo "${REVIEW_OUTPUT:-<empty>}" | head -c 2000
             echo ""
-            echo "::endgroup::"
-            echo "::group::Debug: cleaned output"
+            echo "--- cleaned ---"
             echo "${CLEANED:-<empty>}" | head -c 2000
             echo ""
+            echo "::${STOP_TOKEN}::"
             echo "::endgroup::"
-            echo "::error::Could not parse kiro-cli review output -- failing closed"
+            if [ "${ATTEMPT}" = "1" ]; then
+              echo "::warning::Attempt 1: could not parse kiro-cli review output -- retrying the review once"
+            fi
+          done
+
+          if [ -z "${REVIEW_JSON}" ]; then
+            # FAIL CLOSED: a gate that can't evaluate must not pass
+            echo "::error::Could not parse kiro-cli review output on either attempt (both unparseable) -- failing closed"
             echo "result=ERROR" >> "$GITHUB_OUTPUT"
+            echo "Eval gate review: both attempts returned unparseable output -- failed closed." >> "$GITHUB_STEP_SUMMARY"
             exit 0
           fi
+          echo "Review verdict parsed on attempt ${REVIEW_ATTEMPT} of 2"
+          echo "attempt=${REVIEW_ATTEMPT}" >> "$GITHUB_OUTPUT"
 
           SCORE=$(echo "${REVIEW_JSON}" | jq -r '.score')
           FINDINGS=$(echo "${REVIEW_JSON}" | jq '.findings | length')
@@ -343,10 +421,13 @@ jobs:
           # Determine pass/fail (awk instead of bc -- no extra package needed)
           PASS=$(awk -v s="${SCORE}" 'BEGIN { print (s >= 0.82) ? "true" : "false" }')
           if [ "${HIGH}" -gt 0 ] || [ "${PASS}" != "true" ]; then
-            echo "result=FAIL" >> "$GITHUB_OUTPUT"
+            RESULT=FAIL
           else
-            echo "result=PASS" >> "$GITHUB_OUTPUT"
+            RESULT=PASS
           fi
+          echo "result=${RESULT}" >> "$GITHUB_OUTPUT"
+          # Only numbers and fixed words here; no model text reaches the summary.
+          echo "Eval gate review: ${RESULT} (score ${SCORE}, ${HIGH} high), verdict parsed on attempt ${REVIEW_ATTEMPT} of 2." >> "$GITHUB_STEP_SUMMARY"
 
       - name: Post PR comment
         if: always()
@@ -358,6 +439,8 @@ jobs:
           REVIEW_MEDIUM: ${{ steps.review.outputs.medium }}
           REVIEW_RESULT: ${{ steps.review.outputs.result }}
           REVIEW_SUMMARY: ${{ steps.review.outputs.summary }}
+          REVIEW_MODEL: ${{ steps.review.outputs.model }}
+          REVIEW_MODEL_ERROR: ${{ steps.review.outputs.model_error }}
           GITLEAKS_LEAKS: ${{ steps.gitleaks.outputs.leaks }}
           GITLEAKS_ERROR: ${{ steps.gitleaks.outputs.error }}
           GITLEAKS_INSTALL_ERROR: ${{ steps.gitleaks-install.outputs.error }}
@@ -371,8 +454,10 @@ jobs:
             const result = process.env.REVIEW_RESULT || 'ERROR';
             if (result === 'SKIPPED') {
               body = '⚠️ **PRISM Eval Gate** -- Review skipped (no source files changed or no API key on fork PRs).';
+            } else if (result === 'ERROR' && process.env.REVIEW_MODEL_ERROR === 'true') {
+              body = '❌ **PRISM Eval Gate** -- The review model is invalid (see the job summary). Failing closed; fix `PRISM_REVIEW_MODEL` or `eval.model` in `.prism/config.json`.';
             } else if (result === 'ERROR') {
-              body = '❌ **PRISM Eval Gate** -- Review output could not be parsed. Failing closed; re-run the workflow or review manually.';
+              body = '❌ **PRISM Eval Gate** -- Review output could not be parsed on either attempt (the review is retried once). Failing closed; re-run the workflow or review manually.';
             } else {
                 const score = process.env.REVIEW_SCORE || '?';
                 const findings = process.env.REVIEW_FINDINGS || '0';
@@ -401,7 +486,8 @@ jobs:
                   body += `| File | Line | Severity | Category | Issue |\n|---|---|---|---|---|\n${table}\n\n`;
                 }
 
-                body += `> Powered by kiro-cli headless - Model: claude-haiku-4.5 - Threshold: 0.82`;
+                // The model the review step resolved and validated, not a fixed label.
+                body += `> Powered by kiro-cli headless - Model: ${process.env.REVIEW_MODEL || '?'} - Threshold: 0.82`;
             }
 
             // Secret scanning is reported for every result path, including the
@@ -462,6 +548,7 @@ jobs:
           REVIEW_RESULT: ${{ steps.review.outputs.result }}
           REVIEW_FINDINGS: ${{ steps.review.outputs.findings }}
           REVIEW_HIGH: ${{ steps.review.outputs.high }}
+          REVIEW_MODEL: ${{ steps.review.outputs.model }}
           PR_NUMBER: ${{ github.event.pull_request.number }}
         run: |
           # Only emit when we have a real score (not SKIPPED/ERROR)
@@ -479,9 +566,10 @@ jobs:
             --arg findings "${REVIEW_FINDINGS:-0}" \
             --arg high "${REVIEW_HIGH:-0}" \
             --arg pr_number "${PR_NUMBER}" \
+            --arg model "${REVIEW_MODEL}" \
             '{team_id:$team_id,repo:$repo,timestamp:$timestamp,prism_level:2,
               metric:{name:"eval_score",value:($score|tonumber),unit:"score"},
-              ai_context:{tool:"kiro-cli",model:"claude-haiku-4.5",origin:"ai-generated"},
+              ai_context:{tool:"kiro-cli",model:$model,origin:"ai-generated"},
               eval:{score:($score|tonumber),result:$result,rubric:"kiro-headless",
                     findings:($findings|tonumber),high_findings:($high|tonumber),
                     pr_number:($pr_number|tonumber),method:"kiro-headless"}}')
@@ -823,6 +911,7 @@ jobs:
           REVIEW_HIGH: ${{ steps.review.outputs.high }}
           REVIEW_SCORE: ${{ steps.review.outputs.score }}
           REVIEW_SUMMARY: ${{ steps.review.outputs.summary }}
+          REVIEW_MODEL_ERROR: ${{ steps.review.outputs.model_error }}
           SEC_CRITICAL: ${{ steps.security-gate.outputs.critical }}
           SEC_HIGH: ${{ steps.security-gate.outputs.high }}
           SEC_SCAN_ERROR: ${{ steps.security-gate.outputs.scan_error }}
@@ -841,7 +930,9 @@ jobs:
             echo "  Rotate the credential first -- deleting it from the branch does not un-expose it."
             echo "  False positive? Add an allowlist entry to .gitleaks.toml."
           fi
-          if [ "${REVIEW_RESULT}" = "ERROR" ]; then
+          if [ "${REVIEW_MODEL_ERROR}" = "true" ]; then
+            echo "❌ Eval gate failed closed: the review model is invalid (see the job summary)"
+          elif [ "${REVIEW_RESULT}" = "ERROR" ]; then
             echo "❌ Eval gate failed closed: review output could not be parsed"
           elif [ "${REVIEW_RESULT}" = "FAIL" ]; then
             echo "❌ Kiro found ${REVIEW_HIGH:-?} high-severity issues (score: ${REVIEW_SCORE:-?})"

package/dist/assets/gitlab-workflows/prism-eval-gate.yml

@@ -9,6 +9,8 @@
 #   - CI/CD variable KIRO_API_KEY (masked). Generate at https://app.kiro.dev
 #   - PRISM_AWS_REGION variable in the variables: block below controls the region
 #   - (Optional) CI/CD variable PRISM_METRICS_ROLE_ARN for EventBridge metrics
+#   - (Optional) Review model: CI/CD variable PRISM_REVIEW_MODEL, else
+#     eval.model in .prism/config.json on the target branch, else `auto`
 #
 # The Bedrock rubric gate that used to live in this file is retired. It scored
 # changed files against .prism/eval-harness/rubrics/*.json via run-eval.sh; the
@@ -180,7 +182,39 @@ prism-eval-gate:
 
       echo ""
       echo "── Code quality review (kiro-cli) ──"
-      if [ -z "${KIRO_API_KEY:-}" ]; then
+
+      # --- review model: start (identical in every eval-gate workflow; cli/test/eval-gate-retry.test.ts checks) ---
+      # Order: the PRISM_REVIEW_MODEL variable, then eval.model in the BASE
+      # commit's .prism/config.json, then auto. Never the PR head's config:
+      # the PR author controls it, and a PR must not pick a weaker model to
+      # pass its own review. The value reaches a CLI argument, so it is
+      # validated here and never echoed when invalid.
+      REVIEW_MODEL="${PRISM_REVIEW_MODEL:-}"
+      REVIEW_MODEL_SOURCE="the PRISM_REVIEW_MODEL variable"
+      MODEL_ERROR=""
+      if [ -z "${REVIEW_MODEL}" ]; then
+        REVIEW_MODEL_SOURCE="the default"
+        if [ -n "${BASE_SHA}" ] && git cat-file -e "${BASE_SHA}:.prism/config.json" 2>/dev/null; then
+          if ! BASE_CFG_MODEL=$(git show "${BASE_SHA}:.prism/config.json" | jq -r '.eval.model? // empty | tostring'); then
+            MODEL_ERROR="the base branch's .prism/config.json could not be read as JSON"
+          elif [ -n "${BASE_CFG_MODEL}" ]; then
+            REVIEW_MODEL="${BASE_CFG_MODEL}"
+            REVIEW_MODEL_SOURCE="eval.model in the base branch's .prism/config.json"
+          fi
+        fi
+        REVIEW_MODEL="${REVIEW_MODEL:-auto}"
+      fi
+      if [ -z "${MODEL_ERROR}" ] && ! [[ "${REVIEW_MODEL}" =~ ^[A-Za-z0-9._:/-]{1,100}$ ]]; then
+        MODEL_ERROR="the model from ${REVIEW_MODEL_SOURCE} must match ^[A-Za-z0-9._:/-]{1,100}\$"
+      fi
+      # --- review model: end ---
+
+      if [ -n "${MODEL_ERROR}" ]; then
+        # FAIL CLOSED: a misconfigured model must not fall back silently.
+        echo "❌ Invalid review model: ${MODEL_ERROR}. Failing closed."
+        REVIEW_MODEL=""
+        REVIEW_RESULT="ERROR"
+      elif [ -z "${KIRO_API_KEY:-}" ]; then
         # Fork MRs receive no protected variables. Reported, never silently passed.
         echo "⚠️  KIRO_API_KEY unavailable (fork MR or unset variable) — review skipped."
       elif [ -z "${BASE_SHA}" ] || [ -z "${HEAD_SHA}" ]; then
@@ -213,45 +247,72 @@ prism-eval-gate:
             REVIEW_RESULT="ERROR"
           else
             kiro-cli --version || true
+            echo "Review model: ${REVIEW_MODEL} (from ${REVIEW_MODEL_SOURCE})"
             # Short prompt on purpose: kiro-cli has a bug putting long stdin
             # into HTTP headers, so let it read the patch off disk itself.
             git diff "${BASE_SHA}..${HEAD_SHA}" -- ${FILES} > /tmp/mr-diff.patch
 
-            set +e
-            REVIEW_OUTPUT=$(kiro-cli chat --no-interactive --trust-all-tools --model auto \
-              "Review /tmp/mr-diff.patch for code quality. Read it, then output ONLY JSON: {\"findings\":[{\"file\":\"path\",\"line\":1,\"severity\":\"high|medium|low\",\"category\":\"str\",\"message\":\"str\"}],\"score\":0.0,\"summary\":\"str\"}")
-            set -e
+            # One retry, only when the reply cannot be parsed. Attempt 2 re-runs
+            # the same review (same model, same diff file) with one sentence
+            # added that asks for a single JSON object. It does not hand the bad
+            # reply back for "repair": a broken reply is often truncated, and
+            # repairing it would make the model invent the missing findings.
+            # Nothing is repaired by regex; two unparseable replies fail closed.
+            REVIEW_PROMPT="Review /tmp/mr-diff.patch for code quality. Read it, then output ONLY JSON: {\"findings\":[{\"file\":\"path\",\"line\":1,\"severity\":\"high|medium|low\",\"category\":\"str\",\"message\":\"str\"}],\"score\":0.0,\"summary\":\"str\"}"
+            RETRY_NOTE="Your previous reply was not valid JSON. Return exactly one JSON object matching that schema and nothing else: no prose, no code fences."
+            # Per-attempt cap. The retry gets the same budget as the first attempt.
+            REVIEW_TIMEOUT_SECS=600
+            REVIEW_JSON=""
+            REVIEW_ATTEMPT=""
+            for ATTEMPT in 1 2; do
+              PROMPT="${REVIEW_PROMPT}"
+              if [ "${ATTEMPT}" = "2" ]; then PROMPT="${REVIEW_PROMPT} ${RETRY_NOTE}"; fi
+              set +e
+              REVIEW_OUTPUT=$(timeout "${REVIEW_TIMEOUT_SECS}" kiro-cli chat --no-interactive --trust-all-tools --model "${REVIEW_MODEL}" "${PROMPT}")
+              set -e
 
-            # Extract the LAST JSON object that parses and has a numeric score
-            # and a findings array. kiro-cli writes reasoning notes first, and
-            # they quote code with braces, so a greedy first-brace-to-last-brace
-            # match is not the verdict.
-            CLEANED=$(printf '%s' "${REVIEW_OUTPUT}" | sed 's/\x1b\[[0-9;?]*[a-zA-Z]//g' | tr -d '\r')
-            REVIEW_JSON=$(printf '%s' "${CLEANED}" | python3 -c 'if True:
-                import json, math, sys
-                text = sys.stdin.read()
-                dec = json.JSONDecoder(strict=False)
-                pos = text.rfind("{")
-                while pos != -1:
-                    try:
-                        obj = dec.raw_decode(text, pos)[0]
-                    except ValueError:
-                        obj = None
-                    score = obj.get("score") if isinstance(obj, dict) else None
-                    if (isinstance(score, (int, float)) and not isinstance(score, bool)
-                            and math.isfinite(score) and isinstance(obj.get("findings"), list)):
-                        print(json.dumps(obj))
-                        sys.exit(0)
-                    pos = text.rfind("{", 0, pos)
-                sys.exit(1)
-            ' || true)
+              # Extract the LAST JSON object that parses and has a numeric score
+              # and a findings array. kiro-cli writes reasoning notes first, and
+              # they quote code with braces, so a greedy first-brace-to-last-brace
+              # match is not the verdict.
+              CLEANED=$(printf '%s' "${REVIEW_OUTPUT}" | sed 's/\x1b\[[0-9;?]*[a-zA-Z]//g' | tr -d '\r')
+              REVIEW_JSON=$(printf '%s' "${CLEANED}" | python3 -c 'if True:
+                  import json, math, sys
+                  text = sys.stdin.read()
+                  dec = json.JSONDecoder(strict=False)
+                  pos = text.rfind("{")
+                  while pos != -1:
+                      try:
+                          obj = dec.raw_decode(text, pos)[0]
+                      except ValueError:
+                          obj = None
+                      score = obj.get("score") if isinstance(obj, dict) else None
+                      if (isinstance(score, (int, float)) and not isinstance(score, bool)
+                              and math.isfinite(score) and isinstance(obj.get("findings"), list)):
+                          print(json.dumps(obj))
+                          sys.exit(0)
+                      pos = text.rfind("{", 0, pos)
+                  sys.exit(1)
+              ' || true)
 
-            if [ -z "${REVIEW_JSON}" ] || ! printf '%s' "${REVIEW_JSON}" | jq -e '.score' >/dev/null 2>&1; then
-              echo "❌ Could not parse kiro-cli review output — failing closed."
+              if [ -n "${REVIEW_JSON}" ] && printf '%s' "${REVIEW_JSON}" | jq -e '.score' >/dev/null 2>&1; then
+                REVIEW_ATTEMPT="${ATTEMPT}"
+                break
+              fi
+              REVIEW_JSON=""
+              echo "⚠  Attempt ${ATTEMPT}: could not parse kiro-cli review output. Raw output (first 2000 chars):"
               printf '%s' "${REVIEW_OUTPUT:-<empty>}" | head -c 2000
               echo ""
+              if [ "${ATTEMPT}" = "1" ]; then
+                echo "Retrying the review once."
+              fi
+            done
+
+            if [ -z "${REVIEW_JSON}" ]; then
+              echo "❌ Could not parse kiro-cli review output on either attempt (both unparseable) — failing closed."
               REVIEW_RESULT="ERROR"
             else
+              echo "Review verdict parsed on attempt ${REVIEW_ATTEMPT} of 2."
               printf '%s' "${REVIEW_JSON}" > /tmp/kiro-review.json
               REVIEW_SCORE=$(jq -r '.score' /tmp/kiro-review.json)
               REVIEW_HIGH=$(jq '[.findings[] | select(.severity=="high")] | length' /tmp/kiro-review.json)
@@ -265,7 +326,7 @@ prism-eval-gate:
                 REVIEW_RESULT="PASS"
               fi
 
-              echo "Score: ${REVIEW_SCORE} | Findings: ${REVIEW_TOTAL} (${REVIEW_HIGH} high) | ${REVIEW_RESULT}"
+              echo "Score: ${REVIEW_SCORE} | Findings: ${REVIEW_TOTAL} (${REVIEW_HIGH} high) | ${REVIEW_RESULT} | Model: ${REVIEW_MODEL}"
               echo "Summary: ${REVIEW_SUMMARY}"
               jq -r '.findings[] | "   [\(.severity)] \(.file):\(.line) — \(.message)"' /tmp/kiro-review.json || true
             fi
@@ -308,10 +369,10 @@ prism-eval-gate:
           DETAIL=$(jq -n -c \
             --arg team_id "${TEAM_ID}" --arg repo "${PRISM_REPO}" --arg timestamp "${TIMESTAMP}" \
             --arg score "${REVIEW_SCORE}" --arg result "${REVIEW_RESULT}" \
-            --arg mr_iid "${CI_MERGE_REQUEST_IID:-0}" \
+            --arg mr_iid "${CI_MERGE_REQUEST_IID:-0}" --arg model "${REVIEW_MODEL}" \
             '{team_id:$team_id,repo:$repo,timestamp:$timestamp,prism_level:2,
               metric:{name:"eval_score",value:($score|tonumber),unit:"score"},
-              ai_context:{tool:"kiro-cli",model:"claude-haiku-4.5",origin:"ai-generated"},
+              ai_context:{tool:"kiro-cli",model:$model,origin:"ai-generated"},
               eval:{score:($score|tonumber),result:$result,rubric:"kiro-headless",
                     mr_iid:($mr_iid|tonumber),method:"kiro-headless"}}')
           aws events put-events --region "${AWS_DEFAULT_REGION}" --entries \
@@ -398,10 +459,14 @@ prism-eval-gate:
           echo "  deleting it from the branch does not un-expose what was pushed."
           echo "  False positive? Add an allowlist entry to .gitleaks.toml."
         fi
-        [ "${REVIEW_RESULT}" = "ERROR" ] && echo "  Review failed closed: output could not be parsed."
+        if [ -n "${MODEL_ERROR}" ]; then
+          echo "  Review failed closed: invalid review model (${MODEL_ERROR})."
+        elif [ "${REVIEW_RESULT}" = "ERROR" ]; then
+          echo "  Review failed closed: output could not be parsed."
+        fi
         [ "${REVIEW_RESULT}" = "FAIL" ] && echo "  Review score ${REVIEW_SCORE} below threshold, or high-severity findings."
         exit 1
       fi
 
-      echo "✅ PRISM Eval Gate passed (secret scan: clean, review: ${REVIEW_RESULT})"
+      echo "✅ PRISM Eval Gate passed (secret scan: clean, review: ${REVIEW_RESULT}, model: ${REVIEW_MODEL})"
       exit 0

package/dist/assets/kirocrew-app/README.md

@@ -1,4 +1,4 @@
-# PRISM app for Kiro Crew (v0.2)
+# PRISM app for Kiro Crew
 
 A [Kiro Crew](https://github.com/kirodotdev/KiroCrew) app that brings your local PRISM data into
 Kiro Crew. It adds:
@@ -50,14 +50,13 @@ With prism-cli 1.9.0 or later, which bundles this app:
 npm i -g @prism-d1/cli && prism-cli enable kirocrew
 ```
 
-`prism-cli enable kirocrew` prints its plan (install, update or already current, with the
-versions) and asks before it changes anything. It copies the bundled app to
-`~/.prism/kirocrew-app`, then runs `kirocrew app install`, or `kirocrew app update prism --source`
-when the app is already installed (also from another folder, such as a clone), and
-`kirocrew app enable prism` on a first install. It never installs Kiro Crew. `--dry-run` prints
-the plan only, `--status` shows the installed and bundled versions, the source folder, the API
-grants and the digest cron, and `--uninstall` removes the app. After a prism-cli upgrade,
-`prism-cli version` says when the bundled app is newer than the installed one.
+What the command does, its `--status`, `--dry-run` and `--uninstall` options and the two steps
+that stay with you (trust the app, approve its API routes) are in the User Guide's
+[Kiro Crew app](../USER_GUIDE.md#kiro-crew-app) section; every flag is in the
+[command reference](../docs/CLI-REFERENCE.md#prism-cli-enable-kirocrew). It updates an app that
+was installed from another folder, such as a clone, too. It never installs Kiro Crew.
+
+### Install from a folder
 
 From a local folder instead (a clone, for development):
 
@@ -129,6 +128,10 @@ is kept across app updates unless a later version of the app changes the schedul
 
 ## The page
 
+![PRISM page in Kiro Crew with demo data: spend cards, top models and projects, four repos with codewatch, one expanded with its findings](../assets/images/prism-cli/kirocrew-app-page-light.png)
+
+*The PRISM page, rendered with made-up demo data.*
+
 The **PRISM** sidebar page shows the same data as the editor extension's machine mode:
 
 - spend today and this month (calls, sessions), sync mode, prism-cli version, and when the data

package/dist/assets/kirocrew-app/app.json

@@ -1,12 +1,14 @@
 {
   "name": "prism",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "displayName": "PRISM",
   "description": "Codewatch findings, AI spend and setup status from your local prism-cli for Kiro Crew agents, and a daily digest that speaks only when something changed.",
   "author": "aws-samples",
   "license": "MIT",
   "minKiroCrewVersion": "0.12.1",
   "iconPath": "assets/icon.png",
+  "screenshots": ["assets/screenshots/page-light.png", "assets/screenshots/report-light.png"],
+  "screenshotsDark": ["assets/screenshots/page-dark.png", "assets/screenshots/report-dark.png"],
   "tags": ["code-review", "developer-tools", "code-quality"],
   "highlights": [
     "PRISM page: spend, setup checklist, repos with codewatch newest commit first, their findings and a sandboxed scan report, all read-only",

package/dist/bin/cli.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/bin/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../bin/cli.ts"],"names":[],"mappings":""}

package/dist/bin/cli.js

@@ -0,0 +1,19 @@
+// The commander CLI; bin/prism-cli.ts loads it for every command except the status line fast path.
+import { program } from 'commander';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { registerCommands } from '../src/index.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+// Works from both cli/bin/ (source via tsx) and dist/bin/ (published)
+const pkgPath = existsSync(resolve(__dirname, '..', 'package.json'))
+    ? resolve(__dirname, '..', 'package.json')
+    : resolve(__dirname, '..', '..', 'package.json');
+const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+program
+    .name('prism-cli')
+    .description('PRISM D1 Velocity CLI tool')
+    .version(pkg.version);
+await registerCommands(program);
+program.parse();
+//# sourceMappingURL=cli.js.map

package/dist/bin/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.js","sourceRoot":"","sources":["../../bin/cli.ts"],"names":[],"mappings":"AAAA,mGAAmG;AACnG,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACnD,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAEnD,MAAM,SAAS,GAAG,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;AAC1D,sEAAsE;AACtE,MAAM,OAAO,GAAG,UAAU,CAAC,OAAO,CAAC,SAAS,EAAE,IAAI,EAAE,cAAc,CAAC,CAAC;IAClE,CAAC,CAAC,OAAO,CAAC,SAAS,EAAE,IAAI,EAAE,cAAc,CAAC;IAC1C,CAAC,CAAC,OAAO,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,cAAc,CAAC,CAAC;AACnD,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC;AAEtD,OAAO;KACJ,IAAI,CAAC,WAAW,CAAC;KACjB,WAAW,CAAC,4BAA4B,CAAC;KACzC,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;AAExB,MAAM,gBAAgB,CAAC,OAAO,CAAC,CAAC;AAEhC,OAAO,CAAC,KAAK,EAAE,CAAC"}