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

package/hooks/codex-home.mjs

@@ -0,0 +1,184 @@
+import { join } from 'node:path';
+
+import { getSupportedHarnessPhaseEntries } from '../hook-manifest.mjs';
+import {
+  buildDelegatingPhaseScript,
+  buildRegistryDelegatingPhaseScript,
+  buildReservedPhaseScript,
+} from './shared-phase-scripts.mjs';
+
+export const CODEX_HOME_HOOK_MATCHER = 'startup|resume';
+export const CODEX_HOME_HOOK_STATUS = 'Loading AW router';
+
+function buildCodexCommand(scriptName) {
+  return `bash "$HOME/.codex/hooks/${scriptName}"`;
+}
+
+const CODEX_HOME_PHASE_BLUEPRINTS = {
+  SessionStart: {
+    scriptName: 'aw-session-start.sh',
+    scriptMarker: '# aw-managed: codex-global-session-start',
+    buildScriptContent() {
+      return buildRegistryDelegatingPhaseScript({
+        marker: this.scriptMarker,
+        phase: 'SessionStart',
+        targetCandidates: [
+          '$HOME/.aw_registry/platform/core/skills/using-aw-skills/hooks/session-start.sh',
+          '$HOME/.aw/.aw_registry/platform/core/skills/using-aw-skills/hooks/session-start.sh',
+        ],
+        warningMessage: 'WARNING: AW using-aw-skills hook not found in ~/.aw_registry. Run aw init or aw pull platform.',
+      });
+    },
+    buildEntry(command) {
+      return {
+        matcher: CODEX_HOME_HOOK_MATCHER,
+        hooks: [
+          {
+            type: 'command',
+            command,
+            statusMessage: CODEX_HOME_HOOK_STATUS,
+          },
+        ],
+      };
+    },
+  },
+  UserPromptSubmit: {
+    scriptName: 'aw-user-prompt-submit.sh',
+    scriptMarker: '# aw-managed: codex-global-user-prompt-submit',
+    buildScriptContent() {
+      return buildDelegatingPhaseScript({
+        marker: this.scriptMarker,
+        targetPath: '$HOME/.aw-ecc/scripts/hooks/session-start-rules-context.sh',
+      });
+    },
+    buildEntry(command) {
+      return {
+        hooks: [
+          {
+            type: 'command',
+            command,
+          },
+        ],
+      };
+    },
+  },
+  PreToolUse: {
+    scriptName: 'aw-pre-tool-use.sh',
+    scriptMarker: '# aw-managed: codex-global-pre-tool-use',
+    buildScriptContent() {
+      return buildReservedPhaseScript({
+        marker: this.scriptMarker,
+        phase: 'PreToolUse',
+        harnessLabel: 'Codex home routing',
+      });
+    },
+    buildEntry(command) {
+      return {
+        matcher: '*',
+        hooks: [
+          {
+            type: 'command',
+            command,
+          },
+        ],
+      };
+    },
+  },
+  PostToolUse: {
+    scriptName: 'aw-post-tool-use.sh',
+    scriptMarker: '# aw-managed: codex-global-post-tool-use',
+    buildScriptContent() {
+      return buildReservedPhaseScript({
+        marker: this.scriptMarker,
+        phase: 'PostToolUse',
+        harnessLabel: 'Codex home routing',
+      });
+    },
+    buildEntry(command) {
+      return {
+        matcher: '*',
+        hooks: [
+          {
+            type: 'command',
+            command,
+          },
+        ],
+      };
+    },
+  },
+  Stop: {
+    scriptName: 'aw-stop.sh',
+    scriptMarker: '# aw-managed: codex-global-stop',
+    buildScriptContent() {
+      return buildReservedPhaseScript({
+        marker: this.scriptMarker,
+        phase: 'Stop',
+        harnessLabel: 'Codex home routing',
+      });
+    },
+    buildEntry(command) {
+      return {
+        hooks: [
+          {
+            type: 'command',
+            command,
+          },
+        ],
+      };
+    },
+  },
+};
+
+export function getCodexHomePhaseDefinitions() {
+  return getSupportedHarnessPhaseEntries('codex', 'home').map(entry => {
+    const blueprint = CODEX_HOME_PHASE_BLUEPRINTS[entry.phase];
+    if (!blueprint) {
+      throw new Error(`Missing Codex home hook blueprint for phase: ${entry.phase}`);
+    }
+
+    const command = buildCodexCommand(blueprint.scriptName);
+
+    return {
+      ...entry,
+      hookConfigKey: entry.phase,
+      scriptName: blueprint.scriptName,
+      scriptMarker: blueprint.scriptMarker,
+      command,
+      entry: blueprint.buildEntry(command),
+      scriptContent: blueprint.buildScriptContent(),
+    };
+  });
+}
+
+export function getCodexHomePhaseDefinition(phase) {
+  const definition = getCodexHomePhaseDefinitions().find(entry => entry.phase === phase);
+  if (!definition) {
+    throw new Error(`Unsupported Codex home AW phase: ${phase}`);
+  }
+  return definition;
+}
+
+export function codexHomeHookScriptPath(homeDir, definitionOrPhase) {
+  const definition = typeof definitionOrPhase === 'string'
+    ? getCodexHomePhaseDefinition(definitionOrPhase)
+    : definitionOrPhase;
+
+  return join(homeDir, '.codex', 'hooks', definition.scriptName);
+}
+
+export function isManagedCodexHomeEntry(entry, definitionOrPhase) {
+  const definition = typeof definitionOrPhase === 'string'
+    ? getCodexHomePhaseDefinition(definitionOrPhase)
+    : definitionOrPhase;
+
+  if ('matcher' in definition.entry) {
+    if (entry?.matcher !== definition.entry.matcher) {
+      return false;
+    }
+  } else if (entry?.matcher !== undefined) {
+    return false;
+  }
+
+  return Array.isArray(entry?.hooks)
+    && entry.hooks.some(hook => hook?.type === 'command' && hook?.command === definition.command);
+}

