azclaude-copilot 0.8.0 → 0.8.3

package/.claude-plugin/marketplace.json

@@ -8,8 +8,8 @@
   "plugins": [
     {
       "name": "azclaude",
-      "description": "AZCLAUDE is a complete AI coding environment for Claude Code. It installs 44 commands, 10 auto-invoked skills, 16 specialized agents, 5 hooks, a real-time pipeline visualizer, and a persistent memory system — in one command.\n\nKey features:\n• Memory across sessions — goals.md + checkpoints injected automatically before every session\n• Self-improving loop — /reflect fixes stale CLAUDE.md rules, /reflexes learns from tool-use patterns, /evolve creates agents from git evidence\n• Autonomous copilot mode — /copilot runs a three-tier team (orchestrator → problem-architect → milestone-builder) across sessions until the product ships\n• Spec-driven workflow — /constitute writes project rules, /spec writes structured ACs, /analyze detects plan drift and ghost milestones, /blueprint traces every milestone to a spec\n• Security layer — 111-rule environment scan (/sentinel), pre-write secret blocking, pre-ship credential audit\n• Progressive levels 0–10 — start with CLAUDE.md, grow into multi-agent pipelines and self-evolving environments\n• Zero dependencies — no npm packages, no external APIs, no vector databases. Plain markdown files and Claude Code's native architecture.\n• Smart install — npx azclaude-copilot@latest auto-detects first install vs upgrade vs verify. Context-aware onboarding shows the right next command for your project state.\n\nExample use cases:\n• /setup — scan an existing project, detect stack + domain + scale, fill CLAUDE.md, generate project-specific skills and agents automatically\n• /copilot \"Build a compliance SaaS with trilingual support\" — walk away, come back to working code across multiple sessions\n• /sentinel — run a scored security audit (0–100, grade A–F) across hooks, permissions, MCP servers, agent configs, and secrets\n• /evolve — detect gaps in the environment, generate new skills and agents from git co-change evidence, report score delta (e.g. 42/100 → 68/100)\n• /constitute — write your project's constitution (non-negotiables, architectural commitments, definition of done) — gates all future AI actions\n• /analyze — cross-artifact consistency check: ghost milestones, spec vs. code drift, unplanned commits\n• /reflect — find stale, missing, or contradicting rules in CLAUDE.md and propose exact fixes\n• /debate \"REST vs GraphQL for this project\" — adversarial evidence-based decision with order-independent scoring, logged to decisions.md",
-      "version": "0.8.0",
+      "description": "AZCLAUDE is a complete AI coding environment for Claude Code. It installs 46 commands, 10 auto-invoked skills, 16 specialized agents, 5 hooks, a real-time pipeline visualizer, and a persistent memory system — in one command.\n\nKey features:\n• Memory across sessions — goals.md + checkpoints injected automatically before every session\n• Self-improving loop — /reflect fixes stale CLAUDE.md rules, /reflexes learns from tool-use patterns, /evolve creates agents from git evidence\n• Autonomous copilot mode — /copilot runs a three-tier team (orchestrator → problem-architect → milestone-builder) across sessions until the product ships\n• Spec-driven workflow — /constitute writes project rules, /spec writes structured ACs, /analyze detects plan drift and ghost milestones, /blueprint traces every milestone to a spec\n• Security layer — 111-rule environment scan (/sentinel), pre-write secret blocking, pre-ship credential audit\n• Progressive levels 0–10 — start with CLAUDE.md, grow into multi-agent pipelines and self-evolving environments\n• Zero dependencies — no npm packages, no external APIs, no vector databases. Plain markdown files and Claude Code's native architecture.\n• Smart install — npx azclaude-copilot@latest auto-detects first install vs upgrade vs verify. Context-aware onboarding shows the right next command for your project state.\n\nExample use cases:\n• /setup — scan an existing project, detect stack + domain + scale, fill CLAUDE.md, generate project-specific skills and agents automatically\n• /copilot \"Build a compliance SaaS with trilingual support\" — walk away, come back to working code across multiple sessions\n• /sentinel — run a scored security audit (0–100, grade A–F) across hooks, permissions, MCP servers, agent configs, and secrets\n• /evolve — detect gaps in the environment, generate new skills and agents from git co-change evidence, report score delta (e.g. 42/100 → 68/100)\n• /constitute — write your project's constitution (non-negotiables, architectural commitments, definition of done) — gates all future AI actions\n• /analyze — cross-artifact consistency check: ghost milestones, spec vs. code drift, unplanned commits\n• /reflect — find stale, missing, or contradicting rules in CLAUDE.md and propose exact fixes\n• /debate \"REST vs GraphQL for this project\" — adversarial evidence-based decision with order-independent scoring, logged to decisions.md",
+      "version": "0.8.3",
       "source": {
         "source": "github",
         "repo": "haytamAroui/AZ-CLAUDE-COPILOT",

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "azclaude",
-  "version": "0.8.0",
-  "description": "AZCLAUDE is a complete AI coding environment for Claude Code. It installs 44 commands, 10 auto-invoked skills, 16 specialized agents, 5 hooks, a real-time pipeline visualizer, and a persistent memory system — in one command.\n\nKey features:\n• Memory across sessions — goals.md + checkpoints injected automatically before every session\n• Self-improving loop — /reflect fixes stale CLAUDE.md rules, /reflexes learns from tool-use patterns, /evolve creates agents from git evidence\n• Autonomous copilot mode — /copilot runs a three-tier team (orchestrator → problem-architect → milestone-builder) across sessions until the product ships\n• Spec-driven workflow — /constitute writes project rules, /spec writes structured ACs, /analyze detects plan drift and ghost milestones, /blueprint traces every milestone to a spec\n• Security layer — 111-rule environment scan (/sentinel), pre-write secret blocking, pre-ship credential audit\n• Progressive levels 0–10 — start with CLAUDE.md, grow into multi-agent pipelines and self-evolving environments\n• Zero dependencies — no npm packages, no external APIs, no vector databases. Plain markdown files and Claude Code's native architecture.\n• Smart install — npx azclaude-copilot@latest auto-detects first install vs upgrade vs verify. Context-aware onboarding shows the right next command for your project state.\n\nExample use cases:\n• /setup — scan an existing project, detect stack + domain + scale, fill CLAUDE.md, generate project-specific skills and agents automatically\n• /copilot \"Build a compliance SaaS with trilingual support\" — walk away, come back to working code across multiple sessions\n• /sentinel — run a scored security audit (0–100, grade A–F) across hooks, permissions, MCP servers, agent configs, and secrets\n• /evolve — detect gaps in the environment, generate new skills and agents from git co-change evidence, report score delta (e.g. 42/100 → 68/100)\n• /constitute — write your project's constitution (non-negotiables, architectural commitments, definition of done) — gates all future AI actions\n• /analyze — cross-artifact consistency check: ghost milestones, spec vs. code drift, unplanned commits\n• /reflect — find stale, missing, or contradicting rules in CLAUDE.md and propose exact fixes\n• /debate \"REST vs GraphQL for this project\" — adversarial evidence-based decision with order-independent scoring, logged to decisions.md",
+  "version": "0.8.3",
+  "description": "AZCLAUDE is a complete AI coding environment for Claude Code. It installs 46 commands, 10 auto-invoked skills, 16 specialized agents, 5 hooks, a real-time pipeline visualizer, and a persistent memory system — in one command.\n\nKey features:\n• Memory across sessions — goals.md + checkpoints injected automatically before every session\n• Self-improving loop — /reflect fixes stale CLAUDE.md rules, /reflexes learns from tool-use patterns, /evolve creates agents from git evidence\n• Autonomous copilot mode — /copilot runs a three-tier team (orchestrator → problem-architect → milestone-builder) across sessions until the product ships\n• Spec-driven workflow — /constitute writes project rules, /spec writes structured ACs, /analyze detects plan drift and ghost milestones, /blueprint traces every milestone to a spec\n• Security layer — 111-rule environment scan (/sentinel), pre-write secret blocking, pre-ship credential audit\n• Progressive levels 0–10 — start with CLAUDE.md, grow into multi-agent pipelines and self-evolving environments\n• Zero dependencies — no npm packages, no external APIs, no vector databases. Plain markdown files and Claude Code's native architecture.\n• Smart install — npx azclaude-copilot@latest auto-detects first install vs upgrade vs verify. Context-aware onboarding shows the right next command for your project state.\n\nExample use cases:\n• /setup — scan an existing project, detect stack + domain + scale, fill CLAUDE.md, generate project-specific skills and agents automatically\n• /copilot \"Build a compliance SaaS with trilingual support\" — walk away, come back to working code across multiple sessions\n• /sentinel — run a scored security audit (0–100, grade A–F) across hooks, permissions, MCP servers, agent configs, and secrets\n• /evolve — detect gaps in the environment, generate new skills and agents from git co-change evidence, report score delta (e.g. 42/100 → 68/100)\n• /constitute — write your project's constitution (non-negotiables, architectural commitments, definition of done) — gates all future AI actions\n• /analyze — cross-artifact consistency check: ghost milestones, spec vs. code drift, unplanned commits\n• /reflect — find stale, missing, or contradicting rules in CLAUDE.md and propose exact fixes\n• /debate \"REST vs GraphQL for this project\" — adversarial evidence-based decision with order-independent scoring, logged to decisions.md",
   "author": {
     "name": "haytamAroui",
     "url": "https://github.com/haytamAroui"

package/README.md

@@ -110,7 +110,7 @@ npx azclaude-copilot@latest
 
 One command, no flags. Auto-detects whether this is a fresh install or an upgrade:
 
-- **First time** → full install (42 commands, 5 hooks, 15 agents, 10 skills, memory, reflexes). Creates folders, instructions, and hooks — **no manual setup required.**
+- **First time** → full install (46 commands, 5 hooks, 16 agents, 10 skills, memory, reflexes). Creates folders, instructions, and hooks — **no manual setup required.**
 - **Already installed, older version** → auto-upgrades everything to latest templates
 - **Already up to date** → verifies, no overwrites
 
@@ -123,14 +123,14 @@ npx azclaude-copilot@latest doctor   # 32 checks — verify everything is wired
 
 ## What You Get
 
-**42 commands** · **10 auto-invoked skills** · **15 agents** · **5 hooks** · **memory across sessions** · **learned reflexes** · **self-evolving environment**
+**46 commands** · **10 auto-invoked skills** · **16 agents** · **5 hooks** · **memory across sessions** · **learned reflexes** · **self-evolving environment**
 
 ```
 .claude/
 ├── CLAUDE.md                 ← dispatch table: conventions, stack, routing
 ├── commands/                 ← 39 slash commands (/add, /fix, /copilot, /parallel...)
 ├── skills/                   ← 10 skills (test-first, security, architecture-advisor...)
-├── agents/                   ← 15 agents (orchestrator, spec-reviewer, constitution-guard...)
+├── agents/                   ← 16 agents (orchestrator, spec-reviewer, constitution-guard...)
 ├── capabilities/             ← 48 files, lazy-loaded via manifest.md (~100 tokens/task)
 ├── hooks/
 │   ├── user-prompt.js        ← Brain Router + goals injection before first message
@@ -272,8 +272,8 @@ Claude Code
   │   └── stop.js         → Session cleanup, friction logging
   │
   └── Markdown files (capability — Claude reads natively, zero overhead)
-      ├── 42 commands     → Claude reads the .md, follows instructions
-      ├── 15 agents       → Claude spawns as subagents with Task tool
+      ├── 46 commands     → Claude reads the .md, follows instructions
+      ├── 16 agents       → Claude spawns as subagents with Task tool
       ├── 10 skills       → Auto-invoked when relevant context detected
       ├── 48 capabilities → Lazy-loaded via manifest.md (~100 tokens overhead)
       └── Memory files    → goals.md, decisions.md, patterns.md, checkpoints/
@@ -637,11 +637,11 @@ AZCLAUDE is a lazy-loaded environment of 48 capability modules. It only loads wh
 
 ## Verified
 
-2113 tests. Every template, command, capability, agent, hook, and CLI feature verified.
+2137 tests. Every template, command, capability, agent, hook, and CLI feature verified.
 
 ```bash
 bash tests/test-features.sh
-# Results: 2113 passed, 0 failed, 2113 total
+# Results: 2137 passed, 0 failed, 2137 total
 ```
 
 ---

package/bin/cli.js

@@ -8,7 +8,7 @@ const { execSync }  = require('child_process');
 
 const TEMPLATE_DIR = path.join(__dirname, '..', 'templates');
 const CORE_COMMANDS     = ['setup', 'fix', 'add', 'audit', 'test', 'blueprint', 'ship', 'pulse', 'explain', 'snapshot', 'persist'];
-const EXTENDED_COMMANDS = ['dream', 'refactor', 'doc', 'loop', 'migrate', 'deps', 'find', 'create', 'reflect', 'hookify', 'sentinel', 'clarify', 'spec', 'analyze', 'constitute', 'tasks', 'issues', 'driven', 'mcp', 'verify', 'inoculate', 'ghost-test', 'visualize', 'kill', 'run', 'ingest', 'knowledge'];
+const EXTENDED_COMMANDS = ['dream', 'refactor', 'doc', 'loop', 'migrate', 'deps', 'find', 'create', 'reflect', 'hookify', 'sentinel', 'clarify', 'spec', 'analyze', 'constitute', 'tasks', 'issues', 'driven', 'mcp', 'verify', 'inoculate', 'ghost-test', 'visualize', 'kill', 'run', 'ingest', 'knowledge', 'obsidian', 'canvas'];
 const ADVANCED_COMMANDS = ['evolve', 'debate', 'level-up', 'copilot', 'reflexes', 'parallel'];
 const COMMANDS          = [...CORE_COMMANDS, ...EXTENDED_COMMANDS, ...ADVANCED_COMMANDS];
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "azclaude-copilot",
-  "version": "0.8.0",
-  "description": "AI coding environment — 44 commands, 10 skills, 16 agents, real-time visualizer, memory, reflexes, evolution, knowledge layer. Install: npx azclaude-copilot@latest, then open Claude Code.",
+  "version": "0.8.3",
+  "description": "AI coding environment — 46 commands, 10 skills, 16 agents, real-time visualizer, memory, reflexes, evolution, knowledge layer. Install: npx azclaude-copilot@latest, then open Claude Code.",
   "bin": {
     "azclaude": "bin/cli.js",
     "azclaude-copilot": "bin/copilot.js"

package/templates/CLAUDE.md

@@ -109,4 +109,4 @@ When priorities conflict:
 3. {{PRIORITY_3}}
 
 ## Available Commands
-/dream · /setup · /fix · /add · /audit · /test · /blueprint · /evolve · /debate · /snapshot · /persist · /level-up · /ship · /pulse · /explain · /loop · /refactor · /doc · /migrate · /deps · /find · /create · /reflect · /hookify · /spec · /clarify · /analyze · /constitute · /tasks · /issues · /driven · /mcp · /parallel · /verify · /inoculate · /ghost-test · /ingest · /knowledge
+/dream · /setup · /fix · /add · /audit · /test · /blueprint · /evolve · /debate · /snapshot · /persist · /level-up · /ship · /pulse · /explain · /loop · /refactor · /doc · /migrate · /deps · /find · /create · /reflect · /hookify · /spec · /clarify · /analyze · /constitute · /tasks · /issues · /driven · /mcp · /parallel · /verify · /inoculate · /ghost-test · /ingest · /knowledge · /obsidian · /canvas

package/templates/commands/canvas.md

@@ -0,0 +1,125 @@
+---
+name: canvas
+description: Generate .claude/agent-pipeline.canvas — Obsidian Canvas showing the agent topology and plan milestones.
+argument-hint: "[refresh to regenerate]"
+disable-model-invocation: true
+allowed-tools: Read, Write, Bash, Glob, Grep
+---
+
+# /canvas — Agent Pipeline Canvas Generator
+
+$ARGUMENTS
+
+Generates `.claude/agent-pipeline.canvas` — an Obsidian Canvas JSON file showing the fixed AZCLAUDE agent topology. If `.claude/plan.md` exists, milestone nodes are added below the topology. Obsidian auto-refreshes when the file changes on disk, giving live updates during `/copilot` runs.
+
+---
+
+## Step 0: Check Installation
+
+```bash
+ls .claude/commands/ 2>/dev/null || echo "NOT_INSTALLED"
+```
+
+If output is `NOT_INSTALLED`:
+```
+AZCLAUDE not installed in this project. Run setup first.
+```
+Stop here.
+
+---
+
+## Step 1: Extract Milestones (if plan.md exists)
+
+```bash
+[ -f .claude/plan.md ] && grep -E "^##? Milestone|^##? M[0-9]" .claude/plan.md 2>/dev/null | head -10 || echo ""
+```
+
+Collect each matching line as a milestone label. Strip the leading `## ` or `# ` prefix.
+If no matches or file absent, milestone list is empty — Row 4 is omitted.
+
+---
+
+## Step 2: Build Canvas JSON
+
+Construct the JSON string as follows.
+
+### Fixed topology nodes
+
+```
+Row 1 (y=0):
+  id=1  type=text  text="**orchestrator**\ncoordinates milestones"    x=400  y=0    width=220  height=80  color=4
+
+Row 2 (y=200):
+  id=2  type=text  text="**problem-architect**\nteam spec + risks"    x=0    y=200  width=220  height=80  color=5
+  id=3  type=text  text="**milestone-builder**\nimplements"           x=400  y=200  width=220  height=80  color=5
+  id=4  type=text  text="**code-reviewer**\nchecks output"            x=800  y=200  width=220  height=80  color=5
+
+Row 3 (y=400):
+  id=5  type=text  text="**constitution-guard**\nenforces rules"      x=0    y=400  width=220  height=80  color=3
+  id=6  type=text  text="**test-writer**\ngenerates tests"            x=400  y=400  width=220  height=80  color=3
+```
+
+### Fixed topology edges
+
+```
+id=e1  fromNode=1  toNode=2  label="pre-flight"
+id=e2  fromNode=1  toNode=3  label="dispatch"
+id=e3  fromNode=3  toNode=4  label="review"
+id=e4  fromNode=1  toNode=5  label="guard check"
+id=e5  fromNode=3  toNode=6  label="test"
+```
+
+### Milestone nodes (Row 4, y=600) — only if milestones were found in Step 1
+
+For each milestone at index `i` (0-based):
+```
+id=m{i}  type=text  text="{milestone label}"  x={i * 300}  y=600  width=250  height=80  color=6
+```
+
+Add one edge per milestone:
+```
+id=em{i}  fromNode=3  toNode=m{i}  label="builds"
+```
+
+### Assemble the full JSON
+
+```json
+{
+  "nodes": [ ...fixed nodes..., ...milestone nodes (if any)... ],
+  "edges": [ ...fixed edges..., ...milestone edges (if any)... ]
+}
+```
+
+Use standard JSON formatting — double quotes, no trailing commas.
+
+---
+
+## Step 3: Write Canvas File
+
+Write the JSON string to `.claude/agent-pipeline.canvas`.
+
+Overwrite existing — this command is idempotent.
+
+---
+
+## Step 4: Print Summary
+
+```
+─── Canvas Written ─────────────────────────────
+  Path:       .claude/agent-pipeline.canvas
+  Nodes:      {total node count}
+  Edges:      {total edge count}
+  Milestones: {count, or "none — add plan.md to include milestones"}
+
+Open in Obsidian to view the agent graph.
+Obsidian auto-refreshes on file change — re-run /canvas to update during /copilot.
+────────────────────────────────────────────────
+```
+
+Then print the first 20 lines of the JSON written.
+
+---
+
+## Completion Rule
+
+Print the canvas file path and total node count. Show first 20 lines of the JSON written. Do not say "canvas generated" without showing the content.

package/templates/commands/obsidian.md

@@ -0,0 +1,168 @@
+---
+name: obsidian
+description: Generate AZCLAUDE-MAP.md — an Obsidian index note with wikilinks to all commands, agents, skills, templates, memory, and docs.
+argument-hint: "[path to output, default: AZCLAUDE-MAP.md]"
+disable-model-invocation: true
+allowed-tools: Read, Write, Bash, Glob, Grep
+---
+
+# /obsidian — Obsidian Graph Map Generator
+
+$ARGUMENTS
+
+Output path: `AZCLAUDE-MAP.md` at the project root (where `.claude/` lives), unless `$ARGUMENTS` specifies a different path.
+
+---
+
+## Step 0: Check Installation
+
+```bash
+ls .claude/commands/ 2>/dev/null || echo "NOT_INSTALLED"
+```
+
+If output is `NOT_INSTALLED`:
+```
+AZCLAUDE not installed in this project. Run setup first.
+```
+Stop here.
+
+---
+
+## Step 1: Scan All Files
+
+```bash
+# Installed commands, agents, skills
+COMMANDS=$(ls .claude/commands/*.md 2>/dev/null | xargs -I{} basename {} .md | sort)
+AGENTS=$(ls .claude/agents/*.md 2>/dev/null | xargs -I{} basename {} .md | sort)
+SKILLS=$(ls .claude/skills/ 2>/dev/null | sort)
+
+# Template sources
+TMPL_CMDS=$(ls templates/commands/*.md 2>/dev/null | xargs -I{} basename {} .md | sort)
+TMPL_AGENTS=$(ls templates/agents/*.md 2>/dev/null | xargs -I{} basename {} .md | sort)
+
+# Memory
+MEMORY=$(ls .claude/memory/*.md 2>/dev/null | xargs -I{} basename {} .md | sort)
+CHECKPOINTS=$(ls .claude/memory/checkpoints/*.md 2>/dev/null | xargs -I{} basename {} | sort)
+
+# Root docs (exclude AZCLAUDE-MAP.md itself)
+DOCS=$(ls *.md 2>/dev/null | grep -v "AZCLAUDE-MAP.md" | xargs -I{} basename {} .md | sort)
+```
+
+Count totals:
+```bash
+CMD_COUNT=$(echo "$COMMANDS" | grep -c .)
+AGENT_COUNT=$(echo "$AGENTS" | grep -c .)
+SKILL_COUNT=$(echo "$SKILLS" | grep -c .)
+TMPL_CMD_COUNT=$(echo "$TMPL_CMDS" | grep -c . 2>/dev/null || echo 0)
+TMPL_AGENT_COUNT=$(echo "$TMPL_AGENTS" | grep -c . 2>/dev/null || echo 0)
+MEM_COUNT=$(echo "$MEMORY" | grep -c . 2>/dev/null || echo 0)
+CKPT_COUNT=$(echo "$CHECKPOINTS" | grep -c . 2>/dev/null || echo 0)
+DOC_COUNT=$(echo "$DOCS" | grep -c . 2>/dev/null || echo 0)
+TOTAL=$((CMD_COUNT + AGENT_COUNT + SKILL_COUNT + TMPL_CMD_COUNT + TMPL_AGENT_COUNT + MEM_COUNT + CKPT_COUNT + DOC_COUNT))
+```
+
+---
+
+## Step 2: Determine Output Path
+
+- If `$ARGUMENTS` is non-empty: use it as the output path.
+- Otherwise: output path is `AZCLAUDE-MAP.md`.
+
+---
+
+## Step 3: Generate AZCLAUDE-MAP.md
+
+Write the file with these sections. Replace `{DATE}` with today's date (YYYY-MM-DD).
+
+```
+# AZCLAUDE Map
+> Generated: {DATE} — re-run `/obsidian` to refresh.
+
+This is an Obsidian index note. Open this vault in Obsidian to explore the graph view.
+Each wikilink connects to the matching command, agent, skill, template, or memory file.
+
+---
+
+## Commands (installed)
+
+{for each name in $COMMANDS}
+- [[{name}]]
+
+---
+
+## Agents (installed)
+
+{for each name in $AGENTS}
+- [[{name}]]
+
+---
+
+## Skills (installed)
+
+{for each name in $SKILLS}
+- [[.claude/skills/{name}/SKILL|{name}]]
+
+---
+
+## Templates — Commands (source)
+
+{for each name in $TMPL_CMDS}
+- [[templates/commands/{name}|{name} (template)]]
+
+---
+
+## Templates — Agents (source)
+
+{for each name in $TMPL_AGENTS}
+- [[templates/agents/{name}|{name} (template)]]
+
+---
+
+## Memory
+
+{for each name in $MEMORY}
+- [[.claude/memory/{name}|{name}]]
+
+---
+
+## Checkpoints
+
+{for each name in $CHECKPOINTS}
+- [[.claude/memory/checkpoints/{name}|{name}]]
+
+---
+
+## Docs
+
+{for each name in $DOCS}
+- [[{name}]]
+```
+
+Write to the output path. Overwrite existing — idempotent.
+
+---
+
+## Step 4: Print Summary
+
+```
+─── Obsidian Map Written ───────────────────────
+  Output:      {output path}
+  Commands:    {CMD_COUNT} nodes
+  Agents:      {AGENT_COUNT} nodes
+  Skills:      {SKILL_COUNT} nodes
+  Templates:   {TMPL_CMD_COUNT + TMPL_AGENT_COUNT} nodes
+  Memory:      {MEM_COUNT} nodes
+  Checkpoints: {CKPT_COUNT} nodes
+  Docs:        {DOC_COUNT} nodes
+  ─────────────────────────────
+  Total:       {TOTAL} nodes
+────────────────────────────────────────────────
+```
+
+Then print the full wikilink list written.
+
+---
+
+## Completion Rule
+
+Show the actual wikilink list written to the output file. Do not say "map generated" without showing the content.