create-claudify 1.0.0

package/templates/.claude/agents/auditor.md

@@ -0,0 +1,58 @@
+# Auditor Agent
+
+Quality gate. Reviews all work for errors, inconsistencies, and SOP violations.
+Updates its own memory with patterns. Promotes valid nominations to knowledge-base.
+
+## Role
+
+You are a quality auditor. Your job is to find problems before they reach users.
+You are skeptical by default — assume errors exist until proven otherwise.
+
+## Tools Available
+
+Read, Glob, Grep, Edit, Write, Bash (date only)
+
+## Procedure
+
+When invoked, follow this sequence:
+
+1. **Read context**:
+   - `.claude/knowledge-base.md` (mandatory constraints)
+   - `.claude/agent-memory/auditor.md` (your persistent memory)
+   - The specific files or scope you've been asked to audit
+
+2. **Check against rules**:
+   - Does the work comply with knowledge-base hard rules?
+   - Are there factual errors, inconsistencies, or missing pieces?
+   - Is the output complete (no TODOs, placeholders, or stubs)?
+   - Does the quality match the project's standards?
+
+3. **Score each item**:
+   - **PASS** — meets all standards
+   - **FAIL** — has errors that must be fixed (describe precisely what's wrong)
+   - **NOMINATION** — you discovered a new rule or pattern worth recording
+
+4. **Report findings** in this format:
+   ```
+   ## Audit Report — [scope]
+
+   **Overall:** PASS | FAIL
+   **Items checked:** [count]
+
+   ### Findings
+   - [PASS|FAIL] [item]: [description]
+
+   ### Nominations
+   - [learning] | Evidence: [what you observed]
+   ```
+
+5. **Update your memory**: Append patterns to `.claude/agent-memory/auditor.md`
+
+## Knowledge Promotion
+
+You are the ONLY agent that writes to `.claude/knowledge-base.md`.
+When reviewing nominations from `.claude/knowledge-nominations.md`:
+- Verify the learning is accurate (check evidence)
+- Assign provenance: User override > Empirical > Agent inference
+- Write to the appropriate section with `[Source: type MMDDYY]`
+- Remove promoted items from nominations file

package/templates/.claude/agents/reviewer.md

@@ -0,0 +1,54 @@
+# Reviewer Agent
+
+Read-only quality assurance. Cross-checks work, validates consistency.
+Cannot modify files — only reports findings.
+
+## Role
+
+You are a reviewer. Your job is to verify correctness without changing anything.
+Read everything, trust nothing, report what you find.
+
+## Tools Available
+
+Read, Glob, Grep (read-only tools only)
+
+## Procedure
+
+When invoked, follow this sequence:
+
+1. **Read context**:
+   - `.claude/knowledge-base.md` (mandatory constraints)
+   - The specific files or scope you've been asked to review
+
+2. **Cross-reference checks**:
+   - Do referenced files actually exist?
+   - Do cross-file references match (imports, exports, API contracts)?
+   - Are there naming inconsistencies across files?
+   - Do configuration values match between related files?
+   - Are there dead references or orphaned files?
+
+3. **Consistency checks**:
+   - Is the code style consistent within each file?
+   - Do similar patterns use the same approach?
+   - Are error messages helpful and consistent?
+   - Do comments match what the code actually does?
+
+4. **Report findings**:
+   ```
+   ## Review Report — [scope]
+
+   **Files checked:** [count]
+   **Issues found:** [count]
+
+   ### Issues
+   - [severity: LOW|MEDIUM|HIGH] [file:line]: [description]
+
+   ### Observations
+   - [non-blocking notes or suggestions]
+   ```
+
+## Constraints
+
+- NEVER modify any files
+- NEVER run commands that change state
+- Report only — the main session or auditor decides what to fix

package/templates/.claude/command-index.md

@@ -0,0 +1,26 @@
+# Command Index
+
+All available commands. Every agent reads this to know what's available.
+
+| Command | Trigger | What it does | Tools needed |
+|---|---|---|---|
+| `/start` | Session start | Load context, create daily note | Read, Write |
+| `/sync` | Mid-session | Refresh memory, update daily note | Read, Edit |
+| `/clear` | Context heavy (~30+ calls) | Flush context, write handoff, auto-resume | Read, Write, Edit |
+| `/wrap-up` | Session end | Persist state, archive completed work | Read, Edit |
+| `/audit` | After deliverables | Review work quality via auditor agent | Read, Task |
+
+## How Commands Work
+
+- Commands are markdown files in `.claude/commands/`
+- Any agent can invoke a command by reading its file and following the steps
+- If an agent lacks the required tools, it outputs `RECOMMEND: /command — [reason]`
+- Commands can chain: `/wrap-up` might trigger `/sync` first
+
+## Adding Custom Commands
+
+Create a new `.md` file in `.claude/commands/` with:
+1. A `# /name` heading
+2. `## Steps` section with numbered procedures
+3. `## Trigger Conditions` section describing when to invoke
+4. Add an entry to this index

package/templates/.claude/commands/audit.md

@@ -0,0 +1,24 @@
+# /audit — Review Recent Work Quality
+
+Spawn the auditor agent to review recent outputs for errors, inconsistencies, and improvement opportunities.
+
+## Steps
+
+1. **Determine scope**: Check what was done since the last audit (read daily note `## Done` section).
+
+2. **Spawn auditor agent** with the Task tool:
+   - Agent type: Use the auditor agent definition from `.claude/agents/auditor.md`
+   - Scope: Files modified since last audit
+   - Checks: Consistency, completeness, knowledge-base compliance
+
+3. **Process results**:
+   - **PASS**: Log and continue
+   - **FAIL**: Fix the issue, then re-audit the fix
+   - **NOMINATION**: Append to `.claude/knowledge-nominations.md`
+
+4. **Report**: Summary of findings with action items.
+
+## Trigger Conditions
+- After completing a significant deliverable
+- Before sharing work with others
+- User explicitly requests quality review

package/templates/.claude/commands/clear.md

@@ -0,0 +1,51 @@
+# /clear — Safely Flush Context and Resume
+
+Distill session state, write a handoff, then seamlessly resume work.
+The user should not notice this happening — work just continues.
+
+## Steps
+
+### Step 1: Read state (parallel)
+- `.claude/memory.md`
+- Today's daily note: `Daily Notes/MMDDYY.md`
+
+### Step 2: Distill session
+
+Extract from in-context memory using **restorable compression** — preserve retrieval paths:
+
+1. **Task** — one sentence
+2. **Done/remaining** — 2-4 bullets, conclusions not process
+3. **Decisions** — one line each, WHAT+WHY not HOW
+4. **Files touched** — full paths of every file read or modified (retrieval anchors)
+5. **Active references** — URLs, endpoints, resources consulted (pointers only)
+6. **Next action** — precise instruction including which file(s) to read first
+
+### Step 3: Write handoff to daily note
+
+Append:
+```markdown
+## Session Handoff — HH:MM
+
+**Task:** [one sentence]
+**Done:** [bullets]
+**Remaining:** [bullets]
+**Decisions:** [bullets]
+**Files:** [full paths]
+**Refs:** [URLs, resources — pointers only]
+**Next:** [precise action + which files to read first]
+```
+
+### Step 4: Update memory.md (only if changed)
+
+### Step 5: Auto-resume (restorable decompression)
+
+1. Re-read `.claude/memory.md` and `.claude/knowledge-base.md`
+2. Re-read the daily note handoff
+3. Re-read files specified in **Next** and critical files from **Files** list
+4. **Immediately execute the Next action** — pick up where you left off
+
+## Trigger Conditions
+- After ~30 tool calls
+- When output quality degrades
+- Between unrelated tasks
+- When "compacting conversation" appears

package/templates/.claude/commands/start.md

@@ -0,0 +1,32 @@
+# /start — Begin a Work Session
+
+Load context, create a daily note, and prepare to work.
+
+## Steps
+
+1. **Read state** (parallel):
+   - `.claude/memory.md`
+   - `.claude/knowledge-base.md`
+   - Today's daily note if it exists: `Daily Notes/MMDDYY.md`
+
+2. **Create daily note** (if none exists):
+   ```markdown
+   # {{DAY_NAME}} {{DATE}}
+
+   ## Plan
+   - [Tasks for today]
+
+   ## Notes
+   - [Captured during work]
+
+   ## Done
+   - [Completed items]
+   ```
+
+3. **Check for handoffs**: If a previous session handoff exists in the daily note, read it and resume from the **Next** action.
+
+4. **Report ready**: Brief summary of current state and what's next.
+
+## Trigger Conditions
+- Start of any new work session
+- User says "let's start", "begin", "good morning"

package/templates/.claude/commands/sync.md

@@ -0,0 +1,27 @@
+# /sync — Mid-Session Context Refresh
+
+Re-read state, update memory, and ensure nothing has drifted.
+
+## Steps
+
+1. **Read current state** (parallel):
+   - `.claude/memory.md`
+   - Today's daily note: `Daily Notes/MMDDYY.md`
+   - `.claude/knowledge-base.md` (scan for new entries)
+
+2. **Update memory.md**:
+   - Add any new active work items to `## Now`
+   - Move completed items out of `## Now`
+   - Add new decisions to `## Recent Decisions`
+   - Prune anything stale (>7 days old with no activity)
+
+3. **Update daily note**:
+   - Add completed work to `## Done`
+   - Update `## Notes` with any captured observations
+
+4. **Check context health**: If tool call counter is high, recommend `/clear`.
+
+## Trigger Conditions
+- Mid-session when switching between tasks
+- After completing a significant piece of work
+- When you feel context might be stale

package/templates/.claude/commands/wrap-up.md

@@ -0,0 +1,29 @@
+# /wrap-up — End a Work Session
+
+Close out the session cleanly. Persist everything important.
+
+## Steps
+
+1. **Read state** (parallel):
+   - `.claude/memory.md`
+   - Today's daily note
+
+2. **Update daily note**:
+   - Ensure `## Done` reflects all completed work
+   - Add any unfinished items to `## Notes` with status
+
+3. **Update memory.md**:
+   - Move completed items out of `## Now`
+   - Archive decisions older than 14 days
+   - Prune `## Open Threads` — remove anything resolved
+   - Clear `## Done` section if it's a Friday
+
+4. **Check for knowledge nominations**:
+   - If anything was learned this session, append to `.claude/knowledge-nominations.md`
+   - Format: `- [MMDDYY] [learning] | Evidence: [source]`
+
+5. **Report**: Brief summary of what was accomplished and what carries forward.
+
+## Trigger Conditions
+- End of work session
+- User says "done for today", "wrapping up", "closing out"

package/templates/.claude/hooks/audit-logger.sh

@@ -0,0 +1,31 @@
+#!/bin/bash
+# Audit Logger Hook — records every tool call for traceability
+# Triggered: PostToolUse on all tools
+# Purpose: Create an audit trail of what Claude did, when, and to what files
+
+TOOL_NAME="$1"
+TOOL_INPUT="$2"
+
+LOG_DIR=".claude/logs"
+LOG_FILE="$LOG_DIR/audit-$(date +%m%d%y).log"
+
+mkdir -p "$LOG_DIR"
+
+# Extract file path if present
+FILE_PATH=$(echo "$TOOL_INPUT" | grep -oP '"file_path"\s*:\s*"([^"]*)"' | head -1 | sed 's/.*"file_path"\s*:\s*"//;s/"//')
+
+# Extract command if Bash
+COMMAND=$(echo "$TOOL_INPUT" | grep -oP '"command"\s*:\s*"([^"]*)"' | head -1 | sed 's/.*"command"\s*:\s*"//;s/"$//' | head -c 200)
+
+TIMESTAMP=$(date +"%H:%M:%S")
+
+# Log format: TIME | TOOL | TARGET
+if [ -n "$FILE_PATH" ]; then
+  echo "$TIMESTAMP | $TOOL_NAME | $FILE_PATH" >> "$LOG_FILE"
+elif [ -n "$COMMAND" ]; then
+  echo "$TIMESTAMP | Bash | $COMMAND" >> "$LOG_FILE"
+else
+  echo "$TIMESTAMP | $TOOL_NAME" >> "$LOG_FILE"
+fi
+
+exit 0

package/templates/.claude/hooks/context-monitor.sh

@@ -0,0 +1,30 @@
+#!/bin/bash
+# Context Monitor Hook — tracks tool calls and warns about context health
+# Triggered: Stop (after every Claude response)
+# Purpose: Count tool calls per session and surface warnings before quality degrades
+
+LOG_DIR=".claude/logs"
+COUNTER_FILE="$LOG_DIR/.tool-call-count"
+SESSION_FILE="$LOG_DIR/.current-session-id"
+
+mkdir -p "$LOG_DIR"
+
+# Initialize counter if missing
+if [ ! -f "$COUNTER_FILE" ]; then
+  echo "0" > "$COUNTER_FILE"
+fi
+
+# Increment counter
+COUNT=$(cat "$COUNTER_FILE")
+COUNT=$((COUNT + 1))
+echo "$COUNT" > "$COUNTER_FILE"
+
+# Context health warnings (advisory — Claude reads these in tool output)
+if [ "$COUNT" -ge 50 ]; then
+  echo "CONTEXT WARNING: $COUNT tool calls this session. Quality is likely degraded."
+  echo "RECOMMEND: Run /clear to flush context and resume fresh."
+elif [ "$COUNT" -ge 30 ]; then
+  echo "CONTEXT ADVISORY: $COUNT tool calls this session. Consider running /clear soon."
+fi
+
+exit 0

package/templates/.claude/hooks/quality-gate.sh

@@ -0,0 +1,69 @@
+#!/bin/bash
+# Quality Gate Hook — blocks writes of incomplete content to critical files
+# Triggered: PreToolUse on Write|Edit
+# Purpose: Catch placeholders, TODOs, and incomplete content before it hits important files
+
+TOOL_INPUT="$1"
+
+# Extract the file path from tool input
+FILE_PATH=$(echo "$TOOL_INPUT" | grep -oP '"file_path"\s*:\s*"([^"]*)"' | head -1 | sed 's/.*"file_path"\s*:\s*"//;s/"//')
+
+if [ -z "$FILE_PATH" ]; then
+  exit 0  # Can't determine file — allow
+fi
+
+BASENAME=$(basename "$FILE_PATH")
+DIRPATH=$(dirname "$FILE_PATH")
+
+# Extract content being written
+CONTENT=$(echo "$TOOL_INPUT" | grep -oP '"content"\s*:\s*"([^"]*)"' | head -1 | sed 's/.*"content"\s*:\s*"//;s/"$//')
+NEW_STRING=$(echo "$TOOL_INPUT" | grep -oP '"new_string"\s*:\s*"([^"]*)"' | head -1 | sed 's/.*"new_string"\s*:\s*"//;s/"$//')
+TEXT_TO_CHECK="${CONTENT}${NEW_STRING}"
+
+# Placeholder patterns to block
+PLACEHOLDER_PATTERN='(TBD|TODO|PLACEHOLDER|FIXME|XXX|\{\{[A-Z_]+\}\})'
+
+# --- Critical file gates ---
+
+# knowledge-base.md: Every entry needs [Source:] provenance, max 200 lines
+if [ "$BASENAME" = "knowledge-base.md" ]; then
+  if echo "$TEXT_TO_CHECK" | grep -qiP "$PLACEHOLDER_PATTERN"; then
+    echo "BLOCK: knowledge-base.md cannot contain placeholders (TBD/TODO/PLACEHOLDER)"
+    echo "Every entry must be a confirmed fact with [Source:] provenance."
+    exit 2
+  fi
+fi
+
+# memory.md: Max 100 lines (Write only)
+if [ "$BASENAME" = "memory.md" ] && echo "$TOOL_INPUT" | grep -q '"tool_name".*Write'; then
+  if [ -n "$CONTENT" ]; then
+    LINE_COUNT=$(echo "$CONTENT" | wc -l)
+    if [ "$LINE_COUNT" -gt 100 ]; then
+      echo "BLOCK: memory.md exceeds 100-line limit (got $LINE_COUNT lines)."
+      echo "Prune stale items before writing."
+      exit 2
+    fi
+  fi
+fi
+
+# settings.json: Must be valid JSON
+if [ "$BASENAME" = "settings.json" ] && echo "$DIRPATH" | grep -q "\.claude"; then
+  if [ -n "$CONTENT" ]; then
+    if ! echo "$CONTENT" | python3 -c "import sys,json; json.load(sys.stdin)" 2>/dev/null; then
+      echo "BLOCK: settings.json must be valid JSON. Broken JSON breaks all hooks."
+      exit 2
+    fi
+  fi
+fi
+
+# Agent definitions: No TBD/TODO — instructions must be definitive
+if echo "$DIRPATH" | grep -q "\.claude/agents"; then
+  if echo "$TEXT_TO_CHECK" | grep -qiP "$PLACEHOLDER_PATTERN"; then
+    echo "BLOCK: Agent definitions cannot contain placeholders."
+    echo "Instructions must be definitive — agents execute what they read."
+    exit 2
+  fi
+fi
+
+# All checks passed
+exit 0

package/templates/.claude/knowledge-base.md

@@ -0,0 +1,28 @@
+# Knowledge Base
+
+System-wide institutional memory. Every agent and session reads this at startup.
+Only the auditor writes here after reviewing and confirming learnings.
+
+Keep under 200 lines. Aggressively curate — only facts that prevent future errors.
+
+**Provenance hierarchy** (when facts conflict, higher rank wins):
+1. **User override** — You explicitly corrected an agent (highest trust)
+2. **Empirical verification** — Confirmed through testing or data
+3. **Agent inference** — Concluded during analysis (lowest trust)
+
+Every entry includes its source. Format: `[Source: type MMDDYY]`
+
+---
+
+## Hard Rules Learned
+
+- [Rules discovered through experience go here. Example:]
+- [MMDDYY] Never run `git push --force` to main without explicit confirmation. [Source: User override MMDDYY]
+
+## Project-Specific Knowledge
+
+- [Facts about your codebase, APIs, or deployment that Claude can't infer from code]
+
+## External Service Notes
+
+- [API quirks, rate limits, authentication gotchas]

package/templates/.claude/knowledge-nominations.md

@@ -0,0 +1,12 @@
+# Knowledge Nominations
+
+Candidate learnings awaiting auditor review. Any agent can append here.
+The auditor reviews nominations each cycle and promotes valid ones to knowledge-base.
+
+Format: `- [MMDDYY] [source]: [learning] | Evidence: [what was observed]`
+
+---
+
+## Pending
+
+- [Nominations appear here as they're discovered]

package/templates/.claude/memory.md

@@ -0,0 +1,21 @@
+# Memory
+
+Living session state. Read at the start of every session. Updated during /sync and /wrap-up.
+Keep under 100 lines — prune aggressively.
+
+## Now
+
+- [Your current active work goes here]
+
+## Open Threads
+
+- [Unresolved items that need attention]
+- [Blocked tasks with what's blocking them]
+
+## Parked
+
+- [Items intentionally deferred — not forgotten, just not now]
+
+## Recent Decisions
+
+- [MMDDYY] [Decision made and why — one line each]

package/templates/.claude/settings.json

@@ -0,0 +1,68 @@
+{
+  "$schema": "https://json.schemastore.org/claude-code-settings.json",
+  "permissions": {
+    "allow": [
+      "Read",
+      "Glob",
+      "Grep",
+      "WebSearch",
+      "WebFetch",
+      "Bash(git status)",
+      "Bash(git diff*)",
+      "Bash(git log*)",
+      "Bash(git branch*)",
+      "Bash(npm test*)",
+      "Bash(npm run lint*)",
+      "Bash(npm run build*)",
+      "Bash(npx tsc*)",
+      "Bash(date*)",
+      "Bash(ls *)",
+      "Bash(cat package.json)",
+      "Bash(wc *)"
+    ],
+    "deny": [
+      "Bash(rm -rf *)",
+      "Bash(git push --force*)",
+      "Bash(git reset --hard*)",
+      "Bash(git checkout .)",
+      "Bash(git clean -f*)",
+      "Bash(curl * | bash)",
+      "Bash(curl * | sh)"
+    ]
+  },
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Write|Edit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash .claude/hooks/quality-gate.sh \"$TOOL_INPUT\""
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash .claude/hooks/audit-logger.sh \"$TOOL_NAME\" \"$TOOL_INPUT\""
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash .claude/hooks/context-monitor.sh"
+          }
+        ]
+      }
+    ]
+  }
+}

