continuous-improvement 3.1.0 → 3.8.0

package/SKILL.md

@@ -1,6 +1,7 @@
 ---
 name: continuous-improvement
-description: "Install structured self-improvement loops with instinct-based learning into Claude Code — research, plan, execute, verify, reflect, learn, iterate. Auto-levels from silent observation to active suggestions to auto-applied behaviors."
+tier: core
+description: "Install structured self-improvement loops with instinct-based learning into Claude Code — research, plan, execute, verify, reflect, learn, iterate. On-demand or weekly analysis to save tokens. Supports multi-agent parallel analysis."
 ---
 
 # continuous-improvement
@@ -28,9 +29,9 @@ Before executing, state:
 ## Law 3: One Thing at a Time
 
 - Complete and verify one task before starting the next
-- Never spawn parallel work for tasks you can do directly
 - Never report completion until you've checked actual output
 - If you want to "also quickly add" something — stop. Finish first.
+- **Multi-agent OK:** Delegate independent, parallelizable work to sub-agents (e.g., security review + code review + tests in parallel). Each agent follows the 7 Laws independently. Only parallelize when tasks have no shared state.
 
 ## Law 4: Verify Before Reporting
 
@@ -50,10 +51,35 @@ After non-trivial tasks:
 - What failed:
 - What I'd do differently:
 - Rule to add:
+- Iteration — Next best recommendations (ranked, top 3):
+  1. <primary — strongest next move>
+  2. <alternative — different angle, if user wants to pivot>
+  3. <alternative — smaller/larger scope, if user wants to adjust>
 ```
 
 The "Rule to add" field feeds Law 7 — it becomes an instinct with 0.6 starting confidence.
 
+The "Iteration — Next best recommendations" field feeds Law 6. List the **top 3 ranked** core-development moves based on the current code state — what to build, fix, refactor, or investigate next so the feature/system advances. Item #1 is the strongest recommendation; #2 and #3 are alternative directions the user can pick from. NOT git plumbing (commit, push, PR), NOT pure CI ceremony (run tests, type-check), NOT deploy steps. Those belong in the end-of-run summary, not here.
+
+Format per item: `<verb> <object at path:line> (<why, one clause grounded in current context>)`.
+
+Good examples (development progression):
+- `Implement settleWeekAndPostPrizes writer for quiz source in src/scheduled.ts (real_contest writer exists; quiz path is recognized but inert)`
+- `Refactor contestModeGuard at src/routes/trading-contest.ts to share the 4-mode switch with /admin/mode (logic duplicated, drift risk)`
+- `Investigate why Saturday cron occasionally skips Week activation in src/scheduled.ts:625 (one missed run on 2026-04-19; root cause unknown)`
+- `Add server-side enforcement for the $100 new-deposit rule in real-contest entry handler (currently advisory; admin reviews post-contest)`
+
+Anti-examples (rejected — these are workflow, not development):
+- `Commit changes` / `Open PR` / `Push to origin` → belongs in summary, not here
+- `Run vitest` / `Run tsc` → that is verification (Law 4), already done before reporting
+- `Deploy to prod` → operational, needs-approval, never an autonomous next step
+
+Rules:
+- Always exactly 3 items, ranked. Not 2, not 5.
+- All 3 must be distinct directions — do not pad with rephrases of #1.
+- If fewer than 3 real moves exist, fill remaining slots with `None — goal met from this angle.` rather than inventing busywork.
+- If the goal is fully met across all angles, write `1. None — goal met, stop.` and omit #2 and #3.
+
 ## Law 6: Iterate Means One Thing
 
 One change → verify → next change.
@@ -74,6 +100,19 @@ If the user corrects you, the instinct weakens. If they don't, it strengthens.
 
 Nothing learned is permanent. Everything decays without reinforcement.
 
+### Friction Harvest Pipeline (`/harvest`)
+
+Beyond the reflection-driven path above, the **friction harvest classifier** turns observation logs (`~/.claude/instincts/<project-hash>/observations.jsonl`) into typed instincts automatically. Run via `/harvest` or `node bin/harvest-friction.mjs`. Four typed friction patterns with confidence scoring:
+
+- **`env_issue`** — jq missing, command not found, not recognized as cmdlet
+- **`permission_block`** — sandbox / harness blocked, Permission denied
+- **`wrong_approach`** — file changed since last read (parallel-actor stale)
+- **`buggy_code`** — file not read first, old_string ambiguous, file too large
+
+Idempotent: each instinct's `dedup_key = sha1(type + tool + summary[:120])`; re-running on the same observations does not duplicate previously-written instincts. Confidence weights frequency × recency-decay so old failures fade and recurring ones strengthen, in line with the Law 7 contract above.
+
+The harvest is opt-in: it runs only when explicitly invoked. Cron / hook triggers are deliberately not wired so the operator stays in control of when the classifier reads observation history.
+
 ## The Loop
 
 ```
