@esoteric-logic/praxis-harness 2.11.0 → 2.12.0

package/base/skills/px-doc-lint/SKILL.md

@@ -0,0 +1,107 @@
+---
+name: px-doc-lint
+disable-model-invocation: true
+description: "Fast structural markdown check. No subagent — pure pattern matching. Completes in under 5 seconds. Fires inside px-quality-gate for staged *.md files, or on-demand via /px-doc-lint."
+---
+
+# px-doc-lint — Fast Structural Markdown Check
+
+## Purpose
+
+Lightweight structural validation for markdown files. No subagent.
+Pure pattern matching. Completes in under 5 seconds.
+Use as a quick pre-save check or let px-quality-gate invoke it automatically.
+
+## When It Fires
+
+1. Automatically inside px-quality-gate for every staged `*.md` file
+2. On-demand: `/px-doc-lint {filepath}`
+3. On-demand batch: `/px-doc-lint {directory}` (all .md files in directory)
+
+## Checks by Document Type
+
+### All markdown files
+
+```bash
+# 1. Frontmatter check — if present, must be valid
+head -1 "$f" | grep -q '^---$' && {
+  awk '/^---$/{c++} c==2{found=1; exit} END{if(!found) print "BLOCK: unclosed frontmatter"}' "$f"
+}
+
+# 2. No trailing whitespace
+grep -nE ' +$' "$f" && echo "WARN: trailing whitespace"
+
+# 3. No consecutive blank lines (more than 2)
+awk '/^$/{blank++; if(blank>2) print "WARN: line "NR": excessive blank lines"} /^.+$/{blank=0}' "$f"
+
+# 4. Headers must increment by one level (no h1 -> h3 skip)
+grep -E '^#{1,6} ' "$f" | awk '{
+  level = length($0) - length(gensub(/^#+/, "", 1, $0)) - 1
+  if (prev > 0 && level > prev + 1)
+    print "WARN: header level skip at: "$0
+  prev = level
+}'
+
+# 5. No empty headers
+grep -nE '^#{1,6}\s*$' "$f" && echo "BLOCK: empty header"
+
+# 6. Fluff kill list (same as px-quality-gate prose check)
+grep -inE "$FLUFF_PATTERN" "$f" && echo "BLOCK: fluff phrases detected"
+```
+
+### Design docs (DESIGN-*.md, *-design.md)
+
+```bash
+for section in "## Problem" "## Decision" "## Tradeoffs" "## Acceptance Criteria"; do
+  grep -q "$section" "$f" || echo "BLOCK: missing required section: $section"
+done
+
+tradeoff_count=$(awk '/## Tradeoffs/,/## /' "$f" | grep -c '^- ' || true)
+if [[ "$tradeoff_count" -lt 2 ]]; then
+  echo "BLOCK: Tradeoffs section needs at least 2 items (found: $tradeoff_count)"
+fi
+```
+
+### ADRs (ADR-*.md)
+
+```bash
+for field in "Status:" "Date:" "## Context" "## Decision" "## Consequences"; do
+  grep -q "$field" "$f" || echo "BLOCK: missing required field: $field"
+done
+
+status=$(grep -oE 'Status: .*' "$f" | head -1)
+echo "$status" | grep -qE '(Proposed|Accepted|Deprecated|Superseded)' || \
+  echo "BLOCK: invalid ADR status. Must be: Proposed | Accepted | Deprecated | Superseded by ADR-NNN"
+
+grep -q '### Positive' "$f" || echo "BLOCK: missing Consequences > Positive"
+grep -q '### Negative' "$f" || echo "BLOCK: missing Consequences > Negative"
+```
+
+### READMEs (README.md)
+
+```bash
+for section in "## Install\|## Setup" "## Run" "## Test"; do
+  grep -qE "$section" "$f" || echo "BLOCK: missing required section matching: $section"
+done
+
+awk '/^```/,/^```/' "$f" | grep -E '\{placeholder\}|\{TODO\}|\{TBD\}' && \
+  echo "BLOCK: placeholder found inside code block"
+```
+
+## Output Format
+
+```
+px-doc-lint: {filename}
+Type: {Design Doc | ADR | README | General}
+  [PASS] frontmatter valid
+  [PASS] no trailing whitespace
+  [BLOCK] missing required section: ## Tradeoffs
+  [WARN] header level skip at: ### Details
+Result: BLOCK (1 error, 1 warning)
+```
+
+## Performance Contract
+
+- Single file: under 2 seconds
+- Batch (10 files): under 5 seconds
+- No network calls. No subagent. Pure grep/awk/sed.

