@hailer/mcp 1.0.29 → 1.1.3

package/.claude/hooks/publish-template-guard.cjs

@@ -33,6 +33,22 @@
  * </workflow>
  */
 
+const fs = require('fs');
+const path = require('path');
+
+// Skip in yolo mode
+try {
+  const statePath = path.join(process.env.CLAUDE_PROJECT_DIR || process.cwd(), '.claude', 'yolo-state.json');
+  const state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+  if (state.mode === 'yolo') process.exit(0);
+} catch {}
+
+// Skip in subagent context - subagents can't use AskUserQuestion to recover
+if (process.env.CLAUDE_AGENT_ID || process.env.CLAUDE_SUBAGENT) {
+  console.log(JSON.stringify({ decision: 'allow' }));
+  process.exit(0);
+}
+
 // Read hook input from stdin
 let input = '';
 process.stdin.setEncoding('utf8');

package/.claude/hooks/session-start.cjs

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+/**
+ * SessionStart hook - auto-loads SESSION-HANDOFF.md into context.
+ * Eliminates the need to manually run /recap at session start.
+ */
+const fs = require('fs');
+const path = require('path');
+
+// Consume stdin (required by hook protocol)
+try { fs.readFileSync('/dev/stdin', 'utf8'); } catch (e) { /* stdin may be empty or closed */ }
+const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+
+const files = [
+  { name: 'SESSION-HANDOFF.md', label: 'Session Handoff' },
+  { name: 'DEVELOPMENT.md', label: 'Project Status' }
+];
+
+const sections = [];
+
+for (const file of files) {
+  const filePath = path.join(projectDir, file.name);
+  if (fs.existsSync(filePath)) {
+    const content = fs.readFileSync(filePath, 'utf8').trim();
+    if (content) {
+      sections.push(`## ${file.label}\n\n${content}`);
+    }
+  }
+}
+
+if (sections.length > 0) {
+  const context = `# Auto-loaded Project Context\n\n${sections.join('\n\n---\n\n')}`;
+  console.log(JSON.stringify({ additionalContext: context }));
+} else {
+  console.log(JSON.stringify({}));
+}

package/.claude/hooks/shared-memory-writer.cjs

