@ghl-ai/aw 0.1.93 → 0.2.0

package/hooks/aw-usage/lib/aw-usage-stage-events.js

@@ -0,0 +1,179 @@
+/**
+ * AW Usage Telemetry — loop-aware stage events (B4).
+ *
+ *   isCompletionStatus(status)               — P13 text rule for a finished stage
+ *   decideStageEvents(history, { stage, status, now }) — pure: events + new history
+ *   processStateJsonWrite({ filePath, … })   — read the written state.json, update the
+ *                                              laptop history, return the events to send
+ *
+ * A write to .aw_docs/features/<slug>/state.json is a start when its `stage`
+ * is new or changed (or the same stage again after it was completed), and a
+ * completion when its `status` reads as finished. History lives on the laptop
+ * in ~/.aw/telemetry/stages/<project_hash>/<slug>.json (P12): the hook never
+ * writes into the repo. When the stage skills write a fixed status and a
+ * stage history into state.json (https://app.clickup.com/t/14zhcp5e0bh), only
+ * the input of decideStageEvents changes.
+ */
+
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const { withFileLock, sessionFileName } = require('./aw-usage-envelope');
+const { commandKey } = require('./aw-usage-commands');
+
+const STAGES_DIR = path.join(os.homedir(), '.aw', 'telemetry', 'stages');
+// `investigate` is a valid stage outside the plan → ship order.
+const KNOWN_STAGES = new Set(['plan', 'build', 'test', 'verify', 'review', 'deploy', 'ship', 'investigate']);
+const STAGE_FOR_COMMAND = {
+  plan: 'plan', build: 'build', execute: 'build', test: 'test', verify: 'verify',
+  review: 'review', deploy: 'deploy', ship: 'ship', investigate: 'investigate',
+};
+const STATE_JSON = /(?:^|\/)\.aw_docs\/features\/([^/]+)\/state\.json$/;
+const MAX_STATE_BYTES = 1024 * 1024;
+const MAX_STATUS_RAW = 60;
+const MAX_PATTERN_ID = 100;
+const COMPLETED = /(?:^|_)(?:complete|completed|done|passed|pass)(?:_|$)/;
+const NOT_COMPLETED = /(?:^|_)(?:blocked|failed|fail)(?:_|$)/;
+
+// `stage`: the stage the write is in. `ready_for_<stage>` for that same stage
+// means it has not started yet, so it is not a completion.
+function isCompletionStatus(status, stage = null) {
+  if (typeof status !== 'string' || !status) return false;
+  const value = status.toLowerCase().replace(/[^a-z0-9]+/g, '_');
+  if (NOT_COMPLETED.test(value)) return false;
+  if (value.startsWith('ready_for_')) return !stage || value !== `ready_for_${stage}`;
+  return COMPLETED.test(value);
+}
+
+function decideStageEvents(history, { stage, status, now }) {
+  if (!KNOWN_STAGES.has(stage)) return { events: [], history };
+  const entries = Array.isArray(history?.entries) ? [...history.entries] : [];
+  const events = [];
+  const completion = isCompletionStatus(status, stage);
+  const current = entries[entries.length - 1];
+
+  const isNewStage = !current || current.stage !== stage;
+  if (isNewStage || (current.completed && !completion)) {
+    const loopIndex = entries.filter(entry => entry.stage === stage).length;
+    events.push({ type: 'started', stage, from_stage: current ? current.stage : null, loop_index: loopIndex });
+    entries.push({ stage, loop_index: loopIndex, started_at: now, completed: false });
+  }
+
+  const open = entries[entries.length - 1];
+  if (completion && open.stage === stage && !open.completed) {
+    events.push({ type: 'completed', stage, loop_index: open.loop_index });
+    entries[entries.length - 1] = { ...open, completed: true };
+  }
+  return { events, history: { entries } };
+}
+
+/** 'user' when the last prompt typed the command for this stage, else 'agent'. */
+function stageStartedBy(stage, lastPromptCommands) {
+  const typed = Array.isArray(lastPromptCommands) ? lastPromptCommands : [];
+  return typed.some(command => STAGE_FOR_COMMAND[commandKey(command?.raw_name)] === stage) ? 'user' : 'agent';
+}
+
+function readStateJson(absolutePath) {
+  try {
+    if (fs.statSync(absolutePath).size > MAX_STATE_BYTES) return null;
+    const state = JSON.parse(fs.readFileSync(absolutePath, 'utf8'));
+    return state && typeof state === 'object' && !Array.isArray(state) ? state : null;
+  } catch {
+    // Unreadable or not JSON: no stage event for this write.
+    return null;
+  }
+}
+
+function readHistory(historyPath) {
+  try {
+    return JSON.parse(fs.readFileSync(historyPath, 'utf8'));
+  } catch {
+    // First write for this feature on this laptop.
+    return { entries: [] };
+  }
+}
+
+// tmp file + rename: a crash mid-write never leaves half a history behind.
+function writeHistory(historyPath, history) {
+  const tmpPath = `${historyPath}.${process.pid}.tmp`;
+  fs.writeFileSync(tmpPath, JSON.stringify(history), { mode: 0o600 });
+  fs.renameSync(tmpPath, historyPath);
+}
+
+function toEvent(decision, { slug, relativePath, state, startedBy }) {
+  if (decision.type === 'started') {
+    const patternId = typeof state.pattern_id === 'string' && state.pattern_id.length <= MAX_PATTERN_ID ? state.pattern_id : null;
+    return {
+      eventType: 'sdlc_stage_started',
+      payload: {
+        feature_slug: slug,
+        stage: decision.stage,
+        from_stage: decision.from_stage,
+        loop_index: decision.loop_index,
+        started_by: startedBy,
+        ...(patternId ? { pattern_id: patternId } : {}),
+        file_path: relativePath,
+      },
+    };
+  }
+  return {
+    eventType: 'sdlc_stage_completed',
+    payload: {
+      feature_slug: slug,
+      stage: decision.stage,
+      loop_index: decision.loop_index,
+      status_raw: String(state.status).slice(0, MAX_STATUS_RAW),
+      file_path: relativePath,
+    },
+  };
+}
+
+/**
+ * @param {{ filePath: string, projectRoot: string, projectHash: string|null,
+ *   lastPromptCommands?: Array<{ raw_name: string }>, stagesDir?: string, now?: () => string }} opts
+ * @returns {Array<{ eventType: string, payload: object }>}
+ */
+function processStateJsonWrite({ filePath, projectRoot, projectHash, lastPromptCommands = [], stagesDir = STAGES_DIR, now = () => new Date().toISOString() }) {
+  const norm = String(filePath || '').replace(/\\/g, '/');
+  if (!projectHash || !projectRoot) return [];
+  const root = path.posix.normalize(String(projectRoot).replace(/\\/g, '/')).replace(/\/+$/, '');
+  const isAbsolute = norm.startsWith('/') || /^[A-Za-z]:\//.test(norm);
+  // Resolve `..` before the check, so a path cannot step out of the project.
+  const absolutePath = path.posix.normalize(isAbsolute ? norm : `${root}/${norm}`);
+  // Only the project's own feature folders are read.
+  if (!root || !absolutePath.startsWith(`${root}/`)) return [];
+  const relativePath = absolutePath.slice(root.length + 1);
+  const match = relativePath.match(STATE_JSON);
+  if (!match) return [];
+
+  const state = readStateJson(absolutePath);
+  const stage = typeof state?.stage === 'string' ? state.stage.trim().toLowerCase() : null;
+  if (!state || !KNOWN_STAGES.has(stage)) return [];
+
+  const slug = match[1];
+  const featureDir = path.join(stagesDir, sessionFileName(projectHash));
+  const historyPath = path.join(featureDir, `${sessionFileName(slug)}.json`);
+  try {
+    fs.mkdirSync(featureDir, { recursive: true, mode: 0o700 });
+    const result = withFileLock(`${historyPath}.lock`, () => {
+      const decision = decideStageEvents(readHistory(historyPath), { stage, status: state.status, now: now() });
+      if (decision.events.length > 0) writeHistory(historyPath, decision.history);
+      return decision.events;
+    }, { waitMs: 200 });
+    if (!result.ok) return [];
+    const startedBy = stageStartedBy(stage, lastPromptCommands);
+    return result.value.map(decision => toEvent(decision, { slug, relativePath, state, startedBy }));
+  } catch {
+    // Telemetry folder not writable: no stage event, the rest of the hook is unaffected.
+    return [];
+  }
+}
+
+module.exports = {
+  isCompletionStatus,
+  decideStageEvents,
+  stageStartedBy,
+  processStateJsonWrite,
+};