package/base/skills/px-prose-review/SKILL.md

@@ -0,0 +1,96 @@
+---
+name: px-prose-review
+disable-model-invocation: true
+description: "Deep document review using an isolated subagent. Checks argument quality, clarity, completeness, and adherence to writing-quality.md. Use for design docs, ADRs, READMEs, specs. More thorough than px-doc-lint."
+---
+
+# px-prose-review — Deep Document Review
+
+## Purpose
+
+Performs deep quality review on prose documents using an isolated subagent.
+More thorough than px-doc-lint — checks argument quality, clarity, completeness,
+and adherence to writing-quality.md standards.
+
+## When It Fires
+
+1. On-demand: `/px-prose-review {filepath}`
+2. Automatic: during `/px-ship` against the PR description
+3. Recommended: before finalizing any design doc, ADR, or spec
+
+## Subagent Configuration
+
+The review runs in an isolated context with zero conversation history.
+The subagent receives ONLY the document content and the review instructions.
+
+### Subagent persona
+
+```
+You are a ruthless technical editor. Your job is to make this document
+shorter, clearer, and more precise. You have no loyalty to the author's
+feelings. You have total loyalty to the reader's time.
+
+Rules:
+- Every sentence must earn its place. If it restates something already said, cut it.
+- Every paragraph must have exactly one idea. If it has two, split it.
+- Every claim must be specific. "Improves performance" is not a claim.
+  "Reduces p99 latency from 200ms to 50ms" is.
+- Active voice on all decisions and actions.
+- No fluff words (see kill list in writing-quality.md).
+- No hedging on decided things. "will" not "should" or "might".
+```
+
+The full fluff kill list from writing-quality.md is injected into the subagent prompt.
+
+## Document Type Detection
+
+The subagent detects document type from filename and content:
+
+| Pattern | Type | Structural checks applied |
+| ------- | ---- | ------------------------- |
+| `DESIGN-*.md`, `*-design.md` | Design Doc | Problem, Decision, Tradeoffs, Acceptance Criteria |
+| `ADR-*.md` | ADR | Status, Date, Context, Decision, Consequences (Positive + Negative) |
+| `README.md` | README | First paragraph, Install/Setup, Run, Test |
+| `*.md` in PR context | PR Description | What, Why, How to verify, Breaking changes |
+| All other `*.md` | General prose | Sentence limits, fluff, voice, hedging |
+
+## Review Output Format
+
+```
+## px-prose-review: {filename}
+Type detected: {Design Doc | ADR | README | PR Description | General}
+
+### Structure
+- [PASS|BLOCK] {section}: {detail}
+
+### Clarity
+- Line {N}: {issue} → {suggested fix}
+
+### Fluff
+- Line {N}: "{flagged phrase}" → {replacement or "delete"}
+
+### Voice
+- Line {N}: passive on decision → {active rewrite}
+
+### Verdict
+{CLEAN | {N} issues found — {M} auto-fixable}
+```
+
+## Auto-Fix Flow
+
+For minor issues (fluff deletion, passive-to-active rewrites on clear cases):
+1. Subagent proposes the fix with before/after
+2. Operator is shown the diff
+3. Operator approves or rejects each fix individually
+4. Approved fixes are applied in-place
+
+For structural issues (missing sections, incomplete analysis):
+- Subagent flags the gap and describes what is needed
+- Operator writes the content — subagent does NOT generate missing sections
+- Rationale: the subagent lacks project context to write accurate content
+
+## Limitations
+
+- Does not verify technical accuracy of claims — only prose quality
+- Does not check code blocks inside markdown — only surrounding prose
+- Does not run on files outside the repo (external links, references)

package/base/skills/px-quality-gate/SKILL.md