@@ -0,0 +1,147 @@
+#!/usr/bin/env node
+/**
+ * <hook-name>shared-memory-writer</hook-name>
+ *
+ * <purpose>
+ * Auto-caches Kenji agent results into shared memory for squad reuse.
+ * Watches PostToolUse:Task for Kenji completions, parses schema data,
+ * and writes to .shared-memory.json so subsequent squads skip redundant lookups.
+ * </purpose>
+ *
+ * <triggers>
+ * - PostToolUse on Task
+ * - Only when subagent_type is "agent-kenji-data-reader"
+ * - Only when response contains workflow schema data
+ * </triggers>
+ *
+ * <behavior>
+ * 1. Detects Kenji agent completions
+ * 2. Parses response for workflow schema data (workflow IDs, field lists, phases)
+ * 3. Writes to shared memory under "workflow-schemas" key
+ * 4. Non-blocking: outputs to stderr, never blocks the tool call
+ * </behavior>
+ */
+
+// Skip if stdin is TTY (no piped input)
+if (process.stdin.isTTY) {
+  process.exit(0);
+}
+
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => input += chunk);
+process.stdin.on('end', () => {
+  try {
+    const data = JSON.parse(input);
+    processHook(data);
+  } catch (e) {
+    console.error(`[shared-memory-writer] Failed to parse input: ${e.message}`);
+    process.exit(0);
+  }
+});
+
+function processHook(data) {
+  const { tool_name, tool_input, tool_response } = data;
+
+  // Only process Task tool calls
+  if (tool_name !== 'Task') {
+    process.exit(0);
+  }
+
+  // Only process Kenji agent completions
+  const agentName = tool_input?.subagent_type;
+  if (agentName !== 'agent-kenji-data-reader') {
+    process.exit(0);
+  }
+
+  const responseText = typeof tool_response === 'string'
+    ? tool_response
+    : JSON.stringify(tool_response || '');
+
+  // Check if response contains schema-like data
+  if (!containsSchemaData(responseText)) {
+    console.error('[shared-memory-writer] Kenji response has no schema data, skipping cache.');
+    process.exit(0);
+  }
+
+  // Write to shared memory
+  try {
+    const mem = require('./_shared-memory.cjs');
+    const existing = mem.get('workflow-schemas');
+
+    // Merge with existing data if present, or write fresh
+    const schemaData = extractSchemaData(responseText);
+
+    if (existing && existing.data) {
+      // Merge: keep existing entries, add/overwrite with new ones
+      const merged = { ...existing.data, ...schemaData, lastUpdated: new Date().toISOString() };
+      mem.set('workflow-schemas', merged, 'agent-kenji-data-reader');
+      console.error(`[shared-memory-writer] Merged Kenji schema data into shared memory (${Object.keys(schemaData).length} keys).`);
+    } else {
+      schemaData.lastUpdated = new Date().toISOString();
+      mem.set('workflow-schemas', schemaData, 'agent-kenji-data-reader');
+      console.error(`[shared-memory-writer] Cached Kenji schema data to shared memory (${Object.keys(schemaData).length} keys).`);
+    }
+  } catch (e) {
+    console.error(`[shared-memory-writer] Failed to cache: ${e.message}`);
+  }
+
+  process.exit(0);
+}
+
+/**
+ * Check if response contains workflow schema data indicators.
+ */
+function containsSchemaData(text) {
+  const lower = text.toLowerCase();
+  const indicators = [
+    'workflow',
+    'field',
+    'phase',
+    'processid',
+    'fieldid',
+    'phaseid',
+    'fields.ts',
+    'phases.ts',
+    'workflows.ts'
+  ];
+
+  let matches = 0;
+  for (const indicator of indicators) {
+    if (lower.includes(indicator)) matches++;
+  }
+
+  // Need at least 2 schema indicators to be considered schema data
+  return matches >= 2;
+}
+
+/**
+ * Extract structured schema data from Kenji's response.
+ * Stores the raw response keyed by identifiable workflow references.
+ */
+function extractSchemaData(text) {
+  const data = { _rawResponse: text };
+
+  // Try to parse as JSON first (Kenji often returns JSON)
+  try {
+    const parsed = JSON.parse(text);
+    if (parsed.result) {
+      data._parsed = parsed.result;
+    } else if (parsed.data) {
+      data._parsed = parsed.data;
+    } else {
+      data._parsed = parsed;
+    }
+  } catch {
+    // Not JSON - that's fine, the raw text is still useful context
+  }
+
+  // Extract workflow IDs mentioned (patterns like 24-char hex strings)
+  const workflowIdPattern = /[0-9a-f]{24}/g;
+  const ids = text.match(workflowIdPattern);
+  if (ids) {
+    data._workflowIds = [...new Set(ids)];
+  }
+
+  return data;
+}