@@ -86,11 +125,23 @@ If you're skipping a step, that's the step you need most.
 
 ## Instinct System (Mulahazah)
 
-At the start of every session, check `~/.claude/instincts/` for this project's instincts.
+### Execution Mode: On-Demand (Default)
+
+The instinct system does **NOT** run automatically at session start. This saves tokens.
+
+| Mode | When it runs | Token cost |
+|------|-------------|------------|
+| **On-demand** (default) | Only when user runs `/continuous-improvement` or `/dashboard` | Zero overhead per session |
+| **Weekly** | User schedules via `/loop 7d /continuous-improvement analyze` or cron | One analysis per week |
+| **Always-on** (opt-in) | Set `always_on: true` in project instinct config | Runs at every session start |
+
+**To enable always-on:** Create `~/.claude/instincts/<hash>/config.yaml` with `always_on: true`. Otherwise, instincts are only loaded when explicitly requested.
+
+**Hooks still capture silently** — observations accumulate in `observations.jsonl` with near-zero cost. The expensive part (reading, analyzing, creating instincts) only happens when you ask for it.
 
 ### Auto-Level Detection
 
-Determine current level automatically:
+When analysis is triggered (on-demand, weekly, or always-on), determine level:
 
 1. **Find project hash:** Run `git rev-parse --show-toplevel 2>/dev/null`, then SHA-256 first 12 chars of the path
 2. **Check observations:** Count lines in `~/.claude/instincts/<hash>/observations.jsonl`
@@ -105,9 +156,9 @@ Determine current level automatically:
 
 Multiple levels can be active simultaneously — you might auto-apply some instincts while suggesting others.
 
-### Inline Analysis
+### Analysis (On-Demand)
 
-When 20+ unprocessed observations exist, analyze them as part of session startup:
+When triggered by `/continuous-improvement analyze`, weekly schedule, or always-on mode:
 
 1. Read `observations.jsonl` (last 500 lines)
 2. Read existing instincts (project + global `*.yaml` files)
@@ -119,6 +170,16 @@ When 20+ unprocessed observations exist, analyze them as part of session startup
 4. Create/update instinct YAML files in the project directory
 5. Be conservative: only create instincts for 3+ observations of the same pattern
 
+### Multi-Agent Analysis
+
+For large observation backlogs (500+ lines), parallelize analysis across agents:
+
+- **Agent 1:** Analyze user corrections and error→fix sequences
+- **Agent 2:** Analyze repeated workflows and tool preferences
+- **Agent 3:** Cross-reference with existing instincts for updates/promotions
+
+Each agent writes to separate temp files; the orchestrator merges results and deduplicates.
+
 ### Instinct Format
 
 Each instinct is a YAML file in `~/.claude/instincts/<hash>/` or `~/.claude/instincts/global/`:
@@ -160,12 +221,29 @@ Cap: 0.9 max. Scope: default to project; promote to global when seen in 2+ proje
 
 ## /continuous-improvement Command
 
-Run `/continuous-improvement` after significant work:
+Run `/continuous-improvement` when you want to reflect and learn — not every session.
 
 1. **Reflect** — Generate Law 5 reflection
 2. **Analyze** — Process pending observations into instincts
 3. **Status** — Show all instincts with confidence and current level
 
 Subcommands:
