@ghl-ai/aw 0.1.89 → 0.1.92

package/cli.mjs

@@ -38,7 +38,7 @@ const COMMANDS = {
 
 const COMMAND_NAMES = Object.keys(COMMANDS);
 
-function parseArgs(argv) {
+export function parseArgs(argv) {
   const args = { _positional: [] };
   let command = null;
   let i = 0;
@@ -67,6 +67,9 @@ function parseArgs(argv) {
     } else if (arg === '--yes' || arg === '--non-interactive' || arg === '--headless') {
       args[arg] = true;
       i++;
+    } else if (arg === '--discard-local') {
+      args['--discard-local'] = true;
+      i++;
     } else if (arg === '--version') {
       args['--version'] = true;
       i++;
@@ -154,6 +157,7 @@ function printHelp() {
     cmd('aw pull', 'Re-pull all synced paths (like git pull)'),
     cmd('aw pull <path>', 'Pull agents, skills & more from registry'),
     cmd('aw pull --dry-run <path>', 'Preview what would be downloaded'),
+    cmd('aw pull --discard-local', 'On registry conflict, take remote and continue (agent-safe)'),
 
     sec('Upload'),
     cmd('aw push', 'Push all modified files (creates one PR)'),

package/commands/init.mjs

@@ -43,6 +43,7 @@ import {
   fetchAndMerge,
   addToSparseCheckout,
   addProjectWorktree,
+  pruneAwSelfLinks,
   isWorktree,
   includeToSparsePaths,
   sparseCheckoutAsync,
@@ -460,6 +461,24 @@ export async function initCommand(args) {
     }
 
     ensureAwGitignore(AW_HOME);
+    // Heal installs where an older `aw link` run from inside ~/.aw left a
+    // cycle-forming symlink, which makes recursive walkers die with
+    // ENAMETOOLONG. A fresh clone cannot have one, so only this path needs it.
+    const selfLinks = pruneAwSelfLinks(AW_HOME);
+    if (selfLinks.removed.length > 0 && !silent) {
+      const n = selfLinks.removed.length;
+      fmt.logStep(`Removed ${n} cycle-forming .aw symlink${n > 1 ? 's' : ''}`);
+    }
+    if (selfLinks.failed.length > 0 && !silent) {
+      // A cycle may still be in place — say so, with the paths, rather than
+      // letting the next `vite`/`tsc`/`eslint` run fail with ENAMETOOLONG and
+      // no explanation of why.
+      fmt.logWarn(
+        `Could not clear ${selfLinks.failed.length} cycle-forming .aw symlink(s) under ${AW_HOME}. `
+        + 'Recursive tools may fail with ENAMETOOLONG until these are removed:\n'
+        + selfLinks.failed.map(f => `  ${f.path} (${f.shape}: ${f.reason})`).join('\n')
+      );
+    }
     const freshCfg = config.load(GLOBAL_AW_DIR);
     syncRulesTargets(HOME);
     if (cwd !== HOME) {

package/commands/pull.mjs

@@ -22,6 +22,10 @@ import {
   isValidClone,
   findNearestWorktree,
   rebaseOntoOriginMain,
+  resolveRegistryConflicts,
+  continuePausedRebase,
+  pushForceWithLease,
+  getCurrentBranch,
 } from '../git.mjs';
 import {
   REGISTRY_DIR,
@@ -57,10 +61,71 @@ function removeLegacyRegistryRules() {
   }
 }
 
+function envConflictAction() {
+  const raw = String(process.env.AW_PULL_ON_CONFLICT || '').trim().toLowerCase();
+  if (raw === 'discard' || raw === 'abort' || raw === 'leave') return raw;
+  return '';
+}
+
+function isPushBranchName(branch) {
+  return /^(upload|sync|remove)\//.test(String(branch || ''));
+}
+
+async function forcePushPushBranchIfNeeded(awHome, log) {
+  const branch = getCurrentBranch(awHome);
+  if (!isPushBranchName(branch)) return { ok: true, skipped: true };
+  try {
+    await pushForceWithLease(awHome, branch);
+    if (log?.logStep) log.logStep(`Synced push branch ${branch} after conflict discard`);
+    return { ok: true, skipped: false };
+  } catch (e) {
+    const msg = e?.message || 'push failed';
+    if (log?.logWarn) {
+      log.logWarn(`Could not sync push branch ${branch} after conflict recovery: ${msg}`);
+    }
+    return { ok: false, error: msg };
+  }
+}
+
+function printConflictHint(conflicts) {
+  const paths = (conflicts || []).filter(Boolean).join(',') || '(unknown)';
+  // Always emit — agents in --silent/CI must still parse this line.
+  console.error(`AW_PULL_CONFLICT paths=${paths} next=aw pull --discard-local`);
+}
+
+async function chooseConflictAction({ discardLocal, silent, headless, conflicts, log }) {
+  if (discardLocal) return 'discard';
+  const fromEnv = envConflictAction();
+  if (fromEnv) return fromEnv;
+  if (silent || headless) return 'abort';
+
+  const branch = getCurrentBranch(AW_HOME);
+  if (isPushBranchName(branch)) {
+    log.logWarn(`You are on push branch ${chalk.bold(branch)} — discard may drop unpushed registry commits.`);
+  }
+
+  log.logWarn(`Merge conflict in: ${conflicts.join(', ')}`);
+  const choice = await fmt.select({
+    message: 'How do you want to resolve the registry pull conflict?',
+    options: [
+      { value: 'discard', label: 'Discard conflicting local changes and sync to remote', hint: 'recommended if you did not edit these files' },
+      { value: 'abort', label: 'Cancel aw pull (leave local state unchanged)' },
+      { value: 'leave', label: 'Keep local and resolve conflicts manually' },
+    ],
+  });
+
+  if (fmt.isCancel(choice) || !choice) return 'abort';
+  return choice;
+}
+
 export async function pullCommand(args) {
   const input = args._positional?.[0] || '';
   const cwd = process.cwd();
-  const silent = args['--silent'] === true || args._silent === true;
+  const interaction = fmt.configureInteractionMode(args);
+  const silent = interaction.silent || args['--silent'] === true || args._silent === true;
+  const headless = interaction.headless || silent;
+  const discardLocal = args['--discard-local'] === true
+    || String(process.env.AW_PULL_ON_CONFLICT || '').trim().toLowerCase() === 'discard';
 
   const log = {
     cancel: silent ? (msg) => { throw new fmt.CancelError(msg || 'silent cancel', { exitCode: 0 }); } : fmt.cancel,
@@ -135,32 +200,76 @@ export async function pullCommand(args) {
     }
 
     if (unresolved.length > 0) {
-      log.logWarn('Rebase paused — resolve conflicts in your IDE, then run `aw pull` again.');
-      if (!silent) fmt.outro(chalk.yellow('Pull skipped'));
-      return;
-    }
-
-    try {
-      await exec(`git -C "${AW_HOME}" rebase --continue`, { env: { ...process.env, GIT_EDITOR: 'true' } });
-      log.logStep('Rebase continued after conflict resolution.');
-      const { stdout: branchOut } = await exec(`git -C "${AW_HOME}" rev-parse --abbrev-ref HEAD`);
-      const resumedBranch = branchOut.trim();
-      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
+      const action = await chooseConflictAction({
+        discardLocal,
+        silent,
+        headless,
+        conflicts: unresolved,
+        log,
+      });
+      const resolved = await resolveRegistryConflicts(AW_HOME, {
+        action,
+        conflicts: unresolved,
+      });
+
+      if (action === 'discard') {
+        if (!resolved.ok) {
+          printConflictHint(unresolved);
+          throw new fmt.CancelError(
+            `Could not discard local conflicts: ${resolved.error || 'unknown error'}`,
+            { exitCode: 1 },
+          );
+        }
+        if (!silent) log.logSuccess('Discarded conflicting local changes and synced to remote');
+        await forcePushPushBranchIfNeeded(AW_HOME, log);
+        // Fall through to continue the normal pull after a clean discard.
+      } else if (action === 'leave') {
+        if (!silent) {
+          log.logWarn(`Merge conflict in: ${unresolved.join(', ')}`);
+          log.logWarn('Rebase left in progress — resolve conflict markers, then run `aw pull` again.');
+          fmt.outro(chalk.yellow('Pull paused for manual conflict resolution'));
+        } else {
+          printConflictHint(unresolved);
         }
+        return;
+      } else {
+        if (!silent) {
+          log.logWarn(`Merge conflict in: ${unresolved.join(', ')}`);
+          const kind = resolved.kind === 'merge' ? 'merge' : 'rebase';
+          log.logWarn(`Pull cancelled — local registry left unchanged (${kind} aborted).`);
+          printConflictHint(unresolved);
+          fmt.outro(chalk.yellow('Pull cancelled'));
+        } else {
+          printConflictHint(unresolved);
+        }
+        throw new fmt.CancelError('Registry pull conflict — unresolved', { exitCode: 2 });
       }
-    } catch {
+    } else if (mergeInProgress && !rebaseInProgress) {
       try {
-        await exec(`git -C "${AW_HOME}" rebase --skip`);
-        log.logStep('Empty commit skipped during rebase continuation.');
+        await exec(`git -C "${AW_HOME}" -c core.editor=true commit --no-edit`);
+        log.logStep('Merge continued after conflict resolution.');
       } catch {
-        log.logWarn('Rebase continuation failed — check `~/.aw` and resolve manually.');
-        if (!silent) fmt.outro(chalk.yellow('Pull skipped'));
-        return;
+        printConflictHint(unresolved);
+        throw new fmt.CancelError(
+          'Merge continuation failed — resolve manually or run: git -C ~/.aw merge --abort',
+          { exitCode: 2 },
+        );
+      }
+    } else {
+      const continued = await continuePausedRebase(AW_HOME);
+      if (!continued.ok) {
+        printConflictHint(continued.conflicts);
+        throw new fmt.CancelError(
+          'Rebase continuation failed — resolve manually in ~/.aw',
+          { exitCode: 2 },
+        );
       }
+      log.logStep(
+        continued.skipped
+          ? 'Empty commit skipped during rebase continuation.'
+          : 'Rebase continued after conflict resolution.',
+      );
+      await forcePushPushBranchIfNeeded(AW_HOME, log);
     }
   }
 
@@ -168,7 +277,7 @@ export async function pullCommand(args) {
   s.start('Fetching latest from registry...');
   let fetchResult = { updated: false, conflicts: [] };
   try {
-    fetchResult = await fetchAndMerge(AW_HOME, { silent });
+    fetchResult = await fetchAndMerge(AW_HOME, { silent, onConflict: 'leave' });
     s.stop(fetchResult.updated ? 'Registry updated' : 'Already up to date');
   } catch (e) {
     s.stop(chalk.yellow('Fetch failed'));
@@ -190,12 +299,54 @@ export async function pullCommand(args) {
   }
 
   if (fetchResult.conflicts.length > 0) {
-    if (!silent) {
-      log.logWarn(`Merge conflict in: ${fetchResult.conflicts.join(', ')}`);
-      log.logWarn('Merge aborted — your branch is unchanged. Resolve conflicts and run `aw pull` again.');
+    const action = await chooseConflictAction({
+      discardLocal,
+      silent,
+      headless,
+      conflicts: fetchResult.conflicts,
+      log,
+    });
+
+    const resolved = await resolveRegistryConflicts(AW_HOME, {
+      action,
+      conflicts: fetchResult.conflicts,
+    });
+
+    if (action === 'discard') {
+      if (!resolved.ok) {
+        printConflictHint(fetchResult.conflicts);
+        throw new fmt.CancelError(
+          `Could not discard local conflicts: ${resolved.error || 'unknown error'}`,
+          { exitCode: 1 },
+        );
+      }
+      if (!silent) log.logSuccess('Discarded conflicting local changes and synced to remote');
+      await forcePushPushBranchIfNeeded(AW_HOME, log);
+    } else if (action === 'leave') {
+      if (!silent) {
+        log.logWarn(`Merge conflict in: ${fetchResult.conflicts.join(', ')}`);
+        log.logWarn('Rebase left in progress — resolve conflict markers, then run `aw pull` again.');
+        log.logMessage(chalk.dim('Tip: grep -r "<<<<<<< " ~/.aw/.aw_registry/'));
+        fmt.outro(chalk.yellow('Pull paused for manual conflict resolution'));
+      } else {
+        printConflictHint(fetchResult.conflicts);
+      }
       return;
+    } else {
+      // abort / cancel
+      if (!silent) {
+        log.logWarn(`Merge conflict in: ${fetchResult.conflicts.join(', ')}`);
+        const kind = resolved.kind === 'merge' ? 'merge' : 'rebase';
+        log.logWarn(`Pull cancelled — local registry left unchanged (${kind} aborted).`);
+        log.logMessage(chalk.dim('Tip: if you have intentional skill edits, run `aw push <path>` then `aw pull`.'));
+        log.logMessage(chalk.dim('Or discard with: aw pull --discard-local'));
+        printConflictHint(fetchResult.conflicts);
+        fmt.outro(chalk.yellow('Pull cancelled'));
+      } else {
+        printConflictHint(fetchResult.conflicts);
+      }
+      throw new fmt.CancelError('Registry pull conflict — unresolved', { exitCode: 2 });
     }
-    log.logWarn(`Conflicts in: ${fetchResult.conflicts.join(', ')}`);
   }
 
   // Rebase project worktree branch onto origin/main — only for legacy git worktrees.

package/commands/push.mjs

@@ -155,10 +155,12 @@ function normalizeRelPath(value) {
 
 // Root namespaces publish at the AW docs root (aw_docs/<ns>/...), mirroring the
 // local .aw_docs/<ns>/... subtree 1:1 — NO per-workspace <repo>/<user> segment
-// and full nested folders. Use for shared, repo-keyed doc trees such as PR
-// reviews (pr-reviews/<owner>/<repo>/pr-<n>/<run>) so they do not land under the
-// reviewer's workspace namespace as one mangled flat slug.
-const AW_DOCS_ROOT_NAMESPACES = ['pr-reviews', 'security-audits'];
+// and full nested folders. Use for shared, resource-keyed doc trees such as PR
+// reviews (pr-reviews/<owner>/<repo>/pr-<n>/<run>), security audits
+// (security-audits/<repo>/<date>), support ticket investigations
+// (support-tickets/<ticketId>), and infra incident RCAs (incidents/<fingerprint>)
+// so they do not land under the runner's workspace namespace as one mangled flat slug.
+const AW_DOCS_ROOT_NAMESPACES = ['pr-reviews', 'security-audits', 'support-tickets', 'incidents'];
 
 // Compound root prefixes (multi-segment). Longest match wins in matchRootPrefix().
 const AW_DOCS_ROOT_PREFIX_RULES = [
@@ -174,9 +176,13 @@ const AW_DOCS_ROOT_PREFIX_RULES = [
 //   pr-reviews/<repo>/pr-<number>/<run>  → 4 segments
 //   security-audits/<repo>/<date>        → 3 segments
 //   security/audit/<repo>/<run-id>       → 4 segments
+//   support-tickets/<ticketId>           → 2 segments
+//   incidents/<fingerprint>              → 2 segments
 const AW_DOCS_ROOT_MIN_SEGMENTS = {
   'pr-reviews': 4,
   'security-audits': 3,
+  'support-tickets': 2,
+  'incidents': 2,
 };
 
 function normalizeAwDocsRootInput(stripped) {
@@ -214,7 +220,8 @@ function awDocsRootScope(relPath) {
   if (!rule || segments.length < rule.minSegments) {
     throw new Error(
       'Root-scope docs publish must target pr-reviews/<repo>/pr-<number>/<run>, ' +
-      'security-audits/<repo>/<date>, or security/audit/<repo>/<run-id>, ' +
+      'security-audits/<repo>/<date>, security/audit/<repo>/<run-id>, ' +
+      'support-tickets/<ticketId>, or incidents/<fingerprint>, ' +
       `got "${relPath}".`
     );
   }
@@ -237,7 +244,7 @@ function featureScopeFromInput(input) {
 
   const match = value.match(/^(?:\.aw_docs\/)?features\/([^/]+)$/);
   if (!match) {
-    throw new Error('Docs-only publish path must be .aw_docs/features/<feature-slug>, .aw_docs/pr-reviews/<...>, .aw_docs/security-audits/<...> (or legacy .aw_docs/security/audit/<...>), or use --feature <feature-slug>.');
+    throw new Error('Docs-only publish path must be .aw_docs/features/<feature-slug>, .aw_docs/pr-reviews/<...>, .aw_docs/security-audits/<...>, .aw_docs/support-tickets/<...>, .aw_docs/incidents/<...> (or legacy .aw_docs/security/audit/<...>), or use --feature <feature-slug>.');
   }
   return awDocsFeatureScope(match[1]);
 }

package/git.mjs

@@ -1,13 +1,19 @@
 // git.mjs — Git helpers: sparse checkout (temp) + persistent clone operations.
 
-import { execSync, exec as execCb } from 'node:child_process';
-import { mkdtempSync, existsSync, lstatSync, rmSync, readFileSync, symlinkSync, unlinkSync } from 'node:fs';
-import { join, basename, dirname } from 'node:path';
+import { execSync, exec as execCb, execFile as execFileCb } from 'node:child_process';
+import { mkdtempSync, existsSync, lstatSync, readdirSync, realpathSync, rmSync, readFileSync, statSync, symlinkSync, unlinkSync } from 'node:fs';
+import { join, basename, dirname, sep } from 'node:path';
 import { homedir, tmpdir } from 'node:os';
 import { promisify } from 'node:util';
 import { REGISTRY_BASE_BRANCH, REGISTRY_DIR, DOCS_SOURCE_DIR, AW_DOCS_DIR, RULES_SOURCE_DIR } from './constants.mjs';
 
 const exec = promisify(execCb);
+const execFileAsync = promisify(execFileCb);
+
+/** Run git with argv array (no shell) in awHome. */
+async function gitIn(awHome, args, opts = {}) {
+  return execFileAsync('git', ['-C', awHome, ...args], { encoding: 'utf8', ...opts });
+}
 
 /**
  * Env vars applied to every git command that touches the network.
@@ -306,15 +312,17 @@ export function removeFromSparseCheckout(awHome, removePaths) {
  *  2. Fetch from origin.
  *  3. Fast-forward if possible (clean case, no local commits).
  *  4. Rebase local commits on top of remote if ff-only fails.
- *  5. On rebase conflict in silent mode: abort to keep repo usable.
- *     In interactive mode: leave conflict markers for the user.
+ *  5. On rebase conflict: default policy is abort when silent (keep repo usable
+ *     for init/doctor/daemon). Callers that need to discard/leave (aw pull)
+ *     pass `{ onConflict: 'leave' }` so the rebase stays paused for policy.
  *  NEVER uses --no-edit merge — a merge commit on blob:none + sparse-checkout
  *  disables sparse checkout, emptying the working tree.
  *
  * @param {string} awHome
- * @param {{ silent?: boolean }} opts
+ * @param {{ silent?: boolean, onConflict?: 'abort'|'leave' }} opts
  */
-export async function fetchAndMerge(awHome, { silent = true } = {}) {
+export async function fetchAndMerge(awHome, { silent = true, onConflict } = {}) {
+  const conflictPolicy = onConflict ?? (silent ? 'abort' : 'leave');
   // ── 1. Branch classification ──────────────────────────────────────────────
   // There are three possible states for ~/.aw:
   //
@@ -417,16 +425,232 @@ export async function fetchAndMerge(awHome, { silent = true } = {}) {
       conflicts.push(...stdout.trim().split('\n').filter(Boolean));
     } catch { /* best effort */ }
 
-    if (silent) {
-      // Background: abort so repo stays usable; surface on next explicit aw init
-      try { await exec(`git -C "${awHome}" rebase --abort`); } catch { /* best effort */ }
+    // Default silent/init path aborts so ~/.aw stays usable. aw pull passes
+    // onConflict:'leave' so it can discard / menu / abort itself.
+    if (conflictPolicy === 'abort') {
+      try { await gitIn(awHome, ['rebase', '--abort']); } catch { /* best effort */ }
     }
-    // Interactive: leave conflict markers for the user to resolve
   }
 
   return { updated, conflicts };
 }
 
+function rebaseInProgress(awHome) {
+  return existsSync(join(awHome, '.git', 'rebase-merge'))
+    || existsSync(join(awHome, '.git', 'rebase-apply'));
+}
+
+function mergeInProgress(awHome) {
+  return existsSync(join(awHome, '.git', 'MERGE_HEAD'));
+}
+
+export async function listUnresolvedConflicts(awHome) {
+  try {
+    const { stdout } = await gitIn(awHome, ['diff', '--name-only', '--diff-filter=U']);
+    return stdout.trim().split('\n').filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function gitErrorText(err) {
+  return [err?.stderr, err?.stdout, err?.message, err]
+    .filter(Boolean)
+    .map(String)
+    .join('\n')
+    .toLowerCase();
+}
+
+/** True when git rebase --continue failed because the current patch is empty. */
+export function isEmptyRebasePatchError(err) {
+  const msg = gitErrorText(err);
+  return (
+    msg.includes('nothing to commit')
+    || msg.includes('no changes - did you forget')
+    || msg.includes('no changes')
+    || msg.includes('now empty')
+    || msg.includes('you might want to skip this patch')
+    || msg.includes('please use \'git rebase --skip\'')
+    || msg.includes('please use "git rebase --skip"')
+    || (msg.includes('empty') && (msg.includes('patch') || msg.includes('cherry-pick')))
+  );
+}
+
+/**
+ * Force-push current branch tip with lease (no shell). Used after conflict discard /
+ * rebase continuation on upload|sync|remove branches.
+ */
+export async function pushForceWithLease(awHome, branch) {
+  await gitIn(awHome, ['push', '--force-with-lease', 'origin', branch], { env: GIT_NET_ENV });
+}
+
+/**
+ * Continue a paused rebase by one commit-step. After a failed continue, re-list
+ * conflicts and only `--skip` when Git indicates an empty patch. Never skip when
+ * continue stopped because a later commit conflicted or another non-empty error.
+ * Call again on the next `aw pull` after each new conflict is resolved.
+ *
+ * @returns {Promise<{ ok: boolean, skipped?: boolean, conflicts: string[], error?: string }>}
+ */
+export async function continuePausedRebase(awHome) {
+  try {
+    await gitIn(awHome, ['-c', 'core.editor=true', 'rebase', '--continue'], {
+      env: { ...process.env, GIT_EDITOR: 'true' },
+    });
+    return { ok: true, skipped: false, conflicts: [] };
+  } catch (continueErr) {
+    const conflicts = await listUnresolvedConflicts(awHome);
+    if (conflicts.length > 0) {
+      return {
+        ok: false,
+        skipped: false,
+        conflicts,
+        error: continueErr.message || 'Rebase continue stopped on conflicts',
+      };
+    }
+    if (!isEmptyRebasePatchError(continueErr)) {
+      return {
+        ok: false,
+        skipped: false,
+        conflicts: [],
+        error: continueErr.message || 'Rebase continue failed',
+      };
+    }
+    try {
+      await gitIn(awHome, ['rebase', '--skip']);
+      return { ok: true, skipped: true, conflicts: [] };
+    } catch (skipErr) {
+      return {
+        ok: false,
+        skipped: false,
+        conflicts: await listUnresolvedConflicts(awHome),
+        error: skipErr.message || continueErr.message || 'Rebase continue/skip failed',
+      };
+    }
+  }
+}
+
+const REBASE_CONTINUE_LOOP_LIMIT = 50;
+
+/**
+ * Resolve an in-progress registry rebase or merge conflict in ~/.aw.
+ *
+ * During rebase onto origin/main, `--ours` is upstream (remote).
+ * During merge, `--theirs` is the incoming/remote side.
+ *
+ * @param {string} awHome
+ * @param {{ action?: 'discard'|'abort'|'leave', conflicts?: string[] }} opts
+ * @returns {Promise<{ ok: boolean, action: string, conflicts: string[], kind?: string, error?: string }>}
+ */
+export async function resolveRegistryConflicts(awHome, { action = 'abort', conflicts = [] } = {}) {
+  const initialConflicts = conflicts.length > 0 ? [...conflicts] : await listUnresolvedConflicts(awHome);
+  const isMerge = mergeInProgress(awHome);
+  const isRebase = rebaseInProgress(awHome);
+  const kind = isMerge && !isRebase ? 'merge' : 'rebase';
+
+  if (action === 'leave') {
+    return { ok: true, action: 'leave', conflicts: initialConflicts, kind };
+  }
+
+  if (action === 'abort') {
+    try {
+      if (kind === 'merge') await gitIn(awHome, ['merge', '--abort']);
+      else await gitIn(awHome, ['rebase', '--abort']);
+    } catch { /* best effort */ }
+    return { ok: true, action: 'abort', conflicts: initialConflicts, kind };
+  }
+
+  if (action !== 'discard') {
+    return { ok: false, action, conflicts: initialConflicts, kind, error: `Unknown conflict action: ${action}` };
+  }
+
+  let pending = initialConflicts.length > 0 ? initialConflicts : await listUnresolvedConflicts(awHome);
+  if (pending.length === 0 && !isRebase && !isMerge) {
+    return { ok: true, action: 'discard', conflicts: [], kind };
+  }
+
+  // Merge-in-progress: remote side is --theirs; finish with commit --no-edit.
+  if (kind === 'merge') {
+    for (const file of pending) {
+      try {
+        await gitIn(awHome, ['checkout', '--theirs', '--', file]);
+        await gitIn(awHome, ['add', '--', file]);
+      } catch (e) {
+        try { await gitIn(awHome, ['merge', '--abort']); } catch { /* best effort */ }
+        return { ok: false, action: 'discard', conflicts: pending, kind, error: e.message };
+      }
+    }
+    try {
+      await gitIn(awHome, ['-c', 'core.editor=true', 'commit', '--no-edit']);
+      return { ok: true, action: 'discard', conflicts: initialConflicts, kind };
+    } catch (e) {
+      try { await gitIn(awHome, ['merge', '--abort']); } catch { /* best effort */ }
+      return { ok: false, action: 'discard', conflicts: initialConflicts, kind, error: e.message };
+    }
+  }
+
+  // Rebase-in-progress: remote/upstream is --ours.
+  for (let guard = 0; guard < REBASE_CONTINUE_LOOP_LIMIT; guard++) {
+    pending = pending.length > 0 ? pending : await listUnresolvedConflicts(awHome);
+    for (const file of pending) {
+      try {
+        await gitIn(awHome, ['checkout', '--ours', '--', file]);
+        await gitIn(awHome, ['add', '--', file]);
+      } catch (e) {
+        try { await gitIn(awHome, ['rebase', '--abort']); } catch { /* best effort */ }
+        return { ok: false, action: 'discard', conflicts: pending, kind, error: e.message };
+      }
+    }
+
+    if (!rebaseInProgress(awHome)) {
+      return { ok: true, action: 'discard', conflicts: initialConflicts, kind };
+    }
+
+    try {
+      await gitIn(awHome, ['-c', 'core.editor=true', 'rebase', '--continue']);
+      if (!rebaseInProgress(awHome)) {
+        return { ok: true, action: 'discard', conflicts: initialConflicts, kind };
+      }
+      pending = await listUnresolvedConflicts(awHome);
+    } catch (e) {
+      pending = await listUnresolvedConflicts(awHome);
+      if (pending.length === 0 && isEmptyRebasePatchError(e)) {
+        try {
+          await gitIn(awHome, ['rebase', '--skip']);
+          if (!rebaseInProgress(awHome)) {
+            return { ok: true, action: 'discard', conflicts: initialConflicts, kind };
+          }
+          pending = await listUnresolvedConflicts(awHome);
+          continue;
+        } catch (skipErr) {
+          try { await gitIn(awHome, ['rebase', '--abort']); } catch { /* best effort */ }
+          return {
+            ok: false,
+            action: 'discard',
+            conflicts: initialConflicts,
+            kind,
+            error: skipErr.message || e.message,
+          };
+        }
+      }
+      if (pending.length === 0) {
+        try { await gitIn(awHome, ['rebase', '--abort']); } catch { /* best effort */ }
+        return {
+          ok: false,
+          action: 'discard',
+          conflicts: initialConflicts,
+          kind,
+          error: e.message || 'Rebase continue failed with a non-empty patch',
+        };
+      }
+      // Later commit conflicted during continue — keep looping with new pending.
+    }
+  }
+
+  try { await gitIn(awHome, ['rebase', '--abort']); } catch { /* best effort */ }
+  return { ok: false, action: 'discard', conflicts: initialConflicts, kind, error: 'Discard exceeded rebase continue limit' };
+}
+
 /**
  * Detect local changes in registryDir/ within awHome.
  * Returns { modified: [], added: [], deleted: [], untracked: [] }
@@ -764,6 +988,119 @@ export function isWorktree(dir) {
   }
 }
 
+/** Error message for reporting, without leaking a stack into CLI output. */
+function errText(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+/** Resolve to a real path, falling back to the input when it is not on disk. */
+function realPathOrSelf(path) {
+  try {
+    return realpathSync(path);
+  } catch (err) {
+    void err; // not on disk (yet) — compare the literal path
+    return path;
+  }
+}
+
+/** True iff `candidate` is `root` itself or lives anywhere beneath it. */
+function isWithin(root, candidate) {
+  return candidate === root || candidate.startsWith(root + sep);
+}
+
+/**
+ * True iff `path` is awHome itself or lives anywhere inside it.
+ *
+ * Compares realpaths, which also covers a path that reaches inside awHome
+ * through a symlink. A lexical comparison is deliberately not added on top:
+ * callers pass `process.cwd()`, which the OS already returns resolved, so a
+ * lexical form that differs from the resolved one never reaches this function.
+ * The remaining cycle shape — an alias *under* awHome pointing at an already
+ * linked project — cannot be seen from these two arguments at all and is
+ * handled by pruneAwSelfLinks instead.
+ */
+function isInsideAwHome(awHome, path) {
+  return isWithin(realPathOrSelf(awHome), realPathOrSelf(path));
+}
+
+/**
+ * Remove symlinks under `awHome` that make its tree cyclic.
+ *
+ * Two shapes qualify:
+ *
+ *   1. A direct self-link — e.g. ~/.aw/.aw_registry/…/skills/.aw -> ~/.aw.
+ *   2. An alias to a linked project — ~/.aw/external -> /path/to/project,
+ *      where /path/to/project/.aw -> ~/.aw. Walking ~/.aw/external/.aw then
+ *      re-enters ~/.aw. Here the *alias* is removed, never the project's own
+ *      .aw link, which is how every linked repo is legitimately wired.
+ *
+ * Either shape makes recursive walkers that follow symlinks and keep no
+ * visited set — vite/chokidar, tsc, eslint — re-descend the same segments
+ * until the path exceeds PATH_MAX and the walk dies with ENAMETOOLONG.
+ *
+ * Only descends real directories, never symlinks, so the prune cannot be
+ * caught by the cycle it is removing.
+ *
+ * Returns `{ removed, failed }`. A non-empty `failed` means a cycle may still
+ * be in place, so callers must surface it rather than assume the heal worked.
+ */
+export function pruneAwSelfLinks(awHome) {
+  const root = realPathOrSelf(awHome);
+  const removed = [];
+  const failed = [];
+  if (!existsSync(root)) return { removed, failed };
+
+  /** Remove one cycle-forming link, recording success or the reason it failed. */
+  const drop = (linkPath, shape) => {
+    try {
+      unlinkSync(linkPath);
+      removed.push(linkPath);
+    } catch (error) {
+      failed.push({ path: linkPath, shape, reason: errText(error) });
+    }
+  };
+
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch (error) {
+      // Cannot inspect this subtree — a cycle may be hiding in it, so report
+      // rather than swallow.
+      failed.push({ path: dir, shape: 'unreadable-directory', reason: errText(error) });
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name === '.git') continue; // never touch the registry's own git dir
+      const full = join(dir, entry.name);
+      if (entry.isSymbolicLink()) {
+        let target;
+        try {
+          target = realpathSync(full);
+        } catch (error) {
+          void error; // dangling link — cannot form a cycle, leave it alone
+          continue;
+        }
+        if (target === root) {
+          drop(full, 'self-link');
+          continue;
+        }
+        // Alias shape: does the target directory link back to awHome?
+        try {
+          if (!statSync(target).isDirectory()) continue;
+          if (realpathSync(join(target, '.aw')) === root) drop(full, 'alias-cycle');
+        } catch (error) {
+          void error; // no .aw inside the target, or target vanished — not a cycle
+        }
+      } else if (entry.isDirectory()) {
+        walk(full);
+      }
+    }
+  };
+  walk(root);
+  return { removed, failed };
+}
+
 /**
  * Create project/.aw/ as a symlink to awHome (~/.aw).
  *
@@ -774,6 +1111,16 @@ export function isWorktree(dir) {
  * Safe to call multiple times — skips if already set up correctly.
  */
 export function addProjectWorktree(awHome, projectDir) {
+  // Refuse to link awHome into itself or into anything inside it. Such a link
+  // is a cycle (see pruneAwSelfLinks) that breaks every recursive walker with
+  // ENAMETOOLONG. Compare realpaths, not strings: on macOS homedir() can report
+  // /var/... while process.cwd() reports /private/var/... for the same dir.
+  if (isInsideAwHome(awHome, projectDir)) {
+    throw new Error(
+      `Refusing to link ${projectDir}: it is inside ${awHome}. Run this from a project directory.`
+    );
+  }
+
   const worktreeDir = join(projectDir, '.aw');
 
   // Clean up stale project-root .aw_registry symlink from old installs

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ghl-ai/aw",
-  "version": "0.1.89",
+  "version": "0.1.92",
   "description": "Agentic Workspace CLI — pull, push & manage agents, skills and commands from the registry",
   "type": "module",
   "bin": {