package/.claude/hooks/skill-injector.cjs

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+/**
+ * <hook-name>skill-injector</hook-name>
+ * <purpose>Auto-injects skill content into subagent context via SubagentStart</purpose>
+ * <triggers>SubagentStart</triggers>
+ *
+ * Problem: Agents have skills listed in frontmatter but never actually call
+ * the Skill tool. This hook reads the agent's frontmatter `skills:` list
+ * and injects skill content via additionalContext when the subagent starts.
+ *
+ * Uses SubagentStart hook event with additionalContext (not PreToolUse updatedInput).
+ *
+ * Hook type: SubagentStart
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const PROJECT_DIR = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const AGENTS_DIR = path.join(PROJECT_DIR, '.claude', 'agents');
+const SKILLS_DIR = path.join(PROJECT_DIR, '.claude', 'skills');
+
+// Skip if stdin is TTY
+if (process.stdin.isTTY) {
+  console.log(JSON.stringify({}));
+  process.exit(0);
+}
+
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => input += chunk);
+process.stdin.on('end', () => {
+  try {
+    const data = JSON.parse(input);
+    processHook(data);
+  } catch (e) {
+    console.error(`[skill-injector] Parse error: ${e.message}`);
+    console.log(JSON.stringify({}));
+    process.exit(0);
+  }
+});
+
+/**
+ * Parse skills: list from agent frontmatter
+ */
+function getAgentSkills(agentType) {
+  const agentFile = path.join(AGENTS_DIR, `${agentType}.md`);
+  if (!fs.existsSync(agentFile)) {
+    return [];
+  }
+
+  try {
+    const content = fs.readFileSync(agentFile, 'utf8');
+    const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!fmMatch) return [];
+
+    const frontmatter = fmMatch[1];
+    const skills = [];
+    let inSkills = false;
+
+    for (const line of frontmatter.split('\n')) {
+      if (line.match(/^skills:\s*$/)) {
+        inSkills = true;
+        continue;
+      }
+      if (inSkills) {
+        const skillMatch = line.match(/^\s+-\s+(.+)$/);
+        if (skillMatch) {
+          skills.push(skillMatch[1].trim());
+        } else {
+          break;
+        }
+      }
+    }
+
+    return skills;
+  } catch (e) {
+    console.error(`[skill-injector] Error reading ${agentFile}: ${e.message}`);
+    return [];
+  }
+}
+
+/**
+ * Read skill content from SKILL.md
+ */
+function readSkillContent(skillName) {
+  const skillFile = path.join(SKILLS_DIR, skillName, 'SKILL.md');
+  if (!fs.existsSync(skillFile)) {
+    return null;
+  }
+
+  try {
+    const content = fs.readFileSync(skillFile, 'utf8');
+    // Limit to 20KB per skill to avoid bloating context
+    if (content.length > 20000) {
+      return content.substring(0, 20000) + '\n\n[... truncated at 20KB ...]';
+    }
+    return content;
+  } catch (e) {
+    console.error(`[skill-injector] Error reading skill ${skillName}: ${e.message}`);
+    return null;
+  }
+}
+
+function processHook(data) {
+  const agentType = data.agent_type || '';
+
+  // Get skills for this agent type
+  const skills = getAgentSkills(agentType);
+  if (skills.length === 0) {
+    console.log(JSON.stringify({}));
+    process.exit(0);
+  }
+
+  // Load skill contents
+  const skillBlocks = [];
+  for (const skillName of skills) {
+    const content = readSkillContent(skillName);
+    if (content) {
+      skillBlocks.push(`<skill name="${skillName}">\n${content}\n</skill>`);
+    }
+  }
+
+  if (skillBlocks.length === 0) {
+    console.log(JSON.stringify({}));
+    process.exit(0);
+  }
+
+  const skillSection = `<injected-skills>\nThe following skills have been auto-loaded based on your agent configuration. Use this knowledge for your task.\n\n${skillBlocks.join('\n\n')}\n</injected-skills>`;
+
+  console.error(`[skill-injector] Injected ${skillBlocks.length} skill(s) into ${agentType}: ${skills.join(', ')}`);
+
+  console.log(JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: 'SubagentStart',
+      additionalContext: skillSection
+    }
+  }));
+  process.exit(0);
+}

package/.claude/hooks/skill-usage-logger.cjs

