@ghl-ai/aw 0.1.37-beta.67 → 0.1.37-beta.69

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,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;
@@ -17,13 +18,11 @@ const COMMANDS = {
   '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),
-  doctor:  () => import('./commands/doctor.mjs').then(m => m.doctorCommand),
-  routing: () => import('./commands/startup.mjs').then(m => m.routingCommand),
-  startup: () => import('./commands/startup.mjs').then(m => m.startupCommand),
   search:  () => import('./commands/search.mjs').then(m => m.searchCommand),
   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) {
@@ -98,17 +97,20 @@ function printHelp() {
 
     sec('Manage'),
     cmd('aw status', 'Show synced paths, modified files & conflicts'),
-    cmd('aw doctor', 'Run a health check for routing, MCP, plugin, and AW ECC surfaces'),
     cmd('aw link', 'Link current project as a git worktree (wires IDE symlinks)'),
-    cmd('aw routing status', 'Show global AW session-routing mode for Claude/Cursor/Codex'),
-    cmd('aw routing disable', 'Disable automatic AW session routing globally'),
-    cmd('aw routing enable', 'Re-enable automatic AW session routing globally'),
     cmd('aw drop <path>', 'Stop syncing or delete local content'),
     cmd('aw nuke', 'Remove entire .aw_registry/ & start fresh'),
     cmd('aw daemon install', 'Auto-pull on a schedule (macOS launchd / Linux cron)'),
     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'),
+    cmd('aw telemetry disable', 'Opt out of anonymous analytics'),
+    cmd('aw telemetry enable', 'Re-enable analytics'),
 
     sec('Examples'),
     '',
@@ -158,9 +160,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;
   }
@@ -170,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

@@ -23,13 +23,12 @@ 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, syncHomeHarnessInstructions } from '../integrate.mjs';
+import { generateCommands, copyInstructions, initAwDocs, installIdeHooks } from '../integrate.mjs';
 import { setupMcp } from '../mcp.mjs';
-import { applyStoredStartupPreferences, ensureAwRuntimeHook } from '../startup.mjs';
+import { installLocalCommitHook } from '../hooks.mjs';
 import { autoUpdate, promptUpdate } from '../update.mjs';
 import { installGlobalHooks } from '../hooks.mjs';
 import { installAwEcc } from '../ecc.mjs';
-import { removeWorkspaceHookDefaults } from '../codex.mjs';
 import {
   initPersistentClone,
   isValidClone,
@@ -58,19 +57,6 @@ const HOME = (() => { try { return realpathSync(_rawHome); } catch { return _raw
 const GLOBAL_AW_DIR = join(HOME, '.aw_registry');
 const AW_HOME = join(HOME, '.aw');
 
-function syncInstructionsAndAwDocs(targetDir, namespace) {
-  copyInstructions(targetDir, null, namespace);
-  initAwDocs(targetDir);
-}
-
-function syncHomeAndProjectInstructions(cwd, namespace) {
-  syncHomeHarnessInstructions(HOME);
-  initAwDocs(HOME);
-  if (cwd !== HOME) {
-    syncInstructionsAndAwDocs(cwd, namespace);
-  }
-}
-
 // ── Ensure ~/.aw/.gitignore has personal/local entries ───────────────────
 
 const AW_GITIGNORE_ENTRIES = [
@@ -100,7 +86,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: [],
@@ -221,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;
     }
   }
 
@@ -274,11 +260,11 @@ export async function initCommand(args) {
     }
 
     await installAwEcc(cwd, { silent });
-    ensureAwRuntimeHook(HOME);
-    syncHomeAndProjectInstructions(cwd, freshCfg?.namespace || team);
+    copyInstructions(HOME, null, freshCfg?.namespace || team) || [];
+    initAwDocs(HOME);
     await setupMcp(HOME, freshCfg?.namespace || team, { silent });
-    const removedLegacyStartupFiles = cwd !== HOME ? removeWorkspaceHookDefaults(cwd) : [];
     installGlobalHooks();
+    installIdeHooks();
 
     // Remove old local .git/hooks/post-checkout that pre-dates core.hooksPath (creates stale .aw_registry symlink)
     if (cwd !== HOME) {
@@ -309,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);
@@ -318,9 +305,6 @@ export async function initCommand(args) {
         '',
         `  ${chalk.green('✓')} Registry synced`,
         `  ${chalk.green('✓')} IDE refreshed — ${chalk.bold(symlinks)} symlinks · ${chalk.bold(commands)} commands`,
-        removedLegacyStartupFiles.length > 0
-          ? `  ${chalk.green('✓')} Removed ${removedLegacyStartupFiles.length} legacy repo startup file${removedLegacyStartupFiles.length > 1 ? 's' : ''}`
-          : null,
         cwd !== HOME && isWorktree(join(cwd, '.aw')) ? `  ${chalk.green('✓')} Project linked` : null,
       ].filter(Boolean).join('\n'));
     }
@@ -345,7 +329,7 @@ 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 */ }
   }
 
