@ghl-ai/aw 0.1.37-beta.8 → 0.1.37-beta.80

package/bin.js

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
-// Standalone bin entrypoint for published npm package
-import('./cli.mjs').then(m => m.run(process.argv.slice(2)));
+import { run } from './cli.mjs';
+run(process.argv.slice(2));

package/cli.mjs

@@ -4,7 +4,7 @@ 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';
 
@@ -15,6 +15,7 @@ const COMMANDS = {
   init:   () => import('./commands/init.mjs').then(m => m.initCommand),
   pull:    () => import('./commands/pull.mjs').then(m => m.pullCommand),
   push:    () => import('./commands/push.mjs').then(m => m.pushCommand),
+  'push-rules': () => import('./commands/push-rules.mjs').then(m => m.pushRulesCommand),
   drop:    () => import('./commands/drop.mjs').then(m => m.dropCommand),
   status:  () => import('./commands/status.mjs').then(m => m.statusCommand),
   search:  () => import('./commands/search.mjs').then(m => m.searchCommand),
@@ -88,6 +89,7 @@ function printHelp() {
     sec('Upload'),
     cmd('aw push', 'Push all modified files (creates one PR)'),
     cmd('aw push <path>', 'Push file, folder, or namespace to registry'),
+    cmd('aw push-rules [path]', 'Push platform rules to platform-docs'),
     cmd('aw push --dry-run [path]', 'Preview what would be pushed'),
 
     sec('Discover'),
@@ -102,6 +104,8 @@ function printHelp() {
     cmd('aw daemon install --interval 30m', 'Set custom interval (e.g. 30m, 2h, 3600)'),
     cmd('aw daemon uninstall', 'Stop the background daemon'),
     cmd('aw daemon status', 'Check if daemon is running'),
+    cmd('aw slack-sim run <scenario>', 'Replay Slack-like scenarios against real runtime'),
+    cmd('aw slack-sim list-scenarios', 'List built-in Slack simulator scenarios'),
 
     sec('Settings'),
     cmd('aw telemetry status', 'Show telemetry status'),
@@ -122,6 +126,8 @@ function printHelp() {
     cmd('aw push .aw_registry/<team>/', 'Push entire namespace (one PR)'),
     cmd('aw push .aw_registry/agents/<name>.md', 'Push a single agent'),
     cmd('aw push .aw_registry/skills/<name>/', 'Push a single skill folder'),
+    cmd('aw push .aw_rules', 'Auto-redirects to aw push-rules'),
+    cmd('aw push-rules', 'Pushes .aw_rules or .aw_registry/.aw_rules'),
     '',
     `  ${chalk.dim('# Remove content from workspace')}`,
     cmd('aw drop <team>', 'Stop syncing a namespace (removes all files)'),
@@ -162,6 +168,10 @@ export async function run(argv) {
       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;
     }
@@ -174,5 +184,5 @@ export async function run(argv) {
     process.exit(0);
   }
 
-  fmt.cancel(`Unknown command: ${command}`);
+  fmt.cancelAndExit(`Unknown command: ${command}`);
 }

package/commands/daemon.mjs

@@ -39,9 +39,9 @@ async function installLaunchd(intervalSeconds) {
 
   <key>ProgramArguments</key>
   <array>
-    <string>${awBin}</string>
-    <string>pull</string>
-    <string>--silent</string>
+    <string>/bin/sh</string>
+    <string>-c</string>
+    <string>'${awBin}' pull --silent && '${awBin}' telemetry flush 2>/dev/null</string>
   </array>
 
   <key>StartInterval</key>
@@ -113,7 +113,7 @@ async function installCron(intervalSeconds) {
   if (!existsSync(logDir)) mkdirSync(logDir, { recursive: true });
 
   const cronExpr = toCronExpression(intervalSeconds);
-  const cronLine = `${cronExpr} ${awBin} pull --silent >> ${logDir}/pull.log 2>&1 # aw-daemon`;
+  const cronLine = `${cronExpr} /bin/sh -c '${awBin} pull --silent && ${awBin} telemetry flush 2>/dev/null' >> ${logDir}/pull.log 2>&1 # aw-daemon`;
 
   let current = '';
   try { current = execSync('crontab -l 2>/dev/null', { encoding: 'utf8' }); } catch { /* empty */ }

package/commands/init.mjs

@@ -4,7 +4,17 @@
 // Uses core.hooksPath (git-lfs pattern) for system-wide hook interception.
 // Uses IDE tasks for auto-pull on workspace open.
 
-import { existsSync, writeFileSync, symlinkSync, lstatSync, readdirSync, readFileSync, rmSync, realpathSync, appendFileSync } from 'node:fs';
+import {
+  existsSync,
+  writeFileSync,
+  symlinkSync,
+  lstatSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  realpathSync,
+  appendFileSync,
+} from 'node:fs';
 import { execSync } from 'node:child_process';
 import { join, dirname, sep } from 'node:path';
 import { homedir } from 'node:os';
@@ -13,8 +23,9 @@ import * as config from '../config.mjs';
 import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
 import { linkWorkspace } from '../link.mjs';
-import { generateCommands, copyInstructions, initAwDocs } from '../integrate.mjs';
+import { generateCommands, copyInstructions, initAwDocs, installIdeHooks } from '../integrate.mjs';
 import { setupMcp } from '../mcp.mjs';
+import { installLocalCommitHook } from '../hooks.mjs';
 import { autoUpdate, promptUpdate } from '../update.mjs';
 import { installGlobalHooks } from '../hooks.mjs';
 import { installAwEcc } from '../ecc.mjs';
@@ -31,7 +42,8 @@ import {
   syncWorktreeSparseCheckout,
   findNearestWorktree,
 } from '../git.mjs';
-import { REGISTRY_DIR, REGISTRY_REPO, REGISTRY_URL } from '../constants.mjs';
+import { REGISTRY_DIR, REGISTRY_REPO, REGISTRY_URL, RULES_SOURCE_DIR } from '../constants.mjs';
+import { syncFileTree } from '../file-tree.mjs';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const VERSION = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8')).version;
@@ -195,7 +207,7 @@ export async function initCommand(args) {
     }
 
     if (choice === 'platform-only') {
-      namespace = null; team = null; subTeam = null; folderName = null;
+      namespace = 'platform'; team = 'platform'; subTeam = null; folderName = null;
     }
   }
 
@@ -210,7 +222,7 @@ export async function initCommand(args) {
     const isNewSubTeam = folderName && cfg && !cfg.include.includes(folderName);
     if (isNewSubTeam) {
       if (!silent) fmt.logStep(`Adding sub-team ${chalk.cyan(folderName)}...`);
-      const newSparsePaths = [`.aw_registry/${folderName}`, `content`];
+      const newSparsePaths = [`.aw_registry/${folderName}`, 'content', RULES_SOURCE_DIR];
       addToSparseCheckout(AW_HOME, newSparsePaths);
       config.addPattern(GLOBAL_AW_DIR, folderName);
     } else {
@@ -235,6 +247,9 @@ export async function initCommand(args) {
 
     ensureAwGitignore(AW_HOME);
     const freshCfg = config.load(GLOBAL_AW_DIR);
+    if (existsSync(GLOBAL_AW_DIR)) {
+      syncFileTree(join(AW_HOME, RULES_SOURCE_DIR), join(GLOBAL_AW_DIR, RULES_SOURCE_DIR));
+    }
 
     // Ensure project worktree sparse checkout matches the global clone.
     // Covers the case where a namespace was added from HOME (or another project)
@@ -249,6 +264,7 @@ export async function initCommand(args) {
     initAwDocs(HOME);
     await setupMcp(HOME, freshCfg?.namespace || team, { silent });
     installGlobalHooks();
+    installIdeHooks();
 
     // Remove old local .git/hooks/post-checkout that pre-dates core.hooksPath (creates stale .aw_registry symlink)
     if (cwd !== HOME) {
@@ -279,6 +295,7 @@ export async function initCommand(args) {
     const awDirForLinks = (projectRegistryDir && existsSync(projectRegistryDir)) ? projectRegistryDir : null;
     const symlinks = linkWorkspace(HOME, awDirForLinks, { silent: true });
     const commands = generateCommands(HOME, { silent: true });
+    if (cwd !== HOME) installLocalCommitHook(cwd);
 
     if (silent) {
       autoUpdate(await args._updateCheck);
@@ -312,12 +329,12 @@ export async function initCommand(args) {
 
   if (!user) {
     try {
-      user = execSync('git config user.name', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+      user = execSync('git config --global user.name', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
     } catch { /* git not configured */ }
   }
 
   // Determine sparse paths
-  const sparsePaths = [`.aw_registry/platform`, `content`, `.aw_registry/AW-PROTOCOL.md`, `CODEOWNERS`];
+  const sparsePaths = [`.aw_registry/platform`, `content`, RULES_SOURCE_DIR, `.aw_registry/AW-PROTOCOL.md`, `CODEOWNERS`];
   if (folderName) {
     sparsePaths.push(`.aw_registry/${folderName}`);
   }
@@ -363,11 +380,14 @@ export async function initCommand(args) {
     }
   }
 
-  // Create sync config
-  const cfg = config.create(GLOBAL_AW_DIR, { namespace: team, user });
+  // Create sync config — default to 'platform' when no namespace specified
+  const cfg = config.create(GLOBAL_AW_DIR, { namespace: team || 'platform', user });
   if (folderName) {
     config.addPattern(GLOBAL_AW_DIR, folderName);
   }
+  if (existsSync(GLOBAL_AW_DIR)) {
+    syncFileTree(join(AW_HOME, RULES_SOURCE_DIR), join(GLOBAL_AW_DIR, RULES_SOURCE_DIR));
+  }
 
   // Step 3: Setup tasks, MCP, hooks
   await installAwEcc(cwd, { silent });
@@ -375,6 +395,7 @@ export async function initCommand(args) {
   initAwDocs(HOME);
   const mcpFiles = await setupMcp(HOME, team, { silent }) || [];
   const hooksInstalled = installGlobalHooks();
+  installIdeHooks();
   installIdeTasks();
 
   // Remove old local .git/hooks/post-checkout that pre-dates core.hooksPath
@@ -406,6 +427,7 @@ export async function initCommand(args) {
   const projectRegistryDir = cwd !== HOME ? join(cwd, '.aw', REGISTRY_DIR) : null;
   const awDirForLinks = (projectRegistryDir && existsSync(projectRegistryDir)) ? projectRegistryDir : null;
   const symlinks = linkWorkspace(HOME, awDirForLinks, { silent: true });
+  if (cwd !== HOME) installLocalCommitHook(cwd);
   ideSpinner.message('Generating commands...');
   const commands = generateCommands(HOME, { silent: true });
   ideSpinner.stop(`IDE wired — ${chalk.bold(symlinks)} symlinks · ${chalk.bold(commands)} commands`);

package/commands/link-project.mjs

@@ -9,6 +9,7 @@ import { addProjectWorktree, isWorktree, isValidClone } from '../git.mjs';
 import { REGISTRY_DIR, REGISTRY_URL } from '../constants.mjs';
 import { linkWorkspace } from '../link.mjs';
 import { generateCommands } from '../integrate.mjs';
+import { installLocalCommitHook } from '../hooks.mjs';
 
 const HOME = homedir();
 const AW_HOME = join(HOME, '.aw');
@@ -40,6 +41,7 @@ export function linkProjectCommand(args) {
     const awDirForLinks = existsSync(projectRegistryDir) ? projectRegistryDir : null;
     const symlinks = linkWorkspace(HOME, awDirForLinks, { silent: true });
     const commands = generateCommands(HOME, { silent: true });
+    installLocalCommitHook(cwd);
     fmt.logSuccess(`Already linked — refreshed ${chalk.bold(symlinks)} IDE symlinks · ${chalk.bold(commands)} commands`);
     return;
   }
@@ -50,6 +52,7 @@ export function linkProjectCommand(args) {
     const awDirForLinks = existsSync(projectRegistryDir) ? projectRegistryDir : null;
     const symlinks = linkWorkspace(HOME, awDirForLinks, { silent: true });
     const commands = generateCommands(HOME, { silent: true });
+    installLocalCommitHook(cwd);
     fmt.logSuccess([
       `Project linked — ${chalk.bold(symlinks)} IDE symlinks · ${chalk.bold(commands)} commands`,
       '',

package/commands/nuke.mjs

@@ -143,19 +143,24 @@ async function removeProjectSymlinks() {
   }
 
   // Also remove legacy local .git/hooks/post-checkout installed by old aw versions
+  // and prepare-commit-msg hooks installed by installLocalCommitHook
   let hooksRemoved = 0;
-  const { stdout: hookFiles } = await exec(
-    `find "${HOME}" -maxdepth 5 -path "*/.git/hooks/post-checkout" -type f 2>/dev/null || true`,
-    { encoding: 'utf8', timeout: 30000 }
-  );
-  for (const hookPath of hookFiles.trim().split('\n').filter(Boolean)) {
-    try {
-      const content = readFileSync(hookPath, 'utf8');
-      if (content.includes('aw: auto-link registry') || content.includes('ln -s "$AW_REGISTRY"')) {
-        unlinkSync(hookPath);
-        hooksRemoved++;
-      }
-    } catch { /* best effort */ }
+  const hookNames = ['post-checkout', 'prepare-commit-msg'];
+  for (const hookName of hookNames) {
+    const { stdout: hookFiles } = await exec(
+      `find "${HOME}" -maxdepth 5 -path "*/.git/hooks/${hookName}" -type f 2>/dev/null || true`,
+      { encoding: 'utf8', timeout: 30000 }
+    );
+    for (const hookPath of hookFiles.trim().split('\n').filter(Boolean)) {
+      try {
+        const content = readFileSync(hookPath, 'utf8');
+        // Only remove hooks that AW installed — identified by our marker comment
+        if (content.includes('aw:') || content.includes('aw: auto-link registry') || content.includes('ln -s "$AW_REGISTRY"')) {
+          unlinkSync(hookPath);
+          hooksRemoved++;
+        }
+      } catch { /* best effort */ }
+    }
   }
 
   return { removed, hooksRemoved };
@@ -204,8 +209,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/protocol.mjs

@@ -0,0 +1,107 @@
+// commands/protocol.mjs — Write AW-PROTOCOL into machine-global AI tool files.
+// Uses block-replacement markers so running multiple times is safe.
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { AW_PROTOCOL_START, AW_PROTOCOL_END } from '../constants.mjs';
+import * as fmt from '../fmt.mjs';
+
+const HOME = homedir();
+
+/**
+ * Read AW-PROTOCOL.md from the global registry.
+ * Returns null if not found.
+ */
+function readProtocol() {
+  const path = join(HOME, '.aw_registry', 'AW-PROTOCOL.md');
+  if (!existsSync(path)) return null;
+  return readFileSync(path, 'utf8');
+}
+
+/**
+ * Inject/replace the AW-PROTOCOL block in a target file.
+ * If file doesn't exist, creates it with just the block.
+ * If file exists, replaces content between markers or appends block.
+ * Returns true if file was written/updated.
+ */
+function injectBlock(filePath, content, toolName) {
+  const block = `${AW_PROTOCOL_START}\n${content}\n${AW_PROTOCOL_END}`;
+
+  // Ensure parent directory exists
+  mkdirSync(dirname(filePath), { recursive: true });
+
+  if (!existsSync(filePath)) {
+    writeFileSync(filePath, block + '\n', 'utf8');
+    fmt.logStep(`Created ${toolName} global rules: ${filePath}`);
+    return true;
+  }
+
+  const existing = readFileSync(filePath, 'utf8');
+  const startIdx = existing.indexOf(AW_PROTOCOL_START);
+  const endIdx = existing.indexOf(AW_PROTOCOL_END);
+
+  if (startIdx !== -1 && endIdx !== -1) {
+    // Replace existing block
+    const before = existing.slice(0, startIdx);
+    const after = existing.slice(endIdx + AW_PROTOCOL_END.length);
+    const updated = before + block + after;
+    if (updated === existing) return false; // no change
+    writeFileSync(filePath, updated, 'utf8');
+    fmt.logStep(`Updated ${toolName} global rules: ${filePath}`);
+    return true;
+  }
+
+  // Append block to existing file
+  const updated = existing.trimEnd() + '\n\n' + block + '\n';
+  writeFileSync(filePath, updated, 'utf8');
+  fmt.logStep(`Appended to ${toolName} global rules: ${filePath}`);
+  return true;
+}
+
+/**
+ * Write AW-PROTOCOL into all supported AI tool global files.
+ * Called by aw init. Silent if AW-PROTOCOL.md not found.
+ *
+ * @param {string} [workspaceDir] - Optional workspace root. When provided,
+ *   also writes to <workspaceDir>/.cursor/rules/aw-protocol.mdc so Cursor
+ *   auto-loads it via its workspace rules mechanism (alwaysApply: true).
+ */
+export function writeGlobalProtocolFiles(workspaceDir) {
+  const protocol = readProtocol();
+  if (!protocol) {
+    fmt.logWarn('AW-PROTOCOL.md not found in ~/.aw_registry — skipping global rules install');
+    return [];
+  }
+
+  const written = [];
+  const cursorContent = `---\nalwaysApply: true\n---\n\n${protocol}`;
+
+  // Claude Code + Claude CLI (machine-global)
+  const claudeMd = join(HOME, '.claude', 'CLAUDE.md');
+  if (injectBlock(claudeMd, protocol, 'Claude Code/CLI')) written.push(claudeMd);
+
+  // Cursor — workspace-level rules (auto-loaded by Cursor from .cursor/rules/)
+  // Machine-global ~/.cursor/rules/ is NOT auto-loaded by Cursor; workspace-level is.
+  if (workspaceDir) {
+    const wsCursorMdc = join(workspaceDir, '.cursor', 'rules', 'aw-protocol.mdc');
+    if (injectBlock(wsCursorMdc, cursorContent, 'Cursor workspace')) written.push(wsCursorMdc);
+  }
+
+  // Cursor — also write to ~/.cursor/rules/ as fallback for manual reference
+  const cursorMdc = join(HOME, '.cursor', 'rules', 'aw-protocol.mdc');
+  if (injectBlock(cursorMdc, cursorContent, 'Cursor (home)')) written.push(cursorMdc);
+
+  // Codex CLI (machine-global)
+  const codexAgents = join(HOME, '.codex', 'AGENTS.md');
+  if (injectBlock(codexAgents, protocol, 'Codex')) written.push(codexAgents);
+
+  // Windsurf (known reliability issues — warn user)
+  const windsurfRules = join(HOME, '.codeium', 'windsurf', 'memories', 'global_rules.md');
+  if (injectBlock(windsurfRules, protocol, 'Windsurf')) {
+    written.push(windsurfRules);
+    fmt.logWarn('Windsurf global_rules.md has known reliability issues. Verify in Cascade > Customizations > Rules.');
+  }
+
+  return written;
+}

package/commands/pull.mjs

@@ -1,17 +1,34 @@
 // commands/pull.mjs — Pull content from registry using persistent git clone
 
-import { existsSync, lstatSync } from 'node:fs';
+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 { exec as execCb, execSync } from 'node:child_process';
 import { promisify } from 'node:util';
 
 const exec = promisify(execCb);
 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 } from '../constants.mjs';
+import {
+  fetchAndMerge,
+  addToSparseCheckout,
+  removeFromSparseCheckout,
+  syncWorktreeSparseCheckout,
+  isValidClone,
+  findNearestWorktree,
+  rebaseOntoOriginMain,
+} from '../git.mjs';
+import {
+  REGISTRY_DIR,
+  REGISTRY_URL,
+  DOCS_SOURCE_DIR,
+  RULES_SOURCE_DIR,
+} from '../constants.mjs';
+import { collectAllPaths, syncFileTree } from '../file-tree.mjs';
 import { linkWorkspace } from '../link.mjs';
 import { generateCommands, copyInstructions } from '../integrate.mjs';
 
@@ -25,7 +42,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,
@@ -52,6 +69,15 @@ export async function pullCommand(args) {
     return;
   }
 
+  // Ensure platform pulls also fetch docs and rules on older installs that
+  // pre-date the new sparse-checkout paths.
+  if (input === 'platform') {
+    addToSparseCheckout(AW_HOME, [`.aw_registry/platform`, DOCS_SOURCE_DIR, RULES_SOURCE_DIR]);
+    if (!cfg.include.includes('platform')) {
+      config.addPattern(GLOBAL_AW_DIR, 'platform');
+    }
+  }
+
   // If input is a new namespace to add
   let addedInput = null;
   let addedSparsePath = null;
@@ -64,7 +90,7 @@ export async function pullCommand(args) {
     const label = input.split('/').pop();
     if (!cfg.include.includes(input)) {
       log.logStep(`Adding ${chalk.cyan(label)} to sparse checkout...`);
-      addToSparseCheckout(AW_HOME, [sparsePath, 'content']);
+      addToSparseCheckout(AW_HOME, [sparsePath, DOCS_SOURCE_DIR]);
       config.addPattern(GLOBAL_AW_DIR, input);
       addedInput = input;
       addedSparsePath = sparsePath;
@@ -79,33 +105,33 @@ export async function pullCommand(args) {
   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 */ }
+    } 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.`);
+      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 */ }
+      if (['upload/', 'remove/', 'sync/'].some(prefix => resumedBranch.startsWith(prefix))) {
+        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.');
@@ -115,10 +141,8 @@ export async function pullCommand(args) {
         return;
       }
     }
-    // Fall through to re-link IDE dirs after successful rebase continuation
   }
 
-  // Fetch + merge latest
   const s = log.spinner();
   s.start('Fetching latest from registry...');
   let fetchResult = { updated: false, conflicts: [] };
@@ -130,16 +154,15 @@ export async function pullCommand(args) {
     if (!silent) log.logWarn(`Fetch error: ${e.message}`);
   }
 
-  // Validate that the requested path actually exists in the registry after fetch.
-  // If not, undo the sparse checkout addition and inform the user.
   if (addedInput) {
     const localPath = join(AW_HOME, REGISTRY_DIR, addedInput);
     if (!existsSync(localPath)) {
-      // Undo: remove from sparse checkout and config
       try {
         removeFromSparseCheckout(AW_HOME, [addedSparsePath]);
         config.removePattern(GLOBAL_AW_DIR, addedInput);
-      } catch { /* best effort */ }
+      } catch {
+        // best effort
+      }
       log.cancel(`Path ${chalk.red(addedInput)} not found in the registry.\nCheck the exact path with ${chalk.bold('aw search <query>')} or browse ${chalk.dim('~/.aw_registry/')}.`);
       return;
     }
@@ -147,23 +170,31 @@ export async function pullCommand(args) {
 
   if (fetchResult.conflicts.length > 0) {
     if (!silent) {
-      // 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: rebase was already aborted in fetchAndMerge; just report.
     log.logWarn(`Conflicts in: ${fetchResult.conflicts.join(', ')}`);
   }
 
+  const rulesSrc = join(AW_HOME, RULES_SOURCE_DIR);
+  if (existsSync(rulesSrc)) {
+    const rulesDest = join(GLOBAL_AW_DIR, RULES_SOURCE_DIR);
+    syncFileTree(rulesSrc, rulesDest);
+    if (!silent) log.logSuccess('Synced .aw_rules');
+  }
+
   // Rebase project worktree branch onto origin/main — only for legacy git worktrees.
   // In the symlink model, <project>/.aw IS ~/.aw (same repo), so fetchAndMerge already
   // brought it up to date. Nothing to rebase.
   const localAw = cwd !== HOME ? findNearestWorktree(cwd, HOME) : null;
   let isSymlinkWorktree = false;
   if (localAw) {
-    try { isSymlinkWorktree = lstatSync(localAw).isSymbolicLink(); } catch {}
+    try {
+      isSymlinkWorktree = lstatSync(localAw).isSymbolicLink();
+    } catch {
+      // ignore
+    }
   }
   if (localAw && !isSymlinkWorktree) {
     const rebaseSpinner = log.spinner();
@@ -173,7 +204,9 @@ export async function pullCommand(args) {
       rebaseSpinner.stop('Local branch up to date');
     } catch (e) {
       const isConflict = e.message?.includes('could not apply') || e.message?.includes('CONFLICT');
-      const isAlreadyInProgress = e.message?.includes('rebase-merge') || e.message?.includes('rebase-apply') || e.message?.includes('already in progress');
+      const isAlreadyInProgress = e.message?.includes('rebase-merge')
+        || e.message?.includes('rebase-apply')
+        || e.message?.includes('already in progress');
 
       if (isAlreadyInProgress) {
         rebaseSpinner.stop(chalk.yellow('Rebase paused — conflicts pending'));
@@ -184,26 +217,31 @@ export async function pullCommand(args) {
         try {
           const { stdout } = await exec(`git -C "${localAw}" diff --name-only --diff-filter=U`);
           conflictedFiles = stdout.trim().split('\n').filter(Boolean);
-        } catch { /* best effort */ }
+        } catch {
+          // best effort
+        }
 
         if (!silent) {
-          try { await exec(`git -C "${localAw}" rebase --abort`); } catch { /* best effort */ }
+          try {
+            await exec(`git -C "${localAw}" rebase --abort`);
+          } catch {
+            // best effort
+          }
           log.logWarn('Rebase aborted — your branch is unchanged.');
           if (conflictedFiles.length > 0) {
             log.logWarn(`Conflicting file${conflictedFiles.length > 1 ? 's' : ''}:`);
-            for (const f of conflictedFiles) log.logMessage(`  ${chalk.red('✗')} ${f}`);
+            for (const file of conflictedFiles) log.logMessage(`  ${chalk.red('✗')} ${file}`);
           }
           log.logWarn('Resolve the conflict and run `aw pull` again, or check with `aw status`.');
         }
       } else {
-        const msg = e.message?.split('\n').find(l => l.trim()) ?? e.message;
+        const msg = e.message?.split('\n').find(line => line.trim()) ?? e.message;
         rebaseSpinner.stop(chalk.dim('Rebase skipped'));
         if (!silent) log.logWarn(`Rebase skipped: ${msg}`);
       }
     }
   }
 
-  // Re-link IDE dirs
   if (!args._skipIntegrate) {
     const projectRegistryDir = cwd !== HOME ? join(cwd, '.aw', REGISTRY_DIR) : null;
     const awDirForLinks = (projectRegistryDir && existsSync(projectRegistryDir)) ? projectRegistryDir : null;
@@ -237,6 +275,10 @@ export async function pullAsync(args) {
   return { pattern: args._positional?.[0] || '', actions: [], conflictCount: 0 };
 }
 
+export const __test__ = {
+  collectAllPaths,
+  syncFileTree,
+};
 
 function registerMcp(namespace) {
   const mcpUrl = process.env.GHL_MCP_URL;