@@ -0,0 +1,258 @@
+#!/usr/bin/env node
+/**
+ * <hook-name>skill-usage-logger</hook-name>
+ *
+ * <purpose>
+ * Logs every skill load for analytics - which skills are used, by which agents, in which projects.
+ * </purpose>
+ *
+ * <triggers>
+ * - PostToolUse on Skill
+ * </triggers>
+ *
+ * <log-file>$CLAUDE_PROJECT_DIR/inbox/skill-usage.jsonl</log-file>
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const LOG_FILE = path.join(
+  process.env.HAILER_INBOX_DIR || path.join(process.env.CLAUDE_PROJECT_DIR || process.cwd(), 'inbox'),
+  'skill-usage.jsonl'
+);
+
+// Read hook input from stdin
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => input += chunk);
+process.stdin.on('end', () => {
+  try {
+    const data = JSON.parse(input);
+    processHook(data);
+  } catch (e) {
+    console.error(`[skill-usage-logger] Failed to parse input: ${e.message}`);
+    process.exit(0);
+  }
+});
+
+/**
+ * Detect if running in subagent context from transcript_path
+ * Subagent paths contain /subagents/
+ * Returns: { isSubagent: boolean, agentName: string | null }
+ */
+function detectSubagentContext(transcriptPath) {
+  if (!transcriptPath) {
+    return { isSubagent: false, agentName: null };
+  }
+
+  // Subagent paths look like: .../{session_id}/subagents/agent-{agent_id}.jsonl
+  if (transcriptPath.includes('/subagents/')) {
+    // Extract agent name from path
+    const match = transcriptPath.match(/subagents\/([^/]+)\.jsonl$/);
+    if (match) {
+      // Clean up agent ID - might be like "agent-a7004fa" or full name
+      return { isSubagent: true, agentName: match[1] };
+    }
+    return { isSubagent: true, agentName: 'unknown' };
+  }
+
+  return { isSubagent: false, agentName: null };
+}
+
+function processHook(data) {
+  const { tool_name, tool_input, tool_response, transcript_path } = data;
+
+  // Only process Skill tool
+  if (tool_name !== 'Skill') {
+    process.exit(0);
+  }
+
+  // Extract skill name from tool_input
+  const skillName = tool_input?.skill || tool_input?.command || 'unknown';
+  const skillArgs = tool_input?.args || null;
+
+  // Detect subagent context
+  const { isSubagent, agentName } = detectSubagentContext(transcript_path);
+
+  // Get project from env or cwd
+  const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  const project = path.basename(projectDir);
+
+  const entry = {
+    ts: new Date().toISOString(),
+    skill: skillName,
+    agent: isSubagent ? agentName : 'orchestrator',
+    isSubagent,
+    project,
+    args: skillArgs
+  };
+
+  try {
+    // Ensure directory exists
+    const logDir = path.dirname(LOG_FILE);
+    if (!fs.existsSync(logDir)) {
+      fs.mkdirSync(logDir, { recursive: true });
+    }
+
+    fs.appendFileSync(LOG_FILE, JSON.stringify(entry) + '\n');
+  } catch (err) {
+    console.error(`[skill-usage-logger] Could not write: ${err.message}`);
+  }
+
+  process.exit(0);
+}
+
+// CLI: Show recent skill loads
+if (process.argv[2] === '--recent' || process.argv[2] === '-r') {
+  const limit = parseInt(process.argv[3]) || 20;
+
+  if (!fs.existsSync(LOG_FILE)) {
+    console.log('No skill usage data yet');
+    process.exit(0);
+  }
+
+  const lines = fs.readFileSync(LOG_FILE, 'utf8').trim().split('\n');
+  const recent = lines.slice(-limit);
+
+  console.log(`Last ${recent.length} skill loads:\n`);
+  console.log('Time'.padEnd(10) + 'Skill'.padEnd(30) + 'Agent'.padEnd(20) + 'Project');
+  console.log('-'.repeat(75));
+
+  for (const line of recent) {
+    try {
+      const entry = JSON.parse(line);
+      const time = entry.ts.split('T')[1].split('.')[0];
+      const agent = entry.isSubagent ? entry.agent : 'orchestrator';
+      console.log(`${time.padEnd(10)}${entry.skill.padEnd(30)}${agent.padEnd(20)}${entry.project}`);
+    } catch {}
+  }
+  process.exit(0);
+}
+
+// CLI: Show stats by skill
+if (process.argv[2] === '--stats' || process.argv[2] === '-s') {
+  if (!fs.existsSync(LOG_FILE)) {
+    console.log('No skill usage data yet');
+    process.exit(0);
+  }
+
+  const lines = fs.readFileSync(LOG_FILE, 'utf8').trim().split('\n');
+  const skillStats = {};
+  const agentSkills = {};
+
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+
+      // Count by skill
+      if (!skillStats[entry.skill]) {
+        skillStats[entry.skill] = { total: 0, byOrchestrator: 0, bySubagent: 0 };
+      }
+      skillStats[entry.skill].total++;
+      if (entry.isSubagent) {
+        skillStats[entry.skill].bySubagent++;
+      } else {
+        skillStats[entry.skill].byOrchestrator++;
+      }
+
+      // Track which agents use which skills
+      if (entry.isSubagent && entry.agent) {
+        if (!agentSkills[entry.agent]) {
+          agentSkills[entry.agent] = new Set();
+        }
+        agentSkills[entry.agent].add(entry.skill);
+      }
+    } catch {}
+  }
+
+  console.log('Skill Usage Stats:\n');
+  console.log('Skill'.padEnd(35) + 'Total'.padEnd(8) + 'Orch'.padEnd(8) + 'Subagent');
+  console.log('-'.repeat(60));
+
+  const sorted = Object.entries(skillStats).sort((a, b) => b[1].total - a[1].total);
+  for (const [skill, s] of sorted) {
+    console.log(`${skill.padEnd(35)}${String(s.total).padEnd(8)}${String(s.byOrchestrator).padEnd(8)}${s.bySubagent}`);
+  }
+
+  console.log('-'.repeat(60));
+  console.log(`Total: ${lines.length} skill loads\n`);
+
+  // Show agent -> skill mapping
+  if (Object.keys(agentSkills).length > 0) {
+    console.log('Skills by Agent:\n');
+    for (const [agent, skills] of Object.entries(agentSkills)) {
+      console.log(`  ${agent}: ${[...skills].join(', ')}`);
+    }
+  }
+
+  process.exit(0);
+}
+
+// CLI: Show unused skills (skills in .claude/skills/ not in log)
+if (process.argv[2] === '--unused' || process.argv[2] === '-u') {
+  const skillsDir = path.join(process.cwd(), '.claude', 'skills');
+
+  if (!fs.existsSync(skillsDir)) {
+    console.log('No .claude/skills/ directory found');
+    process.exit(0);
+  }
+
+  // Get all skill directories
+  const allSkills = fs.readdirSync(skillsDir, { withFileTypes: true })
+    .filter(d => d.isDirectory())
+    .map(d => d.name);
+
+  // Get used skills from log
+  const usedSkills = new Set();
+  if (fs.existsSync(LOG_FILE)) {
+    const lines = fs.readFileSync(LOG_FILE, 'utf8').trim().split('\n');
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        usedSkills.add(entry.skill);
+      } catch {}
+    }
+  }
+
+  const unused = allSkills.filter(s => !usedSkills.has(s));
+
+  if (unused.length === 0) {
+    console.log('All skills have been used at least once!');
+  } else {
+    console.log(`Unused skills (${unused.length}):\n`);
+    for (const skill of unused.sort()) {
+      console.log(`  - ${skill}`);
+    }
+  }
+
+  process.exit(0);
+}
+
+// CLI: Clear log
+if (process.argv[2] === '--clear') {
+  if (fs.existsSync(LOG_FILE)) {
+    fs.unlinkSync(LOG_FILE);
+    console.log('✓ Skill usage log cleared');
+  } else {
+    console.log('No log file to clear');
+  }
+  process.exit(0);
+}
+
+// CLI: Help
+if (process.argv[2] === '--help' || process.argv[2] === '-h') {
+  console.log(`
+Skill Usage Logger - Track skill loads by agents
+
+Usage:
+  node skill-usage-logger.cjs --recent [N]   Show last N skill loads (default 20)
+  node skill-usage-logger.cjs --stats        Show usage statistics
+  node skill-usage-logger.cjs --unused       Show skills never loaded
+  node skill-usage-logger.cjs --clear        Clear the log
+  node skill-usage-logger.cjs --help         Show this help
+
+Log file: ${LOG_FILE}
+`);
+  process.exit(0);
+}

package/.claude/hooks/src-edit-guard.cjs

@@ -37,9 +37,24 @@
 
 const fs = require('fs');
 const path = require('path');
+const os = require('os');
+
+// Skip in yolo mode
+try {
+  const statePath = path.join(process.env.CLAUDE_PROJECT_DIR || process.cwd(), '.claude', 'yolo-state.json');
+  const state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+  if (state.mode === 'yolo') process.exit(0);
+} catch {}
+
+// Skip in subagent context - subagents can't use AskUserQuestion or Bash to recover
+if (process.env.CLAUDE_AGENT_ID || process.env.CLAUDE_SUBAGENT) {
+  console.log(JSON.stringify({ decision: 'allow' }));
+  process.exit(0);
+}
 
 // UNIFIED: Use same builder mode file as app-edit-guard.cjs
-const BUILDER_MODE_FILE = '/tmp/.claude-builder-agent-active';
+const TEMP_DIR = os.tmpdir();
+const BUILDER_MODE_FILE = path.join(TEMP_DIR, '.claude-builder-agent-active');
 
 // Read hook input from stdin
 let input = '';