@thanhthi2895/luna-ai 2.16.2

package/agentic/claude/.claude/hooks/skill-loaded-notify.cjs

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+/**
+ * skill-loaded-notify.cjs — Luna PostToolUse Hook (Skill)
+ *
+ * Fires: After Skill tool executes
+ * Purpose: Inject a visible "Skill activated" notification into context
+ *
+ * Payload (PostToolUse): { tool_name, tool_input: { skill, args? } }
+ *
+ * Exit Codes: 0 (non-blocking)
+ */
+'use strict';
+
+try {
+  const fs = require('fs');
+  const { isHookEnabled } = require('./lib/luna-config-utils.cjs');
+
+  if (!isHookEnabled('skill-loaded-notify')) process.exit(0);
+
+  const stdin = fs.readFileSync(0, 'utf-8').trim();
+  if (!stdin) process.exit(0);
+
+  const payload = JSON.parse(stdin);
+  if (payload.tool_name !== 'Skill') process.exit(0);
+
+  const skillName = payload.tool_input?.skill || 'unknown';
+  const args = payload.tool_input?.args ? ` ${payload.tool_input.args}` : '';
+
+  console.log(`✅ Skill activated: **${skillName}**${args}`);
+  process.exit(0);
+} catch {
+  process.exit(0); // fail-open
+}

package/agentic/claude/.claude/hooks/subagent-init.cjs

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+/**
+ * subagent-init.cjs — Luna SubagentStart Hook
+ *
+ * Fires: When a subagent (Task tool call) is started
+ * Purpose: Inject minimal context to subagents (~200 tokens)
+ *   - Active plan path, reports path, naming pattern
+ *   - Core rules (YAGNI/KISS/DRY)
+ *   - Language settings
+ *
+ * Exit Codes: 0 (non-blocking)
+ */
+
+// Crash wrapper
+try {
+  const fs = require('fs');
+  const path = require('path');
+
+  const {
+    loadConfig,
+    resolvePlanPath,
+    getReportsPath,
+    resolveNamingPattern,
+    isHookEnabled
+  } = require('./lib/luna-config-utils.cjs');
+
+  const { getGitBranch } = require('./lib/project-detector.cjs');
+
+  if (!isHookEnabled('subagent-init')) process.exit(0);
+
+  async function main() {
+    try {
+      const stdin = fs.readFileSync(0, 'utf-8').trim();
+      if (!stdin) process.exit(0);
+
+      const payload = JSON.parse(stdin);
+      const agentType = payload.agent_type || 'unknown';
+      const agentId = payload.agent_id || 'unknown';
+
+      const effectiveCwd = payload.cwd?.trim() || process.cwd();
+      const config = loadConfig({
+        cwd: effectiveCwd,
+        includeGlobal: true,
+        searchParents: true,
+        maxParentDepth: 3,
+      });
+
+      const gitBranch = getGitBranch(effectiveCwd);
+      const baseDir = effectiveCwd;
+
+      const sessionId = payload.session_id || process.env.LUNA_SESSION_ID || null;
+      const resolved = resolvePlanPath(sessionId, config);
+      const reportsPath = getReportsPath(resolved.path, config);
+
+      const activePlan = resolved.path || '';
+      const namePattern = resolveNamingPattern(config.plan);
+      const plansPath = path.join(baseDir, config.paths?.plans || 'plans');
+      const docsPath = path.join(baseDir, config.paths?.docs || 'docs');
+
+      const thinkingLang = config.locale?.thinkingLanguage || '';
+      const responseLang = config.locale?.responseLanguage || '';
+
+      const lines = [];
+
+      // Subagent identification
+      lines.push(`## Subagent: ${agentType}`);
+      lines.push(`ID: ${agentId} | CWD: ${effectiveCwd}`);
+      lines.push('');
+
+      // Plan context
+      lines.push('## Context');
+      if (activePlan) {
+        lines.push(`- Plan: ${activePlan}`);
+      } else {
+        lines.push('- Plan: none');
+      }
+      lines.push(`- Reports: ${reportsPath}`);
+      lines.push(`- Paths: ${plansPath}/ | ${docsPath}/`);
+      lines.push('');
+
+      // Language
+      if (thinkingLang || responseLang) {
+        lines.push('## Language');
+        if (thinkingLang) lines.push(`- Thinking: Use ${thinkingLang} for reasoning.`);
+        if (responseLang) lines.push(`- Response: Respond in ${responseLang}.`);
+        lines.push('');
+      }
+
+      // Core rules (minimal)
+      lines.push('## Rules');
+      lines.push('- YAGNI / KISS / DRY');
+      lines.push('- Concise, list unresolved questions at end of report');
+      lines.push('- Reports → ' + reportsPath);
+      lines.push('- See ${CLAUDE_CONFIG_DIR:-~/.claude}/rules/development-rules.md for full rules');
+
+      // Naming
+      lines.push('');
+      lines.push('## Naming');
+      lines.push(`- Report: ${path.join(reportsPath, `${agentType}-${namePattern}.md`)}`);
+      lines.push(`- Plan dir: ${path.join(plansPath, namePattern)}/`);
+
+      const output = {
+        hookSpecificOutput: {
+          hookEventName: 'SubagentStart',
+          additionalContext: lines.join('\n')
+        }
+      };
+
+      console.log(JSON.stringify(output));
+      process.exit(0);
+    } catch (error) {
+      console.error(`[subagent-init] Error: ${error.message}`);
+      process.exit(0);
+    }
+  }
+
+  main();
+} catch (e) {
+  try {
+    const fs = require('fs');
+    const p = require('path');
+    const logDir = p.join(__dirname, '.logs');
+    if (!fs.existsSync(logDir)) fs.mkdirSync(logDir, { recursive: true });
+    fs.appendFileSync(p.join(logDir, 'hook-log.jsonl'),
+      JSON.stringify({ ts: new Date().toISOString(), hook: 'subagent-init', status: 'crash', error: e.message }) + '\n');
+  } catch (_) {}
+  process.exit(0); // fail-open
+}

