thanh-kit 2.5.0 → 2.5.2

package/templates/hooks/__tests__/teammate-idle-handler.test.cjs

@@ -0,0 +1,254 @@
+#!/usr/bin/env node
+/**
+ * Tests for teammate-idle-handler.cjs hook
+ * Run: node --test .claude/hooks/__tests__/teammate-idle-handler.test.cjs
+ */
+
+const { describe, it } = require('node:test');
+const assert = require('node:assert');
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+const HOOK_PATH = path.join(__dirname, '..', 'teammate-idle-handler.cjs');
+
+/**
+ * Execute hook with given stdin data and return parsed output
+ */
+function runHook(inputData, options = {}) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn('node', [HOOK_PATH], {
+      cwd: process.cwd(),
+      env: { ...process.env, ...(options.env || {}) }
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    proc.stdout.on('data', (data) => { stdout += data.toString(); });
+    proc.stderr.on('data', (data) => { stderr += data.toString(); });
+
+    if (inputData !== null && inputData !== undefined) {
+      proc.stdin.write(typeof inputData === 'string' ? inputData : JSON.stringify(inputData));
+    }
+    proc.stdin.end();
+
+    proc.on('close', (code) => {
+      let output = null;
+      try { output = JSON.parse(stdout); } catch { /* non-JSON ok */ }
+      resolve({ stdout, stderr, exitCode: code, output });
+    });
+
+    proc.on('error', reject);
+    setTimeout(() => { proc.kill('SIGTERM'); reject(new Error('Timeout')); }, 10000);
+  });
+}
+
+/**
+ * Create temp team with task files for testing
+ */
+function createTestTeam(baseDir, teamName, tasks) {
+  const taskDir = path.join(baseDir, '.claude', 'tasks', teamName);
+  fs.mkdirSync(taskDir, { recursive: true });
+  for (const task of tasks) {
+    fs.writeFileSync(path.join(taskDir, `${task.id}.json`), JSON.stringify(task));
+  }
+  return taskDir;
+}
+
+describe('teammate-idle-handler.cjs', () => {
+
+  describe('Fail-open behavior', () => {
+
+    it('exits 0 on empty stdin', async () => {
+      const result = await runHook(null);
+      assert.strictEqual(result.exitCode, 0);
+    });
+
+    it('exits 0 on invalid JSON', async () => {
+      const result = await runHook('not valid json{{{');
+      assert.strictEqual(result.exitCode, 0);
+    });
+
+    it('exits 0 when no team_name in payload', async () => {
+      const result = await runHook({ teammate_name: 'worker' });
+      assert.strictEqual(result.exitCode, 0);
+    });
+
+  });
+
+  describe('Output format', () => {
+
+    it('returns valid JSON with hookEventName = TeammateIdle', async () => {
+      const tmpDir = path.join(os.tmpdir(), 'ti-hook-format-' + Date.now());
+      fs.mkdirSync(tmpDir, { recursive: true });
+      try {
+        createTestTeam(tmpDir, 'test-team', [
+          { id: '1', status: 'pending', subject: 'Task 1' }
+        ]);
+
+        const result = await runHook({
+          teammate_name: 'worker-1', team_name: 'test-team'
+        }, { env: { HOME: tmpDir } });
+
+        assert.strictEqual(result.exitCode, 0);
+        assert.ok(result.output, 'Should return JSON');
+        assert.strictEqual(result.output.hookSpecificOutput.hookEventName, 'TeammateIdle');
+        assert.strictEqual(typeof result.output.hookSpecificOutput.additionalContext, 'string');
+      } finally {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+      }
+    });
+
+  });
+
+  describe('Task availability detection', () => {
+
+    it('lists unblocked, unassigned tasks', async () => {
+      const tmpDir = path.join(os.tmpdir(), 'ti-hook-unblocked-' + Date.now());
+      fs.mkdirSync(tmpDir, { recursive: true });
+      try {
+        createTestTeam(tmpDir, 'avail-team', [
+          { id: '1', status: 'completed', subject: 'Done' },
+          { id: '2', status: 'pending', subject: 'Available task' },
+          { id: '3', status: 'pending', subject: 'Blocked', blockedBy: ['99'] }
+        ]);
+
+        const result = await runHook({
+          teammate_name: 'dev-1', team_name: 'avail-team'
+        }, { env: { HOME: tmpDir } });
+
+        const ctx = result.output.hookSpecificOutput.additionalContext;
+        assert.ok(ctx.includes('Available task'), 'Should list unblocked task');
+        assert.ok(!ctx.includes('Blocked'), 'Should not list blocked task');
+      } finally {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+      }
+    });
+
+    it('suggests shutdown when no tasks remain', async () => {
+      const tmpDir = path.join(os.tmpdir(), 'ti-hook-shutdown-' + Date.now());
+      fs.mkdirSync(tmpDir, { recursive: true });
+      try {
+        createTestTeam(tmpDir, 'empty-team', [
+          { id: '1', status: 'completed', subject: 'A' },
+          { id: '2', status: 'completed', subject: 'B' }
+        ]);
+
+        const result = await runHook({
+          teammate_name: 'dev-1', team_name: 'empty-team'
+        }, { env: { HOME: tmpDir } });
+
+        const ctx = result.output.hookSpecificOutput.additionalContext;
+        assert.ok(ctx.includes('No remaining tasks'), 'Should suggest shutdown');
+        assert.ok(ctx.includes('shutting down'), 'Should mention shutdown');
+      } finally {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+      }
+    });
+
+    it('shows "blocked or assigned" when tasks exist but none available', async () => {
+      const tmpDir = path.join(os.tmpdir(), 'ti-hook-blocked-' + Date.now());
+      fs.mkdirSync(tmpDir, { recursive: true });
+      try {
+        createTestTeam(tmpDir, 'blocked-team', [
+          { id: '1', status: 'in_progress', subject: 'Busy', owner: 'dev-2' },
+          { id: '2', status: 'pending', subject: 'Blocked', blockedBy: ['1'] }
+        ]);
+
+        const result = await runHook({
+          teammate_name: 'dev-1', team_name: 'blocked-team'
+        }, { env: { HOME: tmpDir } });
+
+        const ctx = result.output.hookSpecificOutput.additionalContext;
+        assert.ok(ctx.includes('blocked or assigned'), 'Should indicate all tasks blocked/assigned');
+      } finally {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+      }
+    });
+
+    it('skips tasks that have an owner (already claimed)', async () => {
+      const tmpDir = path.join(os.tmpdir(), 'ti-hook-owned-' + Date.now());
+      fs.mkdirSync(tmpDir, { recursive: true });
+      try {
+        createTestTeam(tmpDir, 'owned-team', [
+          { id: '1', status: 'pending', subject: 'Claimed', owner: 'dev-2' },
+          { id: '2', status: 'pending', subject: 'Free task' }
+        ]);
+
+        const result = await runHook({
+          teammate_name: 'dev-1', team_name: 'owned-team'
+        }, { env: { HOME: tmpDir } });
+
+        const ctx = result.output.hookSpecificOutput.additionalContext;
+        assert.ok(ctx.includes('Free task'), 'Should list unowned task');
+        assert.ok(!ctx.includes('#1 "Claimed"'), 'Should not list owned task as available');
+      } finally {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+      }
+    });
+
+    it('correctly identifies unblocked tasks (blockedBy all completed)', async () => {
+      const tmpDir = path.join(os.tmpdir(), 'ti-hook-deps-' + Date.now());
+      fs.mkdirSync(tmpDir, { recursive: true });
+      try {
+        createTestTeam(tmpDir, 'deps-team', [
+          { id: '1', status: 'completed', subject: 'Prereq' },
+          { id: '2', status: 'pending', subject: 'Unblocked now', blockedBy: ['1'] },
+          { id: '3', status: 'pending', subject: 'Still blocked', blockedBy: ['99'] }
+        ]);
+
+        const result = await runHook({
+          teammate_name: 'dev-1', team_name: 'deps-team'
+        }, { env: { HOME: tmpDir } });
+
+        const ctx = result.output.hookSpecificOutput.additionalContext;
+        assert.ok(ctx.includes('Unblocked now'), 'Should list task whose deps are met');
+        assert.ok(!ctx.includes('Still blocked'), 'Should not list task with unmet deps');
+      } finally {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+      }
+    });
+
+  });
+
+  describe('Error resilience', () => {
+
+    it('handles missing task directory gracefully', async () => {
+      const tmpDir = path.join(os.tmpdir(), 'ti-hook-nodir-' + Date.now());
+      fs.mkdirSync(tmpDir, { recursive: true });
+      try {
+        const result = await runHook({
+          teammate_name: 'w', team_name: 'missing-team'
+        }, { env: { HOME: tmpDir } });
+
+        assert.strictEqual(result.exitCode, 0);
+        assert.ok(result.output, 'Should still return JSON');
+      } finally {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+      }
+    });
+
+    it('handles corrupted task JSON gracefully', async () => {
+      const tmpDir = path.join(os.tmpdir(), 'ti-hook-corrupt-' + Date.now());
+      fs.mkdirSync(tmpDir, { recursive: true });
+      try {
+        const taskDir = path.join(tmpDir, '.claude', 'tasks', 'bad-team');
+        fs.mkdirSync(taskDir, { recursive: true });
+        fs.writeFileSync(path.join(taskDir, '1.json'), '{bad{{{');
+        fs.writeFileSync(path.join(taskDir, '2.json'), JSON.stringify({ id: '2', status: 'pending', subject: 'OK' }));
+
+        const result = await runHook({
+          teammate_name: 'w', team_name: 'bad-team'
+        }, { env: { HOME: tmpDir } });
+
+        assert.strictEqual(result.exitCode, 0);
+      } finally {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+      }
+    });
+
+  });
+
+});

