@ghl-ai/aw 0.1.93 → 0.2.1

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, BARE_SLASH_COMMANDS } = require('./aw-usage-commands');
 
 const SENDER_SCRIPT = path.join(__dirname, '..', 'hooks', 'aw-usage-telemetry-send.js');
 const AW_HOME = path.join(os.homedir(), '.aw');
@@ -169,24 +171,31 @@ function resolveProjectHash(context) {
 }
 
 // ── Session file cleanup ─────────────────────────────────────────────
-// Prune session files older than SESSION_MAX_AGE_MS to prevent unbounded growth.
-// Called once per session start — best-effort, never blocks.
+// Prune session files idle longer than SESSION_FILE_RETENTION_MS to prevent
+// unbounded growth. Called once per session start — best-effort, never blocks.
 
-const SESSION_MAX_AGE_MS = 72 * 60 * 60 * 1000; // 72 hours
+const SESSION_MAX_AGE_MS = 72 * 60 * 60 * 1000; // 72 hours: v1 commit link only
+// Long enough that a session's aw_skills survive until its last commit.
+const SESSION_FILE_RETENTION_MS = 5 * 24 * 60 * 60 * 1000;
 
 function pruneStaleSessionFiles() {
+  let entries;
   try {
-    const entries = fs.readdirSync(SESSION_DIR);
-    const now = Date.now();
-    for (const entry of entries) {
-      if (!entry.endsWith('.json')) continue;
+    entries = fs.readdirSync(SESSION_DIR);
+  } catch {
+    return; // No sessions folder yet.
+  }
+  const now = Date.now();
+  for (const entry of entries) {
+    // .tmp: left by a crash between an atomic write and its rename.
+    if (!entry.endsWith('.json') && !entry.endsWith('.seq') && !entry.endsWith('.tmp')) continue;
+    try {
       const filePath = path.join(SESSION_DIR, entry);
-      const stat = fs.statSync(filePath);
-      if (now - stat.mtimeMs > SESSION_MAX_AGE_MS) {
-        fs.unlinkSync(filePath);
-      }
+      if (now - fs.statSync(filePath).mtimeMs > SESSION_FILE_RETENTION_MS) fs.unlinkSync(filePath);
+    } catch {
+      // Gone meanwhile, or not a plain file: skip it and keep pruning the rest.
     }
-  } catch { /* best effort */ }
+  }
 }
 
 // ── Session model persistence ────────────────────────────────────────
