@ghl-ai/aw 0.1.39-beta.8 → 0.1.39

package/commands/init.mjs

@@ -23,12 +23,14 @@ 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, syncHomeHarnessInstructions } 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,
@@ -42,28 +44,11 @@ import {
   syncWorktreeSparseCheckout,
   findNearestWorktree,
 } from '../git.mjs';
-import { REGISTRY_DIR, REGISTRY_REPO, REGISTRY_URL, RULES_SOURCE_DIR } from '../constants.mjs';
+import { REGISTRY_DIR, REGISTRY_REPO, REGISTRY_URL, RULES_SOURCE_DIR, RULES_RUNTIME_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;
-const DEBUG_INIT_LOG = process.env.AW_DEBUG_INIT_LOG;
-
-function debugInit(message) {
-  if (!DEBUG_INIT_LOG) return;
-  try {
-    appendFileSync(DEBUG_INIT_LOG, `${new Date().toISOString()} ${message}\n`);
-  } catch { /* best effort */ }
-}
-
-function createSpinner(enabled) {
-  if (enabled) return fmt.spinner();
-  return {
-    start() {},
-    stop() {},
-    message() {},
-  };
-}
 
 // Resolve HOME to the real path — on macOS /var is a symlink to /private/var,
 // so homedir() returns /var/... while process.cwd() returns /private/var/...
@@ -74,6 +59,35 @@ const HOME = (() => { try { return realpathSync(_rawHome); } catch { return _raw
 const GLOBAL_AW_DIR = join(HOME, '.aw_registry');
 const AW_HOME = join(HOME, '.aw');
 
+function syncRulesTargets(targetDir) {
+  const rulesSrc = join(AW_HOME, RULES_SOURCE_DIR);
+  if (!existsSync(rulesSrc)) return false;
+  syncFileTree(rulesSrc, join(targetDir, RULES_RUNTIME_DIR));
+  return true;
+}
+
+function removeLegacyRegistryRules() {
+  try {
+    rmSync(join(GLOBAL_AW_DIR, RULES_SOURCE_DIR), { recursive: true, force: true });
+    rmSync(join(HOME, RULES_SOURCE_DIR), { recursive: true, force: true });
+  } catch {
+    // best effort cleanup
+  }
+}
+
+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 = [
@@ -138,12 +152,8 @@ export async function initCommand(args) {
   let namespace = args['--namespace'] || null;
   let user = args['--user'] || '';
   const silent = args['--silent'] === true;
-  const interactiveUi = !silent && Boolean(process.stdout.isTTY);
 
-  if (interactiveUi) {
-    fmt.intro(`aw init ${chalk.dim('v' + VERSION)}`);
-  }
-  debugInit('init:start');
+  fmt.intro(`aw init ${chalk.dim('v' + VERSION)}`);
 
   // ── Validate ──────────────────────────────────────────────────────────
 
@@ -191,7 +201,7 @@ export async function initCommand(args) {
 
   let namespaceExistsInRemote = false;
   if (folderName && !silent && !isGitNative && !isLegacy) {
-    const probeSpinner = createSpinner(interactiveUi);
+    const probeSpinner = fmt.spinner();
     probeSpinner.start(`Checking namespace ${chalk.cyan(folderName)} in registry...`);
     try {
       const probePaths = includeToSparsePaths([folderName]);
@@ -204,15 +214,11 @@ export async function initCommand(args) {
       } finally {
         cleanup(probeDir);
       }
-      if (interactiveUi) {
-        probeSpinner.stop(namespaceExistsInRemote
-          ? `Namespace ${chalk.cyan(folderName)} found in registry`
-          : `Namespace ${chalk.cyan(folderName)} not yet in registry`);
-      }
+      probeSpinner.stop(namespaceExistsInRemote
+        ? `Namespace ${chalk.cyan(folderName)} found in registry`
+        : `Namespace ${chalk.cyan(folderName)} not yet in registry`);
     } catch {
-      if (interactiveUi) {
-        probeSpinner.stop(chalk.dim('Could not verify namespace (continuing)'));
-      }
+      probeSpinner.stop(chalk.dim('Could not verify namespace (continuing)'));
       namespaceExistsInRemote = true;
     }
   }
@@ -254,7 +260,7 @@ export async function initCommand(args) {
       if (!silent) fmt.logStep('Already initialized — syncing...');
     }
 
-    const s = createSpinner(interactiveUi);
+    const s = fmt.spinner();
     if (!silent) s.start('Fetching latest from registry...');
     try {
       const { conflicts } = await fetchAndMerge(AW_HOME, { silent });
@@ -272,9 +278,11 @@ 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));
+    syncRulesTargets(HOME);
+    if (cwd !== HOME) {
+      syncRulesTargets(cwd);
     }
+    removeLegacyRegistryRules();
 
     // Ensure project worktree sparse checkout matches the global clone.
     // Covers the case where a namespace was added from HOME (or another project)
@@ -285,9 +293,11 @@ export async function initCommand(args) {
     }
 
     await installAwEcc(cwd, { silent });
-    copyInstructions(HOME, null, freshCfg?.namespace || team) || [];
-    initAwDocs(HOME);
+    ensureAwRuntimeHook(HOME);
+    syncHomeAndProjectInstructions(cwd, freshCfg?.namespace || team);
     await setupMcp(HOME, freshCfg?.namespace || team, { silent });
+    applyStoredStartupPreferences(HOME);
+    const removedLegacyStartupFiles = cwd !== HOME ? removeWorkspaceHookDefaults(cwd) : [];
     installGlobalHooks();
 
     // Remove old local .git/hooks/post-checkout that pre-dates core.hooksPath (creates stale .aw_registry symlink)
@@ -329,6 +339,9 @@ 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'));
     }
@@ -363,26 +376,21 @@ export async function initCommand(args) {
     sparsePaths.push(`.aw_registry/${folderName}`);
   }
 
-  if (interactiveUi) {
-    fmt.note([
-      `${chalk.dim('source:')}     ~/.aw/ → ~/.aw_registry/ (symlink)`,
-      folderName ? `${chalk.dim('namespace:')}  ${folderName}` : `${chalk.dim('namespace:')}  ${chalk.dim('none')}`,
-      user ? `${chalk.dim('user:')}       ${user}` : null,
-      `${chalk.dim('version:')}    v${VERSION}`,
-    ].filter(Boolean).join('\n'), 'Config');
-  }
+  fmt.note([
+    `${chalk.dim('source:')}     ~/.aw/ → ~/.aw_registry/ (symlink)`,
+    folderName ? `${chalk.dim('namespace:')}  ${folderName}` : `${chalk.dim('namespace:')}  ${chalk.dim('none')}`,
+    user ? `${chalk.dim('user:')}       ${user}` : null,
+    `${chalk.dim('version:')}    v${VERSION}`,
+  ].filter(Boolean).join('\n'), 'Config');
 
-  const s = createSpinner(interactiveUi);
+  const s = fmt.spinner();
   s.start(`Cloning registry...`);
 
   try {
-    debugInit(`clone:start repo=${repoUrl}`);
     await initPersistentClone(repoUrl, AW_HOME, sparsePaths);
-    debugInit('clone:done');
     ensureAwGitignore(AW_HOME);
     s.stop('Registry cloned');
   } catch (e) {
-    debugInit(`clone:error ${e.message}`);
     s.stop(chalk.red('Clone failed'));
     fmt.cancel(e.message);
   }
@@ -393,55 +401,42 @@ export async function initCommand(args) {
   try { awRegistryLstat = lstatSync(GLOBAL_AW_DIR); } catch { /* doesn't exist */ }
   if (!awRegistryLstat) {
     try {
-      debugInit('symlink:create:start');
       symlinkSync(join(AW_HOME, REGISTRY_DIR), GLOBAL_AW_DIR);
-      debugInit('symlink:create:done');
       fmt.logStep('Created ~/.aw_registry/ symlink');
     } catch (e) {
-      debugInit(`symlink:create:error ${e.message}`);
       fmt.logWarn(`Could not create symlink ~/.aw_registry/: ${e.message}`);
     }
   } else if (awRegistryLstat.isSymbolicLink()) {
     // Stale or dangling — re-point to the new clone
     try {
-      debugInit('symlink:update:start');
       rmSync(GLOBAL_AW_DIR);
       symlinkSync(join(AW_HOME, REGISTRY_DIR), GLOBAL_AW_DIR);
-      debugInit('symlink:update:done');
       fmt.logStep('Updated ~/.aw_registry/ symlink');
     } catch (e) {
-      debugInit(`symlink:update:error ${e.message}`);
       fmt.logWarn(`Could not update symlink ~/.aw_registry/: ${e.message}`);
     }
   }
 
   // Create sync config — default to 'platform' when no namespace specified
   const cfg = config.create(GLOBAL_AW_DIR, { namespace: team || 'platform', user });
-  debugInit('config:create:done');
   if (folderName) {
     config.addPattern(GLOBAL_AW_DIR, folderName);
-    debugInit('config:add-pattern:done');
   }
-  if (existsSync(GLOBAL_AW_DIR)) {
-    debugInit('sync-file-tree:start');
-    syncFileTree(join(AW_HOME, RULES_SOURCE_DIR), join(GLOBAL_AW_DIR, RULES_SOURCE_DIR));
-    debugInit('sync-file-tree:done');
+  syncRulesTargets(HOME);
+  if (cwd !== HOME) {
+    syncRulesTargets(cwd);
   }
+  removeLegacyRegistryRules();
 
   // Step 3: Setup tasks, MCP, hooks
-  debugInit('ecc:start');
   await installAwEcc(cwd, { silent });
-  debugInit('ecc:done');
-  const instructionFiles = copyInstructions(HOME, null, team) || [];
-  debugInit(`instructions:done count=${instructionFiles.length}`);
-  initAwDocs(HOME);
-  debugInit('aw-docs:done');
+  ensureAwRuntimeHook(HOME);
+  syncHomeAndProjectInstructions(cwd, team);
   const mcpFiles = await setupMcp(HOME, team, { silent }) || [];
-  debugInit(`mcp:done count=${mcpFiles.length}`);
+  applyStoredStartupPreferences(HOME);
+  const removedLegacyStartupFiles = cwd !== HOME ? removeWorkspaceHookDefaults(cwd) : [];
   const hooksInstalled = installGlobalHooks();
-  debugInit(`hooks:done installed=${hooksInstalled}`);
   installIdeTasks();
-  debugInit('ide-tasks:done');
 
   // Remove old local .git/hooks/post-checkout that pre-dates core.hooksPath
   if (cwd !== HOME) {
@@ -460,33 +455,24 @@ export async function initCommand(args) {
   const isAlreadySymlinkFresh = (() => { try { return lstatSync(awLinkFresh).isSymbolicLink() && existsSync(awLinkFresh); } catch { return false; } })();
   if (cwd !== HOME && !isInsideAw && !isAlreadySymlinkFresh) {
     try {
-      debugInit('link-project:start');
       addProjectWorktree(AW_HOME, cwd);
-      debugInit('link-project:done');
       fmt.logStep('Linked current project');
     } catch { /* best effort */ }
   }
 
   // Step 5: Wire ~/.claude/.cursor/.codex to the project's registry when in a project,
   // so edits to project/.aw/.aw_registry/ are instantly visible in global IDE dirs.
-  const ideSpinner = createSpinner(interactiveUi);
+  const ideSpinner = fmt.spinner();
   ideSpinner.start('Wiring IDE symlinks...');
-  debugInit('ide-wire:start');
   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 });
-  debugInit(`ide-wire:done symlinks=${symlinks} commands=${commands}`);
   ideSpinner.stop(`IDE wired — ${chalk.bold(symlinks)} symlinks · ${chalk.bold(commands)} commands`);
 
   // Offer to update if a newer version is available
-  if (silent) {
-    autoUpdate(await args._updateCheck);
-    return;
-  }
-
   await promptUpdate(await args._updateCheck);
 
   fmt.outro([
@@ -495,6 +481,10 @@ 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,6 +9,8 @@ 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();
@@ -41,8 +43,11 @@ 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);
     installLocalCommitHook(cwd);
-    fmt.logSuccess(`Already linked — refreshed ${chalk.bold(symlinks)} IDE symlinks · ${chalk.bold(commands)} commands`);
+    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' : ''}` : ''}`);
+
     return;
   }
 
@@ -52,13 +57,19 @@ 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);
     installLocalCommitHook(cwd);
+    const removedLegacyStartupFiles = removeWorkspaceHookDefaults(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 { join } from 'node:path';
+import { dirname, 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,13 +15,14 @@ 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'];
+const CONTENT_TYPES = ['agents', 'skills', 'commands', 'evals', 'references'];
 
 function loadManifest() {
   if (!existsSync(MANIFEST_PATH)) return null;
@@ -139,7 +140,11 @@ async function removeProjectSymlinks() {
     { encoding: 'utf8', timeout: 30000 }
   );
   for (const linkPath of registryLinks.trim().split('\n').filter(Boolean)) {
-    try { unlinkSync(linkPath); removed++; } catch { /* best effort */ }
+    try {
+      removeWorkspaceHookDefaults(dirname(linkPath));
+      unlinkSync(linkPath);
+      removed++;
+    } catch { /* best effort */ }
   }
 
   // Also remove legacy local .git/hooks/post-checkout installed by old aw versions
@@ -217,7 +222,12 @@ export async function nukeCommand(args) {
   // 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()) unlinkSync(local); } catch { /* fine */ }
+    try {
+      if (lstatSync(local).isSymbolicLink()) {
+        removeWorkspaceHookDefaults(process.cwd());
+        unlinkSync(local);
+      }
+    } catch { /* fine */ }
   }
 
   const manifest = loadManifest();

package/commands/pull.mjs

@@ -3,8 +3,9 @@
 import {
   existsSync,
   lstatSync,
+  rmSync,
 } from 'node:fs';
-import { join, extname } from 'node:path';
+import { dirname, join, extname } from 'node:path';
 import { homedir } from 'node:os';
 import { exec as execCb, execSync } from 'node:child_process';
 import { promisify } from 'node:util';
@@ -27,15 +28,34 @@ import {
   REGISTRY_URL,
   DOCS_SOURCE_DIR,
   RULES_SOURCE_DIR,
+  RULES_RUNTIME_DIR,
 } from '../constants.mjs';
 import { collectAllPaths, syncFileTree } from '../file-tree.mjs';
 import { linkWorkspace } from '../link.mjs';
-import { generateCommands, copyInstructions } from '../integrate.mjs';
+import { generateCommands, copyInstructions, syncHomeHarnessInstructions } from '../integrate.mjs';
+import { removeWorkspaceHookDefaults } from '../codex.mjs';
+import { applyStoredStartupPreferences, ensureAwRuntimeHook } from '../startup.mjs';
 
 const HOME = homedir();
 const AW_HOME = join(HOME, '.aw');
 const GLOBAL_AW_DIR = join(HOME, '.aw_registry');
 
+function syncRulesTargets(targetDir) {
+  const rulesSrc = join(AW_HOME, RULES_SOURCE_DIR);
+  if (!existsSync(rulesSrc)) return false;
+  syncFileTree(rulesSrc, join(targetDir, RULES_RUNTIME_DIR));
+  return true;
+}
+
+function removeLegacyRegistryRules() {
+  try {
+    rmSync(join(GLOBAL_AW_DIR, RULES_SOURCE_DIR), { recursive: true, force: true });
+    rmSync(join(HOME, RULES_SOURCE_DIR), { recursive: true, force: true });
+  } catch {
+    // best effort cleanup
+  }
+}
+
 export async function pullCommand(args) {
   const input = args._positional?.[0] || '';
   const cwd = process.cwd();
@@ -177,13 +197,6 @@ export async function pullCommand(args) {
     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.
@@ -242,9 +255,20 @@ export async function pullCommand(args) {
     }
   }
 
+  let rulesSynced = syncRulesTargets(HOME);
+  const workspaceRoot = localAw ? dirname(localAw) : (cwd !== HOME ? cwd : null);
+  if (workspaceRoot && workspaceRoot !== HOME) {
+    rulesSynced = syncRulesTargets(workspaceRoot) || rulesSynced;
+  }
+  removeLegacyRegistryRules();
+  if (rulesSynced && !silent) {
+    log.logSuccess('Synced .aw_rules');
+  }
+
   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();
@@ -252,12 +276,18 @@ export async function pullCommand(args) {
       const symlinks = linkWorkspace(HOME, awDirForLinks, { silent: true });
       ideSpinner.message('Generating commands...');
       const commands = generateCommands(HOME, { silent: true });
-      copyInstructions(HOME, null, cfg.namespace);
+      syncHomeHarnessInstructions(HOME);
+      ensureAwRuntimeHook(HOME);
+      applyStoredStartupPreferences(HOME);
+      if (startupCleanupDir) removeWorkspaceHookDefaults(startupCleanupDir);
       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 });
-      copyInstructions(HOME, null, cfg.namespace);
+      syncHomeHarnessInstructions(HOME);
+      ensureAwRuntimeHook(HOME);
+      applyStoredStartupPreferences(HOME);
+      if (startupCleanupDir) removeWorkspaceHookDefaults(startupCleanupDir);
     }
   }
 
@@ -290,3 +320,73 @@ 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

@@ -23,11 +23,9 @@ export function isRulesPushInput(input) {
 
 export function resolveRulesPushSource(input, cwd = process.cwd()) {
   const localRulesRoot = join(cwd, RULES_SOURCE_DIR);
-  const syncedRulesRoot = join(cwd, '.aw_registry', RULES_SOURCE_DIR);
 
   if (!input) {
     if (existsSync(localRulesRoot)) return { sourceRoot: localRulesRoot, sourceType: 'local' };
-    if (existsSync(syncedRulesRoot)) return { sourceRoot: syncedRulesRoot, sourceType: 'synced' };
     return null;
   }
 
@@ -39,22 +37,19 @@ export function resolveRulesPushSource(input, cwd = process.cwd()) {
   }
 
   if (normalizedInput === `.aw_registry/${RULES_SOURCE_DIR}` || normalizedInput.startsWith(`.aw_registry/${RULES_SOURCE_DIR}/`)) {
-    if (!existsSync(syncedRulesRoot)) return null;
-
     const relativeRulesPath = normalizedInput.slice(`.aw_registry/${RULES_SOURCE_DIR}`.length).replace(/^\/+/, '');
     const localOverridePath = relativeRulesPath ? join(localRulesRoot, relativeRulesPath) : localRulesRoot;
     if (existsSync(localOverridePath)) {
       return { sourceRoot: localRulesRoot, sourceType: 'local' };
     }
-
-    return { sourceRoot: syncedRulesRoot, sourceType: 'synced' };
+    return null;
   }
 
   return null;
 }
 
 export function hasRulesChanges(cwd = process.cwd()) {
-  const candidateDirs = [RULES_SOURCE_DIR, `.aw_registry/${RULES_SOURCE_DIR}`]
+  const candidateDirs = [RULES_SOURCE_DIR]
     .filter(rel => existsSync(join(cwd, rel)));
 
   if (candidateDirs.length === 0) return false;
@@ -141,9 +136,7 @@ function pushRulesTree(sourceRoot, { repo, dryRun, cwd }) {
       fmt.cancel('Nothing to push — remote rules already match local content.');
     }
 
-    const sourceType = normalize(sourceRoot).includes(normalize(join('.aw_registry', RULES_SOURCE_DIR)))
-      ? 'synced'
-      : 'local';
+    const sourceType = 'local';
     const prTitle = buildRulesPrTitle(sourceRoot, cwd);
     const prBody = buildRulesPrBody(sourceRoot, sourceType, cwd);
 
@@ -191,16 +184,12 @@ export function pushRulesCommand(args) {
     fmt.cancel([
       'Could not find a rules source to push.',
       '',
-      `  Checked ${chalk.cyan('.aw_rules/')} and ${chalk.cyan('.aw_registry/.aw_rules/')}.`,
+      `  Checked ${chalk.cyan('.aw_rules/')}.`,
       '',
       '  Use `aw pull platform` first or create a local `.aw_rules/` authoring tree.',
     ].join('\n'));
   }
 
-  if (resolved.sourceType === 'synced') {
-    fmt.logWarn('Pushing from synced `.aw_registry/.aw_rules/`. Local `.aw_rules/` is safer for authoring.');
-  }
-
   pushRulesTree(resolved.sourceRoot, { repo, dryRun, cwd });
 }