package/templates/hooks/cook-after-plan-reminder.cjs

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+/**
+ * Plan Subagent Stop Hook - Cook Skill Reminder
+ *
+ * Fires when Plan subagent completes. Reminds to invoke /cook --auto before implementation.
+ * Also outputs full absolute path so new sessions (after /clear) can find the plan in worktrees.
+ *
+ * Exit Codes:
+ *   0 - Success (non-blocking)
+ */
+
+// Crash wrapper
+try {
+  const fs = require('fs');
+  const path = require('path');
+  const { isHookEnabled, readSessionState } = require('./lib/ck-config-utils.cjs');
+
+  // Early exit if hook disabled in config
+  if (!isHookEnabled('cook-after-plan-reminder')) {
+    process.exit(0);
+  }
+
+  async function main() {
+  try {
+    const stdin = fs.readFileSync(0, 'utf-8').trim();
+    if (!stdin) process.exit(0);
+
+    // Get active plan path from session state
+    const sessionId = process.env.CK_SESSION_ID;
+    let planPath = null;
+
+    if (sessionId) {
+      const state = readSessionState(sessionId);
+      if (state?.activePlan) {
+        planPath = state.activePlan;
+        // Ensure it's absolute
+        if (!path.isAbsolute(planPath) && state.sessionOrigin) {
+          planPath = path.resolve(state.sessionOrigin, planPath);
+        }
+      }
+    }
+
+    // Output reminder with full absolute path if available
+    console.log('MUST invoke /cook --auto skill before implementing the plan');
+    if (planPath) {
+      const planMdPath = path.join(planPath, 'plan.md');
+      console.log(`Best Practice: Run /clear then /cook ${planMdPath}`);
+    } else {
+      // Fallback when plan path unavailable
+      console.log('Best Practice: Run /clear then /cook {full-absolute-path-to-plan.md}');
+    }
+
+    process.exit(0);
+  } catch (error) {
+    // Silent fail - non-blocking
+    process.exit(0);
+  }
+  }
+
+  main();
+} catch (e) {
+  // Minimal crash logging (zero deps — only Node builtins)
+  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: p.basename(__filename, '.cjs'), status: 'crash', error: e.message }) + '\n');
+  } catch (_) {}
+  process.exit(0); // fail-open
+}