-- `/continuous-improvement status` — Instinct overview only
-- `/continuous-improvement analyze` — Force analysis of pending observations
+- `/continuous-improvement status` — Instinct overview only (lightweight, reads YAML only)
+- `/continuous-improvement analyze` — Process pending observations into instincts
+- `/continuous-improvement weekly` — Set up weekly analysis schedule
+- `/continuous-improvement always-on` — Enable/disable always-on mode for this project
+
+## Planning-With-Files (Opt-In)
+
+Use this workflow only when the user explicitly asks for persistent, file-based planning or asks to use Planning-With-Files.
+
+- Detect the project root with `git rev-parse --show-toplevel`; if that fails, use the current working directory.
+- Create and maintain three project-root files:
+  - `task_plan.md` — phases, status, questions, decisions, errors
+  - `findings.md` — research notes, sources, synthesized discoveries
+  - `progress.md` — session log, verification notes, checkpoints
+- Default phases in `task_plan.md`: `Research`, `Plan`, `Execute`, `Verify`, `Reflect`
+- Never create these files automatically for normal work. This workflow is opt-in.
+- Never overwrite existing planning files unless the user explicitly asks to reset or replace them.
+
+When resuming work, read the three files before making major decisions so context survives long tasks and new sessions.

package/action.yml

@@ -1,33 +1,33 @@
-name: 'AI Agent Discipline Linter'
-description: 'Lint AI agent transcripts for compliance with the 7 Laws of AI Agent Discipline'
-author: 'naimkatiman'
-
-branding:
-  icon: 'check-circle'
-  color: 'green'
-
-inputs:
-  transcript-path:
-    description: 'Path to the agent transcript file (JSONL format)'
-    required: false
-    default: ''
-  observations-path:
-    description: 'Path to observations.jsonl from a CI session'
-    required: false
-    default: ''
-  strict:
-    description: 'Fail the check if any law violations are detected'
-    required: false
-    default: 'false'
-
-outputs:
-  violations:
-    description: 'Number of law violations found'
-  score:
-    description: 'Discipline score (0-100)'
-  report:
-    description: 'Markdown-formatted report'
-
-runs:
-  using: 'node20'
-  main: 'bin/lint-transcript.mjs'
+name: 'AI Agent Discipline Linter'
+description: 'Catch agents that skipped research, planning, or verification — by linting their transcript in CI against the 7 Laws of AI Agent Discipline.'
+author: 'naimkatiman'
+
+branding:
+  icon: 'check-circle'
+  color: 'green'
+
+inputs:
+  transcript-path:
+    description: 'Path to the agent transcript file (JSONL format)'
+    required: false
+    default: ''
+  observations-path:
+    description: 'Path to observations.jsonl from a CI session'
+    required: false
+    default: ''
+  strict:
+    description: 'Fail the check if any law violations are detected'
+    required: false
+    default: 'false'
+
+outputs:
+  violations:
+    description: 'Number of law violations found'
+  score:
+    description: 'Discipline score (0-100)'
+  report:
+    description: 'Markdown-formatted report'
+
+runs:
+  using: 'node20'
+  main: 'bin/lint-transcript.mjs'

package/bin/analyze.sh