package/agentic/claude/.claude/hooks/task-completed-handler.cjs

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+/**
+ * TaskCompleted Hook - Logs task completions and injects progress context
+ *
+ * Fires: When any agent marks a task as completed
+ * Purpose: Track team progress and notify lead agent
+ * Design: Non-blocking, fail-open (exit 0 always)
+ *
+ * Input: { task_id, task_subject, task_description, teammate_name, team_name, ... }
+ * Output: additionalContext with progress summary for lead
+ *
+ * Luna AI
+ */
+
+// Crash wrapper
+try {
+  const fs = require('fs');
+  const path = require('path');
+  const os = require('os');
+  const { isHookEnabled } = require('./lib/luna-config-utils.cjs');
+
+  if (!isHookEnabled('task-completed-handler')) {
+    process.exit(0);
+  }
+
+const CLAUDE_CONFIG_DIR = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
+const TASKS_DIR = path.join(CLAUDE_CONFIG_DIR, 'tasks');
+
+function readJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+  } catch { return null; }
+}
+
+function countTasks(teamName) {
+  const taskDir = path.join(TASKS_DIR, teamName);
+  try {
+    if (!fs.existsSync(taskDir)) return null;
+    const files = fs.readdirSync(taskDir).filter(f => f.endsWith('.json'));
+    let pending = 0, inProgress = 0, completed = 0;
+    for (const file of files) {
+      const task = readJson(path.join(taskDir, file));
+      if (!task?.status) continue;
+      if (task.status === 'pending') pending++;
+      else if (task.status === 'in_progress') inProgress++;
+      else if (task.status === 'completed') completed++;
+    }
+    return { pending, inProgress, completed, total: pending + inProgress + completed };
+  } catch { return null; }
+}
+
+function logCompletion(teamName, taskId, taskSubject, teammateName) {
+  const reportsPath = process.env.LUNA_REPORTS_PATH;
+  if (!reportsPath) return;
+  const logFile = path.join(reportsPath, `team-${teamName}-completions.md`);
+  try {
+    fs.mkdirSync(path.dirname(logFile), { recursive: true });
+    const timestamp = new Date().toISOString().slice(0, 19).replace('T', ' ');
+    const line = `- [${timestamp}] Task #${taskId} "${taskSubject}" completed by ${teammateName}\n`;
+    fs.appendFileSync(logFile, line);
+  } catch { /* fail-open */ }
+}
+
+function main() {
+  try {
+    const stdin = fs.readFileSync(0, 'utf-8').trim();
+    if (!stdin) process.exit(0);
+
+    const payload = JSON.parse(stdin);
+    const { task_id, task_subject, teammate_name, team_name } = payload;
+    if (!team_name) process.exit(0);
+
+    // Log completion to report file
+    logCompletion(team_name, task_id, task_subject, teammate_name);
+
+    // Count task progress
+    const counts = countTasks(team_name);
+    const lines = [];
+    lines.push(`## Task Completed`);
+    lines.push(`Task #${task_id} "${task_subject}" completed by ${teammate_name}.`);
+
+    if (counts) {
+      const remaining = counts.pending + counts.inProgress;
+      lines.push(`Progress: ${counts.completed}/${counts.total} done. ${counts.pending} pending, ${counts.inProgress} in progress.`);
+      if (remaining === 0) {
+        lines.push('');
+        lines.push('**All tasks completed.** Consider shutting down teammates and synthesizing results.');
+      }
+    }
+
+    const output = {
+      hookSpecificOutput: {
+        hookEventName: 'TaskCompleted',
+        additionalContext: lines.join('\n')
+      }
+    };
+    console.log(JSON.stringify(output));
+    process.exit(0);
+  } catch (error) {
+    if (process.env.LUNA_DEBUG) {
+      console.error(`[task-completed-handler] Error: ${error.message}`);
+    }
+    process.exit(0);
+  }
+  }
+
+  main();
+} catch (e) {
+  // Minimal crash logging
+  try {
+    const fs = require('fs');
+    const p = require('path');
+    const logDir = p.join(__dirname, '.logs');
+    if (!fs.existsSync(logDir)) fs.mkdirSync(logDir, { recursive: true });
+    fs.appendFileSync(p.join(logDir, 'hook-log.jsonl'),
+      JSON.stringify({ ts: new Date().toISOString(), hook: 'task-completed-handler', status: 'crash', error: e.message }) + '\n');
+  } catch (_) {}
+  process.exit(0); // fail-open
+}