package/hooks/shared-phase-scripts.mjs

@@ -0,0 +1,69 @@
+function escapeDoubleQuotes(value) {
+  return value.replaceAll('\\', '\\\\').replaceAll('"', '\\"');
+}
+
+export function buildRegistryDelegatingPhaseScript({
+  marker,
+  phase,
+  targetCandidates,
+  warningMessage,
+}) {
+  const targetsBlock = targetCandidates
+    .map(target => `  "${target}"`)
+    .join('\n');
+  const escapedWarning = escapeDoubleQuotes(warningMessage);
+
+  return `#!/usr/bin/env bash
+${marker}
+set -euo pipefail
+
+TARGETS=(
+${targetsBlock}
+)
+
+for target in "\${TARGETS[@]}"; do
+  if [[ -f "\$target" ]]; then
+    exec bash "\$target"
+  fi
+done
+
+CONTEXT="# AW Session Context
+
+${escapedWarning}"
+
+JSON_CONTEXT=$(printf '%s' "\$CONTEXT" | python3 -c 'import json, sys; print(json.dumps(sys.stdin.read()))')
+
+echo "{\\"hookSpecificOutput\\":{\\"hookEventName\\":\\"${phase}\\",\\"additionalContext\\":\${JSON_CONTEXT}}}"
+`;
+}
+
+export function buildDelegatingPhaseScript({
+  marker,
+  targetPath,
+}) {
+  return `#!/usr/bin/env bash
+${marker}
+set -euo pipefail
+
+TARGET="${targetPath}"
+if [[ -f "$TARGET" ]]; then
+  exec bash "$TARGET"
+fi
+
+exit 0
+`;
+}
+
+export function buildReservedPhaseScript({
+  marker,
+  phase,
+  harnessLabel,
+}) {
+  return `#!/usr/bin/env bash
+${marker}
+set -euo pipefail
+
+# Reserved AW ${phase} phase for ${harnessLabel}.
+exit 0
+`;
+}