@@ -0,0 +1,182 @@
+---
+name: px-quality-gate
+disable-model-invocation: true
+description: "Code style and prose quality gate. Checks what linters cannot: naming, doc completeness, prose clarity, structural patterns. Integrated into px-verify as Step 1 item 5b. Also available standalone via /px-quality-gate."
+---
+
+# px-quality-gate — Style and Prose Quality Enforcement
+
+## Purpose
+
+Runs automated style checks against changed files. Catches issues that linters and
+test suites do not: generic variable names, missing docstrings, prose quality,
+structural violations, and import verification.
+
+Integrated into `/px-verify` as Step 1 item 5b (after security scan, before functional check).
+Also available standalone via `/px-quality-gate`.
+
+## When It Fires
+
+1. Automatically inside `/px-verify` after security scan
+2. As the first step of `/px-ship`
+3. On-demand via `/px-quality-gate` for ad-hoc checks
+
+## Scope
+
+Checks run against staged or changed files only (not the full codebase).
+Use `/px-complexity-audit` for full codebase scans.
+
+## Verdicts
+
+- **BLOCK**: violation found — must fix before proceeding. Commit blocked.
+- **WARN**: advisory issue found — commit allowed, fix recommended.
+- **PASS**: all checks clear.
+
+## Check Categories
+
+### 1. Code Structure Checks
+
+Run against all changed code files (exclude vendor/, node_modules/, .git/).
+
+#### File size
+
+```bash
+for f in $(git diff --cached --name-only --diff-filter=ACM | grep -E '\.(go|ts|tsx|js|jsx|py|rs|java|sh|sql)$'); do
+  lines=$(wc -l < "$f")
+  if [[ "$lines" -gt 300 ]]; then
+    echo "BLOCK: $f is $lines lines (limit: 300). Split before committing."
+  fi
+done
+```
+
+#### TODO/FIXME/HACK detection
+
+```bash
+for f in $(git diff --cached --name-only --diff-filter=ACM | grep -E '\.(go|ts|tsx|js|jsx|py|rs|java|sh|sql)$'); do
+  hits=$(grep -nE 'TODO|FIXME|HACK' "$f" || true)
+  if [[ -n "$hits" ]]; then
+    echo "BLOCK: $f contains banned markers. Use QUALITY: with a ticket number instead."
+    echo "$hits"
+  fi
+done
+```
+
+#### Nesting depth heuristic
+
+```bash
+for f in $(git diff --cached --name-only --diff-filter=ACM | grep -E '\.(go|ts|tsx|js|jsx|py|rs|java)$'); do
+  deep=$(grep -nE '^\s{16,}\S|^\t{4,}\S' "$f" || true)
+  if [[ -n "$deep" ]]; then
+    echo "WARN: $f may have deep nesting. Review these lines:"
+    echo "$deep"
+  fi
+done
+```
+
+#### Generic variable names
+
+```bash
+git diff --cached -U0 | grep '^+' | grep -v '^+++' | \
+  grep -oE '\b(data|result|info|temp|tmp|obj|val|item|stuff|thing|ret|res)\b' | \
+  sort | uniq -c | sort -rn | head -10
+```
+
+If any appear 3+ times: WARN with suggestion to use domain-specific names.
+
+#### Missing docstrings on new public functions
+
+```bash
+git diff --cached -U3 | grep -E '^\+.*(func |def |export function |export const .* = )' | \
+  while read -r line; do
+    echo "CHECK: verify doc comment exists for: $line"
+  done
+```
+
+### 2. Prose Checks
+
+Run against all changed markdown files.
+
+#### AI fluff detection
+
+```bash
+FLUFF_PATTERN='leverage|utilize|facilitate|moving forward|going forward|at this point in time|comprehensive solution|robust solution|seamlessly|cutting-edge|best-in-class|in order to|due to the fact that|at the end of the day|synergy|holistic|empower|streamline'
+
+for f in $(git diff --cached --name-only --diff-filter=ACM | grep -E '\.md$'); do
+  hits=$(grep -inE "$FLUFF_PATTERN" "$f" || true)
+  if [[ -n "$hits" ]]; then
+    echo "BLOCK: $f contains fluff phrases. Remove or replace per writing-quality.md."
+    echo "$hits"
+  fi
+done
+```
+
+#### Passive voice on decisions
+
+```bash
+for f in $(git diff --cached --name-only --diff-filter=ACM | grep -E '\.md$'); do
+  hits=$(grep -inE '(it was decided|was implemented|was chosen|was selected|has been determined)' "$f" || true)
+  if [[ -n "$hits" ]]; then
+    echo "WARN: $f uses passive voice on decisions. Rewrite in active voice."
+    echo "$hits"
+  fi
+done
+```
+
+#### Sentence length check
+
+```bash
+for f in $(git diff --cached --name-only --diff-filter=ACM | grep -E '\.md$'); do
+  awk 'BEGIN{RS="[.!?]"} NF>30 {print NR": "NF" words: "$0}' "$f" | head -5
+done
+```
+
+#### Unreplaced placeholders
+
+```bash
+for f in $(git diff --cached --name-only --diff-filter=ACM | grep -E '\.md$'); do
+  hits=$(grep -nE '\{placeholder\}|\{TODO\}|\{TBD\}|\[INSERT\]|\[TBD\]|XXX' "$f" || true)
+  if [[ -n "$hits" ]]; then
+    echo "BLOCK: $f contains unreplaced placeholders."
+    echo "$hits"
+  fi
+done
+```
+
+### 3. Context7 Import Check
+
+```bash
+NEW_IMPORTS=$(git diff --cached -U0 | grep -E '^\+.*(import |require\(|using |use )' | grep -v '^+++' | grep -v '^//\|^#')
+
+if [[ -n "$NEW_IMPORTS" ]]; then
+  echo "GATE: New external imports detected. Each requires a Context7 lookup:"
+  echo "$NEW_IMPORTS"
+  echo ""
+  echo "Confirm each import was verified via Context7 in this session."
+  echo "Internal packages (same repo/module) are excluded."
+fi
+```
+
+## Output Format
+
+```
+━━━ QUALITY GATE ━━━━━━━━━━━━━━━━━━━
+Code checks:   PASS | WARN | BLOCK
+Prose checks:  PASS | WARN | BLOCK
+Import check:  PASS | WARN | BLOCK
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Overall:       PASS | WARN | BLOCK
+
+Details:
+  [BLOCK] services/auth.go: 342 lines (limit: 300)
+  [BLOCK] docs/DESIGN-auth.md: contains "comprehensive solution" (fluff)
+  [WARN]  handlers/login.go: possible deep nesting at line 47
+  [PASS]  All other checks
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+## Rules
+
+- Any single BLOCK = overall BLOCK. Commit prevented.
+- WARN-only = overall WARN. Commit allowed. Fix recommended.
+- Gate re-runs on re-stage. Fix the issue, `git add`, gate runs again.
+- Do NOT bypass the gate. There is no `--force` flag.

package/base/skills/px-risk/SKILL.md

@@ -9,7 +9,10 @@ You are adding a risk register entry for the current project.
 **Step 1 — Detect project and existing risks**
 - Read vault_path from `~/.claude/praxis.config.json`
 - Detect project from CWD
-- Run: `obsidian search query="risk register {project-slug}" limit=3`
+- Search vault for existing risks using configured backend:
+  - If `obsidian`: run `obsidian search query="risk register {project-slug}" limit=3`
+  - If `ripgrep`: run `rg --files-with-matches "risk" {vault_path}/specs/`
+  - If vault search fails: proceed without blocking
 - Check if `{vault_path}/specs/risk-register.md` exists
 - If found: read it to determine next sequential risk ID (R-01, R-02, etc.)
 

package/base/skills/px-scaffold-new/SKILL.md

@@ -46,10 +46,10 @@ Read identity table from `~/.claude/rules/git-workflow.md`.
 
 ## Phase 1 — Gather Info
 
-Before asking, run vault duplicate check:
-```bash
-obsidian search query="{slug}" path="01_Projects" limit=3
-```
+Before asking, run vault duplicate check using configured backend:
+- If `obsidian`: `obsidian search query="{slug}" path="01_Projects" limit=3`
+- If `ripgrep`: `rg --files-with-matches "{slug}" {vault_path}/`
+- If vault search fails: warn and proceed without blocking.
 
 Ask in one message:
 - **Project name** — display name
@@ -71,7 +71,7 @@ today_date   = current date YYYY-MM-DD
 
 ## Phase 2 — Scaffold repo CLAUDE.md
 
-1. Read `references/repo-CLAUDE-md-template.md`
+1. Read `templates/project-index.md` (the repo CLAUDE.md template)
 2. Apply full substitution map. All placeholders must resolve.
 3. Scan output for remaining `{placeholder}` patterns. Resolve before writing.
 4. Write to `{repo_root}/CLAUDE.md`
@@ -85,19 +85,19 @@ Create directories:
 mkdir -p {vault_path}/plans {vault_path}/notes {vault_path}/specs {vault_path}/research
 ```
 
