@ghl-ai/aw 0.1.36-beta.8 → 0.1.36-beta.81

package/cli.mjs

@@ -65,7 +65,8 @@ function parseArgs(argv) {
 
 function printHelp() {
   fmt.banner('aw', {
-    subtitle: `  ${chalk.dim('v' + VERSION)}  ${chalk.hex('#FF6B35')('Agentic Workspace CLI')}  ${chalk.dim('— pull, push & manage agents, skills and more from the registry')}`,
+    icon: '⟁',
+    subtitle: `  ${chalk.hex('#FF6B35')('⟁')}  ${chalk.dim('v' + VERSION)}  ${chalk.hex('#FF6B35')('Agentic Workspace CLI')}  ${chalk.dim('— pull, push & manage agents, skills and more from the registry')}`,
   });
 
   const cmd = (c, d) => `  ${chalk.hex('#FF6B35')(c.padEnd(38))} ${chalk.dim(d)}`;
@@ -92,6 +93,7 @@ function printHelp() {
 
     sec('Manage'),
     cmd('aw status', 'Show synced paths, modified files & conflicts'),
+    cmd('aw link', 'Link current project as a git worktree (wires IDE symlinks)'),
     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)'),

package/commands/daemon.mjs

@@ -2,12 +2,15 @@
 // that silently runs `aw pull` on a schedule without any user interaction.
 
 import { existsSync, writeFileSync, readFileSync, mkdirSync, unlinkSync } from 'node:fs';
-import { execSync } from 'node:child_process';
+import { execSync, exec as execCb } from 'node:child_process';
+import { promisify } from 'node:util';
 import { join } from 'node:path';
 import { homedir, platform } from 'node:os';
 import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
 
+const exec = promisify(execCb);
+
 const LABEL = 'ai.ghl.aw.pull';
 const PLIST_PATH = join(homedir(), 'Library', 'LaunchAgents', `${LABEL}.plist`);
 const DEFAULT_INTERVAL = 3600; // 1 hour in seconds
@@ -22,7 +25,7 @@ function getAwBin() {
 
 // ── macOS: launchd ──────────────────────────────────────────────────────────
 
-function installLaunchd(intervalSeconds) {
+async function installLaunchd(intervalSeconds) {
   const awBin = getAwBin();
   const logDir = join(homedir(), '.aw_registry', 'logs');
   if (!existsSync(logDir)) mkdirSync(logDir, { recursive: true });
@@ -63,22 +66,24 @@ function installLaunchd(intervalSeconds) {
 
   writeFileSync(PLIST_PATH, plist);
 
-  // Unload first if already loaded (to apply new interval)
-  try { execSync(`launchctl unload "${PLIST_PATH}" 2>/dev/null`); } catch { /* not loaded */ }
-  execSync(`launchctl load "${PLIST_PATH}"`);
-
-  fmt.logStep(`Daemon installed — runs every ${formatInterval(intervalSeconds)}`);
-  fmt.logStep(`Logs: ${chalk.dim(logDir + '/pull.log')}`);
+  const s = fmt.spinner();
+  s.start('Installing daemon...');
+  try { await exec(`launchctl unload "${PLIST_PATH}" 2>/dev/null`); } catch { /* not loaded */ }
+  await exec(`launchctl load "${PLIST_PATH}"`);
+  s.stop(`Daemon installed — runs every ${formatInterval(intervalSeconds)}`);
+  fmt.logInfo(`Logs: ${chalk.dim(logDir + '/pull.log')}`);
 }
 
-function uninstallLaunchd() {
+async function uninstallLaunchd() {
   if (!existsSync(PLIST_PATH)) {
     fmt.logStep('No daemon installed.');
     return;
   }
-  try { execSync(`launchctl unload "${PLIST_PATH}"`); } catch { /* ignore */ }
+  const s = fmt.spinner();
+  s.start('Removing daemon...');
+  try { await exec(`launchctl unload "${PLIST_PATH}"`); } catch { /* ignore */ }
   unlinkSync(PLIST_PATH);
-  fmt.logStep('Daemon removed.');
+  s.stop('Daemon removed.');
 }
 
 function statusLaunchd() {
@@ -102,7 +107,7 @@ function toCronExpression(intervalSeconds) {
   return `0 */${hours} * * *`;
 }
 
-function installCron(intervalSeconds) {
+async function installCron(intervalSeconds) {
   const awBin = getAwBin();
   const logDir = join(homedir(), '.aw_registry', 'logs');
   if (!existsSync(logDir)) mkdirSync(logDir, { recursive: true });
@@ -117,17 +122,21 @@ function installCron(intervalSeconds) {
   const cleaned = current.split('\n').filter(l => !l.includes('# aw-daemon')).join('\n');
   const updated = cleaned.trimEnd() + '\n' + cronLine + '\n';
 
-  execSync(`echo ${JSON.stringify(updated)} | crontab -`);
-  fmt.logStep(`Cron job installed — runs every ${formatInterval(intervalSeconds)}`);
-  fmt.logStep(`Logs: ${chalk.dim(logDir + '/pull.log')}`);
+  const s = fmt.spinner();
+  s.start('Installing cron job...');
+  await exec(`echo ${JSON.stringify(updated)} | crontab -`);
+  s.stop(`Cron job installed — runs every ${formatInterval(intervalSeconds)}`);
+  fmt.logInfo(`Logs: ${chalk.dim(logDir + '/pull.log')}`);
 }
 
-function uninstallCron() {
+async function uninstallCron() {
   let current = '';
   try { current = execSync('crontab -l 2>/dev/null', { encoding: 'utf8' }); } catch { return; }
   const cleaned = current.split('\n').filter(l => !l.includes('# aw-daemon')).join('\n');
-  execSync(`echo ${JSON.stringify(cleaned)} | crontab -`);
-  fmt.logStep('Cron job removed.');
+  const s = fmt.spinner();
+  s.start('Removing cron job...');
+  await exec(`echo ${JSON.stringify(cleaned)} | crontab -`);
+  s.stop('Cron job removed.');
 }
 
 // ── Helpers ─────────────────────────────────────────────────────────────────
@@ -148,7 +157,7 @@ function parseInterval(str) {
 
 // ── Main ─────────────────────────────────────────────────────────────────────
 
-export function daemonCommand(args) {
+export async function daemonCommand(args) {
   const subcommand = args._positional[0] || 'install';
   const interval = parseInterval(args['--interval'] || args._positional[1]);
   const isMac = platform() === 'darwin';
@@ -158,13 +167,13 @@ export function daemonCommand(args) {
   if (subcommand === 'install') {
     fmt.logStep(`Platform: ${isMac ? 'macOS (launchd)' : 'Linux (cron)'}`);
     fmt.logStep(`Interval: every ${formatInterval(interval)}`);
-    if (isMac) installLaunchd(interval);
-    else installCron(interval);
+    if (isMac) await installLaunchd(interval);
+    else await installCron(interval);
     fmt.outro(`aw pull will run silently every ${formatInterval(interval)}`);
 
   } else if (subcommand === 'uninstall' || subcommand === 'stop') {
-    if (isMac) uninstallLaunchd();
-    else uninstallCron();
+    if (isMac) await uninstallLaunchd();
+    else await uninstallCron();
     fmt.outro('Daemon stopped.');
 
   } else if (subcommand === 'status') {

package/commands/drop.mjs

@@ -80,7 +80,7 @@ export function dropCommand(args) {
   }
 
   // Re-link to remove dead symlinks
-  linkWorkspace(HOME);
+  linkWorkspace(HOME, null, { silent: true });
 
-  fmt.outro('Done');
+  fmt.outro(`⟁  Dropped ${chalk.cyan(regPath)}`);
 }

package/commands/init.mjs

@@ -4,12 +4,11 @@
 // 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 } 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';
 import { fileURLToPath } from 'node:url';
-import { readFileSync } from 'node:fs';
 import * as config from '../config.mjs';
 import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
@@ -29,16 +28,43 @@ import {
   includeToSparsePaths,
   sparseCheckoutAsync,
   cleanup,
+  syncWorktreeSparseCheckout,
+  findNearestWorktree,
 } from '../git.mjs';
-import { REGISTRY_DIR, REGISTRY_REPO } from '../constants.mjs';
+import { REGISTRY_DIR, REGISTRY_REPO, REGISTRY_URL } from '../constants.mjs';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const VERSION = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8')).version;
 
-const HOME = homedir();
+// 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/...
+// Without normalization, the `cwd !== HOME` guard would fail and HOME would be
+// treated as a project directory, causing addProjectWorktree to delete ~/.aw.
+const _rawHome = homedir();
+const HOME = (() => { try { return realpathSync(_rawHome); } catch { return _rawHome; } })();
 const GLOBAL_AW_DIR = join(HOME, '.aw_registry');
 const AW_HOME = join(HOME, '.aw');
 
+// ── Ensure ~/.aw/.gitignore has personal/local entries ───────────────────
+
+const AW_GITIGNORE_ENTRIES = [
+  '.aw_registry/.sync-config.json',
+  'hooks/',
+];
+
+function ensureAwGitignore(awHome) {
+  // Use .git/info/exclude so the tracked .gitignore stays clean
+  const excludePath = join(awHome, '.git', 'info', 'exclude');
+  let existing = '';
+  try { existing = readFileSync(excludePath, 'utf8'); } catch { /* doesn't exist yet */ }
+  const missing = AW_GITIGNORE_ENTRIES.filter(e => !existing.includes(e));
+  if (missing.length === 0) return;
+  const block = (existing.endsWith('\n') || existing === '' ? '' : '\n')
+    + '# aw: personal/local — do not commit\n'
+    + missing.join('\n') + '\n';
+  try { appendFileSync(excludePath, block); } catch { /* best effort */ }
+}
+
 // ── IDE tasks for auto-pull ─────────────────────────────────────────────
 
 function installIdeTasks() {
@@ -91,7 +117,6 @@ export async function initCommand(args) {
   let nsParts = namespace ? namespace.split('/') : [];
   let team = nsParts[0] || null;
   let subTeam = nsParts[1] || null;
-  let teamNS = subTeam ? `${team}-${subTeam}` : team;
   let folderName = subTeam ? `${team}/${subTeam}` : team;
 
   if (team && !ALLOWED_NAMESPACES.includes(team)) {
@@ -125,7 +150,7 @@ export async function initCommand(args) {
 
   // ── Detect installation state ─────────────────────────────────────────
 
-  const repoUrl = `https://github.com/${REGISTRY_REPO}.git`;
+  const repoUrl = REGISTRY_URL;
   const isGitNative = isValidClone(AW_HOME, repoUrl);
   const isLegacy = !isGitNative && existsSync(GLOBAL_AW_DIR) && !lstatSync(GLOBAL_AW_DIR).isSymbolicLink();
 
@@ -133,6 +158,8 @@ export async function initCommand(args) {
 
   let namespaceExistsInRemote = false;
   if (folderName && !silent && !isGitNative && !isLegacy) {
+    const probeSpinner = fmt.spinner();
+    probeSpinner.start(`Checking namespace ${chalk.cyan(folderName)} in registry...`);
     try {
       const probePaths = includeToSparsePaths([folderName]);
       const probeDir = await sparseCheckoutAsync(REGISTRY_REPO, probePaths);
@@ -144,7 +171,11 @@ export async function initCommand(args) {
       } finally {
         cleanup(probeDir);
       }
+      probeSpinner.stop(namespaceExistsInRemote
+        ? `Namespace ${chalk.cyan(folderName)} found in registry`
+        : `Namespace ${chalk.cyan(folderName)} not yet in registry`);
     } catch {
+      probeSpinner.stop(chalk.dim('Could not verify namespace (continuing)'));
       namespaceExistsInRemote = true;
     }
   }
@@ -164,11 +195,12 @@ export async function initCommand(args) {
     }
 
     if (choice === 'platform-only') {
-      namespace = null; team = null; subTeam = null; teamNS = null; folderName = null;
+      namespace = null; team = null; subTeam = null; folderName = null;
     }
   }
 
-  const cwd = process.cwd();
+  const _rawCwd = process.cwd();
+  const cwd = (() => { try { return realpathSync(_rawCwd); } catch { return _rawCwd; } })();
 
   // ── Re-init path: already set up with native git clone ────────────────
 
@@ -185,29 +217,52 @@ export async function initCommand(args) {
       if (!silent) fmt.logStep('Already initialized — syncing...');
     }
 
-    const s = fmt.spinner ? fmt.spinner() : { start: () => {}, stop: () => {} };
-    if (!silent) s.start('Fetching latest...');
+    const s = fmt.spinner();
+    if (!silent) s.start('Fetching latest from registry...');
     try {
-      fetchAndMerge(AW_HOME);
-      if (!silent) s.stop('Registry updated');
+      await fetchAndMerge(AW_HOME);
+      if (!silent) s.stop('Registry up to date');
     } catch (e) {
-      if (!silent) s.stop(chalk.yellow('Fetch failed (continuing with local)'));
+      if (!silent) s.stop(chalk.yellow('Fetch failed — continuing with local cache'));
     }
 
+    ensureAwGitignore(AW_HOME);
     const freshCfg = config.load(GLOBAL_AW_DIR);
 
+    // Ensure project worktree sparse checkout matches the global clone.
+    // Covers the case where a namespace was added from HOME (or another project)
+    // and this project's .aw/ hasn't been updated yet.
+    const localAw = cwd !== HOME ? findNearestWorktree(cwd, HOME) : null;
+    if (localAw) {
+      try { syncWorktreeSparseCheckout(AW_HOME, localAw); } catch { /* best effort */ }
+    }
+
     await installAwEcc(cwd, { silent });
     copyInstructions(HOME, null, freshCfg?.namespace || team) || [];
     initAwDocs(HOME);
     await setupMcp(HOME, freshCfg?.namespace || team, { silent });
-    if (cwd !== HOME) await setupMcp(cwd, freshCfg?.namespace || team, { silent });
     installGlobalHooks();
 
+    // Remove old local .git/hooks/post-checkout that pre-dates core.hooksPath (creates stale .aw_registry symlink)
+    if (cwd !== HOME) {
+      const oldLocalHook = join(cwd, '.git', 'hooks', 'post-checkout');
+      try {
+        const content = readFileSync(oldLocalHook, 'utf8');
+        if (content.includes('aw: auto-link registry') || content.includes('ln -s "$AW_REGISTRY"')) {
+          rmSync(oldLocalHook);
+          if (!silent) fmt.logStep('Removed legacy .git/hooks/post-checkout');
+        }
+      } catch { /* not there, fine */ }
+    }
+
     const isInsideAw = cwd.endsWith(`${sep}.aw`) || cwd.includes(`${sep}.aw${sep}`);
-    if (cwd !== HOME && !isInsideAw && !isWorktree(join(cwd, '.aw'))) {
+    // Only skip if already a valid symlink (new model). Old git worktrees must be migrated.
+    const awLink = join(cwd, '.aw');
+    const isAlreadySymlink = (() => { try { return lstatSync(awLink).isSymbolicLink() && existsSync(awLink); } catch { return false; } })();
+    if (cwd !== HOME && !isInsideAw && !isAlreadySymlink) {
       try {
         addProjectWorktree(AW_HOME, cwd);
-        if (!silent) fmt.logStep('Linked current project as git worktree');
+        if (!silent) fmt.logStep('Linked current project');
       } catch { /* best effort */ }
     }
 
@@ -215,18 +270,18 @@ export async function initCommand(args) {
     // so edits to project/.aw/.aw_registry/ are instantly visible in global IDE dirs.
     const projectRegistryDir = cwd !== HOME ? join(cwd, '.aw', REGISTRY_DIR) : null;
     const awDirForLinks = (projectRegistryDir && existsSync(projectRegistryDir)) ? projectRegistryDir : null;
-    linkWorkspace(HOME, awDirForLinks);
-    generateCommands(HOME);
+    const symlinks = linkWorkspace(HOME, awDirForLinks, { silent: true });
+    const commands = generateCommands(HOME, { silent: true });
 
     if (silent) {
       autoUpdate(await args._updateCheck);
     } else {
       fmt.outro([
-        isNewSubTeam ? `Sub-team ${chalk.cyan(folderName)} added` : 'Sync complete',
+        `⟁  ${isNewSubTeam ? `Sub-team ${chalk.cyan(folderName)} added` : 'Up to date'}`,
         '',
-        `  ${chalk.green('✓')} Registry updated`,
-        `  ${chalk.green('✓')} IDE integration refreshed`,
-        cwd !== HOME && isWorktree(join(cwd, '.aw')) ? `  ${chalk.green('✓')} Current project linked` : null,
+        `  ${chalk.green('✓')} Registry synced`,
+        `  ${chalk.green('✓')} IDE refreshed — ${chalk.bold(symlinks)} symlinks · ${chalk.bold(commands)} commands`,
+        cwd !== HOME && isWorktree(join(cwd, '.aw')) ? `  ${chalk.green('✓')} Project linked` : null,
       ].filter(Boolean).join('\n'));
     }
     return;
@@ -271,7 +326,8 @@ export async function initCommand(args) {
   s.start(`Cloning registry...`);
 
   try {
-    initPersistentClone(repoUrl, AW_HOME, sparsePaths);
+    await initPersistentClone(repoUrl, AW_HOME, sparsePaths);
+    ensureAwGitignore(AW_HOME);
     s.stop('Registry cloned');
   } catch (e) {
     s.stop(chalk.red('Clone failed'));
@@ -279,13 +335,25 @@ export async function initCommand(args) {
   }
 
   // Create backward-compat symlink: ~/.aw_registry/ → ~/.aw/.aw_registry/
-  if (!existsSync(GLOBAL_AW_DIR)) {
+  // Use lstatSync (not existsSync) so we handle dangling symlinks correctly.
+  let awRegistryLstat = null;
+  try { awRegistryLstat = lstatSync(GLOBAL_AW_DIR); } catch { /* doesn't exist */ }
+  if (!awRegistryLstat) {
     try {
       symlinkSync(join(AW_HOME, REGISTRY_DIR), GLOBAL_AW_DIR);
       fmt.logStep('Created ~/.aw_registry/ symlink');
     } catch (e) {
       fmt.logWarn(`Could not create symlink ~/.aw_registry/: ${e.message}`);
     }
+  } else if (awRegistryLstat.isSymbolicLink()) {
+    // Stale or dangling — re-point to the new clone
+    try {
+      rmSync(GLOBAL_AW_DIR);
+      symlinkSync(join(AW_HOME, REGISTRY_DIR), GLOBAL_AW_DIR);
+      fmt.logStep('Updated ~/.aw_registry/ symlink');
+    } catch (e) {
+      fmt.logWarn(`Could not update symlink ~/.aw_registry/: ${e.message}`);
+    }
   }
 
   // Create sync config
@@ -298,33 +366,48 @@ export async function initCommand(args) {
   await installAwEcc(cwd, { silent });
   const instructionFiles = copyInstructions(HOME, null, team) || [];
   initAwDocs(HOME);
-  const mcpFiles = await setupMcp(HOME, team) || [];
-  if (cwd !== HOME) await setupMcp(cwd, team);
+  const mcpFiles = await setupMcp(HOME, team, { silent }) || [];
   const hooksInstalled = installGlobalHooks();
   installIdeTasks();
 
-  // Step 4: Link current project as a git worktree (gives IDE git panel)
+  // Remove old local .git/hooks/post-checkout that pre-dates core.hooksPath
+  if (cwd !== HOME) {
+    const oldLocalHook = join(cwd, '.git', 'hooks', 'post-checkout');
+    try {
+      const content = readFileSync(oldLocalHook, 'utf8');
+      if (content.includes('aw: auto-link registry') || content.includes('ln -s "$AW_REGISTRY"')) {
+        rmSync(oldLocalHook);
+      }
+    } catch { /* not there, fine */ }
+  }
+
+  // Step 4: Link current project as a symlink to ~/.aw (gives IDE git panel, shared across all workspaces)
   const isInsideAw = cwd.endsWith(`${sep}.aw`) || cwd.includes(`${sep}.aw${sep}`);
-  if (cwd !== HOME && !isInsideAw && !isWorktree(join(cwd, '.aw'))) {
+  const awLinkFresh = join(cwd, '.aw');
+  const isAlreadySymlinkFresh = (() => { try { return lstatSync(awLinkFresh).isSymbolicLink() && existsSync(awLinkFresh); } catch { return false; } })();
+  if (cwd !== HOME && !isInsideAw && !isAlreadySymlinkFresh) {
     try {
       addProjectWorktree(AW_HOME, cwd);
-      fmt.logStep('Linked current project as git worktree');
+      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.
-  fmt.logStep('Linking IDE symlinks...');
+  const ideSpinner = fmt.spinner();
+  ideSpinner.start('Wiring IDE symlinks...');
   const projectRegistryDir = cwd !== HOME ? join(cwd, '.aw', REGISTRY_DIR) : null;
   const awDirForLinks = (projectRegistryDir && existsSync(projectRegistryDir)) ? projectRegistryDir : null;
-  linkWorkspace(HOME, awDirForLinks);
-  generateCommands(HOME);
+  const symlinks = linkWorkspace(HOME, awDirForLinks, { silent: true });
+  ideSpinner.message('Generating commands...');
+  const commands = generateCommands(HOME, { silent: true });
+  ideSpinner.stop(`IDE wired — ${chalk.bold(symlinks)} symlinks · ${chalk.bold(commands)} commands`);
 
   // Offer to update if a newer version is available
   await promptUpdate(await args._updateCheck);
 
   fmt.outro([
-    'Install complete',
+    '⟁  Install complete',
     '',
     `  ${chalk.green('✓')} Source of truth: ~/.aw/ (git clone)`,
     `  ${chalk.green('✓')} Symlink: ~/.aw_registry/ → ~/.aw/.aw_registry/`,

package/commands/link-project.mjs

@@ -6,7 +6,7 @@ import { homedir } from 'node:os';
 import * as fmt from '../fmt.mjs';
 import { chalk } from '../fmt.mjs';
 import { addProjectWorktree, isWorktree, isValidClone } from '../git.mjs';
-import { REGISTRY_DIR, REGISTRY_REPO } from '../constants.mjs';
+import { REGISTRY_DIR, REGISTRY_URL } from '../constants.mjs';
 import { linkWorkspace } from '../link.mjs';
 import { generateCommands } from '../integrate.mjs';
 
@@ -18,8 +18,7 @@ export function linkProjectCommand(args) {
 
   fmt.intro('aw link');
 
-  const repoUrl = `https://github.com/${REGISTRY_REPO}.git`;
-  if (!isValidClone(AW_HOME, repoUrl)) {
+  if (!isValidClone(AW_HOME, REGISTRY_URL)) {
     fmt.cancel('Registry not initialized. Run: aw init');
     return;
   }
@@ -39,9 +38,9 @@ export function linkProjectCommand(args) {
     // Worktree exists — refresh global IDE symlinks pointing to this project's registry
     const projectRegistryDir = join(worktreeDir, REGISTRY_DIR);
     const awDirForLinks = existsSync(projectRegistryDir) ? projectRegistryDir : null;
-    linkWorkspace(HOME, awDirForLinks);
-    generateCommands(HOME);
-    fmt.logSuccess(`Already linked — refreshed IDE symlinks`);
+    const symlinks = linkWorkspace(HOME, awDirForLinks, { silent: true });
+    const commands = generateCommands(HOME, { silent: true });
+    fmt.logSuccess(`Already linked — refreshed ${chalk.bold(symlinks)} IDE symlinks · ${chalk.bold(commands)} commands`);
     return;
   }
 
@@ -49,10 +48,10 @@ export function linkProjectCommand(args) {
     addProjectWorktree(AW_HOME, cwd);
     const projectRegistryDir = join(worktreeDir, REGISTRY_DIR);
     const awDirForLinks = existsSync(projectRegistryDir) ? projectRegistryDir : null;
-    linkWorkspace(HOME, awDirForLinks);
-    generateCommands(HOME);
+    const symlinks = linkWorkspace(HOME, awDirForLinks, { silent: true });
+    const commands = generateCommands(HOME, { silent: true });
     fmt.logSuccess([
-      `Linked project as git worktree`,
+      `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`,
@@ -62,5 +61,5 @@ export function linkProjectCommand(args) {
     fmt.cancel(`Failed to link project: ${e.message}`);
   }
 
-  fmt.outro('Done');
+  fmt.outro('⟁  Done');
 }