package/agentic/claude/.claude/hooks/team-context-inject.cjs

@@ -0,0 +1,215 @@
+#!/usr/bin/env node
+/**
+ * SubagentStart Hook - Injects team context for Agent Team teammates
+ *
+ * Fires: When a subagent is started (SubagentStart event)
+ * Purpose: If spawned agent is a team member, inject peer info + task summary
+ * Design: Non-blocking, fail-open (exit 0 always)
+ *
+ * Luna AI
+ */
+
+// Crash wrapper
+try {
+  const fs = require('fs');
+  const path = require('path');
+  const os = require('os');
+  const { isHookEnabled } = require('./lib/luna-config-utils.cjs');
+
+  if (!isHookEnabled('team-context-inject')) {
+    process.exit(0);
+  }
+
+const CLAUDE_CONFIG_DIR = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
+const TEAMS_DIR = path.join(CLAUDE_CONFIG_DIR, 'teams');
+const TASKS_DIR = path.join(CLAUDE_CONFIG_DIR, 'tasks');
+const { resolveLunaConfig } = require('./lib/luna-config-resolver.cjs');
+
+/**
+ * Extract team name from agent_id (format: "name@team-name")
+ * Returns null if not a team agent or if name contains path separators
+ */
+function extractTeamName(agentId) {
+  if (!agentId || typeof agentId !== 'string') return null;
+  const atIdx = agentId.indexOf('@');
+  if (atIdx < 1) return null;
+  const name = agentId.substring(atIdx + 1);
+  // Reject path traversal attempts
+  if (name.includes('/') || name.includes('\\') || name.includes('..')) return null;
+  return name;
+}
+
+function readJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Build peer list from team config, excluding the current agent
+ */
+function buildPeerList(config, currentAgentId) {
+  if (!config?.members?.length) return '';
+  const peers = config.members
+    .filter(m => m.agentId !== currentAgentId)
+    .map(m => `${m.name} (${m.agentType})`)
+    .join(', ');
+  return peers || 'none';
+}
+
+/**
+ * Load fallback Luna paths via shared config resolver when CLAUDE_ENV_FILE is not set.
+ * Uses global runtime config only.
+ */
+function loadLunaConfigFallback() {
+  const { config, resolvedFrom, configPath } = resolveLunaConfig({
+    cwd: process.cwd(),
+    includeWorkspace: false,
+    includeGlobal: true,
+    searchParents: true,
+    maxParentDepth: 3,
+  });
+
+  if (!configPath) return null;
+
+  const baseDir = resolvedFrom === 'workspace'
+    ? path.dirname(configPath)
+    : process.cwd();
+
+  return { dir: baseDir, config, resolvedFrom };
+}
+
+/**
+ * Build Luna env context from environment variables.
+ * Falls back to .luna.json when CLAUDE_ENV_FILE was not set (C4 fix).
+ */
+function buildLunaContext() {
+  const ctx = [];
+  const env = process.env;
+
+  // Check if env vars were injected by session-init
+  const hasEnvVars = !!(env.LUNA_REPORTS_PATH || env.LUNA_PLANS_PATH || env.LUNA_PROJECT_ROOT);
+
+  if (hasEnvVars) {
+    if (env.LUNA_REPORTS_PATH) ctx.push(`Reports: ${env.LUNA_REPORTS_PATH}`);
+    if (env.LUNA_PLANS_PATH) ctx.push(`Plans: ${env.LUNA_PLANS_PATH}`);
+    if (env.LUNA_PROJECT_ROOT) ctx.push(`Project: ${env.LUNA_PROJECT_ROOT}`);
+    if (env.LUNA_NAME_PATTERN) ctx.push(`Naming: ${env.LUNA_NAME_PATTERN}`);
+    if (env.LUNA_GIT_BRANCH) ctx.push(`Branch: ${env.LUNA_GIT_BRANCH}`);
+    if (env.LUNA_ACTIVE_PLAN) ctx.push(`Active plan: ${env.LUNA_ACTIVE_PLAN}`);
+  } else {
+    // Fallback: derive paths from shared config resolver when CLAUDE_ENV_FILE was not set
+    const fallback = loadLunaConfigFallback();
+    if (fallback) {
+      const { dir, config, resolvedFrom } = fallback;
+      const plansPath = path.join(dir, config.paths?.plans || 'plans');
+      const docsPath = path.join(dir, config.paths?.docs || 'docs');
+      const reportsPath = path.join(plansPath, 'reports');
+      ctx.push(`Reports: ${reportsPath}`);
+      ctx.push(`Plans: ${plansPath}`);
+      ctx.push(`Project: ${dir}`);
+      if (config.plan?.namingFormat) ctx.push(`Naming: ${config.plan.namingFormat}`);
+      ctx.push(`Docs: ${docsPath}`);
+      ctx.push(`Note: Luna env vars not injected (CLAUDE_ENV_FILE unset) — using ${resolvedFrom} config fallback`);
+    }
+  }
+
+  ctx.push('Commits: conventional (feat:, fix:, docs:, refactor:, test:, chore:)');
+
+  return ctx;
+}
+
+/**
+ * Summarize tasks from team task directory
+ */
+function summarizeTasks(teamName) {
+  const taskDir = path.join(TASKS_DIR, teamName);
+  try {
+    if (!fs.existsSync(taskDir)) return null;
+    const files = fs.readdirSync(taskDir).filter(f => f.endsWith('.json'));
+    let pending = 0, inProgress = 0, completed = 0;
+    for (const file of files) {
+      const task = readJson(path.join(taskDir, file));
+      if (!task?.status) continue;
+      if (task.status === 'pending') pending++;
+      else if (task.status === 'in_progress') inProgress++;
+      else if (task.status === 'completed') completed++;
+    }
+    return { pending, inProgress, completed, total: files.length };
+  } catch {
+    return null;
+  }
+}
+
+function main() {
+  try {
+    const stdin = fs.readFileSync(0, 'utf-8').trim();
+    if (!stdin) process.exit(0);
+
+    const payload = JSON.parse(stdin);
+    const agentId = payload.agent_id || '';
+
+    // Detect team membership from agent_id pattern (name@team-name)
+    const teamName = extractTeamName(agentId);
+    if (!teamName) process.exit(0); // Not a team agent, exit silently
+
+    // Read team config
+    const configPath = path.join(TEAMS_DIR, teamName, 'config.json');
+    const config = readJson(configPath);
+    if (!config) process.exit(0);
+
+    const peerList = buildPeerList(config, agentId);
+    const tasks = summarizeTasks(teamName);
+
+    const lines = [];
+    lines.push(`## Team Context`);
+    lines.push(`Team: ${config.name || teamName}`);
+    lines.push(`Your peers: ${peerList}`);
+
+    if (tasks) {
+      lines.push(`Task summary: ${tasks.pending} pending, ${tasks.inProgress} in progress, ${tasks.completed} completed`);
+    }
+
+    // Luna env context
+    const lunaCtx = buildLunaContext();
+    if (lunaCtx.length > 1) {
+      lines.push('');
+      lines.push('## Luna Context');
+      lines.push(...lunaCtx);
+    }
+
+    lines.push('');
+    lines.push('Remember: Check TaskList, claim tasks, respect file ownership, use SendMessage to communicate.');
+
+    const output = {
+      hookSpecificOutput: {
+        hookEventName: "SubagentStart",
+        additionalContext: lines.join('\n')
+      }
+    };
+
+    console.log(JSON.stringify(output));
+    process.exit(0);
+  } catch (error) {
+    if (process.env.LUNA_DEBUG) {
+      console.error(`[team-context-inject] Error: ${error.message}`);
+    }
+    process.exit(0);
+  }
+  }
+
+  main();
+} catch (e) {
+  // Minimal crash logging
+  try {
+    const fs = require('fs');
+    const p = require('path');
+    const logDir = p.join(__dirname, '.logs');
+    if (!fs.existsSync(logDir)) fs.mkdirSync(logDir, { recursive: true });
+    fs.appendFileSync(p.join(logDir, 'hook-log.jsonl'),
+      JSON.stringify({ ts: new Date().toISOString(), hook: 'team-context-inject', status: 'crash', error: e.message }) + '\n');
+  } catch (_) {}
+  process.exit(0); // fail-open
+}

