shipwright-cli 1.7.0 → 1.9.0

package/scripts/{cct-prep.sh → sw-prep.sh}

@@ -4,14 +4,15 @@
 # ║  Analyze repos · Generate configs · Equip autonomous agents            ║
 # ╚═══════════════════════════════════════════════════════════════════════════╝
 set -euo pipefail
+trap 'echo "ERROR: $BASH_SOURCE:$LINENO exited with status $?" >&2' ERR
 
-VERSION="1.7.0"
+VERSION="1.9.0"
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 
 # ─── Handle subcommands ───────────────────────────────────────────────────────
 if [[ "${1:-}" == "test" ]]; then
     shift
-    exec "$SCRIPT_DIR/cct-prep-test.sh" "$@"
+    exec "$SCRIPT_DIR/sw-prep-test.sh" "$@"
 fi
 
 # ─── Colors (matches Seth's tmux theme) ─────────────────────────────────────
@@ -25,6 +26,9 @@ DIM='\033[2m'
 BOLD='\033[1m'
 RESET='\033[0m'
 
+# ─── Cross-platform compatibility ──────────────────────────────────────────
+# shellcheck source=lib/compat.sh
+[[ -f "$SCRIPT_DIR/lib/compat.sh" ]] && source "$SCRIPT_DIR/lib/compat.sh"
 # ─── Output Helpers ─────────────────────────────────────────────────────────
 info()    { echo -e "${CYAN}${BOLD}▸${RESET} $*"; }
 success() { echo -e "${GREEN}${BOLD}✓${RESET} $*"; }
@@ -74,6 +78,10 @@ HAS_DB=false
 HAS_MIDDLEWARE=false
 ROUTE_PATTERNS=""
 DB_PATTERNS=""
+ARCHITECTURE_PATTERN=""
+SEMICOLONS=""
+QUOTE_STYLE=""
+INDENT_STYLE=""
 
 # Tracking generated files
 GENERATED_FILES=()