package/templates/hooks/descriptive-name.cjs

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+
+// Crash wrapper
+try {
+  const { isHookEnabled } = require('./lib/ck-config-utils.cjs');
+
+  // Early exit if hook disabled in config
+  if (!isHookEnabled('descriptive-name')) {
+    process.exit(0);
+  }
+
+  try {
+  let injectedPrompt = `## File naming guidance:
+- Skip this guidance if you are creating markdown or plain text files
+- Prefer kebab-case for JS/TS/Python/shell (.js, .ts, .py, .sh) with descriptive names
+- Respect language conventions: C#/Java/Kotlin/Swift use PascalCase (.cs, .java, .kt, .swift), Go/Rust use snake_case (.go, .rs)
+- Other languages: follow their ecosystem's standard naming convention
+- Goal: self-documenting names for LLM tools (Grep, Glob, Search)`
+
+  console.log(JSON.stringify({
+    "hookSpecificOutput": {
+      "hookEventName": "PreToolUse",
+      "permissionDecision": "allow",
+      "additionalContext": injectedPrompt
+    }
+  }));
+
+    // All paths allowed
+    process.exit(0);
+
+  } catch (error) {
+    // Fail-open for unexpected errors
+    console.error('WARN: Hook error, allowing operation -', error.message);
+    process.exit(0);
+  }
+} catch (e) {
+  // Minimal crash logging (zero deps — only Node builtins)
+  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: p.basename(__filename, '.cjs'), status: 'crash', error: e.message }) + '\n');
+  } catch (_) {}
+  process.exit(0); // fail-open
+}

