arckit-cli 6.1.1__py3-none-any.whl

arckit_cli-6.1.1.data/data/share/arckit/scripts/autoresearch/program.md

@@ -0,0 +1,269 @@
+# ArcKit Command Prompt Optimiser
+
+This is an experiment to have the LLM optimise its own command prompts.
+
+Inspired by [karpathy/autoresearch](https://github.com/karpathy/autoresearch). Instead of optimising `train.py` against `val_bpb`, you optimise a command `.md` file against a two-layer quality score.
+
+---
+
+## 1. Setup
+
+To set up a new experiment, work with the user to:
+
+1. **Agree on a target command.** The user tells you which command to optimise (e.g. `requirements`). The file is at `plugins/arckit-claude/commands/<command>.md`.
+
+2. **Create a worktree.** Run:
+
+   ```bash
+   git worktree add ../autoresearch-<command> -b autoresearch/<command>-<tag>
+   ```
+
+   where `<tag>` is today's date (e.g. `mar21`). The branch must not already exist. Then `cd` into the worktree:
+
+   ```bash
+   cd ../autoresearch-<command>
+   ```
+
+   All subsequent work happens in this worktree. The main checkout stays clean.
+
+3. **Read the in-scope files.** Read these files for full context:
+   - `plugins/arckit-claude/commands/<command>.md` — the prompt you will optimise. This is the ONLY file you modify.
+   - The template file referenced in the command's instructions (search for `templates/` in the command `.md` to find the actual filename — names don't always match the command name). Read-only.
+   - `plugins/arckit-claude/references/quality-checklist.md` — quality criteria. Read-only.
+   - Note the current `effort:` and `model:` values in the command's YAML frontmatter — these are tuneable parameters (see section 4).
+
+4. **Check for agent delegation.** If the command contains "Launch the agent" or references the Task tool to delegate to an agent, you MUST follow its "Alternative: Direct Execution" or fallback section instead. Agent wrappers are too thin to optimise meaningfully.
+
+5. **Create the scratch project.** Copy fixture files from `scripts/autoresearch/fixtures/` into `scratch/projects/`, preserving directory structure:
+   - `fixtures/000-global/` → `scratch/projects/000-global/`
+   - `fixtures/001-test-project/` → `scratch/projects/001-test-project/`
+
+   These fixture files are READ-ONLY. They provide stable input context.
+
+6. **Set the test argument.** `$ARGUMENTS` = `"001"` for every iteration. This is fixed — the same input each time so the only variable is the prompt.
+
+7. **Initialize results.tsv.** Create `results.tsv` with just the header row:
+
+   ```text
+   commit structural score effort model status description
+   ```
+
+8. **Run the baseline.** Execute the command unmodified against the scratch project (see "How Commands Are Executed" below). Score it using both evaluation layers. Log the result as the first data row in `results.tsv` with status `keep` and description `baseline`. Then begin the experiment loop.
+
+---
+
+## 2. How Commands Are Executed
+
+Commands are plugin slash commands — you cannot invoke them as `/arckit:<command>` from this context. Instead:
+
+1. Read `plugins/arckit-claude/commands/<command>.md`
+2. Follow its instructions directly, as if the user had typed the slash command
+3. Apply these substitutions:
+   - Replace `$ARGUMENTS` with `"001"`
+   - Replace all `${CLAUDE_PLUGIN_ROOT}` references with `plugins/arckit-claude/`
+   - Ignore any references to "ArcKit Project Context hook" — instead, manually scan `scratch/projects/` for existing artifacts
+   - Write all generated artifacts to paths under `scratch/projects/` (not `projects/`)
+
+---
+
+## 3. Evaluation
+
+Each iteration produces an artifact. Score it in two layers.
+
+### Layer 1: Structural Checks (pass/fail gate)
+
+Read the generated artifact and verify ALL of the following. If ANY check fails, the iteration scores `FAIL 0.0` and is discarded immediately.
+
+1. **Document Control table present** with all 14 required fields: Document ID, Document Type, Project, Classification, Status, Version, Created Date, Last Modified, Review Cycle, Next Review Date, Owner, Reviewed By, Approved By, Distribution
+2. **Document ID format**: Follows `ARC-NNN-TYPE-vX.Y` pattern (e.g. `ARC-001-REQ-v1.0`)
+3. **Revision History table present** with columns: Version, Date, Author, Changes, Approved By, Approval Date. At least one row.
+4. **Standard footer present** with fields: Generated by, Generated on, ArcKit Version, Project, Model
+5. **Template sections present**: All major sections from the template file appear in the output
+6. **File path correct**: Written to a path under `scratch/projects/`
+7. **Domain-specific IDs correct**: Where applicable — BR-xxx, FR-xxx, NFR-xxx, INT-xxx, DR-xxx for requirements; RISK-xxx for risk registers; etc.
+8. **Wardley Map math validation** (WARD/WVCH commands only — skip for non-Wardley artifacts). Based on the mathematical model M = (V, E, u, v, e, t) from `tractorjuice/wardleymap_math_model`:
+   a. **Stage-evolution alignment**: For each component in the Component Inventory table, the Stage column must match the evolution value (0.00-0.24 = Genesis, 0.25-0.49 = Custom, 0.50-0.74 = Product, 0.75-1.00 = Commodity)
+   b. **Coordinate range**: All visibility and evolution values must be in [0.00, 1.00]
+   c. **OWM-to-table consistency**: Component coordinates in the `wardley` code block must exactly match the Component Inventory table — no mismatches between the map code and the written analysis
+   d. **DAG acyclicity**: Dependencies must form a directed acyclic graph — no circular dependencies
+   e. **Visibility ordering**: If component A depends on component B, then visibility(A) >= visibility(B) — parents must be higher than children in the value chain
+   f. **Strategic metric consistency**: Compute these metrics for each component and verify the strategic analysis is consistent:
+      - Differentiation Pressure: D(v) = visibility(v) x (1 - evolution(v)) — high D should be flagged as strategic differentiators
+      - Commodity Leverage: K(v) = (1 - visibility(v)) x evolution(v) — high K should be flagged as commodity candidates
+      - Dependency Risk: R(a,b) = visibility(a) x (1 - evolution(b)) — high R should be flagged as risk areas
+
+### Layer 2: LLM-as-Judge (qualitative score, 1.0–10.0)
+
+If structural checks pass, score the artifact on five dimensions, each 1–10:
+
+| Dimension | What it measures |
+|-----------|-----------------|
+| **Completeness** | Are all sections substantively filled? No empty placeholders, no "TBD" without justification |
+| **Specificity** | Does content reference the actual project context, not generic boilerplate? |
+| **Traceability** | Are cross-references between artifacts present and correctly formatted? |
+| **Actionability** | Could a vendor, architect, or review board use this document as-is? |
+| **Clarity** | Is the writing clear, well-structured, and free of contradictions? |
+
+The combined score is the arithmetic mean of the five dimensions, rounded to one decimal place.
+
+**Scoring discipline**: Adopt an adversarial reviewer persona. Actively look for weaknesses. Do not anchor on the score you expect — score each dimension independently by citing specific evidence from the document. If a section is present but shallow, it scores low on Specificity and Actionability regardless of structural correctness. Re-read the template and quality checklist before every scoring pass to prevent anchor drift.
+
+---
+
+## 4. The Experiment Loop
+
+### LOOP UNTIL STOP CONDITION
+
+The loop runs until one of three explicit stop conditions fires (see step 12 below) — score target reached, iteration budget exhausted, or double plateau detected. There is no "loop forever" mode.
+
+1. Read the current command prompt and review `results.tsv` history
+2. Identify ONE specific improvement to the prompt
+   - Draw ideas from: low-scoring dimensions, structural failures, template gaps, quality checklist criteria, prompt engineering best practices, previous near-misses in results history, or effort/model tuning (see below)
+   - **Effort and model tuning**: The `effort:` and `model:` fields in the YAML frontmatter are tuneable parameters, just like the prompt text. Valid effort values: `low`, `medium`, `high`, `max`. Valid model values: `sonnet`, `opus`, `haiku`, `inherit` (inherits user's session model). Consider testing different combinations — a well-written prompt at `high` effort may outperform a mediocre prompt at `max` effort, and `inherit` may be better than a hardcoded model. Treat these as single-variable changes: change effort OR model OR prompt text in one iteration, not multiple at once.
+3. Edit `plugins/arckit-claude/commands/<command>.md` with the change
+4. Git commit with a short description of what changed
+5. Clean the scratch project: delete previously generated artifacts but keep the read-only fixture files (PRIN, STKE, README)
+6. Execute the command instructions against the scratch project (see "How Commands Are Executed" above)
+7. Score the output:
+   a. Run structural checks — if FAIL, skip LLM scoring, score = `0.0`
+   b. If PASS, run LLM-as-judge across five dimensions
+   c. Compute combined score (mean of five dimensions)
+8. Compare to previous best score:
+   - If improved by >= 0.3 → KEEP
+   - If less than 0.3 improvement → DISCARD
+9. Log to `results.tsv` (append a new row — see "Output Format" below)
+10. **Print status line** after logging:
+
+    ```text
+    [iter N] score: X.X (best: Y.Y) | effort: high model: inherit | status: keep/discard | keeps: K discards: D | streak: S/15 to plateau
+    ```
+
+    This gives the human live visibility in the terminal without needing to read `results.tsv`.
+11. If DISCARD: revert the command file to its previous-best content:
+
+    ```bash
+    git checkout <previous-best-commit> -- plugins/arckit-claude/commands/<command>.md
+    ```
+
+    Then commit the revert: `"revert: <description> (no improvement)"`
+    Do NOT use `git reset --hard` or `git revert`
+12. **Check stopping conditions** before going back to step 1:
+    - **Score target hit** — if `best >= 9.5`: log a row with status `complete` and description `score target reached (best={best})`, then exit the loop.
+    - **Iteration budget** — if `iter >= 30`: log a row with status `budget-exhausted` and description `30-iteration budget reached (best={best})`, then exit the loop.
+    - **Double plateau** — if the Plateau Detection trigger has fired twice in this run (i.e. two `plateau` rows already logged and the second was within the last 10 iterations): log a row with status `complete` and description `double plateau — diminishing returns`, then exit the loop.
+    - Otherwise: Go to step 1.
+
+    These thresholds are tunable. To extend a run, change the constants here (e.g. `>= 9.7` for higher target, `>= 50` for longer budget) and re-launch — do not let the LLM negotiate past a hit threshold mid-run.
+
+### Plateau Detection
+
+If the last 15 consecutive iterations have all been discarded (no score improvement), log a `plateau` marker in `results.tsv` and shift strategy:
+
+- Re-read the template line by line looking for sections the prompt doesn't address
+- Review the quality checklist for uncovered criteria
+- Try prompt simplification (removing instructions that don't contribute to score)
+- Try combining ideas from previous near-misses in the results history
+- Try changing `effort:` or `model:` if you haven't already — a different thinking level or model may unlock gains that prompt wording alone cannot
+
+The plateau strategy shift resets the discard streak to 0. If a second plateau marker is logged within 10 iterations of the first, step 12's double-plateau condition fires and the run exits — that's the diminishing-returns signal that further iteration is unlikely to pay off.
+
+---
+
+## 5. Output Format (Results TSV)
+
+Tab-separated, NOT comma-separated (commas break in descriptions). Header row plus one row per experiment:
+
+```text
+commit structural score effort model status description
+```
+
+Columns:
+
+1. git commit hash (short, 7 chars)
+2. structural check result: `PASS` or `FAIL`
+3. combined LLM-as-judge score (e.g. `7.4`) — use `0.0` for structural failures
+4. effort value used for this iteration (e.g. `high`, `max`, or `-` if not set)
+5. model value used for this iteration (e.g. `inherit`, `sonnet`, or `-` if not set)
+6. status: `keep`, `discard`, `plateau`, or `crash`
+7. short text description of what this experiment tried
+
+Example:
+
+```text
+commit structural score effort model status description
+a1b2c3d PASS 6.8 high inherit keep baseline
+b2c3d4e PASS 7.2 high inherit keep added explicit instruction to fill all NFR subcategories
+c3d4e5f FAIL 0.0 high inherit discard removed Document Control instruction (broke structure)
+d4e5f6g PASS 7.1 high inherit discard reordered sections (no improvement)
+e5f6g7h PASS 7.6 high inherit keep added example requirement IDs in prompt
+f6g7h8i PASS 7.5 max inherit discard changed effort to max (no improvement)
+g7h8i9j PASS 7.4 high inherit discard reworded traceability section
+h8i9j0k PASS 7.6 high inherit discard added stakeholder cross-ref reminder
+i9j0k1l PASS 7.3 high inherit discard moved NFR subcategories earlier in prompt
+j0k1l2m PASS 7.5 high inherit plateau 15 consecutive discards — shifting strategy
+```
+
+---
+
+## 6. What You CAN Do / CANNOT Do
+
+**What you CAN do:**
+
+- Modify `plugins/arckit-claude/commands/<command>.md` — this is the only file you edit. Everything is fair game: instruction wording, section ordering, examples, emphasis, formatting, adding/removing guidance, and the `effort:` / `model:` YAML frontmatter fields.
+
+**What you CANNOT do:**
+
+- Modify the template file. It defines expected output structure — changing it moves the goalposts.
+- Modify `plugins/arckit-claude/references/quality-checklist.md`. The evaluation standard must be stable.
+- Modify the evaluation rubric. It's the fixed metric, like `val_bpb`.
+- Modify the scratch project fixture files (PRIN, STKE, README). Controlled input.
+- Change the test argument (`$ARGUMENTS` = `"001"`). Same input every iteration.
+- Use `git reset --hard`. Use targeted `git checkout` + revert commits.
+- Install new packages or add dependencies.
+
+---
+
+## 7. Constraints
+
+- **One change per iteration.** Isolate variables. If you change two things and the score improves, you don't know which helped.
+- **Minimum delta of 0.3.** Keep only if the score improves by >= 0.3. This filters noise from non-deterministic generation and evaluation.
+- **Simplicity criterion.** All else being equal, simpler is better. A small improvement that adds ugly complexity to the prompt is not worth it. Conversely, removing something and getting equal or better results is a great outcome — that's a simplification win. When evaluating whether to keep a change, weigh the complexity cost against the improvement magnitude.
+- **Log everything.** Every iteration gets a row in `results.tsv`, whether kept or discarded. The history is the research record.
+
+---
+
+## 8. NEVER STOP
+
+Once the experiment loop has begun (after the initial setup), do NOT pause to ask the human if you should continue. Do NOT ask "should I keep going?" or "is this a good stopping point?". The human might be asleep, or gone from the computer and expects you to continue working *indefinitely* until you are manually stopped. You are autonomous. If you run out of ideas, think harder — re-read the template line by line, review the quality checklist for uncovered criteria, try prompt simplification, try combining previous near-misses, try more radical restructuring. The loop runs until the human interrupts you, period.
+
+Each iteration takes roughly 2-3 minutes. That's ~20-30 experiments per hour. If a user leaves you running overnight, that's potentially 200+ iterations. The user wakes up to a fully optimised command prompt, all completed by you while they slept.
+
+---
+
+## 9. Ephemeral Files
+
+The worktree, `results.tsv`, and the `scratch/` directory are ephemeral. The experiment branch tip (the improved command `.md`) is the deliverable.
+
+**After the run:**
+
+- Cherry-pick the kept commits onto a clean branch for the PR
+- Remove the worktree: `git worktree remove ../autoresearch-<command>`
+- Delete the experiment branch if no longer needed: `git branch -D autoresearch/<command>-<tag>`
+
+---
+
+## 10. Usage
+
+```bash
+# Start a run:
+# Human tells Claude: "read scripts/autoresearch/program.md and optimise the requirements command"
+# Claude reads this file, creates a worktree, and enters the loop
+
+# Stop a run:
+# Human interrupts Claude at any time. The worktree has the best prompt so far.
+
+# Clean up:
+# git worktree remove ../autoresearch-<command>
+```
+
+The human's only interactions are: starting the run, and optionally stopping it.

arckit_cli-6.1.1.data/data/share/arckit/scripts/bash/check-prerequisites.sh

@@ -0,0 +1,250 @@
+#!/usr/bin/env bash
+
+# Consolidated prerequisite checking script for ArcKit
+#
+# This script provides unified prerequisite checking for ArcKit workflow.
+# It helps find projects, validate environment, and check for required files.
+#
+# Usage: ./check-prerequisites.sh [OPTIONS]
+#
+# OPTIONS:
+#   --json                Output in JSON format
+#   --project <prefix>    Specify project by number or name prefix
+#   --require-file <file> Require specific file to exist (can be used multiple times)
+#   --paths-only          Only output path variables (no validation)
+#   --list-projects       List all available projects
+#   --help, -h            Show help message
+#
+# OUTPUTS:
+#   JSON mode: {"REPO_ROOT":"...", "PROJECT_DIR":"...", "AVAILABLE_DOCS":["..."]}
+#   Text mode: REPO_ROOT: ... \n PROJECT_DIR: ... \n AVAILABLE_DOCS: \n ✓/✗ file.md
+#   Paths only: REPO_ROOT: ... \n PROJECT_DIR: ... etc.
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/common.sh"
+
+# Parse command line arguments
+JSON_MODE=false
+PATHS_ONLY=false
+LIST_PROJECTS=false
+PROJECT_PREFIX=""
+REQUIRED_FILES=()
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --json)
+            JSON_MODE=true
+            shift
+            ;;
+        --project)
+            PROJECT_PREFIX="$2"
+            shift 2
+            ;;
+        --require-file)
+            REQUIRED_FILES+=("$2")
+            shift 2
+            ;;
+        --paths-only)
+            PATHS_ONLY=true
+            shift
+            ;;
+        --list-projects)
+            LIST_PROJECTS=true
+            shift
+            ;;
+        --help|-h)
+            cat << 'EOF'
+Usage: check-prerequisites.sh [OPTIONS]
+
+Consolidated prerequisite checking for ArcKit workflow.
+
+OPTIONS:
+  --json                Output in JSON format
+  --project <prefix>    Specify project by number or name prefix
+  --require-file <file> Require specific file to exist (can be used multiple times)
+  --paths-only          Only output path variables (no validation)
+  --list-projects       List all available projects
+  --help, -h            Show this help message
+
+EXAMPLES:
+  # Check prerequisites in JSON mode
+  ./check-prerequisites.sh --json
+
+  # Find project by prefix
+  ./check-prerequisites.sh --project "payment"
+
+  # Require specific files
+  ./check-prerequisites.sh --project "001" --require-file "requirements.md"
+
+  # List all projects
+  ./check-prerequisites.sh --list-projects
+
+EXIT CODES:
+  0 - Success
+  1 - Error (missing required files, project not found, etc.)
+
+EOF
+            exit 0
+            ;;
+        *)
+            log_error "Unknown option: $1"
+            exit 1
+            ;;
+    esac
+done
+
+# Get repository root
+REPO_ROOT="$(find_repo_root)"
+
+# List projects if requested
+if [[ "$LIST_PROJECTS" == "true" ]]; then
+    list_projects "$REPO_ROOT"
+    exit 0
+fi
+
+# Paths only mode - just output variables
+if [[ "$PATHS_ONLY" == "true" ]]; then
+    echo "REPO_ROOT: $REPO_ROOT"
+    echo "ARCKIT_DIR: $(get_arckit_dir "$REPO_ROOT")"
+    echo "PROJECTS_DIR: $(get_projects_dir "$REPO_ROOT")"
+    echo "MEMORY_DIR: $(get_memory_dir "$REPO_ROOT")"
+    echo "TEMPLATES_DIR: $(get_templates_dir "$REPO_ROOT")"
+
+    if [[ -n "$PROJECT_PREFIX" ]]; then
+        PROJECT_DIR=$(find_project_dir_by_prefix "$PROJECT_PREFIX" "$REPO_ROOT" 2>/dev/null || echo "")
+        if [[ -n "$PROJECT_DIR" ]]; then
+            echo "PROJECT_DIR: $PROJECT_DIR"
+            PROJECT_NUMBER=$(get_project_number_from_dir "$PROJECT_DIR")
+            echo "PROJECT_NUMBER: $PROJECT_NUMBER"
+        fi
+    fi
+    exit 0
+fi
+
+# Find project if prefix specified
+PROJECT_DIR=""
+PROJECT_NUMBER=""
+if [[ -n "$PROJECT_PREFIX" ]]; then
+    PROJECT_DIR=$(find_project_dir_by_prefix "$PROJECT_PREFIX" "$REPO_ROOT")
+    if [[ $? -ne 0 ]]; then
+        exit 1
+    fi
+    PROJECT_NUMBER=$(get_project_number_from_dir "$PROJECT_DIR")
+fi
+
+# Check for available documentation files
+AVAILABLE_DOCS=()
+if [[ -n "$PROJECT_DIR" ]]; then
+    # Check for all standard ArcKit artifacts
+    ARTIFACTS=(
+        "stakeholder-drivers.md"
+        "risk-register.md"
+        "sobc.md"
+        "requirements.md"
+        "data-model.md"
+        "research-findings.md"
+        "sow.md"
+        "evaluation-criteria.md"
+        "traceability-matrix.md"
+        "servicenow-design.md"
+    )
+
+    for artifact in "${ARTIFACTS[@]}"; do
+        if [[ -f "$PROJECT_DIR/$artifact" ]]; then
+            AVAILABLE_DOCS+=("$artifact")
+        fi
+    done
+
+    # Check for Wardley maps
+    if [[ -d "$PROJECT_DIR/wardley-maps" ]] && [[ -n $(ls -A "$PROJECT_DIR/wardley-maps" 2>/dev/null) ]]; then
+        AVAILABLE_DOCS+=("wardley-maps/")
+    fi
+
+    # Check for vendor proposals
+    if [[ -d "$PROJECT_DIR/vendors" ]] && [[ -n $(ls -A "$PROJECT_DIR/vendors" 2>/dev/null) ]]; then
+        AVAILABLE_DOCS+=("vendors/")
+    fi
+fi
+
+# Check required files if specified
+ALL_REQUIRED_FOUND=true
+for required_file in "${REQUIRED_FILES[@]}"; do
+    if [[ -n "$PROJECT_DIR" ]]; then
+        full_path="$PROJECT_DIR/$required_file"
+    else
+        full_path="$REPO_ROOT/$required_file"
+    fi
+
+    if [[ ! -f "$full_path" ]]; then
+        if [[ "$JSON_MODE" != "true" ]]; then
+            log_error "Required file not found: $required_file"
+        fi
+        ALL_REQUIRED_FOUND=false
+    fi
+done
+
+# Output results
+if [[ "$JSON_MODE" == "true" ]]; then
+    # JSON output
+    echo "{"
+    echo "  \"REPO_ROOT\": \"$REPO_ROOT\","
+    echo "  \"ARCKIT_DIR\": \"$(get_arckit_dir "$REPO_ROOT")\","
+    echo "  \"PROJECTS_DIR\": \"$(get_projects_dir "$REPO_ROOT")\","
+    echo "  \"MEMORY_DIR\": \"$(get_memory_dir "$REPO_ROOT")\","
+    echo "  \"TEMPLATES_DIR\": \"$(get_templates_dir "$REPO_ROOT")\","
+
+    if [[ -n "$PROJECT_DIR" ]]; then
+        echo "  \"PROJECT_DIR\": \"$PROJECT_DIR\","
+        echo "  \"PROJECT_NUMBER\": \"$PROJECT_NUMBER\","
+    else
+        echo "  \"PROJECT_DIR\": null,"
+        echo "  \"PROJECT_NUMBER\": null,"
+    fi
+
+    echo -n "  \"AVAILABLE_DOCS\": "
+    output_json_array "${AVAILABLE_DOCS[@]}"
+    echo ""
+    echo "}"
+else
+    # Text output
+    echo "ArcKit Environment:"
+    echo "==================="
+    echo ""
+    echo "Repository:"
+    echo "  REPO_ROOT: $REPO_ROOT"
+    echo "  ARCKIT_DIR: $(get_arckit_dir "$REPO_ROOT")"
+    echo "  PROJECTS_DIR: $(get_projects_dir "$REPO_ROOT")"
+    echo "  MEMORY_DIR: $(get_memory_dir "$REPO_ROOT")"
+    echo "  TEMPLATES_DIR: $(get_templates_dir "$REPO_ROOT")"
+    echo ""
+
+    if [[ -n "$PROJECT_DIR" ]]; then
+        echo "Project:"
+        echo "  PROJECT_DIR: $PROJECT_DIR"
+        echo "  PROJECT_NUMBER: $PROJECT_NUMBER"
+        echo ""
+
+        echo "Available Artifacts:"
+        if [[ ${#AVAILABLE_DOCS[@]} -eq 0 ]]; then
+            echo "  (no artifacts found)"
+        else
+            for doc in "${AVAILABLE_DOCS[@]}"; do
+                echo "  ✓ $doc"
+            done
+        fi
+    else
+        echo "Project: (not specified)"
+        echo ""
+        echo "Use --project <prefix> to specify a project"
+        list_projects "$REPO_ROOT"
+    fi
+fi
+
+# Exit with error if required files missing
+if [[ "$ALL_REQUIRED_FOUND" != "true" ]]; then
+    exit 1
+fi
+
+exit 0