@@ -1,153 +1,161 @@
-#!/usr/bin/env bash
-# analyze.sh — Read observations.jsonl, detect patterns, create instinct YAML files
-# Runs via /continuous-improvement command. Uses claude CLI with Haiku for cost-efficient analysis.
-
-set -euo pipefail
-
-INSTINCTS_DIR="${HOME}/.claude/instincts"
-
-# ---------------------------------------------------------------------------
-# Detect project
-# ---------------------------------------------------------------------------
-PROJECT_ROOT=""
-if [[ -n "${CLAUDE_PROJECT_DIR:-}" && -d "${CLAUDE_PROJECT_DIR}" ]]; then
-  PROJECT_ROOT="${CLAUDE_PROJECT_DIR}"
-fi
-if [[ -z "$PROJECT_ROOT" ]]; then
-  PROJECT_ROOT="$(git rev-parse --show-toplevel 2>/dev/null || true)"
-fi
-if [[ -z "$PROJECT_ROOT" ]]; then
-  PROJECT_ROOT="global"
-fi
-
-PROJECT_HASH="$(printf '%s' "$PROJECT_ROOT" | sha256sum | cut -c1-12)"
-PROJECT_NAME="$(basename "${PROJECT_ROOT%.git}")"
-PROJECT_DIR="${INSTINCTS_DIR}/${PROJECT_HASH}"
-OBS_FILE="${PROJECT_DIR}/observations.jsonl"
-
-# ---------------------------------------------------------------------------
-# Check observations exist
-# ---------------------------------------------------------------------------
-if [[ ! -f "$OBS_FILE" ]] || [[ ! -s "$OBS_FILE" ]]; then
-  echo "No observations found at ${OBS_FILE}"
-  echo "Use Claude Code with hooks installed to generate observations."
-  exit 0
-fi
-
-OBS_COUNT=$(wc -l < "$OBS_FILE")
-echo "Found ${OBS_COUNT} observations in ${OBS_FILE}"
-
-if (( OBS_COUNT < 20 )); then
-  echo "Need at least 20 observations for meaningful analysis. Keep using Claude Code (${OBS_COUNT}/20)."
-  exit 0
-fi
-
-# ---------------------------------------------------------------------------
-# Read existing instincts to avoid duplicates
-# ---------------------------------------------------------------------------
-EXISTING_INSTINCTS=""
-for f in "${PROJECT_DIR}"/*.yaml "${INSTINCTS_DIR}/global"/*.yaml; do
-  [[ -f "$f" ]] && EXISTING_INSTINCTS="${EXISTING_INSTINCTS}$(cat "$f")"$'\n'
-done
-
-# ---------------------------------------------------------------------------
-# Take last 500 observations
-# ---------------------------------------------------------------------------
-RECENT_OBS=$(tail -500 "$OBS_FILE")
-
-# ---------------------------------------------------------------------------
-# Build analysis prompt
-# ---------------------------------------------------------------------------
-ANALYSIS_PROMPT="Analyze these Claude Code session observations and extract behavioral patterns as instinct YAML files.
-
-OBSERVATIONS (JSONL — each line is a tool call):
-${RECENT_OBS}
-
-EXISTING INSTINCTS (already learned — do NOT duplicate these):
-${EXISTING_INSTINCTS}
-
-YOUR TASK:
-1. Look for REPEATED PATTERNS — same tool sequence used 3+ times
-2. Look for ERROR-THEN-FIX sequences — tool fails, next tools fix it
-3. Look for TOOL PREFERENCES — one tool consistently chosen over alternatives
-4. Look for WORKFLOW PATTERNS — consistent ordering of operations
-5. Look for USER CORRECTIONS — user says no/stop/don't after an action
-
-OUTPUT FORMAT — output ONLY new instincts as YAML blocks, separated by ---:
-
-id: descriptive-kebab-case-id
-trigger: \"when [specific situation]\"
-confidence: 0.5
-domain: workflow|tooling|testing|patterns
-source: observation
-scope: project
-project_id: ${PROJECT_HASH}
-created: \"$(date -u +%Y-%m-%d)\"
-last_seen: \"$(date -u +%Y-%m-%d)\"
-observation_count: [number of times pattern was seen]
----
-[One sentence describing the specific actionable behavior]
-
-Rules:
-- Only create instincts for patterns seen 3+ times
-- Start confidence at 0.5 (suggest level)
-- Be specific and actionable (not vague advice)
-- Different from existing instincts listed above
-
-If no new patterns are found, output exactly: NO_NEW_PATTERNS
-
-Output ONLY the YAML blocks or NO_NEW_PATTERNS. No explanation, no preamble."
-
-# ---------------------------------------------------------------------------
-# Run analysis with Haiku
-# ---------------------------------------------------------------------------
-echo "Analyzing patterns with Haiku..."
-RESULT=$(echo "$ANALYSIS_PROMPT" | claude --model haiku --print -p - 2>/dev/null) || {
-  echo "Analysis failed — claude CLI error. Try running manually."
-  exit 1
-}
-
-if [[ "$RESULT" == "NO_NEW_PATTERNS" ]] || [[ -z "$RESULT" ]]; then
-  echo "No new patterns detected yet. Keep using Claude Code — patterns emerge over time."
-  exit 0
-fi
-
-# ---------------------------------------------------------------------------
-# Write instinct YAML files
-# ---------------------------------------------------------------------------
-mkdir -p "$PROJECT_DIR"
-
-NEW_COUNT=0
-INSTINCT_ID=""
-BLOCK=""
-
-while IFS= read -r line; do
-  if [[ "$line" == "---" ]] && [[ -n "$BLOCK" ]]; then
-    if [[ -n "$INSTINCT_ID" ]]; then
-      DEST="${PROJECT_DIR}/${INSTINCT_ID}.yaml"
-      printf '%s\n' "$BLOCK" > "$DEST"
-      echo "  + ${INSTINCT_ID} -> ${DEST}"
-      NEW_COUNT=$((NEW_COUNT + 1))
-    fi
-    INSTINCT_ID=""
-    BLOCK=""
-  else
-    BLOCK="${BLOCK}${line}"$'\n'
-    if [[ "$line" =~ ^id:\ (.+) ]]; then
-      INSTINCT_ID="${BASH_REMATCH[1]}"
-      INSTINCT_ID="${INSTINCT_ID//\"/}"
-      INSTINCT_ID="${INSTINCT_ID//\'/}"
-    fi
-  fi
-done <<< "$RESULT"
-
-# Handle last block
-if [[ -n "$INSTINCT_ID" ]] && [[ -n "$BLOCK" ]]; then
-  DEST="${PROJECT_DIR}/${INSTINCT_ID}.yaml"
-  printf '%s\n' "$BLOCK" > "$DEST"
-  echo "  + ${INSTINCT_ID} -> ${DEST}"
-  NEW_COUNT=$((NEW_COUNT + 1))
-fi
-
-echo ""
-echo "Created ${NEW_COUNT} new instinct(s) in ${PROJECT_DIR}/"
+#!/usr/bin/env bash
+# analyze.sh — Read observations.jsonl, detect patterns, create instinct YAML files
+# Runs via /continuous-improvement command. Uses claude CLI with Haiku for cost-efficient analysis.
+
+set -euo pipefail
+
+INSTINCTS_DIR="${HOME}/.claude/instincts"
+
+# ---------------------------------------------------------------------------
+# Detect project
+# ---------------------------------------------------------------------------
+PROJECT_ROOT=""
+if [[ -n "${CLAUDE_PROJECT_DIR:-}" && -d "${CLAUDE_PROJECT_DIR}" ]]; then
+  PROJECT_ROOT="${CLAUDE_PROJECT_DIR}"
+fi
+if [[ -z "$PROJECT_ROOT" ]]; then
+  PROJECT_ROOT="$(git rev-parse --show-toplevel 2>/dev/null || true)"
+fi
+if [[ -z "$PROJECT_ROOT" ]]; then
+  PROJECT_ROOT="global"
+fi
+
+# Use shasum on macOS, sha256sum on Linux
+if command -v sha256sum &>/dev/null; then
+  PROJECT_HASH="$(printf '%s' "$PROJECT_ROOT" | sha256sum | cut -c1-12)"
+elif command -v shasum &>/dev/null; then
+  PROJECT_HASH="$(printf '%s' "$PROJECT_ROOT" | shasum -a 256 | cut -c1-12)"
+else
+  # Fallback: use project root basename if no hashing available
+  PROJECT_HASH="$(basename "$PROJECT_ROOT" | tr -cd 'a-zA-Z0-9' | cut -c1-12)"
+fi
+PROJECT_NAME="$(basename "${PROJECT_ROOT%.git}")"
+PROJECT_DIR="${INSTINCTS_DIR}/${PROJECT_HASH}"
+OBS_FILE="${PROJECT_DIR}/observations.jsonl"
+
+# ---------------------------------------------------------------------------
+# Check observations exist
+# ---------------------------------------------------------------------------
+if [[ ! -f "$OBS_FILE" ]] || [[ ! -s "$OBS_FILE" ]]; then
+  echo "No observations found at ${OBS_FILE}"
+  echo "Use Claude Code with hooks installed to generate observations."
+  exit 0
+fi
+
+OBS_COUNT=$(wc -l < "$OBS_FILE")
+echo "Found ${OBS_COUNT} observations in ${OBS_FILE}"
+
+if (( OBS_COUNT < 20 )); then
+  echo "Need at least 20 observations for meaningful analysis. Keep using Claude Code (${OBS_COUNT}/20)."
+  exit 0
+fi
+
+# ---------------------------------------------------------------------------
+# Read existing instincts to avoid duplicates
+# ---------------------------------------------------------------------------
+EXISTING_INSTINCTS=""
+for f in "${PROJECT_DIR}"/*.yaml "${INSTINCTS_DIR}/global"/*.yaml; do
+  [[ -f "$f" ]] && EXISTING_INSTINCTS="${EXISTING_INSTINCTS}$(cat "$f")"$'\n'
+done
+
+# ---------------------------------------------------------------------------
+# Take last 500 observations
+# ---------------------------------------------------------------------------
+RECENT_OBS=$(tail -500 "$OBS_FILE")
+
+# ---------------------------------------------------------------------------
+# Build analysis prompt
+# ---------------------------------------------------------------------------
+ANALYSIS_PROMPT="Analyze these Claude Code session observations and extract behavioral patterns as instinct YAML files.
+
+OBSERVATIONS (JSONL — each line is a tool call):
+${RECENT_OBS}
+
+EXISTING INSTINCTS (already learned — do NOT duplicate these):
+${EXISTING_INSTINCTS}
+
+YOUR TASK:
+1. Look for REPEATED PATTERNS — same tool sequence used 3+ times
+2. Look for ERROR-THEN-FIX sequences — tool fails, next tools fix it
+3. Look for TOOL PREFERENCES — one tool consistently chosen over alternatives
+4. Look for WORKFLOW PATTERNS — consistent ordering of operations
+5. Look for USER CORRECTIONS — user says no/stop/don't after an action
+
+OUTPUT FORMAT — output ONLY new instincts as YAML blocks, separated by ---:
+
+id: descriptive-kebab-case-id
+trigger: \"when [specific situation]\"
+confidence: 0.5
+domain: workflow|tooling|testing|patterns
+source: observation
+scope: project
+project_id: ${PROJECT_HASH}
+created: \"$(date -u +%Y-%m-%d)\"
+last_seen: \"$(date -u +%Y-%m-%d)\"
+observation_count: [number of times pattern was seen]
+---
+[One sentence describing the specific actionable behavior]
+
+Rules:
+- Only create instincts for patterns seen 3+ times
+- Start confidence at 0.5 (suggest level)
+- Be specific and actionable (not vague advice)
+- Different from existing instincts listed above
+
+If no new patterns are found, output exactly: NO_NEW_PATTERNS
+
+Output ONLY the YAML blocks or NO_NEW_PATTERNS. No explanation, no preamble."
+
+# ---------------------------------------------------------------------------
+# Run analysis with Haiku
+# ---------------------------------------------------------------------------
+echo "Analyzing patterns with Haiku..."
+RESULT=$(echo "$ANALYSIS_PROMPT" | claude --model haiku --print -p - 2>/dev/null) || {
+  echo "Analysis failed — claude CLI error. Try running manually."
+  exit 1
+}
+
+if [[ "$RESULT" == "NO_NEW_PATTERNS" ]] || [[ -z "$RESULT" ]]; then
+  echo "No new patterns detected yet. Keep using Claude Code — patterns emerge over time."
+  exit 0
+fi
+
+# ---------------------------------------------------------------------------
+# Write instinct YAML files
+# ---------------------------------------------------------------------------
+mkdir -p "$PROJECT_DIR"
+
+NEW_COUNT=0
+INSTINCT_ID=""
+BLOCK=""
+
+while IFS= read -r line; do
+  if [[ "$line" == "---" ]] && [[ -n "$BLOCK" ]]; then
+    if [[ -n "$INSTINCT_ID" ]]; then
+      DEST="${PROJECT_DIR}/${INSTINCT_ID}.yaml"
+      printf '%s\n' "$BLOCK" > "$DEST"
+      echo "  + ${INSTINCT_ID} -> ${DEST}"
+      NEW_COUNT=$((NEW_COUNT + 1))
+    fi
+    INSTINCT_ID=""
+    BLOCK=""
+  else
+    BLOCK="${BLOCK}${line}"$'\n'
+    if [[ "$line" =~ ^id:\ (.+) ]]; then
+      INSTINCT_ID="${BASH_REMATCH[1]}"
+      INSTINCT_ID="${INSTINCT_ID//\"/}"
+      INSTINCT_ID="${INSTINCT_ID//\'/}"
+    fi
+  fi
+done <<< "$RESULT"
+
+# Handle last block
+if [[ -n "$INSTINCT_ID" ]] && [[ -n "$BLOCK" ]]; then
+  DEST="${PROJECT_DIR}/${INSTINCT_ID}.yaml"
+  printf '%s\n' "$BLOCK" > "$DEST"
+  echo "  + ${INSTINCT_ID} -> ${DEST}"
+  NEW_COUNT=$((NEW_COUNT + 1))
+fi
+
+echo ""
+echo "Created ${NEW_COUNT} new instinct(s) in ${PROJECT_DIR}/"