package/hooks/aw-usage/lib/aw-usage-telemetry.js

@@ -16,6 +16,8 @@ const fs = require('fs');
 const os = require('os');
 const { spawn, execSync } = require('child_process');
 const crypto = require('crypto');
+const { newEventId, readHookVersion, nextSeq, withFileLock } = require('./aw-usage-envelope');
+const { commandKey } = require('./aw-usage-commands');
 
 const SENDER_SCRIPT = path.join(__dirname, '..', 'hooks', 'aw-usage-telemetry-send.js');
 const AW_HOME = path.join(os.homedir(), '.aw');
@@ -179,7 +181,7 @@ function pruneStaleSessionFiles() {
     const entries = fs.readdirSync(SESSION_DIR);
     const now = Date.now();
     for (const entry of entries) {
-      if (!entry.endsWith('.json')) continue;
+      if (!entry.endsWith('.json') && !entry.endsWith('.seq')) continue;
       const filePath = path.join(SESSION_DIR, entry);
       const stat = fs.statSync(filePath);
       if (now - stat.mtimeMs > SESSION_MAX_AGE_MS) {
@@ -289,6 +291,82 @@ function persistSessionSlashCommand(sessionId, slashCommand, context = {}) {
   } catch { /* ignore */ }
 }
 
+// last_prompt and its `matched` list are written under the session lock and
+// replaced atomically (tmp file + rename), so a tool hook never reads half a
+// file or overwrites a newer prompt.
+const SESSION_LOCK_WAIT_MS = 200;
+
+function sessionLockPath(sessionId) {
+  return path.join(SESSION_DIR, sessionId + '.json.lock');
+}
+
+function writeSessionStateAtomic(sessionId, state) {
+  const filePath = path.join(SESSION_DIR, sessionId + '.json');
+  const tmpPath = `${filePath}.${process.pid}.${crypto.randomUUID()}.tmp`;
+  fs.writeFileSync(tmpPath, JSON.stringify(state));
+  fs.renameSync(tmpPath, filePath);
+}
+
+// last_prompt: the commands typed in the most recent prompt (empty for a
+// plain prompt). `matched` lists command keys already paired with a skill
+// load, so only the first matching load gets follows_typed_command.
+function persistSessionPrompt(sessionId, { turn_id: turnId = null, commands = [] } = {}) {
+  if (!sessionId || sessionId === 'unknown') return;
+  const write = () => {
+    const state = readSessionState(sessionId);
+    writeSessionStateAtomic(sessionId, {
+      ...state,
+      last_prompt: {
+        turn_id: turnId || null,
+        commands: commands.map(({ raw_name, command_form, namespace }) => ({ raw_name, command_form, namespace })),
+        matched: [],
+        at: new Date().toISOString(),
+      },
+    });
+  };
+  try {
+    fs.mkdirSync(SESSION_DIR, { recursive: true });
+    // A new prompt must land even when a tool hook holds the lock too long.
+    if (!withFileLock(sessionLockPath(sessionId), write, { waitMs: SESSION_LOCK_WAIT_MS }).ok) write();
+  } catch { /* ignore: best effort, like the other session records */ }
+}
+
+const TYPED_COMMAND_WINDOW_MS = 10 * 60 * 1000;
+
+function isCurrentPrompt(prompt, turnId, now) {
+  if (prompt.turn_id && turnId) return prompt.turn_id === turnId;
+  return now - parseUpdatedAt(prompt.at) <= TYPED_COMMAND_WINDOW_MS;
+}
+
+// B1 follows_typed_command: true once per typed command, for the first skill
+// load whose key matches it in the same prompt (same turn, or within 10
+// minutes when the IDE gives no turn id). The pairing is recorded in
+// last_prompt.matched under a lock so two tool hooks cannot both claim it.
+function claimTypedCommandMatch(sessionId, turnId, skillName, { now = Date.now() } = {}) {
+  const key = commandKey(skillName);
+  if (!sessionId || !key) return false;
+  try {
+    const result = withFileLock(sessionLockPath(sessionId), () => {
+      const state = readSessionState(sessionId);
+      const prompt = state.last_prompt;
+      if (!prompt || !Array.isArray(prompt.commands) || !isCurrentPrompt(prompt, turnId, now)) return false;
+      const matched = Array.isArray(prompt.matched) ? prompt.matched : [];
+      if (matched.includes(key) || !prompt.commands.some(command => commandKey(command.raw_name) === key)) return false;
+      writeSessionStateAtomic(sessionId, { ...state, last_prompt: { ...prompt, matched: [...matched, key] } });
+      return true;
+    }, { waitMs: SESSION_LOCK_WAIT_MS });
+    return result.ok && result.value === true;
+  } catch {
+    // Session file not writable: the field is omitted for this event.
+    return false;
+  }
+}
+
+function readSessionLastPrompt(sessionId) {
+  const prompt = readSessionState(sessionId)?.last_prompt;
+  return prompt && Array.isArray(prompt.commands) ? prompt : null;
+}
+
 function readSessionLastSlashCommand(sessionId) {
   const cmd = readSessionState(sessionId)?.last_slash_command;
   if (!cmd?.command_name) return null;
@@ -348,6 +426,59 @@ function findRecentSdlcSessionForProject(cwd, maxAgeMs = SESSION_MAX_AGE_MS) {
   return best;
 }
 
+// ── Session activity index (B9) ──────────────────────────────────────
+// sessions/by-project/<project_hash>.activity.json lists the IDE sessions
+// active in a project in the last 2 hours. Every event except commit_created
+// touches it; the commit hook reads it to name the IDE a commit came from.
+// The v1 by-project/<hash>.json SDLC index is separate and unchanged.
+
+const ACTIVITY_WINDOW_MS = 2 * 60 * 60 * 1000;
+
+function activityIndexPath(projectHash) {
+  return path.join(SESSION_PROJECT_DIR, `${projectHash}.activity.json`);
+}
+
+function readActivityIndex(projectHash) {
+  try {
+    const sessions = JSON.parse(fs.readFileSync(activityIndexPath(projectHash), 'utf8'))?.sessions;
+    return sessions && typeof sessions === 'object' && !Array.isArray(sessions) ? sessions : {};
+  } catch {
+    // No index yet, or unreadable: no active sessions known.
+    return {};
+  }
+}
+
+function recentEntries(sessions, now) {
+  return Object.entries(sessions).filter(([, entry]) => now - parseUpdatedAt(entry?.last_active_at) <= ACTIVITY_WINDOW_MS);
+}
+
+function touchSessionActivity(projectHash, sessionId, harness, { now = Date.now() } = {}) {
+  if (!projectHash || !sessionId || sessionId === 'unknown') return;
+  const filePath = activityIndexPath(projectHash);
+  try {
+    fs.mkdirSync(SESSION_PROJECT_DIR, { recursive: true });
+    withFileLock(`${filePath}.lock`, () => {
+      const sessions = Object.fromEntries(recentEntries(readActivityIndex(projectHash), now));
+      sessions[sessionId] = { harness, last_active_at: new Date(now).toISOString() };
+      const tmpPath = `${filePath}.${process.pid}.${crypto.randomUUID()}.tmp`;
+      fs.writeFileSync(tmpPath, JSON.stringify({ sessions }));
+      fs.renameSync(tmpPath, filePath);
+    });
+  } catch {
+    // Index not writable: commits from this project carry no origin fields.
+  }
+}
+
+/** Most recent session active in the project in the last 2 hours, or null. */
+function findRecentActiveSessionForProject(projectHash, { now = Date.now() } = {}) {
+  if (!projectHash) return null;
+  const recent = recentEntries(readActivityIndex(projectHash), now)
+    .sort(([, a], [, b]) => parseUpdatedAt(b.last_active_at) - parseUpdatedAt(a.last_active_at));
+  if (recent.length === 0) return null;
+  const [sessionId, entry] = recent[0];
+  return { session_id: sessionId, harness: typeof entry.harness === 'string' ? entry.harness : 'unknown', ambiguous: recent.length > 1 };
+}
+
 // ── Short-TTL dedupe guards ──────────────────────────────────────────
 
 function normalizeDedupePart(value) {
@@ -512,6 +643,14 @@ function readLastAssistantFromTranscript(transcriptPath) {
 
 // ── buildEvent ───────────────────────────────────────────────────────
 
+const SCHEMA_VERSION = 2;
+let _hookVersion;
+
+function getHookVersion() {
+  if (_hookVersion === undefined) _hookVersion = readHookVersion();
+  return _hookVersion;
+}
+
 function buildEvent(hookInput, eventType, payload) {
   const input = hookInput || {};
   const cfg = loadConfig();
@@ -540,6 +679,17 @@ function buildEvent(hookInput, eventType, payload) {
     || (input.workspace_roots && input.workspace_roots[0])
     || null;
 
+  // A8: the email the IDE itself is signed in with, when the IDE provides one.
+  // Cursor passes it in the hook input and to hook scripts; Claude Code and Codex do not.
+  const rawAccountEmail = input.user_email || process.env.CURSOR_USER_EMAIL;
+  const accountEmail = typeof rawAccountEmail === 'string' && rawAccountEmail ? rawAccountEmail.slice(0, 200) : null;
+
+  // v2 envelope (spec 4.2). seq is omitted when it cannot be taken safely.
+  const hookVersion = getHookVersion();
+  const seq = nextSeq(sessionId);
+  const projectHash = computeProjectHash(cwd);
+  if (eventType !== 'commit_created') touchSessionActivity(projectHash, sessionId, harness);
+
   return {
     session_id: sessionId,
     generation_id: generationId,
@@ -548,13 +698,17 @@ function buildEvent(hookInput, eventType, payload) {
     machine_id: cfg.machine_id || 'unknown',
     github_user: git.user || input.user_email || null,
     github_email: git.email || input.user_email || null,
-    project_hash: computeProjectHash(cwd),
+    project_hash: projectHash,
     aw_version: awCli.version,
     aw_cli_version: awCli.version,
     aw_cli_version_source: awCli.source,
     event: eventType,
     client_ts: new Date().toISOString(),
-    payload: payload || {},
+    ...(accountEmail ? { account_email: accountEmail } : {}),
+    event_id: newEventId(),
+    schema_version: SCHEMA_VERSION,
+    ...(hookVersion ? { hook_version: hookVersion } : {}),
+    payload: { ...(payload || {}), ...(seq ? { seq } : {}) },
   };
 }
 
@@ -587,8 +741,14 @@ module.exports = {
   persistSessionSkill,
   readSessionSkill,
   persistSessionSlashCommand,
+  persistSessionPrompt,
+  claimTypedCommandMatch,
+  readSessionLastPrompt,
   readSessionLastSlashCommand,
+  computeProjectHash,
   findRecentSdlcSessionForProject,
+  findRecentActiveSessionForProject,
+  touchSessionActivity,
   readLastAssistantFromTranscript,
   resolvePromptText,
   getAwCliVersionDetails,

package/hooks/aw-usage/package.json

@@ -1,4 +1,4 @@
 {
   "type": "commonjs",
-  "_comment": "Override parent libs/aw/package.json's \"type\": \"module\". The aw-usage hook scripts use require() because they're invoked by Claude Code / Cursor / Codex hooks via `node <path>` — they need to behave the same when bundled in @ghl-ai/aw as when installed by aw-ecc directly into ~/.claude/scripts/hooks/."
+  "_comment": "Override parent libs/aw/package.json's \"type\": \"module\". The aw-usage hook scripts use require() because Claude Code, Cursor, Codex and git run them with `node <path>`. aw copies this file with the scripts to ~/.aw/aw-usage/ so they stay CommonJS there too."
 }

package/hooks/codex-home.mjs

@@ -1,5 +1,6 @@
 import { join } from 'node:path';
 
+import { awUsageShellScriptPath } from '../aw-usage-wiring.mjs';
 import { getSupportedHarnessPhaseEntries } from '../hook-manifest.mjs';
 import {
   buildRegistryDelegatingPhaseScriptWithTelemetry,
@@ -32,7 +33,7 @@ const CODEX_HOME_PHASE_BLUEPRINTS = {
           '$HOME/.aw/.aw_registry/platform/core/skills/using-aw-skills/hooks/session-start.sh',
         ],
         warningMessage: 'WARNING: AW using-aw-skills hook not found in ~/.aw_registry. Run aw init or aw pull platform.',
-        telemetryHookPath: '$HOME/.aw-ecc/scripts/hooks/aw-usage-session-start.js',
+        telemetryHookPath: awUsageShellScriptPath('aw-usage-session-start.js'),
         harnessEnv: 'codex',
       });
     },
@@ -60,7 +61,7 @@ set -euo pipefail
 # Capture stdin so we can feed it to both telemetry and the reminder delegate.
 STDIN=$(cat)
 
-TELEMETRY_HOOK="$HOME/.aw-ecc/scripts/hooks/aw-usage-prompt-submit.js"
+TELEMETRY_HOOK="${awUsageShellScriptPath('aw-usage-prompt-submit.js')}"
 if [[ -f "$TELEMETRY_HOOK" ]] && command -v node >/dev/null 2>&1; then
   printf '%s' "$STDIN" | AW_HARNESS=codex node "$TELEMETRY_HOOK" >/dev/null 2>&1 || true
 fi
@@ -116,9 +117,10 @@ ${this.scriptMarker}
 set -euo pipefail
 
 # AW PostToolUse phase for Codex — usage telemetry.
-# Codex exposes PostToolUse for Bash commands only; telemetry derives
-# tool_error and Bash-based fallback skill signals from the payload.
-TELEMETRY_HOOK="$HOME/.aw-ecc/scripts/hooks/aw-usage-post-tool-use.js"
+# The interactive Codex app sends PostToolUse for Bash commands and for
+# apply_patch (codex exec may send none); telemetry derives tool_error, shell
+# skill reads and stage documents from the payload.
+TELEMETRY_HOOK="${awUsageShellScriptPath('aw-usage-post-tool-use.js')}"
 if [[ -f "$TELEMETRY_HOOK" ]]; then
   exec node "$TELEMETRY_HOOK"
 fi
@@ -148,7 +150,7 @@ set -euo pipefail
 # Capture stdin before invoking non-blocking sidecars.
 STDIN=$(cat)
 
-TELEMETRY_HOOK="$HOME/.aw-ecc/scripts/hooks/aw-usage-stop.js"
+TELEMETRY_HOOK="${awUsageShellScriptPath('aw-usage-stop.js')}"
 if [[ -f "$TELEMETRY_HOOK" ]] && command -v node >/dev/null 2>&1; then
   printf '%s' "$STDIN" | AW_HARNESS=codex node "$TELEMETRY_HOOK" >/dev/null 2>&1 || true
 fi

package/hooks.mjs

@@ -10,6 +10,9 @@ import { join } from 'node:path';
 import { homedir } from 'node:os';
 import * as fmt from './fmt.mjs';
 import { AW_CO_AUTHOR } from './constants.mjs';
+import { awUsageShellScriptPath } from './aw-usage-wiring.mjs';
+
+const COMMIT_TELEMETRY_HOOK = awUsageShellScriptPath('aw-usage-commit-created.js');
 
 const HOME = homedir();
 const HOOKS_DIR = join(HOME, '.aw', 'hooks');
@@ -97,10 +100,7 @@ fi
 
 # Fire commit_created telemetry if commit has AW co-author trailer
 if git log -1 --format='%b' HEAD 2>/dev/null | grep -qF "Co-Authored-By: AW"; then
-  TELEMETRY_HOOK="$HOME/.claude/scripts/hooks/aw-usage-commit-created.js"
-  if [ ! -f "$TELEMETRY_HOOK" ]; then
-    TELEMETRY_HOOK="$HOME/.aw-ecc/scripts/hooks/aw-usage-commit-created.js"
-  fi
+  TELEMETRY_HOOK="${COMMIT_TELEMETRY_HOOK}"
   if command -v node >/dev/null 2>&1 && [ -f "$TELEMETRY_HOOK" ]; then
     COMMIT_HASH="$(git rev-parse HEAD 2>/dev/null || echo unknown)"
     BRANCH="$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo unknown)"
@@ -281,10 +281,7 @@ case "$(pwd)" in /tmp/aw-*|/var/folders/*/aw-*|*/.aw|*/.aw/*) exit 0 ;; esac
 
 # Fire commit_created telemetry if commit has AW co-author trailer
 if git log -1 --format='%b' HEAD 2>/dev/null | grep -qF "Co-Authored-By: AW"; then
-  TELEMETRY_HOOK="$HOME/.claude/scripts/hooks/aw-usage-commit-created.js"
-  if [ ! -f "$TELEMETRY_HOOK" ]; then
-    TELEMETRY_HOOK="$HOME/.aw-ecc/scripts/hooks/aw-usage-commit-created.js"
-  fi
+  TELEMETRY_HOOK="${COMMIT_TELEMETRY_HOOK}"
   if command -v node >/dev/null 2>&1 && [ -f "$TELEMETRY_HOOK" ]; then
     COMMIT_HASH="$(git rev-parse HEAD 2>/dev/null || echo unknown)"
     BRANCH="$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo unknown)"