package/integrate.mjs

@@ -1,23 +1,172 @@
 // integrate.mjs — Generate commands for all IDEs, instructions (CLAUDE.md, AGENTS.md)
 
 import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, rmSync } from 'node:fs';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
 import { homedir } from 'node:os';
 import * as fmt from './fmt.mjs';
 import * as config from './config.mjs';
 import { getLocalRegistryDir } from './git.mjs';
-import { renderRules } from './render-rules.mjs';
+import {
+  generateAgentsMdRulesSection,
+  generateClaudeMdRulesSection,
+  renderRules,
+  resolveRulesSourceDir,
+} from './render-rules.mjs';
+
+const AW_ROUTER_BRIDGE_HEADER = 'AW Router Bridge';
+const AW_ROUTER_BRIDGE_START_MARKER = '<!-- aw-managed:start router-bridge -->';
+const AW_ROUTER_BRIDGE_END_MARKER = '<!-- aw-managed:end router-bridge -->';
+const AGENTS_RULES_HEADER = 'Platform Rules — Non-Negotiables';
+const CLAUDE_RULES_HEADER = 'Platform Rules (MUST)';
+
+function generateAwRouterBridgeSection() {
+  return `${AW_ROUTER_BRIDGE_START_MARKER}
+## ${AW_ROUTER_BRIDGE_HEADER}
+
+### 1. Route First (MANDATORY)
+- Before any substantive response, resolve and apply \`using-aw-skills\`
+- Select the smallest correct AW route and stage skill for this task
+- Do not assume the previous skill stack is still active
+
+### 2. Read Rules Before Acting (MANDATORY)
+- Read applicable AW rules from \`~/.aw/.aw_rules/platform/<domain>/AGENTS.md\`
+- Also read \`universal\` and \`security\` rules whenever they apply
+- If repo-local instructions conflict with org-level sources of truth, follow org-level sources
+
+### 3. Explore Before Building
+- Read existing code, adjacent patterns, configs, generated artifacts, and tests before writing anything
+- For non-trivial work, inspect platform docs, runtime behavior, app surfaces, and integration boundaries first
+- Ask one short clarifying question only when ambiguity remains after exploration
+
+### 4. Build in Small Steps
+- For multi-step work, resolve and apply \`incremental-implementation\`
+- Break work into thin, reversible slices with validation at each step
+- Prefer extending existing patterns over inventing new ones
+- Never batch unrelated changes in one pass
+
+### 5. Verify With Proof
+- For bug fixes and behavior changes, use Red -> Green -> Refactor
+- For config, docs, scaffolding, and integration wiring, use focused verification appropriate to the changed surface
+- Use \`aw-debug\`, \`aw-build\`, \`aw-test\`, and \`aw-review\` as needed
+- Never mark work complete without focused proof
+
+### 6. Core Principles
+- Correctness over cleverness
+- Clarity over complexity
+- Small diffs over broad rewrites
+- Evidence over assumption
+- When corrected, update the working pattern and do not repeat the same mistake
+${AW_ROUTER_BRIDGE_END_MARKER}`;
+}
+
+function stripManagedBlock(content, startMarker, endMarker) {
+  const startIdx = content.indexOf(startMarker);
+  if (startIdx === -1) {
+    return content;
+  }
+
+  const endIdx = content.indexOf(endMarker, startIdx + startMarker.length);
+  if (endIdx === -1) {
+    return content;
+  }
 
-function upsertRulesSection(content, header, section) {
-  if (!section) return content;
+  return `${content.slice(0, startIdx).trimEnd()}${content.slice(endIdx + endMarker.length)}`;
+}
 
+function stripManagedSection(content, header, stopHeaders = []) {
   const marker = `## ${header}`;
   const idx = content.indexOf(marker);
   if (idx === -1) {
-    return `${content.trimEnd()}\n\n${section}\n`;
+    return content;
+  }
+
+  let end = content.length;
+  for (const stopHeader of stopHeaders) {
+    const stopIdx = content.indexOf(`## ${stopHeader}`, idx + marker.length);
+    if (stopIdx !== -1 && stopIdx < end) {
+      end = stopIdx;
+    }
+  }
+
+  return `${content.slice(0, idx).trimEnd()}${content.slice(end)}`;
+}
+
+function defaultInstructionPreamble(file) {
+  return file === 'CLAUDE.md' ? '# CLAUDE.md\n' : '# AGENTS.md\n';
+}
+
+function shouldResetHomeInstructionFile(content, file) {
+  const legacyMarkers = file === 'CLAUDE.md'
+    ? [
+      '# CLAUDE.md — ',
+      '## Routing Rule (ABSOLUTE)',
+      'This supplements the root `AGENTS.md` with Codex-specific guidance.',
+      '<!-- BEGIN ECC -->',
+    ]
+    : [
+      '# AGENTS.md — ',
+      '# ECC for Codex CLI',
+      '# AW SDLC Repo Instructions',
+      'Use the repo-local AW SDLC files as the source of truth for routing and stage behavior.',
+      '<!-- BEGIN ECC -->',
+    ];
+
+  return legacyMarkers.some(marker => content.includes(marker));
+}
+
+function stripLegacyRepoInstructionContent(content, file) {
+  const legacyMarkers = file === 'CLAUDE.md'
+    ? [
+      '# CLAUDE.md — ',
+      '## Routing Rule (ABSOLUTE)',
+      'This supplements the root `AGENTS.md` with Codex-specific guidance.',
+      '<!-- BEGIN ECC -->',
+    ]
+    : [
+      '# AGENTS.md — ',
+      '# ECC for Codex CLI',
+      '# AW SDLC Repo Instructions',
+      'Use the repo-local AW SDLC files as the source of truth for routing and stage behavior.',
+      '## Agent System',
+      '<!-- BEGIN ECC -->',
+    ];
+
+  const startIndexes = legacyMarkers
+    .map(marker => content.indexOf(marker))
+    .filter(idx => idx !== -1);
+
+  if (startIndexes.length === 0) return content;
+
+  const startIdx = Math.min(...startIndexes);
+  const preserved = content.slice(0, startIdx).trimEnd();
+  return preserved ? `${preserved}\n` : '';
+}
+
+function applyManagedInstructionSections(content, file, rulesSections = {}, options = {}) {
+  const rulesHeader = file === 'CLAUDE.md' ? CLAUDE_RULES_HEADER : AGENTS_RULES_HEADER;
+  const rulesSection = file === 'CLAUDE.md' ? rulesSections.claudeSection : rulesSections.agentsSection;
+  const includeBridge = options.includeBridge !== false;
+
+  let next = stripLegacyRepoInstructionContent(content, file);
+  next = stripManagedBlock(next, AW_ROUTER_BRIDGE_START_MARKER, AW_ROUTER_BRIDGE_END_MARKER);
+  next = stripManagedSection(next, AW_ROUTER_BRIDGE_HEADER, [rulesHeader]);
+  next = stripManagedSection(next, rulesHeader);
+  next = next.trimEnd();
+
+  const sections = [includeBridge ? generateAwRouterBridgeSection() : null, rulesSection].filter(Boolean);
+  if (sections.length === 0) {
+    return next ? `${next}\n` : '';
   }
 
-  return `${content.slice(0, idx).trimEnd()}\n\n${section}\n`;
+  // Marker tells users (and aw init) where the managed section starts.
+  // Everything BEFORE this marker is repo-owned and never touched by aw.
+  // Everything AFTER is managed by aw — re-rendered on every aw init.
+  const managedBoundary = '<!-- aw-managed: content below is regenerated by `aw init` — put your own content above this line -->';
+  const appended = [managedBoundary, ...sections].join('\n\n').trim();
+  // Strip any prior managedBoundary line from `next` so we don't accumulate them
+  // when re-running aw init.
+  const cleaned = next.split('\n').filter(line => line.trim() !== managedBoundary).join('\n').trimEnd();
+  return cleaned ? `${cleaned}\n\n${appended}\n` : `${appended}\n`;
 }
 
 /**
@@ -75,59 +224,90 @@ function findFiles(dir, typeName) {
 }
 
 /**
- * Copy AGENTS.md to project root and refresh rules sections in any existing
- * CLAUDE.md. New CLAUDE.md files are intentionally not generated because their
- * routing rules can hijack plugin command dispatch in some workspaces.
+ * Refresh rules sections in any existing AGENTS.md/CLAUDE.md at the repo
+ * root.
+ *
+ * Repo instruction files are user-owned. aw init no longer creates or updates
+ * managed sections in repo-local AGENTS.md / CLAUDE.md.
+ *
+ * The only repo-file behavior left is cleanup: if a repo still contains old
+ * aw-managed sections from prior versions, strip those sections while leaving
+ * the user's own content intact.
  */
 export function copyInstructions(cwd, tempDir, namespace) {
   const rulesSections = renderRules(cwd);
   const createdFiles = [];
+
   for (const file of ['AGENTS.md', 'CLAUDE.md']) {
     const dest = join(cwd, file);
     if (existsSync(dest)) {
       const existing = readFileSync(dest, 'utf8');
-      const updated = file === 'CLAUDE.md'
-        ? upsertRulesSection(existing, 'Platform Rules (MUST)', rulesSections.claudeSection)
-        : upsertRulesSection(existing, 'Platform Rules — Non-Negotiables', rulesSections.agentsSection);
+      const updated = applyManagedInstructionSections(existing, file, {}, { includeBridge: false });
 
       if (updated !== existing) {
         writeFileSync(dest, updated);
-        fmt.logSuccess(`Updated ${file}`);
+        fmt.logStep(`Stripped aw-managed sections from ${file} (now in ~/.claude/CLAUDE.md / ~/.codex/AGENTS.md)`);
       }
       continue;
     }
 
-    if (file === 'CLAUDE.md') continue;
-
-    if (tempDir) {
-      const src = join(tempDir, '.aw_registry', file);
-      if (existsSync(src)) {
-        let content = readFileSync(src, 'utf8');
-        if (namespace) {
-          content = content.replace(/\{\{TEAM\}\}/g, namespace);
-        }
-        writeFileSync(dest, content);
-        fmt.logSuccess(`Created ${file}`);
-        createdFiles.push(dest);
-        continue;
-      }
-    }
-
-    const content = generateAgentsMd(cwd, namespace, rulesSections);
-    if (content) {
-      writeFileSync(dest, content);
-      fmt.logSuccess(`Created ${file}`);
-      createdFiles.push(dest);
-    }
+    // Never create repo instruction files anymore.
   }
   return createdFiles;
 }
 
+function syncHomeInstructionFile(destPath, file, rulesSection) {
+  const existing = existsSync(destPath)
+    ? readFileSync(destPath, 'utf8')
+    : defaultInstructionPreamble(file);
+  const base = shouldResetHomeInstructionFile(existing, file)
+    ? defaultInstructionPreamble(file)
+    : existing;
+  const updated = applyManagedInstructionSections(
+    base,
+    file,
+    file === 'CLAUDE.md' ? { claudeSection: rulesSection } : { agentsSection: rulesSection },
+  );
+
+  if (updated === existing) return null;
+
+  mkdirSync(dirname(destPath), { recursive: true });
+  writeFileSync(destPath, updated);
+  return destPath;
+}
+
+export function syncHomeHarnessInstructions(homeDir = homedir()) {
+  const rulesDir = resolveRulesSourceDir(homeDir, { homeDir });
+  const codexRulesSection = rulesDir
+    ? generateAgentsMdRulesSection(rulesDir, {
+      outputDir: join(homeDir, '.codex'),
+    })
+    : '';
+  const cursorRulesSection = rulesDir
+    ? generateAgentsMdRulesSection(rulesDir, {
+      outputDir: join(homeDir, '.cursor'),
+    })
+    : '';
+  const claudeRulesSection = rulesDir ? generateClaudeMdRulesSection(rulesDir) : '';
+
+  return [
+    syncHomeInstructionFile(join(homeDir, '.codex', 'AGENTS.md'), 'AGENTS.md', codexRulesSection),
+    syncHomeInstructionFile(join(homeDir, '.claude', 'CLAUDE.md'), 'CLAUDE.md', claudeRulesSection),
+    syncHomeInstructionFile(join(homeDir, '.cursor', 'AGENTS.md'), 'AGENTS.md', cursorRulesSection),
+  ].filter(Boolean);
+}
+
+export function syncCodexHomeAgents(homeDir = homedir()) {
+  const codexAgentsPath = join(homeDir, '.codex', 'AGENTS.md');
+  syncHomeHarnessInstructions(homeDir);
+  return existsSync(codexAgentsPath) ? codexAgentsPath : null;
+}
+
 function generateClaudeMd(cwd, namespace, rulesSections = {}) {
   const team = namespace || 'my-team';
   let base = `# CLAUDE.md — ${team}
 
-Team: ${team} | Local-first orchestration via \`.aw_docs/\` | MCPs: \`memory/*\` (shared knowledge), \`git-jenkins\` (CI/CD), \`grafana\` (observability)
+Team: ${team} | Local-first orchestration via \`.aw_docs/\` | MCPs: \`memory/*\` (shared knowledge), \`jenkins_*\` (CI/CD via ghl-ai MCP), \`grafana\` (observability)
 
 ## Routing Rule (ABSOLUTE)
 
@@ -198,7 +378,7 @@ memory/search  → Search shared team knowledge base
 memory/store   → Push learnings to shared knowledge (eager sync after runs)
 memory/get     → Fetch specific memory by ID
 grafana/*      → External observability
-git-jenkins/*  → External CI/CD pipelines
+jenkins_*      → CI/CD pipelines (provided by ghl-ai MCP)
 stitch/*       → External design generation
 \`\`\`
 
@@ -259,11 +439,7 @@ Gates are shell scripts in \`scripts/gates/\` — CANNOT be bypassed by LLM judg
 - **Local-first**: No MCP calls for orchestration — file reads are faster and always available
 `;
 
-  if (rulesSections.claudeSection) {
-    base += '\n' + rulesSections.claudeSection;
-  }
-
-  return base;
+  return applyManagedInstructionSections(base, 'CLAUDE.md', rulesSections);
 }
 
 function generateAgentsMd(cwd, namespace, rulesSections = {}) {
@@ -401,11 +577,7 @@ Each agent has quality test cases in \`.claude/evals/\`:
 Run with: \`/platform:eval agent:<slug>\` or \`/platform:eval skill:<slug>\`
 `;
 
-  if (rulesSections.agentsSection) {
-    base += '\n' + rulesSections.agentsSection;
-  }
-
-  return base;
+  return applyManagedInstructionSections(base, 'AGENTS.md', rulesSections);
 }
 
 /**

package/link.mjs

@@ -14,7 +14,7 @@ function forceSymlink(target, linkPath) {
 const IDE_DIRS = ['.claude', '.cursor', '.codex'];
 // Per-file symlink types
 const FILE_TYPES = ['agents'];
-const ALL_KNOWN_TYPES = new Set([...FILE_TYPES, 'skills', 'commands', 'evals', 'docs']);
+const ALL_KNOWN_TYPES = new Set([...FILE_TYPES, 'skills', 'commands', 'evals', 'references', 'docs']);
 
 /**
  * List namespace directories inside .aw_registry/ (skip dotfiles).
@@ -77,6 +77,8 @@ function cleanIdeSymlinks(cwd) {
   if (cwd === HOME) {
     const agentsSkillsDir = join(cwd, '.agents', 'skills');
     if (existsSync(agentsSkillsDir)) cleanSymlinksRecursive(agentsSkillsDir);
+    const agentsReferencesDir = join(cwd, '.agents', 'references');
+    if (existsSync(agentsReferencesDir)) cleanSymlinksRecursive(agentsReferencesDir);
   }
 }
 
@@ -203,6 +205,25 @@ export function linkWorkspace(cwd, awDirOverride = null, { silent = false } = {}
     }
   }
 
+  // Shared references: flatten namespace references into each IDE's references/
+  // so links like ../../references/foo.md continue to work from flattened skill dirs.
+  for (const ns of namespaces) {
+    for (const { typeDirPath: referencesDir } of findNestedTypeDirs(join(awDir, ns), 'references')) {
+      for (const file of readdirSync(referencesDir).filter(f => !f.startsWith('.'))) {
+        const targetPath = join(referencesDir, file);
+        if (lstatSync(targetPath).isDirectory()) continue;
+
+        for (const ide of IDE_DIRS) {
+          const linkDir = join(cwd, ide, 'references');
+          mkdirSync(linkDir, { recursive: true });
+          const linkPath = join(linkDir, file);
+          const relTarget = relative(linkDir, targetPath);
+          try { forceSymlink(relTarget, linkPath); created++; } catch { /* best effort */ }
+        }
+      }
+    }
+  }
+
   // Codex per-skill symlinks: ~/.agents/skills/<name> (global only)
   if (cwd === homedir()) {
     const agentsSkillsDir = join(cwd, '.agents/skills');
@@ -218,6 +239,20 @@ export function linkWorkspace(cwd, awDirOverride = null, { silent = false } = {}
         }
       }
     }