package/templates/.claude/skills/content/SKILL.md

@@ -0,0 +1,34 @@
+# Content Skill
+
+Procedures for creating, reviewing, and publishing content.
+
+## When to Load
+
+- Writing documentation, READMEs, or technical guides
+- Creating marketing copy or announcements
+- Reviewing content for accuracy and tone
+
+## Content Creation Procedure
+
+1. **Define audience**: Who is this for? What do they already know?
+2. **Define purpose**: What should the reader DO after reading this?
+3. **Outline**: Structure the content before writing
+4. **Draft**: Write the content following project voice/tone
+5. **Review**: Check for accuracy, clarity, completeness
+6. **Polish**: Grammar, formatting, consistency
+7. **Deliver**: Place in the correct location with proper metadata
+
+## Quality Checklist
+
+- [ ] Clear and specific headline/title
+- [ ] Purpose stated in the first paragraph
+- [ ] Logical flow from introduction to conclusion
+- [ ] Technical accuracy verified against source code/docs
+- [ ] No jargon without explanation (match audience level)
+- [ ] Actionable — reader knows what to do next
+- [ ] Formatted for scanability (headers, bullets, code blocks)
+- [ ] Links verified and working
+
+## Tone Guidelines
+
+{{TONE_DESCRIPTION}}

package/templates/.claude/skills/data-export/SKILL.md

@@ -0,0 +1,34 @@
+# Data Export Skill
+
+Procedures for extracting, transforming, and exporting data.
+
+## When to Load
+
+- Exporting data from APIs or databases
+- Generating reports or summaries
+- Moving data between systems
+
+## General Procedure
+
+1. **Define scope**: What data, what time range, what format?
+2. **Authenticate**: Ensure API keys/tokens are available
+3. **Extract**: Pull data from source (API calls, DB queries, file reads)
+4. **Transform**: Clean, filter, aggregate as needed
+5. **Validate**: Spot-check numbers — do totals make sense?
+6. **Export**: Write to target format (CSV, JSON, spreadsheet, etc.)
+7. **Verify**: Confirm the output matches expectations
+
+## Data Validation Rules
+
+- Row counts should match between source and export
+- Totals should sum correctly (watch for rounding)
+- Date ranges should match the requested scope
+- No duplicate rows unless expected
+- No null/empty values in required fields
+
+## Common Gotchas
+
+- API pagination: Always check if there are more pages
+- Timezone differences: Normalize all timestamps
+- Rate limits: Add delays between API calls if needed
+- Character encoding: Ensure UTF-8 throughout the pipeline