-Create files from templates in `references/`:
-- `_index.md` from `vault-index-template.md`
-- `status.md` from `vault-status-template.md` (`current_plan:` empty)
-- `tasks.md` from `vault-tasks-template.md`
-- `notes/learnings.md` from `vault-learnings-template.md`
-- `notes/decision-log.md` from `decision-log` template (append-only decision log)
-- `.gitignore` from `gitignore-template.txt` (new repos only)
+Create files from templates in `templates/`:
+- `_index.md` from `templates/_index.md`
+- `status.md` from `templates/status.md` (`current_plan:` empty)
+- `tasks.md` from `templates/tasks.md`
+- `notes/learnings.md` — scaffold minimal learnings file (no template exists; create with YAML frontmatter + empty `## Learnings` section)
+- `notes/decision-log.md` from `templates/decision-log.md` (append-only decision log)
+- `.gitignore` — scaffold standard gitignore for detected stack (new repos only)
 
 ---
 
 ## Phase 3.5 — Scaffold claude-progress.json
 
-From `references/claude-progress-template.json`. Apply substitution map.
+From `templates/claude-progress.json`. Apply substitution map.
 Write to `{vault_path}/claude-progress.json`.
 
 ---
@@ -105,7 +105,9 @@ Write to `{vault_path}/claude-progress.json`.
 ## Phase 4 — Vault Search Check
 
 Vault indexing is automatic for `obsidian` backend. No manual re-index needed.