@@ -159,7 +167,7 @@ should_write() {
     fi
     if $UPDATE_MODE; then
         # In update mode, only write if file has auto markers
-        if grep -q "<!-- cct:auto-start -->" "$filepath" 2>/dev/null; then
+        if grep -q "<!-- sw:auto-start -->" "$filepath" 2>/dev/null; then
             return 0
         fi
         info "Skipping ${filepath##"$PROJECT_ROOT"/} (no auto markers, user-customized)"
@@ -175,11 +183,11 @@ update_auto_section() {
     local filepath="$1"
     local new_content="$2"
 
-    if $UPDATE_MODE && [[ -f "$filepath" ]] && grep -q "<!-- cct:auto-start -->" "$filepath"; then
+    if $UPDATE_MODE && [[ -f "$filepath" ]] && grep -q "<!-- sw:auto-start -->" "$filepath"; then
         # Replace content between markers, preserve everything else
         local before after
-        before=$(sed '/<!-- cct:auto-start -->/,$d' "$filepath")
-        after=$(sed '1,/<!-- cct:auto-end -->/d' "$filepath")
+        before=$(sed '/<!-- sw:auto-start -->/,$d' "$filepath")
+        after=$(sed '1,/<!-- sw:auto-end -->/d' "$filepath")
         {
             echo "$before"
             echo "$new_content"
@@ -507,8 +515,8 @@ prep_extract_patterns() {
     # ── Import style ──
     if [[ "$LANG_DETECTED" == "nodejs" || "$LANG_DETECTED" == "typescript" ]]; then
         local es_count cjs_count
-        es_count=$(grep -rl "^import " "$root/src" "$root/app" "$root/lib" 2>/dev/null | wc -l | tr -d ' ')
-        cjs_count=$(grep -rl "require(" "$root/src" "$root/app" "$root/lib" 2>/dev/null | wc -l | tr -d ' ')
+        es_count=$( { grep -rl "^import " "$root/src" "$root/app" "$root/lib" 2>/dev/null || true; } | wc -l | tr -d ' ')
+        cjs_count=$( { grep -rl "require(" "$root/src" "$root/app" "$root/lib" 2>/dev/null || true; } | wc -l | tr -d ' ')
         if [[ "$es_count" -gt "$cjs_count" ]]; then
             IMPORT_STYLE="ES modules (import/export)"
         elif [[ "$cjs_count" -gt 0 ]]; then
@@ -520,9 +528,9 @@ prep_extract_patterns() {
 
     # ── Naming convention ──
     local camel_count snake_count
-    camel_count=$(grep -roh '[a-z][a-zA-Z]*(' "$root/src" "$root/app" "$root/lib" 2>/dev/null | grep -c '[a-z][A-Z]' 2>/dev/null || true)
+    camel_count=$( { grep -roh '[a-z][a-zA-Z]*(' "$root/src" "$root/app" "$root/lib" 2>/dev/null || true; } | grep -c '[a-z][A-Z]' 2>/dev/null || true)
     camel_count="${camel_count:-0}"
-    snake_count=$(grep -roh '[a-z_]*_[a-z]*(' "$root/src" "$root/app" "$root/lib" 2>/dev/null | wc -l 2>/dev/null | tr -d ' ')
+    snake_count=$( { grep -roh '[a-z_]*_[a-z]*(' "$root/src" "$root/app" "$root/lib" 2>/dev/null || true; } | wc -l 2>/dev/null | tr -d ' ')
     snake_count="${snake_count:-0}"
     if [[ "$camel_count" -gt "$snake_count" ]]; then
         NAMING_CONVENTION="camelCase"
@@ -569,6 +577,271 @@ prep_extract_patterns() {
     success "Patterns: ${NAMING_CONVENTION} naming${IMPORT_STYLE:+, ${IMPORT_STYLE}}${ROUTE_PATTERNS:+, ${ROUTE_PATTERNS}}"
 }
 
+# ─── Intelligence Check ──────────────────────────────────────────────────
+
+intelligence_available() {
+    command -v claude &>/dev/null || return 1
+    # Honor --with-claude flag
+    $WITH_CLAUDE && return 0
+    # Check daemon config for intelligence.enabled
+    local config="${PROJECT_ROOT}/.claude/daemon-config.json"
+    if [[ -f "$config" ]]; then
+        local enabled
+        enabled=$(jq -r '.intelligence.enabled // false' "$config" 2>/dev/null || echo "false")
+        [[ "$enabled" == "true" ]] && return 0
+    fi
+    return 1
+}
+
+# ─── prep_smart_detect — Claude-enhanced detection ────────────────────────
+
+prep_smart_detect() {
+    intelligence_available || return 0
+
+    info "Running intelligent stack analysis..."
+
+    # Collect dependency manifests (truncated)
+    local dep_info=""
+    local manifest
+    for manifest in package.json requirements.txt Cargo.toml go.mod pyproject.toml Gemfile pom.xml build.gradle; do
+        if [[ -f "$PROJECT_ROOT/$manifest" ]]; then
+            dep_info+="=== ${manifest} ===
+$(head -100 "$PROJECT_ROOT/$manifest" 2>/dev/null)
+
+"
+        fi
+    done
+
+    # Collect grep detection results summary
+    local grep_results="Language: ${LANG_DETECTED:-unknown}
+Framework: ${FRAMEWORK:-unknown}
+Package Manager: ${PACKAGE_MANAGER:-unknown}
+Test Framework: ${TEST_FRAMEWORK:-unknown}
+Import Style: ${IMPORT_STYLE:-unknown}
+Naming: ${NAMING_CONVENTION:-unknown}
+Routes: ${ROUTE_PATTERNS:-none}
+Database: ${DB_PATTERNS:-none}"
+
+    # Sample code from entry points (first 50 lines of up to 3 files)
+    local code_samples=""
+    local sample_count=0
+    local entry
+    for entry in $ENTRY_POINTS; do
+        [[ $sample_count -ge 3 ]] && break
+        if [[ -f "$PROJECT_ROOT/$entry" ]]; then
+            code_samples+="=== ${entry} (first 50 lines) ===
+$(head -50 "$PROJECT_ROOT/$entry" 2>/dev/null)
+
+"
+            sample_count=$((sample_count + 1))
+        fi
+    done
+
+    # If no entry points found, sample some source files
+    if [[ $sample_count -eq 0 ]]; then
+        local f
+        while IFS= read -r f; do
+            [[ $sample_count -ge 3 ]] && break
+            [[ -z "$f" ]] && continue
+            local relpath="${f#"$PROJECT_ROOT"/}"
+            code_samples+="=== ${relpath} (first 50 lines) ===
+$(head -50 "$f" 2>/dev/null)
+
+"
+            sample_count=$((sample_count + 1))
+        done < <(find "$PROJECT_ROOT/src" "$PROJECT_ROOT/app" "$PROJECT_ROOT/lib" \
+            \( -name '*.ts' -o -name '*.js' -o -name '*.py' -o -name '*.go' -o -name '*.rs' \) \
+            -not -path "*/node_modules/*" 2>/dev/null | head -3)
+    fi
+
+    # Sample route files if routes detected
+    local route_samples=""
+    if $HAS_ROUTES; then
+        local route_count=0
+        local f
+        while IFS= read -r f; do
+            [[ $route_count -ge 2 ]] && break
+            [[ -z "$f" ]] && continue
+            local relpath="${f#"$PROJECT_ROOT"/}"
+            route_samples+="=== ${relpath} (first 40 lines) ===
+$(head -40 "$f" 2>/dev/null)
+
+"
+            route_count=$((route_count + 1))
+        done < <(find "$PROJECT_ROOT/src" "$PROJECT_ROOT/app" "$PROJECT_ROOT/routes" "$PROJECT_ROOT/lib" \
+            \( -name '*route*' -o -name '*controller*' -o -name '*handler*' -o -name '*endpoint*' \) \
+            -not -path "*/node_modules/*" 2>/dev/null | head -2)
+    fi
+
+    # Sample style from up to 10 source files (first 20 lines each)
+    local style_samples=""
+    local style_count=0
+    local f
+    while IFS= read -r f; do
+        [[ $style_count -ge 10 ]] && break
+        [[ -z "$f" ]] && continue
+        local relpath="${f#"$PROJECT_ROOT"/}"
+        style_samples+="=== ${relpath} (first 20 lines) ===
+$(head -20 "$f" 2>/dev/null)
+
+"
+        style_count=$((style_count + 1))
+    done < <(find "$PROJECT_ROOT/src" "$PROJECT_ROOT/app" "$PROJECT_ROOT/lib" \
+        \( -name '*.ts' -o -name '*.js' -o -name '*.py' -o -name '*.go' -o -name '*.rs' -o -name '*.rb' -o -name '*.java' \) \
+        -not -path "*/node_modules/*" -not -path "*/.git/*" 2>/dev/null | head -10)
+
+    [[ -z "$dep_info" && -z "$code_samples" && -z "$style_samples" ]] && return 0
+
+    local prompt
+    prompt="Analyze this project and respond in EXACTLY this format (one value per line, no extra text):
+PRIMARY_LANGUAGE: <language>
+FRAMEWORK: <framework or none>
+ARCHITECTURE: <monolith|microservice|serverless|CLI|library>
+TEST_FRAMEWORK: <test framework or unknown>
+CI_SYSTEM: <CI system or unknown>
+IMPORT_STYLE: <ESM|CJS|mixed|N/A>
+NAMING: <camelCase|snake_case|PascalCase|kebab-case|mixed>
+SEMICOLONS: <yes|no|N/A>
+QUOTE_STYLE: <single|double|mixed|N/A>
+INDENT: <spaces-2|spaces-4|tabs|mixed>
+ROUTE_STYLE: <description of routing pattern or none>
+DB_PATTERN: <description of database access pattern or none>
+
+Detected so far by grep:
+${grep_results}
+
+Dependencies:
+${dep_info}
+Code samples:
+${code_samples}
+${route_samples:+Route files:
+${route_samples}}
+Style samples (analyze imports, naming, code style):
+${style_samples}"
+
+    local analysis
+    analysis=$(claude --print "$prompt" 2>/dev/null || true)
+
+    [[ -z "$analysis" ]] && { warn "Smart detection returned empty — using grep results"; return 0; }
+
+    # Parse and enrich (only override gaps — grep results take priority)
+    local smart_val
+
+    smart_val=$(echo "$analysis" | grep "^FRAMEWORK:" | sed 's/^FRAMEWORK:[[:space:]]*//' | head -1)
+    if [[ -n "$smart_val" && "$smart_val" != "none" && "$smart_val" != "unknown" && -z "$FRAMEWORK" ]]; then
+        FRAMEWORK="$smart_val"
+    fi
+
+    smart_val=$(echo "$analysis" | grep "^TEST_FRAMEWORK:" | sed 's/^TEST_FRAMEWORK:[[:space:]]*//' | head -1)
+    if [[ -n "$smart_val" && "$smart_val" != "unknown" && -z "$TEST_FRAMEWORK" ]]; then
+        TEST_FRAMEWORK="$smart_val"
+    fi
+
+    smart_val=$(echo "$analysis" | grep "^IMPORT_STYLE:" | sed 's/^IMPORT_STYLE:[[:space:]]*//' | head -1)
+    if [[ -n "$smart_val" && "$smart_val" != "N/A" ]]; then
+        case "$smart_val" in
+            ESM)   IMPORT_STYLE="ES modules (import/export)" ;;
+            CJS)   IMPORT_STYLE="CommonJS (require/module.exports)" ;;
+            mixed) IMPORT_STYLE="Mixed (ESM + CJS)" ;;
+        esac
+    fi
+
+    smart_val=$(echo "$analysis" | grep "^NAMING:" | sed 's/^NAMING:[[:space:]]*//' | head -1)
+    if [[ -n "$smart_val" && "$smart_val" != "mixed" && "$smart_val" != "unknown" ]]; then
+        NAMING_CONVENTION="$smart_val"
+    fi
+
+    smart_val=$(echo "$analysis" | grep "^ARCHITECTURE:" | sed 's/^ARCHITECTURE:[[:space:]]*//' | head -1)
+    ARCHITECTURE_PATTERN="${smart_val:-}"
+
+    smart_val=$(echo "$analysis" | grep "^ROUTE_STYLE:" | sed 's/^ROUTE_STYLE:[[:space:]]*//' | head -1)
+    if [[ -n "$smart_val" && "$smart_val" != "none" && -z "$ROUTE_PATTERNS" ]]; then
+        HAS_ROUTES=true
+        ROUTE_PATTERNS="$smart_val"
+    fi
+
+    smart_val=$(echo "$analysis" | grep "^DB_PATTERN:" | sed 's/^DB_PATTERN:[[:space:]]*//' | head -1)
+    if [[ -n "$smart_val" && "$smart_val" != "none" && -z "$DB_PATTERNS" ]]; then
+        HAS_DB=true
+        DB_PATTERNS="$smart_val"
+    fi
+
+    SEMICOLONS=$(echo "$analysis" | grep "^SEMICOLONS:" | sed 's/^SEMICOLONS:[[:space:]]*//' | head -1)
+    QUOTE_STYLE=$(echo "$analysis" | grep "^QUOTE_STYLE:" | sed 's/^QUOTE_STYLE:[[:space:]]*//' | head -1)
+    INDENT_STYLE=$(echo "$analysis" | grep "^INDENT:" | sed 's/^INDENT:[[:space:]]*//' | head -1)
+
+    success "Smart detection: ${ARCHITECTURE_PATTERN:-unknown} architecture${FRAMEWORK:+, ${FRAMEWORK}}"
+}
+
+# ─── prep_learn_patterns — Record detected patterns per repo ──────────────
+
+prep_learn_patterns() {
+    intelligence_available || return 0
+
+    local repo_hash
+    repo_hash=$(compute_md5 --string "$PROJECT_ROOT" || echo "default")
+
+    local baselines_dir="${HOME}/.shipwright/baselines/${repo_hash}"
+    mkdir -p "$baselines_dir"
+
+    local patterns_file="${baselines_dir}/file-patterns.json"
+
+    # Detect test file patterns present in this repo
+    local test_patterns="[]"
+    if find "$PROJECT_ROOT" -name "*.test.*" -not -path "*/node_modules/*" -not -path "*/.git/*" 2>/dev/null | head -1 | grep -q .; then
+        test_patterns=$(echo "$test_patterns" | jq '. + ["*.test.*"]')
+    fi
+    if find "$PROJECT_ROOT" -name "*.spec.*" -not -path "*/node_modules/*" -not -path "*/.git/*" 2>/dev/null | head -1 | grep -q .; then
+        test_patterns=$(echo "$test_patterns" | jq '. + ["*.spec.*"]')
+    fi
+    if find "$PROJECT_ROOT" -name "*_test.*" -not -path "*/node_modules/*" -not -path "*/.git/*" 2>/dev/null | head -1 | grep -q .; then
+        test_patterns=$(echo "$test_patterns" | jq '. + ["*_test.*"]')
+    fi
+    if find "$PROJECT_ROOT" -name "test_*" -not -path "*/node_modules/*" -not -path "*/.git/*" 2>/dev/null | head -1 | grep -q .; then
+        test_patterns=$(echo "$test_patterns" | jq '. + ["test_*"]')
+    fi
+
+    # Build config file list
+    local config_json="[]"
+    local f
+    for f in $CONFIG_FILES; do
+        config_json=$(echo "$config_json" | jq --arg f "$f" '. + [$f]')
+    done
+
+    # Build entry points list
+    local entry_json="[]"
+    for f in $ENTRY_POINTS; do
+        entry_json=$(echo "$entry_json" | jq --arg f "$f" '. + [$f]')
+    done
+
+    # Write patterns file atomically
+    local tmp_patterns
+    tmp_patterns=$(mktemp)
+    jq -n \
+        --arg ts "$(date -u +"%Y-%m-%dT%H:%M:%SZ")" \
+        --arg lang "${LANG_DETECTED:-}" \
+        --arg framework "${FRAMEWORK:-}" \
+        --arg naming "${NAMING_CONVENTION:-}" \
+        --arg imports "${IMPORT_STYLE:-}" \
+        --arg arch "${ARCHITECTURE_PATTERN:-}" \
+        --argjson test_patterns "$test_patterns" \
+        --argjson config_files "$config_json" \
+        --argjson entry_points "$entry_json" \
+        '{
+            updated_at: $ts,
+            language: $lang,
+            framework: $framework,
+            architecture: $arch,
+            naming_convention: $naming,
+            import_style: $imports,
+            test_file_patterns: $test_patterns,
+            config_files: $config_files,
+            entry_points: $entry_points
+        }' > "$tmp_patterns" 2>/dev/null && mv "$tmp_patterns" "$patterns_file" || rm -f "$tmp_patterns"
+
+    success "Learned file patterns → ${patterns_file##"$HOME"/}"
+}
+
 # ─── prep_generate_claude_md ────────────────────────────────────────────────
 
 prep_generate_claude_md() {
@@ -613,8 +886,7 @@ prep_generate_claude_md() {
     fi
 
     local content
-    content=$(cat <<HEREDOC
-<!-- cct:auto-start -->
+    content="<!-- sw:auto-start -->
 # Project: ${PROJECT_NAME}
 
 ## Stack
@@ -638,9 +910,7 @@ $(echo -e "$conventions")
 
 ## Important Files
 $(echo -e "$important")
-<!-- cct:auto-end -->
-HEREDOC
-)
+<!-- sw:auto-end -->"
 
     update_auto_section "$filepath" "$content"
     track_file "$filepath"
@@ -883,7 +1153,7 @@ prep_generate_architecture() {
         fi
     elif [[ -f "$PROJECT_ROOT/go.mod" ]]; then
         local go_deps
-        go_deps=$(grep "^\t" "$PROJECT_ROOT/go.mod" 2>/dev/null | awk '{print $1}' | head -15)
+        go_deps=$( { grep "^\t" "$PROJECT_ROOT/go.mod" 2>/dev/null || true; } | awk '{print $1}' | head -15)
         if [[ -n "$go_deps" ]]; then
             deps_section="## Dependencies\n"
             while IFS= read -r dep; do
@@ -902,35 +1172,52 @@ prep_generate_architecture() {
         data_flow+="Request → ${ROUTE_PATTERNS:-Router} → Handler → Response\n"
     fi
 
+    # Pre-compute entry points section
+    local entry_section=""
+    if [[ -n "$ENTRY_POINTS" ]]; then
+        for f in $ENTRY_POINTS; do
+            entry_section+="- \`${f}\`"$'\n'
+        done
+    else
+        entry_section="- No standard entry points detected"$'\n'
+    fi
+
+    # Pre-compute module map section
+    local module_section=""
+    if [[ -n "$module_map" ]]; then
+        module_section=$(echo -e "$module_map")
+    else
+        module_section="No standard module directories detected."
+    fi
+
+    # Pre-compute infrastructure section
+    local infra_section=""
+    $HAS_DOCKER && infra_section+="- Docker: Dockerfile present"$'\n'
+    $HAS_COMPOSE && infra_section+="- Docker Compose: multi-service setup"$'\n'
+    $HAS_CI && infra_section+="- CI/CD: GitHub Actions workflows"$'\n'
+    $HAS_MAKEFILE && infra_section+="- Makefile: build automation"$'\n'
+    if [[ -z "$infra_section" ]]; then
+        infra_section="- No infrastructure files detected"$'\n'
+    fi
+
     local content
-    content=$(cat <<HEREDOC
-<!-- cct:auto-start -->
+    content="<!-- sw:auto-start -->
 # Architecture
 
 ## Overview
 **${PROJECT_NAME}** is a ${LANG_DETECTED:-unknown}${FRAMEWORK:+ / ${FRAMEWORK}} project with ${SRC_FILE_COUNT} source files and ~${TOTAL_LINES} lines of code.
 
 ## Entry Points
-$(for f in $ENTRY_POINTS; do echo "- \`${f}\`"; done)
-$(if [[ -z "$ENTRY_POINTS" ]]; then echo "- No standard entry points detected"; fi)
-
+${entry_section}
 ## Module Map
-$(echo -e "$module_map")
-$(if [[ -z "$module_map" ]]; then echo "No standard module directories detected."; fi)
+${module_section}
 
 $(echo -e "${deps_section}")
 
 $(echo -e "${data_flow}")
 
 ## Infrastructure
-$(if $HAS_DOCKER; then echo "- Docker: \`Dockerfile\` present"; fi)
-$(if $HAS_COMPOSE; then echo "- Docker Compose: multi-service setup"; fi)
-$(if $HAS_CI; then echo "- CI/CD: GitHub Actions workflows"; fi)
-$(if $HAS_MAKEFILE; then echo "- Makefile: build automation"; fi)
-$(if ! $HAS_DOCKER && ! $HAS_COMPOSE && ! $HAS_CI && ! $HAS_MAKEFILE; then echo "- No infrastructure files detected"; fi)
-<!-- cct:auto-end -->
-HEREDOC
-)
+${infra_section}<!-- sw:auto-end -->"
 
     update_auto_section "$filepath" "$content"
     track_file "$filepath"
@@ -945,44 +1232,43 @@ prep_generate_standards() {
 
     info "Generating .claude/CODING-STANDARDS.md..."
 
+    local file_org=""
+    if [[ -n "${SRC_DIRS:-}" ]]; then
+        file_org+="- Source code: \`${SRC_DIRS}\`"$'\n'
+    fi
+    if [[ -n "${TEST_DIRS:-}" ]]; then
+        file_org+="- Tests: \`${TEST_DIRS}\`"$'\n'
+    fi
+
     local content
-    content=$(cat <<HEREDOC
-<!-- cct:auto-start -->
+    content="<!-- sw:auto-start -->
 # Coding Standards
 
 ## Naming
 - Convention: **${NAMING_CONVENTION:-not detected}**
 - Files: follow existing file naming patterns in the project
-- Variables/functions: use ${NAMING_CONVENTION:-the project's established} style consistently
+- Variables/functions: use **${NAMING_CONVENTION:-mixed}** style consistently
 
 ## Imports
 - Style: **${IMPORT_STYLE:-follow existing patterns}**
 - Keep imports organized: stdlib → external deps → internal modules
 
 ## Error Handling
-- Use the project's existing error handling patterns
+- Use the existing error handling patterns
 - Always handle promise rejections / async errors
 - Provide meaningful error messages
-- Don't swallow errors silently
+- Do not swallow errors silently
 
 ## Testing
 - Framework: **${TEST_FRAMEWORK:-unknown}**
 - Write tests for all new functionality
 - Test both success and error paths
-- Use descriptive test names: \`describe("module") → it("should do X when Y")\`
+- Use descriptive test names
 - Keep tests focused — one assertion per test where practical
 
 ## File Organization
-$(if [[ -n "$SRC_DIRS" ]]; then
-    echo "- Source code: \`${SRC_DIRS}\`"
-fi)
-$(if [[ -n "$TEST_DIRS" ]]; then
-    echo "- Tests: \`${TEST_DIRS}\`"
-fi)
-- Follow the existing directory structure — don't create new top-level dirs without discussion
-<!-- cct:auto-end -->
-HEREDOC
-)
+${file_org}- Follow the existing directory structure — do not create new top-level dirs without discussion
+<!-- sw:auto-end -->"
 
     update_auto_section "$filepath" "$content"
     track_file "$filepath"
@@ -1080,7 +1366,7 @@ prep_generate_manifest() {
         fname="${entry%%|*}"
         flines="${entry##*|}"
         local checksum
-        checksum=$(md5 -q "$PROJECT_ROOT/$fname" 2>/dev/null || md5sum "$PROJECT_ROOT/$fname" 2>/dev/null | awk '{print $1}' || echo "unknown")
+        checksum=$(compute_md5 "$PROJECT_ROOT/$fname" || echo "unknown")
         if $first; then
             first=false
         else
@@ -1245,7 +1531,7 @@ prep_check() {
 
             # Check for auto markers in markdown files
             if [[ "$f" == *.md && "$f" != *"ISSUE_TEMPLATE"* && "$f" != *"DEFINITION-OF-DONE"* ]]; then
-                if grep -q "<!-- cct:auto-start -->" "$PROJECT_ROOT/$f" 2>/dev/null; then
+                if grep -q "<!-- sw:auto-start -->" "$PROJECT_ROOT/$f" 2>/dev/null; then
                     echo -e "    ${DIM}↳ Has auto-update markers${RESET}"
                 else
                     echo -e "    ${YELLOW}↳ No auto-update markers (user-customized)${RESET}"
@@ -1328,6 +1614,10 @@ main() {
     prep_scan_structure
     prep_extract_patterns
 
+    # Smart detection (intelligence-gated)
+    prep_smart_detect
+    prep_learn_patterns
+
     # Generation
     prep_generate_claude_md
     prep_generate_settings

package/scripts/{cct-ps.sh → sw-ps.sh}

@@ -1,11 +1,13 @@
 #!/usr/bin/env bash
 # ╔═══════════════════════════════════════════════════════════════════════════╗
-# ║  cct-ps.sh — Show running agent process status                          ║
+# ║  sw-ps.sh — Show running agent process status                          ║
 # ║                                                                          ║
 # ║  Displays a table of agents running in claude-* tmux windows with       ║
 # ║  PID, status, idle time, and pane references.                           ║
 # ╚═══════════════════════════════════════════════════════════════════════════╝
+VERSION="1.9.0"
 set -euo pipefail
+trap 'echo "ERROR: $BASH_SOURCE:$LINENO exited with status $?" >&2' ERR
 
 # ─── Colors ──────────────────────────────────────────────────────────────────
 CYAN='\033[38;2;0;212;255m'
@@ -82,7 +84,7 @@ status_display() {
 
 # ─── Header ─────────────────────────────────────────────────────────────────
 echo ""
-echo -e "${CYAN}${BOLD}  Claude Code Teams — Process Status${RESET}"
+echo -e "${CYAN}${BOLD}  Shipwright — Process Status${RESET}"
 echo -e "${DIM}  $(date '+%Y-%m-%d %H:%M:%S')${RESET}"
 echo -e "${DIM}  ══════════════════════════════════════════${RESET}"
 echo ""
@@ -118,13 +120,13 @@ while IFS='|' read -r window_name pane_title pane_pid cmd pane_active pane_idle
     local_idle_fmt="$(format_idle "$pane_idle")"
 
     # Active pane indicator
-    local active_marker=""
+    active_marker=""
     if [[ "$pane_active" == "1" ]]; then
         active_marker=" ${CYAN}●${RESET}"
     fi
 
     # Agent display name
-    local agent_name="${pane_title:-${cmd}}"
+    agent_name="${pane_title:-${cmd}}"
 
     printf "  %-20s %-8s " "$agent_name" "$pane_pid"
     status_display "$local_status"

package/scripts/{cct-reaper.sh → sw-reaper.sh}

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 # ╔═══════════════════════════════════════════════════════════════════════════╗
-# ║  cct-reaper.sh — Automatic tmux pane cleanup when agents exit           ║
+# ║  sw-reaper.sh — Automatic tmux pane cleanup when agents exit           ║
 # ║                                                                          ║
 # ║  Detects agent panes where the Claude process has exited (shell is      ║
 # ║  idle), kills them after a grace period, and cleans up associated       ║
@@ -11,7 +11,9 @@
 # ║    shipwright reaper --watch      Continuous loop (default: 5s)         ║
 # ║    shipwright reaper --dry-run    Preview what would be reaped          ║
 # ╚═══════════════════════════════════════════════════════════════════════════╝
+VERSION="1.9.0"
 set -euo pipefail
+trap 'echo "ERROR: $BASH_SOURCE:$LINENO exited with status $?" >&2' ERR
 
 # ─── Colors (matches Seth's tmux theme) ────────────────────────────────────
 CYAN='\033[38;2;0;212;255m'
@@ -35,7 +37,7 @@ VERBOSE=false
 INTERVAL=5
 GRACE_PERIOD=15
 LOG_FILE=""
-PID_FILE="${HOME}/.cct-reaper.pid"
+PID_FILE="${HOME}/.sw-reaper.pid"
 
 # ─── Parse Args ────────────────────────────────────────────────────────────
 show_help() {
@@ -65,7 +67,7 @@ show_help() {
     echo ""
     echo -e "${BOLD}EXAMPLES${RESET}"
     echo -e "  ${DIM}shipwright reaper --watch --interval 10 --grace-period 30${RESET}"
-    echo -e "  ${DIM}shipwright reaper --watch --log-file ~/.cct-reaper.log &${RESET}"
+    echo -e "  ${DIM}shipwright reaper --watch --log-file ~/.sw-reaper.log &${RESET}"
 }
 
 while [[ $# -gt 0 ]]; do
@@ -108,7 +110,7 @@ release_pid_lock() {
     rm -f "$PID_FILE"
 }
 
-# ─── tmux format string (reused from cct-ps.sh) ──────────────────────────
+# ─── tmux format string (reused from sw-ps.sh) ──────────────────────────
 # Fields: window_name | pane_title | pane_pid | pane_current_command | pane_active | pane_idle | pane_dead | session:window.pane
 FORMAT='#{window_name}|#{pane_title}|#{pane_pid}|#{pane_current_command}|#{pane_active}|#{pane_idle}|#{pane_dead}|#{session_name}:#{window_index}.#{pane_index}'