@@ -396,8 +380,8 @@ 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);
   }
@@ -407,12 +391,11 @@ export async function initCommand(args) {
 
   // Step 3: Setup tasks, MCP, hooks
   await installAwEcc(cwd, { silent });
-  ensureAwRuntimeHook(HOME);
-  syncHomeAndProjectInstructions(cwd, team);
+  const instructionFiles = copyInstructions(HOME, null, team) || [];
+  initAwDocs(HOME);
   const mcpFiles = await setupMcp(HOME, team, { silent }) || [];
-  applyStoredStartupPreferences(HOME);
-  const removedLegacyStartupFiles = cwd !== HOME ? removeWorkspaceHookDefaults(cwd) : [];
   const hooksInstalled = installGlobalHooks();
+  installIdeHooks();
   installIdeTasks();
 
   // Remove old local .git/hooks/post-checkout that pre-dates core.hooksPath
@@ -444,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`);
@@ -457,10 +441,6 @@ export async function initCommand(args) {
     `  ${chalk.green('✓')} Source of truth: ~/.aw/ (git clone)`,
     `  ${chalk.green('✓')} Symlink: ~/.aw_registry/ → ~/.aw/.aw_registry/`,
     `  ${chalk.green('✓')} IDE integration: ~/.claude/, ~/.cursor/, ~/.codex/`,
-    cwd !== HOME ? `  ${chalk.green('✓')} Global startup managed from ~/.claude/, ~/.cursor/, ~/.codex/` : null,
-    removedLegacyStartupFiles.length > 0
-      ? `  ${chalk.green('✓')} Removed ${removedLegacyStartupFiles.length} legacy repo startup file${removedLegacyStartupFiles.length > 1 ? 's' : ''}`
-      : null,
     hooksInstalled ? `  ${chalk.green('✓')} Git hooks: auto-sync on pull/clone (core.hooksPath)` : null,
     `  ${chalk.green('✓')} IDE task: auto-sync on workspace open`,
     cwd !== HOME && isWorktree(join(cwd, '.aw')) ? `  ${chalk.green('✓')} Linked in current project` : null,

package/commands/link-project.mjs

@@ -9,8 +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 { removeWorkspaceHookDefaults } from '../codex.mjs';
-import { applyStoredStartupPreferences } from '../startup.mjs';
+import { installLocalCommitHook } from '../hooks.mjs';
 
 const HOME = homedir();
 const AW_HOME = join(HOME, '.aw');
@@ -42,9 +41,8 @@ export function linkProjectCommand(args) {
     const awDirForLinks = existsSync(projectRegistryDir) ? projectRegistryDir : null;
     const symlinks = linkWorkspace(HOME, awDirForLinks, { silent: true });
     const commands = generateCommands(HOME, { silent: true });
-    applyStoredStartupPreferences(HOME);
-    const removedLegacyStartupFiles = removeWorkspaceHookDefaults(cwd);
-    fmt.logSuccess(`Already linked — refreshed ${chalk.bold(symlinks)} IDE symlinks · ${chalk.bold(commands)} commands${removedLegacyStartupFiles.length > 0 ? ` · removed ${removedLegacyStartupFiles.length} legacy repo startup file${removedLegacyStartupFiles.length > 1 ? 's' : ''}` : ''}`);
+    installLocalCommitHook(cwd);
+    fmt.logSuccess(`Already linked — refreshed ${chalk.bold(symlinks)} IDE symlinks · ${chalk.bold(commands)} commands`);
     return;
   }
 
@@ -54,18 +52,13 @@ export function linkProjectCommand(args) {
     const awDirForLinks = existsSync(projectRegistryDir) ? projectRegistryDir : null;
     const symlinks = linkWorkspace(HOME, awDirForLinks, { silent: true });
     const commands = generateCommands(HOME, { silent: true });
-    applyStoredStartupPreferences(HOME);
-    const removedLegacyStartupFiles = removeWorkspaceHookDefaults(cwd);
+    installLocalCommitHook(cwd);
     fmt.logSuccess([
       `Project linked — ${chalk.bold(symlinks)} IDE symlinks · ${chalk.bold(commands)} commands`,
       '',
       `  ${chalk.green('✓')} ${chalk.dim('.aw/')}                  git worktree (IDE git panel enabled)`,
       `  ${chalk.green('✓')} ${chalk.dim(`.aw/${REGISTRY_DIR}/`)} registry content`,
       `  ${chalk.green('✓')} ${chalk.dim('.claude/.cursor/.codex/')} IDE symlinks wired`,
-      `  ${chalk.green('✓')} ${chalk.dim('startup mode')}          global-first via ~/.claude/, ~/.cursor/, ~/.codex/`,
-      removedLegacyStartupFiles.length > 0
-        ? `  ${chalk.green('✓')} ${chalk.dim('legacy repo hooks')} removed ${removedLegacyStartupFiles.length} AW-managed file${removedLegacyStartupFiles.length > 1 ? 's' : ''}`
-        : null,
     ].join('\n'));
   } catch (e) {
     fmt.cancel(`Failed to link project: ${e.message}`);

package/commands/nuke.mjs

@@ -2,7 +2,7 @@
 //
 // Safety guarantee: NEVER deletes files that AW didn't create.
 
-import { dirname, join } from 'node:path';
+import { join } from 'node:path';
 import { existsSync, rmSync, lstatSync, unlinkSync, readdirSync, readFileSync, readlinkSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { execSync, exec as execCb } from 'node:child_process';
@@ -15,14 +15,13 @@ import { removeGlobalHooks } from '../hooks.mjs';
 import { uninstallAwEcc } from '../ecc.mjs';
 import { removeMcpConfig } from '../mcp.mjs';
 import { listProjectWorktrees } from '../git.mjs';
-import { removeWorkspaceHookDefaults } from '../codex.mjs';
 
 const HOME = homedir();
 const GLOBAL_AW_DIR = join(HOME, '.aw_registry');
 const MANIFEST_PATH = join(GLOBAL_AW_DIR, '.aw-manifest.json');
 
 const IDE_DIRS = ['.claude', '.cursor', '.codex', '.agents'];
-const CONTENT_TYPES = ['agents', 'skills', 'commands', 'evals', 'references'];
+const CONTENT_TYPES = ['agents', 'skills', 'commands', 'evals'];
 
 function loadManifest() {
   if (!existsSync(MANIFEST_PATH)) return null;
@@ -140,27 +139,28 @@ async function removeProjectSymlinks() {
     { encoding: 'utf8', timeout: 30000 }
   );
   for (const linkPath of registryLinks.trim().split('\n').filter(Boolean)) {
-    try {
-      removeWorkspaceHookDefaults(dirname(linkPath));
-      unlinkSync(linkPath);
-      removed++;
-    } catch { /* best effort */ }
+    try { unlinkSync(linkPath); removed++; } catch { /* best effort */ }
   }
 
   // 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 };
@@ -209,20 +209,15 @@ 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');
 
   // Remove stale local .aw_registry symlink if present (skip if cwd IS home — that's the global one)
   if (process.cwd() !== HOME) {
     const local = join(process.cwd(), '.aw_registry');
-    try {
-      if (lstatSync(local).isSymbolicLink()) {
-        removeWorkspaceHookDefaults(process.cwd());
-        unlinkSync(local);
-      }
-    } catch { /* fine */ }
+    try { if (lstatSync(local).isSymbolicLink()) unlinkSync(local); } catch { /* fine */ }
   }
 
   const manifest = loadManifest();

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

@@ -4,7 +4,7 @@ import {
   existsSync,
   lstatSync,
 } from 'node:fs';
-import { dirname, join, extname } from 'node:path';
+import { join, extname } from 'node:path';
 import { homedir } from 'node:os';
 import { exec as execCb, execSync } from 'node:child_process';
 import { promisify } from 'node:util';
@@ -30,9 +30,7 @@ import {
 } from '../constants.mjs';
 import { collectAllPaths, syncFileTree } from '../file-tree.mjs';
 import { linkWorkspace } from '../link.mjs';
-import { generateCommands, copyInstructions, syncHomeHarnessInstructions } from '../integrate.mjs';
-import { removeWorkspaceHookDefaults } from '../codex.mjs';
-import { applyStoredStartupPreferences, ensureAwRuntimeHook } from '../startup.mjs';
+import { generateCommands, copyInstructions } from '../integrate.mjs';
 
 const HOME = homedir();
 const AW_HOME = join(HOME, '.aw');
@@ -44,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,
@@ -247,7 +245,6 @@ export async function pullCommand(args) {
   if (!args._skipIntegrate) {
     const projectRegistryDir = cwd !== HOME ? join(cwd, '.aw', REGISTRY_DIR) : null;
     const awDirForLinks = (projectRegistryDir && existsSync(projectRegistryDir)) ? projectRegistryDir : null;
-    const startupCleanupDir = localAw ? dirname(localAw) : (cwd !== HOME ? cwd : null);
 
     if (!silent) {
       const ideSpinner = log.spinner();
@@ -255,18 +252,12 @@ export async function pullCommand(args) {
       const symlinks = linkWorkspace(HOME, awDirForLinks, { silent: true });
       ideSpinner.message('Generating commands...');
       const commands = generateCommands(HOME, { silent: true });
-      syncHomeHarnessInstructions(HOME);
-      ensureAwRuntimeHook(HOME);
-      applyStoredStartupPreferences(HOME);
-      if (startupCleanupDir) removeWorkspaceHookDefaults(startupCleanupDir);
+      copyInstructions(HOME, null, cfg.namespace);
       ideSpinner.stop(`IDE wired — ${chalk.bold(symlinks)} symlink${symlinks !== 1 ? 's' : ''}, ${chalk.bold(commands)} command${commands !== 1 ? 's' : ''}`);
     } else {
       linkWorkspace(HOME, awDirForLinks, { silent: true });
       generateCommands(HOME, { silent: true });
-      syncHomeHarnessInstructions(HOME);
-      ensureAwRuntimeHook(HOME);
-      applyStoredStartupPreferences(HOME);
-      if (startupCleanupDir) removeWorkspaceHookDefaults(startupCleanupDir);
+      copyInstructions(HOME, null, cfg.namespace);
     }
   }
 
@@ -299,73 +290,3 @@ function registerMcp(namespace) {
     fmt.logWarn('MCP registration failed (pull still successful)');
   }
 }
-function printDryRun(actions, verbose) {
-  const counts = { ADD: 0, UPDATE: 0, CONFLICT: 0, ORPHAN: 0, UNCHANGED: 0 };
-  const lines = [];
-
-  for (const type of ['agents', 'skills', 'commands', 'evals', 'references']) {
-    const items = actions.filter(a => a.type === type);
-    if (items.length === 0) continue;
-
-    lines.push(chalk.bold(`${type}/`));
-    for (const act of items.sort((a, b) => a.targetFilename.localeCompare(b.targetFilename))) {
-      counts[act.action] = (counts[act.action] || 0) + 1;
-      if (!verbose && act.action === 'UNCHANGED') continue;
-      const ns = act.namespacePath ? chalk.dim(` [${act.namespacePath}]`) : '';
-      lines.push(`  ${fmt.actionLabel(act.action)} ${act.targetFilename}${ns}`);
-    }
-  }
-
-  if (lines.length > 0) {
-    fmt.note(lines.join('\n'), 'Dry Run');
-  }
-
-  fmt.logInfo(`Summary: ${fmt.countSummary(counts)}`);
-  fmt.logWarn('No files modified (--dry-run)');
-}
-
-function printSummary(actions, verbose, conflictCount) {
-  const conflicts = actions.filter(a => a.action === 'CONFLICT');
-
-  for (const type of ['agents', 'skills', 'commands', 'evals', 'references']) {
-    const typeActions = actions.filter(a => a.type === type);
-    if (typeActions.length === 0) continue;
-
-    const counts = { ADD: 0, UPDATE: 0, CONFLICT: 0, ORPHAN: 0, UNCHANGED: 0 };
-    for (const a of typeActions) counts[a.action]++;
-
-    const parts = [];
-    if (counts.ADD > 0) parts.push(chalk.green(`${counts.ADD} new`));
-    if (counts.UPDATE > 0) parts.push(chalk.cyan(`${counts.UPDATE} updated`));
-    if (counts.CONFLICT > 0) parts.push(chalk.red(`${counts.CONFLICT} conflict`));
-    if (counts.ORPHAN > 0) parts.push(chalk.yellow(`${counts.ORPHAN} removed`));
-    const detail = parts.length > 0 ? ` (${parts.join(', ')})` : '';
-
-    fmt.logSuccess(`${typeActions.length} ${type} pulled${detail}`);
-
-    if (verbose) {
-      for (const a of typeActions.filter(a => a.action !== 'UNCHANGED')) {
-        const ns = a.namespacePath ? chalk.dim(` [${a.namespacePath}]`) : '';
-        fmt.logMessage(`  ${fmt.actionLabel(a.action)} ${a.targetFilename}${ns}`);
-      }
-    }
-  }
-
-  if (conflicts.length > 0) {
-    const conflictLines = conflicts.map(c => {
-      return `${chalk.red('both modified:')}  ${c.type}/${c.targetFilename}`;
-    }).join('\n');
-
-    fmt.note(
-      conflictLines + '\n\n' +
-      chalk.dim('Fix conflicts, then re-run pull to verify.\n') +
-      chalk.dim('grep -r "<<<<<<< " .aw_registry/'),
-      chalk.red('Merge Conflicts')
-    );
-
-    fmt.outro(chalk.red('Pull completed with conflicts — resolve and re-run'));
-    process.exit(1);
-  }
-
-  fmt.outro('Pull complete');
-}

package/commands/push-rules.mjs

@@ -5,7 +5,7 @@ import { tmpdir } from 'node:os';
 
 import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
-import { REGISTRY_BASE_BRANCH, REGISTRY_REPO, RULES_SOURCE_DIR } from '../constants.mjs';
+import { REGISTRY_BASE_BRANCH, REGISTRY_REPO, RULES_SOURCE_DIR, AW_CO_AUTHOR } from '../constants.mjs';
 import { syncFileTree } from '../file-tree.mjs';
 
 function normalizeSlashes(path) {
@@ -147,7 +147,7 @@ function pushRulesTree(sourceRoot, { repo, dryRun, cwd }) {
     const prTitle = buildRulesPrTitle(sourceRoot, cwd);
     const prBody = buildRulesPrBody(sourceRoot, sourceType, cwd);
 
-    execSync('git commit -m "registry: sync platform rules"', { cwd: tempDir, stdio: 'pipe' });
+    execSync(`git commit -m "registry: sync platform rules\n\n${AW_CO_AUTHOR}"`, { cwd: tempDir, stdio: 'pipe' });
     s2.stop('Rules sync prepared');
 
     const s3 = fmt.spinner();