-Verify the new project is searchable: `obsidian search query="{slug}" limit=1`
+Verify the new project is searchable using configured backend:
+- If `obsidian`: `obsidian search query="{slug}" limit=1`
+- If `ripgrep`: `rg --files-with-matches "{slug}" {vault_path}/`
 On failure: warn, do not block.
 
 ---

package/base/skills/px-session-retro/SKILL.md

@@ -48,7 +48,7 @@ Classify each: type, tag (`bugfix|convention|perf|security|tooling|arch|process`
 For each finding with clear root cause:
 - Project-specific → `{vault_path}/notes/learnings.md`
 - Global/harness pattern → harness project learnings.md
-- Check for duplicates via `obsidian search` before writing
+- Check for duplicates via vault search (using configured backend) before writing. If vault search unavailable: skip duplicate check and proceed.
 
 Format:
 ```markdown

package/base/skills/px-spec/SKILL.md

@@ -21,11 +21,15 @@ You are creating a spec for the current project.
 Ask the following in a single message:
 - What is this spec for? (one sentence)
 - Type: ADR (architecture decision) / RISK (risk register entry) / SPEC (technical spec)
-- Is there an existing related spec in `specs/`? (run `obsidian search query="{topic}" limit=3` first)
+- Is there an existing related spec in `specs/`?
+  - Read `vault_backend` from `~/.claude/praxis.config.json`
+  - If `obsidian`: run `obsidian search query="{topic}" limit=3`
+  - If `ripgrep`: run `rg --files-with-matches "{topic}" {vault_path}/specs/`
+  - If vault search fails (e.g., Obsidian not running): warn "Vault search unavailable — skipping conflict check" and proceed without blocking
 
 **Step 2b — Cross-spec conflict check**
 After the vault search from Step 2, check for conflicts with accepted ADRs:
-- Run: `obsidian search query="{topic}" limit=10`
+- Run vault search for topic (using backend detected above) with limit=10
 - For each result with `status: accepted` or `status: proposed`:
   - Compare the decision direction. Does the new spec contradict an accepted decision?
 - If conflict detected, present:

package/base/skills/px-verify/SKILL.md

@@ -17,7 +17,8 @@ Execute in order, showing actual output (never assertions):
    - **DeepSource**: `deepsource issues list <file>` for files in diff (if deepsource CLI available)
    - If either tool finds HIGH/CRITICAL: treat as blocking — must fix before proceeding.
    - If tools not installed: skip with advisory note, do not block. DeepSource cloud validates on push.
-6. **Functional check** — ask: "Is there a smoke test, `terraform plan` output, or browser check needed for this milestone?" If yes: block until user confirms it passed. If no: proceed.
+6. **Quality gate** → run `/px-quality-gate` on changed files → BLOCK on naming/prose/structure violations. See `px-quality-gate` skill for full check list.
+7. **Functional check** — ask: "Is there a smoke test, `terraform plan` output, or browser check needed for this milestone?" If yes: block until user confirms it passed. If no: proceed.
 
 Read test/lint/build commands from the project CLAUDE.md `## Commands` section.
 If no commands are defined: warn and ask user for the correct commands.

package/bin/praxis.js

@@ -19,7 +19,7 @@ function fail(msg)   { console.error('  \x1b[31m\u2717\x1b[0m ' + msg); }
 function dim(msg)    { console.log('  \x1b[2m' + msg + '\x1b[0m'); }
 
 function toolExists(name) {
-  const r = spawnSync('which', [name], { stdio: 'pipe' });
+  const r = spawnSync('command', ['-v', name], { stdio: 'pipe', shell: true });
   return r.status === 0;
 }
 
@@ -94,12 +94,33 @@ async function install() {
     const hooksConfig = path.join(hooksDir, 'settings-hooks.json');
     const settingsFile = path.join(CLAUDE_DIR, 'settings.json');
     if (fs.existsSync(hooksConfig)) {
-      const hooksCfg = JSON.parse(fs.readFileSync(hooksConfig, 'utf8'));
+      let hooksCfg;
+      try {
+        hooksCfg = JSON.parse(fs.readFileSync(hooksConfig, 'utf8'));
+      } catch (hookParseErr) {
+        fail('settings-hooks.json has invalid JSON: ' + hookParseErr.message);
+        hooksCfg = {};
+      }
       let settings = {};
       if (fs.existsSync(settingsFile)) {
-        try { settings = JSON.parse(fs.readFileSync(settingsFile, 'utf8')); } catch { /* invalid JSON — use empty defaults */ }
+        const raw = fs.readFileSync(settingsFile, 'utf8');
+        try {
+          settings = JSON.parse(raw);
+        } catch (parseErr) {
+          // Preserve corrupt file as backup before overwriting
+          const backupPath = settingsFile + '.backup';
+          fs.writeFileSync(backupPath, raw);
+          fail('settings.json has invalid JSON — backed up to ' + backupPath);
+        }
+      }
+      // Deep merge: preserve existing keys, overlay hooks
+      for (const [key, value] of Object.entries(hooksCfg)) {
+        if (typeof value === 'object' && !Array.isArray(value) && settings[key] && typeof settings[key] === 'object') {
+          settings[key] = { ...settings[key], ...value };
+        } else {
+          settings[key] = value;
+        }
       }
-      Object.assign(settings, hooksCfg);
       fs.writeFileSync(settingsFile, JSON.stringify(settings, null, 2) + '\n');
       ok('hooks configuration merged into settings.json');
     }
@@ -261,7 +282,7 @@ function health() {
       } else {
         total++; fail('vault_path not set in config');
       }
-    } catch { total++; fail('praxis.config.json is invalid JSON'); }
+    } catch (configErr) { total++; fail('praxis.config.json is invalid JSON: ' + configErr.message); }
   }
 
   // Tools
