@ghl-ai/aw 0.1.36-beta.99 → 0.1.37-beta.10

package/cli.mjs

@@ -4,8 +4,9 @@ import { readFileSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import * as fmt from './fmt.mjs';
-import { chalk } from './fmt.mjs';
+import { chalk, CancelError } from './fmt.mjs';
 import { checkForUpdate, notifyUpdate } from './update.mjs';
+import { startSpan } from './telemetry.mjs';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const VERSION = JSON.parse(readFileSync(join(__dirname, 'package.json'), 'utf8')).version;
@@ -20,6 +21,7 @@ const COMMANDS = {
   link:    () => import('./commands/link-project.mjs').then(m => m.linkProjectCommand),
   nuke:    () => import('./commands/nuke.mjs').then(m => m.nukeCommand),
   daemon:  () => import('./commands/daemon.mjs').then(m => m.daemonCommand),
+  telemetry: () => import('./commands/telemetry.mjs').then(m => m.telemetryCommand),
 };
 
 function parseArgs(argv) {
@@ -101,6 +103,11 @@ function printHelp() {
     cmd('aw daemon uninstall', 'Stop the background daemon'),
     cmd('aw daemon status', 'Check if daemon is running'),
 
+    sec('Settings'),
+    cmd('aw telemetry status', 'Show telemetry status'),
+    cmd('aw telemetry disable', 'Opt out of anonymous analytics'),
+    cmd('aw telemetry enable', 'Re-enable analytics'),
+
     sec('Examples'),
     '',
     `  ${chalk.dim('# Pull content from registry using path')}`,
@@ -147,9 +154,21 @@ export async function run(argv) {
   }
 
   if (command && COMMANDS[command]) {
+    const span = await startSpan(command, args);
+    span.notice();
     args._updateCheck = updateCheck;
-    const handler = await COMMANDS[command]();
-    await handler(args);
+    try {
+      const handler = await COMMANDS[command]();
+      await handler(args);
+      await span.end({ status: 'completed' });
+    } catch (err) {
+      if (err instanceof CancelError) {
+        await span.end({ status: 'cancelled', error_type: 'CancelError' });
+        process.exit(err.exitCode ?? 1);
+      }
+      await span.end({ status: 'failed', error_type: err.constructor.name });
+      throw err;
+    }
     notifyUpdate(await updateCheck);
     return;
   }
@@ -159,5 +178,5 @@ export async function run(argv) {
     process.exit(0);
   }
 
-  fmt.cancel(`Unknown command: ${command}`);
+  fmt.cancelAndExit(`Unknown command: ${command}`);
 }

package/commands/init.mjs

@@ -74,7 +74,7 @@ function installIdeTasks() {
       {
         label: 'aw: sync registry',
         type: 'shell',
-        command: 'aw init --silent',
+        command: 'AW_TRIGGER=ide:task aw init --silent',
         presentation: { reveal: 'silent', panel: 'shared', close: true },
         runOptions: { runOn: 'folderOpen' },
         problemMatcher: [],

package/commands/nuke.mjs

@@ -204,8 +204,8 @@ function removeIdeTasks() {
 
 export async function nukeCommand(args) {
   // Catch unhandled errors and surface them instead of letting clack show generic "Something went wrong"
-  process.on('uncaughtException', (e) => { fmt.cancel(`Unexpected error: ${e.message}`); });
-  process.on('unhandledRejection', (e) => { fmt.cancel(`Unexpected error: ${e?.message ?? e}`); });
+  process.on('uncaughtException', (e) => { fmt.cancelAndExit(`Unexpected error: ${e.message}`); });
+  process.on('unhandledRejection', (e) => { fmt.cancelAndExit(`Unexpected error: ${e?.message ?? e}`); });
 
   fmt.intro('aw nuke');
 

package/commands/pull.mjs

@@ -1,7 +1,7 @@
 // commands/pull.mjs — Pull content from registry using persistent git clone
 
-import { mkdirSync, existsSync, readdirSync, copyFileSync, unlinkSync, rmdirSync, lstatSync } from 'node:fs';
-import { join, relative, extname } from 'node:path';
+import { existsSync, lstatSync } from 'node:fs';
+import { join, extname } from 'node:path';
 import { homedir } from 'node:os';
 import { exec as execCb } from 'node:child_process';
 import { promisify } from 'node:util';
@@ -11,7 +11,7 @@ import * as config from '../config.mjs';
 import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
 import { fetchAndMerge, addToSparseCheckout, removeFromSparseCheckout, syncWorktreeSparseCheckout, isValidClone, findNearestWorktree, rebaseOntoOriginMain } from '../git.mjs';
-import { REGISTRY_DIR, REGISTRY_REPO, REGISTRY_URL, DOCS_SOURCE_DIR } from '../constants.mjs';
+import { REGISTRY_DIR, REGISTRY_REPO, REGISTRY_URL } from '../constants.mjs';
 import { linkWorkspace } from '../link.mjs';
 import { generateCommands, copyInstructions } from '../integrate.mjs';
 
@@ -25,7 +25,7 @@ export async function pullCommand(args) {
   const silent = args['--silent'] === true || args._silent === true;
 
   const log = {
-    cancel: silent ? () => { process.exit(0); } : fmt.cancel,
+    cancel: silent ? (msg) => { throw new fmt.CancelError(msg || 'silent cancel', { exitCode: 0 }); } : fmt.cancel,
     logInfo: silent ? () => {} : fmt.logInfo,
     logSuccess: silent ? () => {} : fmt.logSuccess,
     logStep: silent ? () => {} : fmt.logStep,
@@ -74,14 +74,48 @@ export async function pullCommand(args) {
     }
   }
 
-  // Guard: if a rebase or merge is already in progress on awHome, don't proceed
+  // Guard: if a rebase or merge is already in progress on awHome, try to continue it.
   const awGitDir = join(AW_HOME, '.git');
-  if (existsSync(join(awGitDir, 'rebase-merge')) ||
-      existsSync(join(awGitDir, 'rebase-apply')) ||
-      existsSync(join(awGitDir, 'MERGE_HEAD'))) {
-    log.logWarn('Rebase paused — resolve conflicts in your IDE, then run `aw pull` again.');
-    if (!silent) fmt.outro(chalk.yellow('Pull skipped'));
-    return;
+  const rebaseInProgress = existsSync(join(awGitDir, 'rebase-merge')) || existsSync(join(awGitDir, 'rebase-apply'));
+  const mergeInProgress = existsSync(join(awGitDir, 'MERGE_HEAD'));
+  if (rebaseInProgress || mergeInProgress) {
+    // Check for still-unresolved files (conflict markers present in index)
+    let unresolved = [];
+    try {
+      const { stdout } = await exec(`git -C "${AW_HOME}" diff --name-only --diff-filter=U`);
+      unresolved = stdout.trim().split('\n').filter(Boolean);
+    } catch { /* best effort */ }
+
+    if (unresolved.length > 0) {
+      // Still has conflicts — user needs to finish resolving
+      log.logWarn(`Rebase paused — resolve conflicts in your IDE, then run \`aw pull\` again.`);
+      if (!silent) fmt.outro(chalk.yellow('Pull skipped'));
+      return;
+    }
+
+    // All conflicts resolved (files are staged) — continue the rebase automatically
+    try {
+      await exec(`git -C "${AW_HOME}" rebase --continue`, { env: { ...process.env, GIT_EDITOR: 'true' } });
+      log.logStep('Rebase continued after conflict resolution.');
+      // Force-push if on a push branch so origin stays in sync
+      const { stdout: branchOut } = await exec(`git -C "${AW_HOME}" rev-parse --abbrev-ref HEAD`);
+      const resumedBranch = branchOut.trim();
+      if (['upload/', 'remove/', 'sync/'].some(p => resumedBranch.startsWith(p))) {
+        try { await exec(`git -C "${AW_HOME}" push --force-with-lease origin "${resumedBranch}"`); } catch { /* non-blocking */ }
+      }
+    } catch {
+      // Could happen if there are more conflicting commits in the rebase sequence,
+      // or if the resolved changes result in an empty commit (skip it).
+      try {
+        await exec(`git -C "${AW_HOME}" rebase --skip`);
+        log.logStep('Empty commit skipped during rebase continuation.');
+      } catch {
+        log.logWarn('Rebase continuation failed — check `~/.aw` and resolve manually.');
+        if (!silent) fmt.outro(chalk.yellow('Pull skipped'));
+        return;
+      }
+    }
+    // Fall through to re-link IDE dirs after successful rebase continuation
   }
 
   // Fetch + merge latest
@@ -89,7 +123,7 @@ export async function pullCommand(args) {
   s.start('Fetching latest from registry...');
   let fetchResult = { updated: false, conflicts: [] };
   try {
-    fetchResult = await fetchAndMerge(AW_HOME);
+    fetchResult = await fetchAndMerge(AW_HOME, { silent });
     s.stop(fetchResult.updated ? 'Registry updated' : 'Already up to date');
   } catch (e) {
     s.stop(chalk.yellow('Fetch failed'));
@@ -113,13 +147,13 @@ export async function pullCommand(args) {
 
   if (fetchResult.conflicts.length > 0) {
     if (!silent) {
-      // Interactive mode: abort the merge so the working tree is clean again
-      try { await exec(`git -C "${AW_HOME}" merge --abort`); } catch { /* best effort */ }
+      // Interactive mode: rebase is paused with conflict markers in the working tree.
+      // Leave it for the user to resolve in their IDE, then re-run `aw pull`.
       log.logWarn(`Merge conflict in: ${fetchResult.conflicts.join(', ')}`);
       log.logWarn('Merge aborted — your branch is unchanged. Resolve conflicts and run `aw pull` again.');
       return;
     }
-    // Silent mode: leave conflict markers in place for IDE to show
+    // Silent mode: rebase was already aborted in fetchAndMerge; just report.
     log.logWarn(`Conflicts in: ${fetchResult.conflicts.join(', ')}`);
   }
 
@@ -169,9 +203,6 @@ export async function pullCommand(args) {
     }
   }
 
-  // Sync content/ → platform/docs/
-  syncDocs(AW_HOME, GLOBAL_AW_DIR);
-
   // Re-link IDE dirs
   if (!args._skipIntegrate) {
     const projectRegistryDir = cwd !== HOME ? join(cwd, '.aw', REGISTRY_DIR) : null;
@@ -198,16 +229,6 @@ export async function pullCommand(args) {
   }
 }
 
-/**
- * Sync ~/.aw/content/ markdown files → ~/.aw_registry/platform/docs/
- */
-function syncDocs(awHome, globalAwDir) {
-  const contentSrc = join(awHome, DOCS_SOURCE_DIR);
-  if (!existsSync(contentSrc)) return;
-  const docsDest = join(globalAwDir, 'platform', 'docs');
-  syncMarkdownTree(contentSrc, docsDest);
-}
-
 /**
  * pullAsync — kept for backward compat; now delegates to pullCommand.
  */
@@ -216,58 +237,6 @@ export async function pullAsync(args) {
   return { pattern: args._positional?.[0] || '', actions: [], conflictCount: 0 };
 }
 
-/**
- * Collect all .md file paths (relative) in a directory tree.
- */
-function collectMarkdownPaths(dir, base) {
-  const paths = new Set();
-  if (!existsSync(dir)) return paths;
-  for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    if (entry.name.startsWith('.')) continue;
-    const full = join(dir, entry.name);
-    if (entry.isDirectory()) {
-      for (const p of collectMarkdownPaths(full, base)) paths.add(p);
-    } else if (entry.name.endsWith('.md')) {
-      paths.add(relative(base, full));
-    }
-  }
-  return paths;
-}
-
-/**
- * Sync .md files from src to dest: copy new/changed, delete removed, prune empty dirs.
- */
-function syncMarkdownTree(src, dest) {
-  mkdirSync(dest, { recursive: true });
-
-  const remotePaths = collectMarkdownPaths(src, src);
-  const localPaths = collectMarkdownPaths(dest, dest);
-
-  for (const rel of remotePaths) {
-    const srcPath = join(src, rel);
-    const destPath = join(dest, rel);
-    mkdirSync(join(dest, rel, '..'), { recursive: true });
-    copyFileSync(srcPath, destPath);
-  }
-
-  for (const rel of localPaths) {
-    if (!remotePaths.has(rel)) {
-      const destPath = join(dest, rel);
-      try { unlinkSync(destPath); } catch { /* best effort */ }
-    }
-  }
-
-  function pruneEmpty(dir) {
-    if (!existsSync(dir)) return;
-    for (const entry of readdirSync(dir, { withFileTypes: true })) {
-      if (entry.isDirectory()) pruneEmpty(join(dir, entry.name));
-    }
-    try {
-      if (readdirSync(dir).length === 0 && dir !== dest) rmdirSync(dir);
-    } catch { /* best effort */ }
-  }
-  pruneEmpty(dest);
-}
 
 function registerMcp(namespace) {
   const mcpUrl = process.env.GHL_MCP_URL;

package/commands/push.mjs

@@ -1,7 +1,8 @@
 // commands/push.mjs — Push local agents/skills to registry via PR using persistent git clone
 
 import { existsSync, statSync, readFileSync, appendFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { exec as execCb, execFile as execFileCb } from 'node:child_process';
 import { promisify } from 'node:util';
 import { homedir } from 'node:os';
@@ -25,6 +26,9 @@ import {
   logAheadOfMain,
 } from '../git.mjs';
 
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const VERSION = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8')).version;
+
 const PUSHABLE_TYPES = ['agents', 'skills', 'commands', 'evals'];
 
 // ── PR content generation ────────────────────────────────────────────
@@ -187,11 +191,14 @@ function generateCommitMsg(files) {
   const deletedParts = Object.entries(groupBy(deleted, 'type')).map(([t, items]) => `${items.length} ${singular(t, items.length)} removed`);
   const countParts = [...addedParts, ...deletedParts];
 
+  const version = VERSION;
+  const trailer = `\n\nGenerated-By: aw/${version}`;
+
   if (files.length === 1) {
     const f = files[0];
-    return `registry: ${f.deleted ? 'remove' : 'add'} ${f.type}/${f.slug} ${f.deleted ? 'from' : 'to'} ${f.namespace}`;
+    return `registry: ${f.deleted ? 'remove' : 'add'} ${f.type}/${f.slug} ${f.deleted ? 'from' : 'to'} ${f.namespace}${trailer}`;
   }
-  return `registry: sync ${files.length} files (${countParts.join(', ')})`;
+  return `registry: sync ${files.length} files (${countParts.join(', ')})${trailer}`;
 }
 
 // ── Batch file collection from folder ────────────────────────────────
@@ -319,7 +326,7 @@ async function createOrUpdatePR(awHome, branch, prTitle, prBody) {
 //   - Always creates a new branch from current state, commits, pushes, stays there.
 //   - Every aw push = one new branch + one new PR. No force-push, no reuse.
 // Global flow (worktreeFlow=false): same but returns to main after push.
-async function doPush(files, awHome, dryRun, worktreeFlow = false, preStaged = false) {
+async function doPush(files, awHome, dryRun, worktreeFlow = false, preStaged = false, extraPaths = []) {
   const added = files.filter(f => !f.deleted);
   const deleted = files.filter(f => f.deleted);
 
@@ -369,6 +376,10 @@ async function doPush(files, awHome, dryRun, worktreeFlow = false, preStaged = f
   if (newNamespaces.length > 0 && existsSync(codeownersPath)) {
     pathsToStage.push('CODEOWNERS');
   }
+  // Also stage any extra paths (content/, CODEOWNERS manual edits) passed from the caller
+  for (const p of extraPaths) {
+    if (!pathsToStage.includes(p)) pathsToStage.push(p);
+  }
 
   const commitMsg = generateCommitMsg(files);
   const prTitle = generatePrTitle(files, awHome);
@@ -449,10 +460,31 @@ export async function pushCommand(args) {
 
   // No args = staged files first (git commit behaviour), else auto-detect all changes
   if (!input) {
+    // Extra paths outside .aw_registry/ that aw also manages: content/ and CODEOWNERS.
+    // Detect staged variants for staged-mode and unstaged variants for auto-mode.
+    const getExtraStagedPaths = async () => {
+      try {
+        const { stdout } = await exec(`git -C "${awHome}" diff --cached --name-only -- content/ CODEOWNERS`);
+        return stdout.trim().split('\n').filter(Boolean);
+      } catch { return []; }
+    };
+    const getExtraChangedPaths = async () => {
+      try {
+        const { stdout } = await exec(`git -C "${awHome}" status --porcelain -- content/ CODEOWNERS`);
+        // git status --porcelain prefix is XY (2 chars) + optional space + path.
+        // Staged-only files: `M path` (2-char prefix); unstaged files: ` M path` (3-char prefix).
+        // slice(2).trimStart() handles both cases correctly.
+        return stdout.trim().split('\n').filter(Boolean)
+          .map(l => l.slice(2).trimStart())
+          .filter(Boolean);
+      } catch { return []; }
+    };
+
     // ── Staged mode: use whatever is in the index ──────────────────────
     const staged = getStagedFiles(awHome, REGISTRY_DIR);
+    const extraStaged = await getExtraStagedPaths();
 
-    if (staged.length > 0) {
+    if (staged.length > 0 || extraStaged.length > 0) {
       const files = staged.map(f => {
         const meta = parseRegistryPath(f.registryPath);
         const parts = f.registryPath.split('/');
@@ -465,26 +497,28 @@ export async function pushCommand(args) {
           deleted: f.deleted,
         };
       });
-      fmt.logInfo(`${chalk.dim('mode:')} staged (${files.length} file${files.length > 1 ? 's' : ''})`);
-      await doPush(files, awHome, dryRun, worktreeFlow, true);
+      const totalCount = files.length + extraStaged.length;
+      fmt.logInfo(`${chalk.dim('mode:')} staged (${totalCount} file${totalCount > 1 ? 's' : ''})`);
+      await doPush(files, awHome, dryRun, worktreeFlow, true, extraStaged);
       return;
     }
 
     // ── Auto mode: stage all changes in .aw_registry/ ─────────────────
     const changes = detectChanges(awHome, REGISTRY_DIR);
+    const extraChanged = await getExtraChangedPaths();
     const allEntries = [
       ...changes.modified.map(e => ({ ...e, deleted: false })),
       ...changes.untracked.map(e => ({ ...e, deleted: false })),
       ...changes.deleted.map(e => ({ ...e, deleted: true })),
     ];
 
-    if (allEntries.length === 0 && commitsAheadOfMain(awHome) > 0) {
+    if (allEntries.length === 0 && extraChanged.length === 0 && commitsAheadOfMain(awHome) > 0) {
       fmt.logInfo(`${chalk.dim('mode:')} auto (no new changes — branching current state)`);
       await doPush([], awHome, dryRun, worktreeFlow, false);
       return;
     }
 
-    if (allEntries.length === 0) {
+    if (allEntries.length === 0 && extraChanged.length === 0) {
       fmt.cancel('Nothing to push — no staged or modified files.\n\n  Stage files in your IDE or use `aw status` to see changes.');
       return;
     }
@@ -503,7 +537,7 @@ export async function pushCommand(args) {
         };
       });
 
-    if (files.length === 0) {
+    if (files.length === 0 && extraChanged.length === 0) {
       if (commitsAheadOfMain(awHome) > 0) {
         fmt.logInfo(`${chalk.dim('mode:')} auto (no new changes — branching current state)`);
         await doPush([], awHome, dryRun, worktreeFlow, false);
@@ -513,8 +547,9 @@ export async function pushCommand(args) {
       return;
     }
 
-    fmt.logInfo(`${chalk.dim('mode:')} auto (${files.length} file${files.length > 1 ? 's' : ''} — stage specific files to push a subset)`);
-    await doPush(files, awHome, dryRun, worktreeFlow, false);
+    const totalCount = files.length + extraChanged.length;
+    fmt.logInfo(`${chalk.dim('mode:')} auto (${totalCount} file${totalCount > 1 ? 's' : ''} — stage specific files to push a subset)`);
+    await doPush(files, awHome, dryRun, worktreeFlow, false, extraChanged);
     return;
   }
 

package/commands/telemetry.mjs

@@ -0,0 +1,31 @@
+// commands/telemetry.mjs — `aw telemetry [enable|disable|status]`
+
+import { enableTelemetry, disableTelemetry, getStatus } from '../telemetry.mjs';
+import * as fmt from '../fmt.mjs';
+import { chalk } from '../fmt.mjs';
+
+export async function telemetryCommand(args) {
+  const sub = args._positional?.[0];
+
+  if (sub === 'disable') {
+    disableTelemetry();
+    fmt.logSuccess('Telemetry disabled. No anonymous usage data will be sent.');
+    return;
+  }
+
+  if (sub === 'enable') {
+    enableTelemetry();
+    fmt.logSuccess('Telemetry enabled. Anonymous usage stats help improve aw.');
+    return;
+  }
+
+  // status (default)
+  const status = getStatus();
+  fmt.intro('aw telemetry');
+  fmt.logStep(`Status:     ${status.enabled ? chalk.green('enabled') : chalk.red('disabled')}`);
+  fmt.logStep(`Machine ID: ${chalk.dim(status.machine_id)}`);
+  fmt.logStep(`Config:     ${chalk.dim(status.config_path)}`);
+  fmt.logMessage('');
+  fmt.logMessage(`  ${chalk.dim('aw telemetry disable')}  — opt out of anonymous analytics`);
+  fmt.logMessage(`  ${chalk.dim('aw telemetry enable')}   — re-enable analytics`);
+}

package/constants.mjs

@@ -4,7 +4,7 @@ import { homedir } from 'node:os';
 import { join } from 'node:path';
 
 /** Base branch for PRs and sync checkout */
-export const REGISTRY_BASE_BRANCH = process.env.AW_REGISTRY_BASE_BRANCH || 'chore/stream-registry';
+export const REGISTRY_BASE_BRANCH = process.env.AW_REGISTRY_BASE_BRANCH || 'main';
 
 /** Default registry repository */
 export const REGISTRY_REPO = 'GoHighLevel/platform-docs';
@@ -24,3 +24,6 @@ export const DOCS_SOURCE_DIR = 'content';
 
 /** Persistent git clone root — ~/.aw/ */
 export const AW_HOME = join(homedir(), '.aw');
+
+/** Telemetry endpoint — override with AW_TELEMETRY_URL env var */
+export const TELEMETRY_URL = process.env.AW_TELEMETRY_URL || 'https://services.leadconnectorhq.com/v1/events';

package/fmt.mjs

@@ -72,7 +72,21 @@ export const isCancel = p.isCancel;
 
 export const spinner = () => p.spinner();
 
+export class CancelError extends Error {
+  constructor(message, { exitCode = 1 } = {}) {
+    super(message);
+    this.name = 'CancelError';
+    this.exitCode = exitCode;
+  }
+}
+
 export function cancel(msg) {
+  p.cancel(msg);
+  throw new CancelError(msg);
+}
+
+/** Hard exit — for use in process exception handlers where throwing is unsafe */
+export function cancelAndExit(msg) {
   p.cancel(msg);
   process.exit(1);
 }

package/git.mjs

@@ -293,22 +293,30 @@ export async function fetchAndMerge(awHome, { silent = true } = {}) {
   let updated = false;
   const conflicts = [];
 
-  // ── 3. Fast-forward (no local commits ahead of remote) ───────────────────
-  try {
-    const { stdout } = await exec(
-      `git -C "${awHome}" merge origin/${REGISTRY_BASE_BRANCH} --ff-only`,
-    );
-    updated = !stdout.includes('Already up to date');
-    return { updated, conflicts };
-  } catch { /* local commits exist — fall through to rebase */ }
-
-  // ── 4. Rebase current branch onto remote REGISTRY_BASE_BRANCH ────────────
-  // For push branches: stacks our local commits on top of latest remote.
-  // For base branch:   only reached if local commits exist (unusual).
-  // Never uses --no-edit merge — that disables sparse checkout on blob:none.
+  // ── 3 + 4. Rebase onto remote REGISTRY_BASE_BRANCH ──────────────────────
+  // Handles both cases in one path:
+  //  • No local commits (base branch, clean tree) → fast-forward via rebase
+  //  • Local commits (push branch)                → rebases on top
+  //  • Uncommitted local changes                  → rebase refuses to run,
+  //    sync is skipped this run, changes are preserved
+  //
+  // We avoid `merge --ff-only` and `merge --no-edit` entirely: both trigger a
+  // git 2.46+ bug on blob:none + no-cone sparse-checkout repos that silently
+  // drops bare-name patterns (e.g. "content", "CODEOWNERS") when HEAD advances.
   try {
     await exec(`git -C "${awHome}" rebase origin/${REGISTRY_BASE_BRANCH}`);
     updated = true;
+    // Push branch rebase rewrites commit SHAs — force-push so origin/upload/...
+    // stays in sync with the rebased local branch.  Without this, VS Code and
+    // plain `git pull` show a false divergence ("2↑ 1↓") that can't be resolved
+    // without specifying a reconcile strategy.
+    // --force-with-lease is safer than --force: it refuses to overwrite if
+    // someone else pushed to the remote tracking branch since our last fetch.
+    if (isPushBranch) {
+      try {
+        await exec(`git -C "${awHome}" push --force-with-lease origin "${currentBranch}"`);
+      } catch { /* non-blocking — divergence will be resolved on next aw push */ }
+    }
   } catch {
     try {
       const { stdout } = await exec(`git -C "${awHome}" diff --name-only --diff-filter=U`);

package/hooks.mjs

@@ -51,15 +51,21 @@ exit 0
 
 const POST_MERGE = makeDispatcher('post-merge', `\
 if command -v aw >/dev/null 2>&1; then
-  aw init --silent >/dev/null 2>&1 &
+  # Unset ALL git env vars so aw's "git -C ~/.aw" runs against the correct repo,
+  # not the project repo that triggered this hook. Using git's own list of
+  # local env vars is more robust than hardcoding specific names.
+  unset $(git rev-parse --local-env-vars 2>/dev/null)
+  AW_TRIGGER=hook:post-merge aw pull --silent >/dev/null 2>&1 &
 fi`);
 
 const POST_CHECKOUT = makeDispatcher('post-checkout', `\
+# Unset ALL git env vars so aw's "git -C ~/.aw" runs against the correct repo.
+unset $(git rev-parse --local-env-vars 2>/dev/null)
 if [ -d "$HOME/.aw" ] && [ ! -d ".aw" ] && [ -d ".git" ] && command -v aw >/dev/null 2>&1; then
-  aw link >/dev/null 2>&1 &
+  AW_TRIGGER=hook:post-checkout aw link >/dev/null 2>&1 &
 fi
 if command -v aw >/dev/null 2>&1; then
-  aw init --silent >/dev/null 2>&1 &
+  AW_TRIGGER=hook:post-checkout aw pull --silent >/dev/null 2>&1 &
 fi`);
 
 // post-commit: written separately — needs different guard logic than other hooks.
@@ -68,13 +74,16 @@ fi`);
 const POST_COMMIT = `#!/bin/sh
 # aw: global post-commit dispatcher (installed by aw init)
 
+# Unset ALL git env vars so aw's "git -C ~/.aw" runs against the correct repo.
+unset $(git rev-parse --local-env-vars 2>/dev/null)
+
 # Skip temp sparse checkouts
 case "$(pwd)" in /tmp/aw-*|/var/folders/*/aw-*) exit 0 ;; esac
 
 # Committing inside .aw/ worktree itself → refresh from parent project dir
 case "$(pwd)" in */.aw)
   if command -v aw >/dev/null 2>&1; then
-    (cd "$(dirname "$(pwd)")" && aw link >/dev/null 2>&1) &
+    (cd "$(dirname "$(pwd)")" && AW_TRIGGER=hook:post-commit aw link >/dev/null 2>&1) &
   fi
   exit 0
   ;;
@@ -82,7 +91,7 @@ esac
 
 # Committing in a project that has a .aw/ worktree → refresh symlinks
 if [ -f ".aw/.git" ] && command -v aw >/dev/null 2>&1; then
-  aw link >/dev/null 2>&1 &
+  AW_TRIGGER=hook:post-commit aw link >/dev/null 2>&1 &
 fi
 
 # Chain to previous hooksPath

package/mcp.mjs

@@ -297,10 +297,16 @@ export async function setupMcp(cwd, namespace, { silent = false } = {}) {
   }
 
   // ── Codex: ~/.codex/config.toml (TOML format) ──
+  // Also merge into the ECC source file (~/.aw-ecc/.codex/config.toml) so
+  // that when installAwEcc re-copies it on subsequent inits the ghl-ai entry
+  // survives — without this, each re-init overwrites ~/.codex/config.toml
+  // from the ECC source which doesn't have the ghl-ai block.
   const codexTomlPath = join(HOME, '.codex', 'config.toml');
   if (mergeTomlMcpServer(codexTomlPath, 'ghl-ai', ghlAiServerLocal)) {
     updatedFiles.push(codexTomlPath);
   }
+  const eccCodexTomlPath = join(HOME, '.aw-ecc', '.codex', 'config.toml');
+  mergeTomlMcpServer(eccCodexTomlPath, 'ghl-ai', ghlAiServerLocal);
 
   // Deduplicate
   const unique = [...new Set(updatedFiles)];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ghl-ai/aw",
-  "version": "0.1.36-beta.99",
+  "version": "0.1.37-beta.10",
   "description": "Agentic Workspace CLI — pull, push & manage agents, skills and commands from the registry",
   "type": "module",
   "bin": "bin.js",
@@ -23,7 +23,8 @@
     "apply.mjs",
     "update.mjs",
     "hooks.mjs",
-    "ecc.mjs"
+    "ecc.mjs",
+    "telemetry.mjs"
   ],
   "engines": {
     "node": ">=18.0.0"

package/telemetry.mjs

@@ -0,0 +1,233 @@
+// telemetry.mjs — Anonymous usage analytics. Zero new dependencies.
+//
+// Span-based: each command sends command_started + command_completed/command_failed,
+// linked by a run_id. Orphaned started events = stuck/killed commands.
+//
+// Opt out: AW_TELEMETRY_DISABLED=1, DO_NOT_TRACK=1, or `aw telemetry disable`.
+
+import { createHash, randomUUID } from 'node:crypto';
+import { hostname, userInfo, platform, arch, release } from 'node:os';
+import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { execSync } from 'node:child_process';
+import { TELEMETRY_URL, AW_HOME } from './constants.mjs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const VERSION = JSON.parse(readFileSync(join(__dirname, 'package.json'), 'utf8')).version;
+
+const CONFIG_PATH = join(AW_HOME, '.telemetry');
+
+// ── Config ──────────────────────────────────────────────────────────
+
+export function generateMachineId() {
+  const raw = `${hostname()}:${userInfo().username}`;
+  return createHash('sha256').update(raw).digest('hex');
+}
+
+export function loadConfig() {
+  try {
+    if (existsSync(CONFIG_PATH)) {
+      return JSON.parse(readFileSync(CONFIG_PATH, 'utf8'));
+    }
+  } catch { /* corrupt file — recreate */ }
+
+  const config = {
+    machine_id: generateMachineId(),
+    enabled: true,
+    noticed: false,
+  };
+  saveConfig(config);
+  return config;
+}
+
+export function saveConfig(config) {
+  try {
+    mkdirSync(dirname(CONFIG_PATH), { recursive: true });
+    writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + '\n');
+  } catch { /* best effort — don't break CLI */ }
+}
+
+// ── Opt-out detection ───────────────────────────────────────────────
+
+export function isDisabled(config) {
+  if (process.env.DO_NOT_TRACK === '1') return true;
+  if (process.env.AW_TELEMETRY_DISABLED === '1') return true;
+  if (config && config.enabled === false) return true;
+  return false;
+}
+
+// ── Environment collection ──────────────────────────────────────────
+
+function getRegistryHead() {
+  try {
+    return execSync('git -C "' + AW_HOME + '" rev-parse --short HEAD', {
+      encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 2000,
+    }).trim();
+  } catch { return null; }
+}
+
+function detectIDEs() {
+  const ides = [];
+  const cwd = process.cwd();
+  const checks = [
+    ['.cursor', 'cursor'],
+    ['.vscode', 'vscode'],
+    ['.claude', 'claude'],
+    ['.codex', 'codex'],
+  ];
+  for (const [dir, name] of checks) {
+    try {
+      if (existsSync(join(cwd, dir))) ides.push(name);
+    } catch { /* skip */ }
+  }
+  return ides;
+}
+
+function getNamespace() {
+  try {
+    const cfgPath = join(AW_HOME, '.aw_registry', '.sync-config.json');
+    if (existsSync(cfgPath)) {
+      const cfg = JSON.parse(readFileSync(cfgPath, 'utf8'));
+      return cfg.namespace || null;
+    }
+  } catch { /* skip */ }
+  return null;
+}
+
+function projectHash() {
+  return createHash('sha256').update(process.cwd()).digest('hex').slice(0, 8);
+}
+
+function getGitConfig(key) {
+  try {
+    return execSync(`git config --global ${key}`, {
+      encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 1000,
+    }).trim() || null;
+  } catch { return null; }
+}
+
+export function collectEnv(config) {
+  return {
+    machine_id: config.machine_id,
+    aw_version: VERSION,
+    node_version: process.version,
+    os: platform(),
+    arch: arch(),
+    is_ci: !!(process.env.CI || process.env.CONTINUOUS_INTEGRATION || process.env.BUILD_NUMBER),
+    namespace: getNamespace(),
+    ides_detected: detectIDEs(),
+    project_hash: projectHash(),
+    trigger: process.env.AW_TRIGGER || 'interactive',
+    registry_head: getRegistryHead(),
+    github_user: getGitConfig('user.name'),
+    github_email: getGitConfig('user.email'),
+  };
+}
+
+// ── Network ─────────────────────────────────────────────────────────
+
+export async function send(payload) {
+  try {
+    await fetch(TELEMETRY_URL, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(3000),
+    });
+  } catch {
+    // Swallow ALL errors — telemetry must never break the CLI
+  }
+}
+
+// ── Span API ────────────────────────────────────────────────────────
+
+export async function startSpan(command, args) {
+  const config = loadConfig();
+  const disabled = isDisabled(config);
+  const runId = randomUUID();
+  const startTime = Date.now();
+
+  // Extract flags and positional args for the payload
+  const flags = [];
+  const positional = [];
+  if (args) {
+    for (const [key, val] of Object.entries(args)) {
+      if (key === '_positional') {
+        positional.push(...(val || []));
+      } else if (key.startsWith('-') || key.startsWith('--')) {
+        if (val === true) flags.push(key);
+        else flags.push(`${key}=${val}`);
+      }
+    }
+  }
+
+  const env = disabled ? null : collectEnv(config);
+
+  // Await command_started so it always lands before the command runs
+  if (!disabled) {
+    await send({
+      event: 'command_started',
+      run_id: runId,
+      timestamp: new Date().toISOString(),
+      env,
+      command: { name: command, args: positional, flags },
+    });
+  }
+
+  return {
+    runId,
+
+    /** Show one-time first-run notice (only in interactive/TTY mode) */
+    notice() {
+      if (disabled || config.noticed) return;
+      if (args?.['--silent'] || !process.stderr.isTTY) return;
+      console.error('\u2139  Telemetry is on \u2014 anonymous usage stats help improve aw. Opt out: aw telemetry disable');
+      config.noticed = true;
+      saveConfig(config);
+    },
+
+    /** End the span with outcome */
+    async end({ status = 'completed', error_type = null, data = {} } = {}) {
+      if (disabled) return;
+      const duration_ms = Date.now() - startTime;
+      // Re-read registry_head so completed event reflects post-command state
+      const endEnv = { ...env, registry_head: getRegistryHead() };
+      await send({
+        event: status === 'completed' ? 'command_completed'
+             : status === 'cancelled' ? 'command_cancelled'
+             : 'command_failed',
+        run_id: runId,
+        timestamp: new Date().toISOString(),
+        env: endEnv,
+        command: { name: command, args: positional, flags },
+        outcome: { status, duration_ms, error_type, data },
+      });
+    },
+  };
+}
+
+// ── Telemetry management (for `aw telemetry` command) ───────────────
+
+export function enableTelemetry() {
+  const config = loadConfig();
+  config.enabled = true;
+  saveConfig(config);
+  return config;
+}
+
+export function disableTelemetry() {
+  const config = loadConfig();
+  config.enabled = false;
+  saveConfig(config);
+  return config;
+}
+
+export function getStatus() {
+  const config = loadConfig();
+  return {
+    enabled: !isDisabled(config),
+    machine_id: config.machine_id,
+    config_path: CONFIG_PATH,
+  };
+}