azclaude-copilot 0.7.0 → 0.7.2

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
     {
       "name": "azclaude",
       "description": "AZCLAUDE is a complete AI coding environment for Claude Code. It installs 40 commands, 10 auto-invoked skills, 15 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.7.0",
+      "version": "0.7.2",
       "source": {
         "source": "github",
         "repo": "haytamAroui/AZ-CLAUDE-COPILOT",

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "azclaude",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "AZCLAUDE is a complete AI coding environment for Claude Code. It installs 40 commands, 10 auto-invoked skills, 15 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",

package/README.md

@@ -637,11 +637,11 @@ AZCLAUDE is a lazy-loaded environment of 48 capability modules. It only loads wh
 
 ## Verified
 
-1868 tests. Every template, command, capability, agent, hook, and CLI feature verified.
+1881 tests. Every template, command, capability, agent, hook, and CLI feature verified.
 
 ```bash
 bash tests/test-features.sh
-# Results: 1868 passed, 0 failed, 1868 total
+# Results: 1881 passed, 0 failed, 1881 total
 ```
 
 ---

package/bin/cli.js

@@ -144,8 +144,8 @@ function buildHookEntries(scriptsDir) {
   return {
     UserPromptSubmit: [{ matcher: '',                           hooks: [{ type: 'command', command: `"${nodeExe}" "${userPromptScript}"` }]  }],
     Stop:             [{ matcher: '',                           hooks: [{ type: 'command', command: `"${nodeExe}" "${stopScript}"` }]         }],
-    PreToolUse:       [{ matcher: 'Write|Edit|MultiEdit',      hooks: [{ type: 'command', command: `"${nodeExe}" "${preToolUseScript}"` }]  }],
-    PostToolUse:      [{ matcher: 'Write|Edit|Read|Bash|Grep', hooks: [{ type: 'command', command: `"${nodeExe}" "${postToolUseScript}"` }] }],
+    PreToolUse:       [{ matcher: '',                           hooks: [{ type: 'command', command: `"${nodeExe}" "${preToolUseScript}"` }]  }],
+    PostToolUse:      [{ matcher: '',                           hooks: [{ type: 'command', command: `"${nodeExe}" "${postToolUseScript}"` }] }],
     Notification:     [{ matcher: '',                           hooks: [{ type: 'command', command: `"${nodeExe}" "${vizScript}"` }]         }],
     SubagentStart:    [{ matcher: '',                           hooks: [{ type: 'command', command: `"${nodeExe}" "${vizScript}"` }]         }],
     SubagentStop:     [{ matcher: '',                           hooks: [{ type: 'command', command: `"${nodeExe}" "${vizScript}"` }]         }],
@@ -1146,7 +1146,10 @@ if (process.argv[2] === 'visualize') {
     console.error('Visualizer not installed. Run: npx azclaude-copilot');
     process.exit(1);
   }
+  const settingsPath = path.join(process.cwd(), vizCfg, 'settings.local.json');
+
   if (action === 'stop') {
+    // 1. Kill server
     const pidFile = path.join(os.tmpdir(), '.azclaude-visualizer.pid');
     if (fs.existsSync(pidFile)) {
       const pid = parseInt(fs.readFileSync(pidFile, 'utf8'), 10);
@@ -1156,8 +1159,22 @@ if (process.argv[2] === 'visualize') {
     } else {
       info('No running visualizer found');
     }
+    // 2. Remove env var from settings.local.json
+    if (fs.existsSync(settingsPath)) {
+      try {
+        const s = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+        if (s.env && s.env.AZCLAUDE_VISUALIZER) {
+          delete s.env.AZCLAUDE_VISUALIZER;
+          if (Object.keys(s.env).length === 0) delete s.env;
+          atomicWriteFileSync(settingsPath, JSON.stringify(s, null, 2));
+          ok('Removed AZCLAUDE_VISUALIZER from settings');
+        }
+      } catch (_) {}
+    }
   } else {
     const port = process.argv[4] || '8765';
+
+    // 1. Start server
     const { spawn } = require('child_process');
     const child = spawn(process.execPath, [serverPath], {
       detached: true, stdio: 'ignore',
@@ -1167,8 +1184,28 @@ if (process.argv[2] === 'visualize') {
     const pidFile = path.join(os.tmpdir(), '.azclaude-visualizer.pid');
     fs.writeFileSync(pidFile, String(child.pid));
     ok(`Visualizer started on port ${port} (PID: ${child.pid})`);
-    info(`Open: http://localhost:${port}`);
-    info(`Set env: AZCLAUDE_VISUALIZER=${port}`);
+
+    // 2. Write AZCLAUDE_VISUALIZER env var into settings.local.json
+    //    Claude Code reads env from here — hooks pick it up automatically
+    let settings = {};
+    if (fs.existsSync(settingsPath)) {
+      try { settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8')); } catch (_) {}
+    }
+    if (!settings.env) settings.env = {};
+    settings.env.AZCLAUDE_VISUALIZER = port;
+    atomicWriteFileSync(settingsPath, JSON.stringify(settings, null, 2));
+    ok(`AZCLAUDE_VISUALIZER=${port} written to settings.local.json`);
+
+    // 3. Open browser (cross-platform)
+    const url = `http://localhost:${port}`;
+    try {
+      const openCmd = process.platform === 'win32' ? `start "" "${url}"`
+        : process.platform === 'darwin' ? `open "${url}"`
+        : `xdg-open "${url}" 2>/dev/null || true`;
+      require('child_process').exec(openCmd);
+    } catch (_) {}
+    ok(`Dashboard: ${url}`);
+    info('Hooks will send events automatically — just open Claude Code and work');
   }
   process.exit(0);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "azclaude-copilot",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "AI coding environment — 40 commands, 10 skills, 15 agents, real-time visualizer, memory, reflexes, evolution. Install: npx azclaude-copilot@latest, then open Claude Code.",
   "bin": {
     "azclaude": "bin/cli.js",

package/templates/CLAUDE.md

@@ -77,11 +77,12 @@ Agents live in `.claude/agents/`. Spawn them via the Agent tool with the matchin
 
 **Mandatory pipeline for ALL code tasks (enforced by hook on every message):**
 1. **ALWAYS** spawn `problem-architect` FIRST → get Team Spec (agents, skills, files, risks)
-2. Follow Team Spec exactly: load listed skills, pre-read listed files, in order
-3. If structural decision flagged → spawn `architecture-advisor` skill or run /debate
-4. Implement following Team Spec patterns
-5. **ALWAYS** spawn `code-reviewer` after implementation
-6. **ALWAYS** spawn `test-writer` if tests are needed
+2. **RELAY**: Pass Team Spec + pre-read file contents to the next agent via `## Pre-loaded Context` block. The receiving agent MUST NOT re-read files listed in that block. See `capabilities/shared/context-relay.md` for role-based filters and size limits.
+3. Follow Team Spec exactly: load listed skills, pre-read listed files, in order
+4. If structural decision flagged → spawn `architecture-advisor` skill or run /debate
+5. Implement following Team Spec patterns
+6. **ALWAYS** spawn `code-reviewer` after implementation
+7. **ALWAYS** spawn `test-writer` if tests are needed
 
 **Skip pipeline only if:** message is a pure question with no action verb (e.g., "what does this function do?").
 **Never skip for:** any code change, no matter how small. The pipeline catches bugs in 1-line changes too.

package/templates/agents/orchestrator.md

@@ -155,11 +155,13 @@ If verdict is `APPROVED` or `APPROVED (no constitution found)`: proceed to Step
 
 Load `capabilities/shared/parallel-coordination.md` first.
 Load `capabilities/shared/context-inoculation.md` and prepend its Required Preamble to every agent prompt below.
+Load `capabilities/shared/context-relay.md` for relay protocol and role-based filters.
 
 1. Write `.claude/ownership.md` table (branch, directories, status) for every agent in this batch
 2. Write `.claude/parallel-wave-state.md` with `dispatch_mode: dag` (see parallel-coordination.md)
-3. **Pre-read shared files** (models, schemas, configs referenced by 2+ agents) and inject their content inline into each agent's prompt — eliminates redundant file reads across agents
-4. Spawn each builder via Task with `isolation: "worktree"` in the same message (true parallel)
+3. **Pre-read shared files** (models, schemas, configs referenced by 2+ agents) and relay their content via a `## Pre-loaded Context` block in each agent's prompt — builders MUST NOT re-read relayed files
+4. If problem-architect returned a `## Relay` section, include it in the builder prompt as-is
+5. Spawn each builder via Task with `isolation: "worktree"` in the same message (true parallel)
 5. Include worktree rules + **test scope** (`Test scope: {test-dir}`) in every parallel prompt
 6. **Merge-on-complete**: as each agent reports done, merge its branch immediately (don't wait for all)
 7. After each merge: check if newly-unblocked milestones exist → dispatch them immediately
@@ -168,6 +170,7 @@ Load `capabilities/shared/context-inoculation.md` and prepend its Required Pream
 **Sequential dispatch (single milestone OR overlapping files):**
 
 Load `capabilities/shared/context-inoculation.md` and prepend its Required Preamble to the agent prompt below.
+Load `capabilities/shared/context-relay.md` for relay protocol and size limits.
 
 Spawn milestone-builder via Task with fully packaged context:
 
@@ -177,25 +180,33 @@ Task: Implement Milestone {N} — {title}
 Agent role: {agent-name from spec} (owns {directories})
 Skills to activate: {skill list from spec}
 
-Pre-read BEFORE writing anything:
-  - {file}: {reason}
-  - {file}: {reason}
+## Pre-loaded Context (do NOT re-read these files)
 
-Pre-conditions verified:
-  - {checklist from spec}
+### Team Spec
+{paste problem-architect's full Team Spec}
+
+### Relay (from problem-architect)
+{paste problem-architect's ## Relay section if present — condensed file contents it already read}
+
+### File contents (pre-read by orchestrator)
+{paste contents of files listed in Team Spec's "Pre-Read Files" that you already have in context}
 
-Conventions (from patterns.md):
-  - {relevant entries}
+### Conventions (from patterns.md)
+{relevant entries}
 
-Anti-patterns (from antipatterns.md):
-  - {relevant entries}
+### Anti-patterns (from antipatterns.md)
+{relevant entries}
 
-Architecture decisions (from decisions.md):
-  - {relevant entries}
+### Architecture decisions (from decisions.md)
+{relevant entries}
+
+Pre-conditions verified:
+  - {checklist from spec}
 
 Complexity: {SIMPLE|MEDIUM|COMPLEX}
 Fix attempts: {2 for SIMPLE/MEDIUM, 3 for COMPLEX}
 
+Only read files NOT listed in Pre-loaded Context.
 When done, report: files changed + test status + new patterns/anti-patterns.
 ```
 

package/templates/agents/problem-architect.md

@@ -161,6 +161,15 @@ YES | NO
 If NO: reason = {specific conflict — shared file, schema dependency, runtime ordering}
 The orchestrator uses this to decide whether to use worktree isolation or sequential dispatch.
 Parallel Safe = YES requires: isolated directories, no shared config/schema, no runtime dependency on a sibling milestone.
+
+### Relay (for milestone-builder — do not re-read)
+{Include condensed contents of key files you read during analysis.
+Only include files the builder will need. Filter by relevance.
+For files >200 lines, include only the relevant section with line ranges.
+Maximum ~4000 tokens for this section.}
+
+### {file-path} (lines N-M)
+{content}
 ```
 </output_format>
 

package/templates/capabilities/manifest.md

@@ -29,6 +29,7 @@ Load only the files that match the current task. Never load the full list.
 | shared/context-inoculation.md | /copilot dispatch, milestone-builder spawn, autonomous agent context — inject anti-reward-hack boundaries (75-90% reduction) | ~120 |
 | shared/reward-hack-detection.md | /audit, /ship, post-milestone review — detect reward hacking patterns in test modifications | ~150 |
 | shared/ultrathink.md | $ARGUMENTS contains --deep, or command needs extended thinking for complex analysis | ~80 |
+| shared/context-relay.md | About to spawn a subagent — pass pre-read files to eliminate redundant reads across agent boundaries | ~300 |
 
 ## Level Builders — load ONE at a time
 | File | When to load | Tokens |

package/templates/capabilities/shared/context-relay.md

@@ -0,0 +1,125 @@
+# Context Relay — Eliminate Redundant Reads Across Agent Boundaries
+
+Every agent spawn is a context boundary. Without relay, each agent re-reads the same files
+its parent already has in context. This wastes 5-15 tool calls per spawn and 20-50k tokens
+per pipeline run.
+
+## The Rule
+
+**When spawning a subagent via Agent() or Task(), include a `## Pre-loaded Context` block
+in the prompt with the relevant files you already read. The subagent MUST NOT re-read
+files listed in this block.**
+
+## What to Relay
+
+Pass context **filtered by the subagent's role**. Not everything — just what this agent needs.
+
+### Role-based relay filters
+
+| Subagent | Relay these | Skip these |
+|----------|------------|------------|
+| problem-architect | CLAUDE.md identity + rules, goals.md current threads, file list from recent reads | Full checkpoint, session history |
+| milestone-builder | Team Spec (from problem-architect), file contents listed in `Files:`, patterns relevant to this milestone | Other milestones' files, decisions.md |
+| code-reviewer | The diff (what changed), relevant test patterns, CLAUDE.md rules section | Goals, checkpoints, deployment config |
+| test-writer | Source file under test, existing test file patterns (first 20 lines), test framework config | Goals, security rules, deployment |
+| security-auditor | Files being reviewed, security patterns from CLAUDE.md | Test patterns, frontend config |
+| orchestrator | plan.md, goals.md, constitution.md non-negotiables | Individual file contents (too large) |
+
+### Size limits
+
+- Maximum relay block: **4000 tokens** (~3000 words)
+- If the content exceeds this, summarize: include file paths + key findings, not raw content
+- File contents: include only the **relevant section**, not the full file
+- For large files (>200 lines): include line range references (`file.ts:45-120`) instead of content
+
+## Protocol
+
+### For commands (/add, /fix, /refactor)
+
+When the command reads files to understand context, and then spawns a subagent:
+
+```
+Spawn Agent(subagent_type="problem-architect") with this prompt:
+  "Task: {description}
+
+  ## Pre-loaded Context
+  The following files were already read. Do NOT re-read them.
+
+  ### CLAUDE.md (rules section)
+  {paste rules section only — not the full file}
+
+  ### Current goals
+  {paste goals.md current threads — not done history}
+
+  ### Relevant source files
+  {paste key file sections already in your context}
+  "
+```
+
+### For orchestrator → milestone-builder
+
+The orchestrator already reads plan.md and gets Team Specs from problem-architect.
+When dispatching a milestone-builder:
+
+```
+Task: Implement milestone M3 — {title}
+
+## Pre-loaded Context (do NOT re-read these)
+
+### Team Spec (from problem-architect)
+{paste the full Team Spec for this milestone}
+
+### File contents (pre-read by orchestrator)
+{paste contents of files listed in Team Spec's "Files to pre-read"}
+
+### Project patterns
+{paste relevant patterns from CLAUDE.md or patterns.md}
+
+## Instructions
+Implement the milestone. You have all the context you need above.
+Only read files NOT listed in Pre-loaded Context.
+```
+
+### For problem-architect → return relay data
+
+When problem-architect returns a Team Spec, it SHOULD include a `## Relay` section
+with condensed file contents it read during analysis:
+
+```
+## Relay (for milestone-builder — do not re-read)
+### src/auth/jwt.ts (lines 1-45)
+{content}
+### src/types/user.ts (full file, 30 lines)
+{content}
+```
+
+The orchestrator passes this relay block directly into the milestone-builder's prompt.
+
+## What NOT to relay
+
+- **Mutable state** — goals.md "In progress" section changes between agent spawns
+- **Large binary/config files** — package-lock.json, node_modules paths
+- **Full git history** — pass only the relevant commit message or diff
+- **Other agents' results** — unless explicitly needed (e.g., code-reviewer's findings for a fix)
+
+## Anti-patterns
+
+1. **Relay everything** — bloats the subagent prompt, wastes tokens on irrelevant context
+2. **Relay nothing** — status quo, each agent re-reads 5-15 files
+3. **Relay stale data** — if a file was modified between parent read and agent spawn, the relay is wrong. Only relay files that won't change during this pipeline run.
+4. **Skip the filter** — sending a code-reviewer the full decisions.md when it only needs the diff
+
+## Measuring impact
+
+Before context-relay:
+- problem-architect: ~8 Read calls to understand the project
+- milestone-builder: ~6 Read calls to re-read what problem-architect already read
+- code-reviewer: ~4 Read calls for CLAUDE.md + patterns + the files under review
+- Total per /add pipeline: ~18 Read calls, ~40k tokens on re-reads
+
+After context-relay:
+- problem-architect: ~8 Read calls (unchanged — it's the first reader)
+- milestone-builder: ~1-2 Read calls (only files not in relay)
+- code-reviewer: ~1 Read call (only the diff, everything else relayed)
+- Total per /add pipeline: ~11 Read calls, ~15k tokens on re-reads
+- **Savings: ~40% fewer reads, ~60% fewer re-read tokens**

package/templates/capabilities/shared/intelligent-dispatch.md

@@ -42,11 +42,20 @@ Available skills: {output of: ls .claude/skills/ 2>/dev/null}
 |-------|--------|
 | Skills to Load | Load each skill before implementing |
 | Pre-Read Files | Read every file listed, in order: schema → source → tests → patterns → antipatterns |
+| Relay | Pass directly to builder prompt (see below) |
 | Pre-Conditions | Verify each; STOP if any unmet |
 | Files Written | Note for parallel safety — no concurrent work on same files |
 | Structural Decision: YES | Run /debate before proceeding; log result to `.claude/memory/decisions.md` |
 | Risks | Read mitigation; apply to implementation approach |
 
+### Context Relay — Eliminate Redundant Reads
+
+After reading pre-read files, if spawning a builder agent:
+1. Include a `## Pre-loaded Context` block in the builder's prompt with file contents you already read
+2. Filter by the builder's role — see `capabilities/shared/context-relay.md` for role-based filters and size limits
+3. The spawned agent **MUST NOT** re-read files listed in the Pre-loaded Context block
+4. If problem-architect returned a `## Relay` section, pass it directly into the builder prompt
+
 ---
 
 ## Implementation Protocol (milestone-builder)

package/templates/capabilities/shared/parallel-coordination.md

@@ -83,7 +83,7 @@ Do NOT push to origin. Commit locally only.
 Report branch name in completion message.
 
 ## Pre-loaded Context (do NOT re-read these files)
-{orchestrator pre-reads shared files and injects content here}
+{orchestrator pre-reads shared files and relays content here — see context-relay.md for role-based filters and size limits}
 
 {standard milestone context from orchestrator Step 4}
 ```

package/templates/hooks/post-tool-use.js

@@ -24,11 +24,19 @@ let filePath = '';
 let changeSummary = '';
 let toolName = '';
 let toolOutput = '';
+let _rawInput  = null;
+let _agentId   = null;
+let _agentType = null;
+let _toolUseId = null;
 try {
   const raw  = fs.readFileSync(0, 'utf8'); // fd 0 = stdin, cross-platform
   const data = JSON.parse(raw);
   toolName   = data.tool_name || '';
   filePath   = data.tool_input?.file_path || data.tool_input?.path || data.tool_input?.command || '';
+  _rawInput  = data.tool_input || null;
+  _agentId   = data.agent_id || null;
+  _agentType = data.agent_type || null;
+  _toolUseId = data.tool_use_id || null;
   // Extract change summary from old_string/new_string diff hint (Edit tool)
   // MultiEdit: edits[] array — use first edit's new_string
   const oldStr = data.tool_input?.old_string || data.tool_input?.edits?.[0]?.old_string || '';
@@ -47,6 +55,36 @@ try {
 // Also accept env var fallback (older Claude Code versions)
 if (!filePath) filePath = process.env.CLAUDE_FILE_PATH || '';
 
+// ── Forward full hook event to visualizer (so dashboard shows tool results) ──
+if (process.env.AZCLAUDE_VISUALIZER && toolName) {
+  try {
+    const vPort = parseInt(process.env.AZCLAUDE_VISUALIZER, 10) || 8765;
+    let vizId = _toolUseId || null;
+    if (!vizId) {
+      const vizIdPath = path.join(os.tmpdir(), `.azclaude-vizid-${process.ppid || process.pid}`);
+      try { vizId = fs.readFileSync(vizIdPath, 'utf8').trim(); } catch (_) {}
+    }
+    const fwd = JSON.stringify({
+      hook_event_name: 'PostToolUse',
+      tool_name: toolName,
+      tool_input: _rawInput,
+      tool_response: toolOutput ? toolOutput.slice(0, 2000) : null,
+      tool_use_id: vizId,
+      session_id: String(process.ppid || process.pid),
+      agent_id: _agentId,
+      agent_type: _agentType,
+    });
+    const vReq = require('http').request(
+      { hostname: '127.0.0.1', port: vPort, path: '/event', method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(fwd) } },
+      () => {}
+    );
+    vReq.setTimeout(1500, () => vReq.destroy());
+    vReq.on('error', () => {});
+    vReq.end(fwd);
+  } catch (_) {}
+}
+
 const cfg       = process.env.AZCLAUDE_CFG || '.claude';
 // Guard: cfg must resolve inside the project root
 if (path.resolve(cfg).indexOf(process.cwd()) !== 0) process.exit(0);

package/templates/hooks/pre-tool-use.js

@@ -14,16 +14,24 @@ const path = require('path');
 const os   = require('os');
 
 // ── Parse stdin ──────────────────────────────────────────────────────────────
-let toolName = '';
-let filePath = '';
-let content  = '';
-let command  = '';
+let toolName  = '';
+let filePath  = '';
+let content   = '';
+let command   = '';
+let _rawInput = null;  // full tool_input for visualizer
+let _agentId  = null;
+let _agentType = null;
+let _toolUseId = null;
 try {
   const raw  = fs.readFileSync(0, 'utf8'); // fd 0 = stdin
   const data = JSON.parse(raw);
   toolName   = data.tool_name || '';
   filePath   = data.tool_input?.file_path || data.tool_input?.path || '';
   command    = data.tool_input?.command || '';
+  _rawInput  = data.tool_input || null;
+  _agentId   = data.agent_id || null;
+  _agentType = data.agent_type || null;
+  _toolUseId = data.tool_use_id || null;
   // Edit uses new_string; Write/MultiEdit use content
   content    = data.tool_input?.new_string || data.tool_input?.content || '';
   // MultiEdit: scan all edits
@@ -34,6 +42,32 @@ try {
   process.exit(0); // malformed JSON — stay out of the way
 }
 
+// ── Forward full hook event to visualizer (so dashboard shows tool cards) ────
+if (process.env.AZCLAUDE_VISUALIZER && toolName) {
+  try {
+    const vPort = parseInt(process.env.AZCLAUDE_VISUALIZER, 10) || 8765;
+    const vizId = _toolUseId || `pre-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const fwd = JSON.stringify({
+      hook_event_name: 'PreToolUse',
+      tool_name: toolName,
+      tool_input: _rawInput,
+      tool_use_id: vizId,
+      session_id: String(process.ppid || process.pid),
+      agent_id: _agentId,
+      agent_type: _agentType,
+    });
+    try { fs.writeFileSync(path.join(os.tmpdir(), `.azclaude-vizid-${process.ppid || process.pid}`), vizId); } catch (_) {}
+    const vReq = require('http').request(
+      { hostname: '127.0.0.1', port: vPort, path: '/event', method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(fwd) } },
+      () => {}
+    );
+    vReq.setTimeout(1500, () => vReq.destroy());
+    vReq.on('error', () => {});
+    vReq.end(fwd);
+  } catch (_) {}
+}
+
 // ── Session security event log (shared with post-tool-use, stop) ─────────────
 const _secSid     = process.ppid || process.pid;
 const _seclogPath = path.join(os.tmpdir(), `.azclaude-seclog-${_secSid}`);