@@ -386,7 +407,7 @@ else if (arg === '--version' || arg === '-v') { console.log(VERSION); }
 else if (commands[arg]) {
   const result = commands[arg]();
   if (result && typeof result.catch === 'function') {
-    result.catch(err => { fail(err.message); process.exit(1); });
+    result.catch(err => { fail(err?.message || String(err)); process.exit(1); });
   }
 }
 else { fail('Unknown command: ' + arg); printHelp(); process.exit(1); }

package/kits/api/install.sh

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 set -euo pipefail
 
 echo "=== Praxis: Installing api kit ==="

package/kits/api/teardown.sh

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 set -euo pipefail
 
 echo "=== Praxis: Removing api kit ==="

package/kits/code-quality/hooks/generate-baseline.sh

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 # Run once on kit install to snapshot existing violations
 # Pre-push hook only blocks on NET NEW violations above this baseline
 

package/kits/code-quality/hooks/post-commit.sh

@@ -1,4 +1,5 @@
-#!/bin/bash
+#!/usr/bin/env bash
+set -euo pipefail
 # Triggers Claude AI self-review after commit
 # This is advisory — does not block, surfaces findings for next commit
 
@@ -11,7 +12,7 @@ if ! command -v claude &>/dev/null; then
 fi
 
 CHANGED=$(git diff --name-only HEAD~1...HEAD 2>/dev/null | head -20)
-if [ -z "$CHANGED" ]; then
+if [[ -z "$CHANGED" ]]; then
   exit 0
 fi