package/agentic/claude/.claude/hooks/teammate-idle-handler.cjs

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+/**
+ * TeammateIdle Hook - Injects available task context when teammate goes idle
+ *
+ * Fires: When an agent team teammate is about to go idle after finishing its turn
+ * Purpose: Inform lead agent about pending work for idle teammate
+ * Design: Non-blocking, fail-open (exit 0 always)
+ *
+ * Input: { teammate_name, team_name, permission_mode, ... }
+ * Output: additionalContext summarizing available tasks for lead
+ *
+ * Luna AI
+ */
+
+// Crash wrapper
+try {
+  const fs = require('fs');
+  const path = require('path');
+  const os = require('os');
+  const { isHookEnabled } = require('./lib/luna-config-utils.cjs');
+
+  if (!isHookEnabled('teammate-idle-handler')) {
+    process.exit(0);
+  }
+
+const CLAUDE_CONFIG_DIR = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
+const TASKS_DIR = path.join(CLAUDE_CONFIG_DIR, 'tasks');
+
+function readJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+  } catch { return null; }
+}
+
+function getAvailableTasks(teamName) {
+  const taskDir = path.join(TASKS_DIR, teamName);
+  try {
+    if (!fs.existsSync(taskDir)) return null;
+    const files = fs.readdirSync(taskDir).filter(f => f.endsWith('.json'));
+    const tasks = files.map(f => readJson(path.join(taskDir, f))).filter(Boolean);
+
+    const completedIds = new Set(
+      tasks.filter(t => t.status === 'completed').map(t => t.id)
+    );
+
+    let pending = 0, inProgress = 0, completed = 0;
+    const unblocked = [];
+
+    for (const task of tasks) {
+      if (task.status === 'completed') { completed++; continue; }
+      if (task.status === 'in_progress') { inProgress++; continue; }
+      if (task.status !== 'pending') continue;
+      pending++;
+
+      // Check if all blockers are completed
+      const blockers = task.blockedBy || [];
+      const isUnblocked = blockers.every(id => completedIds.has(id));
+      if (isUnblocked && !task.owner) {
+        unblocked.push({ id: task.id, subject: task.subject });
+      }
+    }
+
+    return { pending, inProgress, completed, total: pending + inProgress + completed, unblocked };
+  } catch { return null; }
+}
+
+function main() {
+  try {
+    const stdin = fs.readFileSync(0, 'utf-8').trim();
+    if (!stdin) process.exit(0);
+
+    const payload = JSON.parse(stdin);
+    const { teammate_name, team_name } = payload;
+    if (!team_name) process.exit(0);
+
+    const taskInfo = getAvailableTasks(team_name);
+    const lines = [];
+    lines.push(`## Teammate Idle`);
+    lines.push(`${teammate_name} is idle.`);
+
+    if (taskInfo) {
+      const remaining = taskInfo.pending + taskInfo.inProgress;
+      lines.push(`Tasks: ${taskInfo.completed}/${taskInfo.total} done. ${remaining} remaining.`);
+
+      if (taskInfo.unblocked.length > 0) {
+        lines.push(`Unblocked & unassigned: ${taskInfo.unblocked.map(t => `#${t.id} "${t.subject}"`).join(', ')}`);
+        lines.push(`Consider assigning work to ${teammate_name} or waking them with a message.`);
+      } else if (remaining === 0) {
+        lines.push(`No remaining tasks. Consider shutting down ${teammate_name}.`);
+      } else {
+        lines.push(`All remaining tasks are blocked or assigned. ${teammate_name} may be waiting for dependencies.`);
+      }
+    }
+
+    const output = {
+      hookSpecificOutput: {
+        hookEventName: 'TeammateIdle',
+        additionalContext: lines.join('\n')
+      }
+    };
+    console.log(JSON.stringify(output));
+    process.exit(0);
+  } catch (error) {
+    if (process.env.LUNA_DEBUG) {
+      console.error(`[teammate-idle-handler] Error: ${error.message}`);
+    }
+    process.exit(0);
+  }
+  }
+
+  main();
+} catch (e) {
+  // Minimal crash logging
+  try {
+    const fs = require('fs');
+    const p = require('path');
+    const logDir = p.join(__dirname, '.logs');
+    if (!fs.existsSync(logDir)) fs.mkdirSync(logDir, { recursive: true });
+    fs.appendFileSync(p.join(logDir, 'hook-log.jsonl'),
+      JSON.stringify({ ts: new Date().toISOString(), hook: 'teammate-idle-handler', status: 'crash', error: e.message }) + '\n');
+  } catch (_) {}
+  process.exit(0); // fail-open
+}