@@ -211,6 +220,8 @@ function readSessionModel(sessionId) {
 
 function readSessionState(sessionId) {
   if (!sessionId) return {};
+  // Keep the session's AW-skills file alive with the session, main file or not.
+  try { const now = new Date(); fs.utimesSync(awSkillsPath(sessionId), now, now); } catch { /* none recorded yet */ }
   try {
     const filePath = path.join(SESSION_DIR, sessionId + '.json');
     const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
@@ -289,6 +300,156 @@ 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;
+
+// aw_skills: the AW skills and stages this session ran, as the harness reported
+// them. The prepare-commit-msg hook writes them as the AW-Skills trailer; the
+// server decides which count as SDLC. Only where a skill came from is checked
+// here, so non-AW skill names never reach a commit.
+const AW_SKILLS_MAX = 20;
+const SAFE_AW_SKILL = /^[a-z0-9:_/$.-]{1,60}$/;
+// The AW router in any form: using-aw-skills, aw:/platform-core:using-aw-skills,
+// aw-using-aw-skills, platform-core-using-aw-skills (registry link folders).
+const ROUTER_SKILL = /(?:^|[:/-])using-aw-skills$/;
+
+// Typed forms other than slash_ns only match `aw-` names (aw-usage-commands.js);
+// slash_ns also carries other plugins' namespaces (`/caveman`, `/codex:rescue`).
+function isAwTypedCommand(name, commandForm) {
+  return commandForm !== 'slash_ns' || name.startsWith('aw:') || BARE_SLASH_COMMANDS.has(name);
+}
+
+/** The aw_skills entry for an event, or null when it is not AW evidence. */
+function awSkillEntry(eventType, payload) {
+  let entry = null;
+  if (eventType === 'sdlc_stage_started' || eventType === 'sdlc_stage_completed') {
+    entry = typeof payload?.stage === 'string' ? `stage:${payload.stage.toLowerCase()}` : null;
+  } else if (eventType === 'skill_invoked' && typeof payload?.skill_name === 'string') {
+    const name = payload.skill_name.toLowerCase();
+    const isAw = payload.source === 'user_prompt' ? isAwTypedCommand(name, payload.command_form) : payload.skill_origin === 'aw';
+    entry = isAw ? name : null;
+  }
+  if (!entry || !SAFE_AW_SKILL.test(entry)) return null;
+  return ROUTER_SKILL.test(entry) ? null : entry;
+}
+
+// Own file per session: the older session writers (model, last skill) rewrite
+// <session>.json without the lock, so they could wipe or half-write aw_skills.
+function awSkillsPath(sessionId) {
+  return path.join(SESSION_DIR, sessionId + '.aw.json');
+}
+
+function readAwSkillsState(sessionId) {
+  try {
+    const state = JSON.parse(fs.readFileSync(awSkillsPath(sessionId), 'utf8'));
+    return state && typeof state === 'object' ? state : {};
+  } catch {
+    // Missing or unreadable: no AW skills recorded for this session.
+    return {};
+  }
+}
+
+function recordSessionAwSkill(sessionId, entry, { now = Date.now() } = {}) {
+  if (!sessionId || sessionId === 'unknown') return;
+  const write = () => {
+    const state = readAwSkillsState(sessionId);
+    const skills = Array.isArray(state.aw_skills) ? state.aw_skills : [];
+    const filePath = awSkillsPath(sessionId);
+    const tmpPath = `${filePath}.${process.pid}.${crypto.randomUUID()}.tmp`;
+    fs.writeFileSync(tmpPath, JSON.stringify({
+      aw_skills: skills.includes(entry) || skills.length >= AW_SKILLS_MAX ? skills : [...skills, entry],
+      aw_used_at: new Date(now).toISOString(),
+    }));
+    fs.renameSync(tmpPath, filePath);
+  };
+  try {
+    fs.mkdirSync(SESSION_DIR, { recursive: true });
+    if (!withFileLock(sessionLockPath(sessionId), write, { waitMs: SESSION_LOCK_WAIT_MS }).ok) write();
+  } catch {
+    // Not writable: commits from this session carry no AW trailer.
+  }
+}
+
+/** The AW skills the session ran, safe for a trailer; [] when unknown. */
+function readSessionAwSkills(sessionId) {
+  if (!sessionId) return [];
+  const skills = readAwSkillsState(sessionId).aw_skills;
+  return Array.isArray(skills) ? skills.filter(s => typeof s === 'string' && SAFE_AW_SKILL.test(s)) : [];
+}
+
+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 +509,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 +726,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 +762,19 @@ 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);
+  const awSkill = awSkillEntry(eventType, payload);
+  if (awSkill) recordSessionAwSkill(sessionId, awSkill);
+
   return {
     session_id: sessionId,
     generation_id: generationId,
@@ -548,13 +783,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 +826,15 @@ module.exports = {
   persistSessionSkill,
   readSessionSkill,
   persistSessionSlashCommand,
+  persistSessionPrompt,
+  claimTypedCommandMatch,
+  readSessionLastPrompt,
   readSessionLastSlashCommand,
+  computeProjectHash,
   findRecentSdlcSessionForProject,
+  findRecentActiveSessionForProject,
+  readSessionAwSkills,
+  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,18 @@ 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 COMMIT_TRAILER_HOOK = awUsageShellScriptPath('aw-usage-commit-trailer.js');
+
+// Adds Agent-Harness, and AW-Skills + AW co-author + AW-Version for sessions
+// that ran an AW skill or stage (see aw-usage-commit-trailer.js). Never fails the commit.
+const ADD_COMMIT_TRAILERS = `\
+    TRAILER_HOOK="${COMMIT_TRAILER_HOOK}"
+    if command -v node >/dev/null 2>&1 && [ -f "$TRAILER_HOOK" ]; then
+      node "$TRAILER_HOOK" "$1" "${AW_CO_AUTHOR}" >/dev/null 2>&1 || true
+    fi`;
 
 const HOME = homedir();
 const HOOKS_DIR = join(HOME, '.aw', 'hooks');
@@ -97,10 +109,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)"
@@ -127,24 +136,15 @@ fi
 exit 0
 `;
 
-// prepare-commit-msg: synchronous hook — appends Co-Authored-By trailer to commits
+// prepare-commit-msg: synchronous hook — adds attribution trailers to commits
 // in AW-linked repos. Skips merge commits and respects AW_NO_COAUTHOR=1 opt-out.
+// Trailers the agent wrote (Claude, Cursor, Codex) are kept.
 const PREPARE_COMMIT_MSG = makeDispatcher('prepare-commit-msg', `\
-# Inject co-author trailer unless it's a merge commit or opt-out is set
+# Add attribution trailers unless it's a merge commit or opt-out is set
 if [ "$2" != "merge" ] && [ "$AW_NO_COAUTHOR" != "1" ]; then
-  # Only brand AW-linked repos (check for .aw/ symlink or worktree)
+  # Only AW-linked repos (check for .aw/ symlink or worktree)
   if [ -L ".aw" ] || [ -f ".aw/.git" ]; then
-    TRAILER="${AW_CO_AUTHOR}"
-    # Replace Claude/Cursor co-author trailers with AW
-    sed -i.bak '/^Co-Authored-By:.*Claude/d' "$1" 2>/dev/null || true
-    sed -i.bak '/^Co-Authored-By:.*noreply@anthropic\\.com/d' "$1" 2>/dev/null || true
-    sed -i.bak '/^Co-Authored-By:.*Cursor/d' "$1" 2>/dev/null || true
-    rm -f "$1.bak"
-    # Only append if not already present (idempotent)
-    if ! grep -qF "$TRAILER" "$1"; then
-      echo "" >> "$1"
-      echo "$TRAILER" >> "$1"
-    fi
+${ADD_COMMIT_TRAILERS}
   fi
 fi`);
 
@@ -253,19 +253,9 @@ case "$(pwd)" in /tmp/aw-*|/var/folders/*/aw-*|*/.aw|*/.aw/*) exit 0 ;; esac
 # Opt-out escape hatch
 [ "$AW_NO_COAUTHOR" = "1" ] && exit 0
 
-# Only brand AW-linked repos (check for .aw/ symlink or worktree)
+# Only AW-linked repos (check for .aw/ symlink or worktree)
 if [ -L ".aw" ] || [ -f ".aw/.git" ]; then
-  TRAILER="${AW_CO_AUTHOR}"
-  # Replace Claude/Cursor co-author trailers with AW
-  sed -i.bak '/^Co-Authored-By:.*Claude/d' "$1" 2>/dev/null || true
-  sed -i.bak '/^Co-Authored-By:.*noreply@anthropic\\.com/d' "$1" 2>/dev/null || true
-  sed -i.bak '/^Co-Authored-By:.*Cursor/d' "$1" 2>/dev/null || true
-  rm -f "$1.bak"
-  # Only append if not already present (idempotent)
-  if ! grep -qF "$TRAILER" "$1"; then
-    echo "" >> "$1"
-    echo "$TRAILER" >> "$1"
-  fi
+${ADD_COMMIT_TRAILERS}
 fi
 
 exit 0
@@ -281,10 +271,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)"