package/templates/hooks/dev-rules-reminder.cjs

@@ -7,201 +7,26 @@
  *
  * Exit Codes:
  *   0 - Success (non-blocking, allows continuation)
+ *
+ * Core logic extracted to lib/context-builder.cjs for OpenCode plugin reuse.
  */
 
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { execSync } = require('child_process');
-const {
-  loadConfig,
-  resolvePlanPath,
-  getReportsPath,
-  resolveNamingPattern,
-  normalizePath
-} = require('./lib/ck-config-utils.cjs');
-
-// ═══════════════════════════════════════════════════════════════════════════
-// HELPER FUNCTIONS
-// ═══════════════════════════════════════════════════════════════════════════
-
-function execSafe(cmd) {
-  try {
-    return execSync(cmd, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
-  } catch (e) {
-    return null;
-  }
-}
-
-function resolveWorkflowPath(filename) {
-  const localPath = path.join(process.cwd(), '.claude', 'workflows', filename);
-  const globalPath = path.join(os.homedir(), '.claude', 'workflows', filename);
-  if (fs.existsSync(localPath)) return `.claude/workflows/${filename}`;
-  if (fs.existsSync(globalPath)) return `~/.claude/workflows/${filename}`;
-  return null;
-}
-
-function resolveScriptPath(filename) {
-  const localPath = path.join(process.cwd(), '.claude', 'scripts', filename);
-  const globalPath = path.join(os.homedir(), '.claude', 'scripts', filename);
-  if (fs.existsSync(localPath)) return `.claude/scripts/${filename}`;
-  if (fs.existsSync(globalPath)) return `~/.claude/scripts/${filename}`;
-  return null;
-}
+// Crash wrapper
+try {
+  const fs = require('fs');
 
-function resolveSkillsVenv() {
-  const isWindows = process.platform === 'win32';
-  const venvBin = isWindows ? 'Scripts' : 'bin';
-  const pythonExe = isWindows ? 'python.exe' : 'python3';
-
-  const localVenv = path.join(process.cwd(), '.claude', 'skills', '.venv', venvBin, pythonExe);
-  const globalVenv = path.join(os.homedir(), '.claude', 'skills', '.venv', venvBin, pythonExe);
-
-  if (fs.existsSync(localVenv)) {
-    return isWindows
-      ? '.claude\\skills\\.venv\\Scripts\\python.exe'
-      : '.claude/skills/.venv/bin/python3';
-  }
-  if (fs.existsSync(globalVenv)) {
-    return isWindows
-      ? '~\\.claude\\skills\\.venv\\Scripts\\python.exe'
-      : '~/.claude/skills/.venv/bin/python3';
-  }
-  return null;
-}
-
-function buildPlanContext(sessionId, config) {
-  const { plan, paths } = config;
-  const gitBranch = execSafe('git branch --show-current');
-  const resolved = resolvePlanPath(sessionId, config);
-  const reportsPath = getReportsPath(resolved.path, resolved.resolvedBy, plan, paths);
-
-  // Compute naming pattern directly for reliable injection
-  const namePattern = resolveNamingPattern(plan, gitBranch);
-
-  const planLine = resolved.resolvedBy === 'session'
-    ? `- Plan: ${resolved.path}`
-    : resolved.resolvedBy === 'branch'
-      ? `- Plan: none | Suggested: ${resolved.path}`
-      : `- Plan: none`;
-
-  // Validation config (injected so LLM can reference it)
-  const validation = plan.validation || {};
-  const validationMode = validation.mode || 'prompt';
-  const validationMin = validation.minQuestions || 3;
-  const validationMax = validation.maxQuestions || 8;
-
-  return { reportsPath, gitBranch, planLine, namePattern, validationMode, validationMin, validationMax };
-}
+  // Import shared context building logic
+  const {
+    buildReminderContext,
+    wasRecentlyInjected
+  } = require('./lib/context-builder.cjs');
+  const { isHookEnabled } = require('./lib/ck-config-utils.cjs');
 
-function wasRecentlyInjected(transcriptPath) {
-  try {
-    if (!transcriptPath || !fs.existsSync(transcriptPath)) return false;
-    const transcript = fs.readFileSync(transcriptPath, 'utf-8');
-    // Check last 150 lines (hook output is ~30 lines, so this covers ~5 user prompts)
-    return transcript.split('\n').slice(-150).some(line => line.includes('[IMPORTANT] Consider Modularization'));
-  } catch (e) {
-    return false;
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// REMINDER TEMPLATE (all output in one place for visibility)
-// ═══════════════════════════════════════════════════════════════════════════
-
-function buildReminder({ thinkingLanguage, responseLanguage, devRulesPath, catalogScript, skillsVenv, reportsPath, plansPath, docsPath, planLine, gitBranch, namePattern, validationMode, validationMin, validationMax }) {
-  // Build language instructions based on config
-  // Auto-default thinkingLanguage to 'en' when only responseLanguage is set
-  const effectiveThinking = thinkingLanguage || (responseLanguage ? 'en' : null);
-  const hasThinking = effectiveThinking && effectiveThinking !== responseLanguage;
-  const hasResponse = responseLanguage;
-  const languageLines = [];
-
-  if (hasThinking || hasResponse) {
-    languageLines.push(`## Language`);
-    if (hasThinking) {
-      languageLines.push(`- Thinking: Use ${effectiveThinking} for reasoning (logic, precision).`);
-    }
-    if (hasResponse) {
-      languageLines.push(`- Response: Respond in ${responseLanguage} (natural, fluent).`);
-    }
-    languageLines.push(``);
+  // Early exit if hook disabled in config
+  if (!isHookEnabled('dev-rules-reminder')) {
+    process.exit(0);
   }
 
-  return [
-    // ─────────────────────────────────────────────────────────────────────────
-    // LANGUAGE (thinking + response, if configured)
-    // ─────────────────────────────────────────────────────────────────────────
-    ...languageLines,
-
-    // ─────────────────────────────────────────────────────────────────────────
-    // SESSION CONTEXT
-    // ─────────────────────────────────────────────────────────────────────────
-    `## Session`,
-    `- DateTime: ${new Date().toLocaleString()}`,
-    `- CWD: ${process.cwd()}`,
-    ``,
-
-    // ─────────────────────────────────────────────────────────────────────────
-    // RULES
-    // ─────────────────────────────────────────────────────────────────────────
-    `## Rules`,
-    ...(devRulesPath ? [`- Read and follow development rules: "${devRulesPath}"`] : []),
-    `- Markdown files are organized in: Plans → "plans/" directory, Docs → "docs/" directory`,
-    `- **IMPORTANT:** DO NOT create markdown files out of "plans/" or "docs/" directories UNLESS the user explicitly requests it.`,
-    ...(catalogScript ? [
-      `- Activate skills: Run \`python ${catalogScript} --skills\` to generate a skills catalog and analyze it, then activate the relevant skills that are needed for the task during the process.`,
-      `- Execute commands: Run \`python ${catalogScript} --commands\` to generate a commands catalog and analyze it, then execute the relevant SlashCommands that are needed for the task during the process.`
-    ] : []),
-    ...(skillsVenv ? [`- Python scripts in .claude/skills/: Use \`${skillsVenv}\``] : []),
-    `- When skills' scripts are failed to execute, always fix them and run again, repeat until success.`,
-    `- Follow **YAGNI (You Aren't Gonna Need It) - KISS (Keep It Simple, Stupid) - DRY (Don't Repeat Yourself)** principles`,
-    `- **[CRITICAL] Class Responsibility Rule:** Logic belongs in LOWEST layer (Entity/Model > Service > Component/Handler). Backend: mapping → Command/DTO, not Handler. Frontend: constants/columns/roles → Model class, not Component.`,
-    `- Sacrifice grammar for the sake of concision when writing reports.`,
-    `- In reports, list any unresolved questions at the end, if any.`,
-    `- IMPORTANT: Ensure token consumption efficiency while maintaining high quality.`,
-    ``,
-
-    // ─────────────────────────────────────────────────────────────────────────
-    // MODULARIZATION
-    // ─────────────────────────────────────────────────────────────────────────
-    `## **[IMPORTANT] Consider Modularization:**`,
-    `- Check existing modules before creating new`,
-    `- Analyze logical separation boundaries (functions, classes, concerns)`,
-    `- Use kebab-case naming with descriptive names, it's fine if the file name is long because this ensures file names are self-documenting for LLM tools (Grep, Glob, Search)`,
-    `- Write descriptive code comments`,
-    `- After modularization, continue with main task`,
-    `- When not to modularize: Markdown files, plain text files, bash scripts, configuration files, environment variables files, etc.`,
-    ``,
-
-    // ─────────────────────────────────────────────────────────────────────────
-    // PATHS
-    // ─────────────────────────────────────────────────────────────────────────
-    `## Paths`,
-    `Reports: ${reportsPath} | Plans: ${plansPath}/ | Docs: ${docsPath}/`,
-    ``,
-
-    // ─────────────────────────────────────────────────────────────────────────
-    // PLAN CONTEXT
-    // ─────────────────────────────────────────────────────────────────────────
-    `## Plan Context`,
-    planLine,
-    `- Reports: ${reportsPath}`,
-    ...(gitBranch ? [`- Branch: ${gitBranch}`] : []),
-    `- Validation: mode=${validationMode}, questions=${validationMin}-${validationMax}`,
-    ``,
-
-    // ─────────────────────────────────────────────────────────────────────────
-    // NAMING (computed pattern for consistent file naming)
-    // ─────────────────────────────────────────────────────────────────────────
-    `## Naming`,
-    `- Report: \`${reportsPath}{type}-${namePattern}.md\``,
-    `- Plan dir: \`${plansPath}/${namePattern}/\``,
-    `- Replace \`{type}\` with: agent name, report type, or context`,
-    `- Replace \`{slug}\` in pattern with: descriptive-kebab-slug`
-  ];
-}
-
 // ═══════════════════════════════════════════════════════════════════════════
 // MAIN EXECUTION
 // ═══════════════════════════════════════════════════════════════════════════
@@ -214,36 +39,34 @@ async function main() {
     const payload = JSON.parse(stdin);
     if (wasRecentlyInjected(payload.transcript_path)) process.exit(0);
 
-    const sessionId = process.env.CK_SESSION_ID || null;
-    const config = loadConfig({ includeProject: false, includeAssertions: false });
-    const devRulesPath = resolveWorkflowPath('development-rules.md');
-    const catalogScript = resolveScriptPath('generate_catalogs.py');
-    const skillsVenv = resolveSkillsVenv();
-    const { reportsPath, gitBranch, planLine, namePattern, validationMode, validationMin, validationMax } = buildPlanContext(sessionId, config);
+    // Get session ID from hook input or env var
+    const sessionId = payload.session_id || process.env.CK_SESSION_ID || null;
 
-    const output = buildReminder({
-      thinkingLanguage: config.locale?.thinkingLanguage,
-      responseLanguage: config.locale?.responseLanguage,
-      devRulesPath,
-      catalogScript,
-      skillsVenv,
-      reportsPath,
-      plansPath: normalizePath(config.paths?.plans) || 'plans',
-      docsPath: normalizePath(config.paths?.docs) || 'docs',
-      planLine,
-      gitBranch,
-      namePattern,
-      validationMode,
-      validationMin,
-      validationMax
-    });
+    // Issue #327: Use CWD as base for subdirectory workflow support
+    // The baseDir is passed to buildReminderContext for absolute path resolution
+    const baseDir = process.cwd();
 
-    console.log(output.join('\n'));
+    // Use shared context builder with baseDir for absolute paths
+    const { content } = buildReminderContext({ sessionId, baseDir });
+
+    console.log(content);
     process.exit(0);
   } catch (error) {
     console.error(`Dev rules hook error: ${error.message}`);
     process.exit(0);
   }
-}
+  }
 
-main();
+  main();
+} catch (e) {
+  // Minimal crash logging (zero deps — only Node builtins)
+  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: p.basename(__filename, '.cjs'), status: 'crash', error: e.message }) + '\n');
+  } catch (_) {}
+  process.exit(0); // fail-open
+}