+
+    const agentsReferencesDir = join(cwd, '.agents', 'references');
+    for (const ns of namespaces) {
+      for (const { typeDirPath: referencesDir } of findNestedTypeDirs(join(awDir, ns), 'references')) {
+        mkdirSync(agentsReferencesDir, { recursive: true });
+        for (const file of readdirSync(referencesDir).filter(f => !f.startsWith('.'))) {
+          const targetPath = join(referencesDir, file);
+          if (lstatSync(targetPath).isDirectory()) continue;
+          const linkPath = join(agentsReferencesDir, file);
+          const relTarget = relative(agentsReferencesDir, targetPath);
+          try { forceSymlink(relTarget, linkPath); created++; } catch { /* best effort */ }
+        }
+      }
+    }
   }
 
   // Commands: per-file symlinks (recursive for nested domain dirs)

package/mcp.mjs

@@ -168,16 +168,8 @@ async function resolveClickUpToken(silent = false, cwd = process.cwd()) {
     return existing.token;
   }
 
-  // In silent mode (git hooks, auto-pull) there is no terminal — skip prompt.
-  // Also skip in any non-TTY context so automation and CI runs never crash
-  // while trying to render interactive prompts for an optional integration.
-  const hasInteractiveTty = Boolean(process.stdin.isTTY && process.stdout.isTTY);
-  if (silent || !hasInteractiveTty) {
-    if (!silent && !hasInteractiveTty) {
-      fmt.logInfo('Skipping ClickUp setup — no interactive terminal detected');
-    }
-    return null;
-  }
+  // In silent mode (git hooks, auto-pull) there is no terminal — skip prompt
+  if (silent) return null;
 
   // 3. Ask first — don't assume the user wants ClickUp
   const wantsClickUp = await p.select({