@aria_asi/cli 0.2.25 → 0.2.29

package/src/connectors/claude-code.ts

@@ -36,6 +36,23 @@ const HOOK_FILES = [
   // Pre-text gate — validates state-dependent claims in prose against
   // probe evidence before emission. Closes "WHEN TO LOOK before speaking" gap.
   'aria-pre-text-gate.mjs',
+  // Discovery-ledger write primitive (#83) — sub-agents pipe findings here;
+  // outcome-record fires on every state-mutating tool PostToolUse.
+  'aria-discovery-record.mjs',
+  'aria-outcome-record.mjs',
+  // Substrate-binding gate — validates cognition lenses cite real loaded
+  // substrate (axioms, frames, memories) not forged/generic anchors.
+  // Writes ~/.claude/.aria-loaded-substrate.json manifest (#142).
+  'aria-cognition-substrate-binding.mjs',
+  // Repo-side doctrine gate — scans edited/staged source files for
+  // mock/stub/pending semantics in doctrine-bound packages.
+  'aria-repo-doctrine-gate.mjs',
+  // Pre-emit dry-run validator (#140) — model self-checks draft against
+  // substrate-binding + drift-triggers before emit. CLI tool, not auto-hook.
+  'aria-pre-emit-dryrun.mjs',
+];
+const HOOK_DIRS = [
+  'lib',
 ];
 // Compiled location: <pkg>/dist/aria-connector/src/connectors/claude-code.js
 // (tsc preserves the src/ rooted layout under outDir). From this file:
@@ -53,7 +70,12 @@ const HOOK_FILES = [
 // the fix lands in the same turn as the discovery.
 function packageHooksDir(): string {
   const here = path.dirname(fileURLToPath(import.meta.url));
-  return path.resolve(here, '..', '..', '..', '..', 'hooks');
+  const candidates = [
+    path.resolve(here, '..', '..', '..', '..', 'hooks'),
+    path.resolve(here, '..', '..', '..', 'assets', 'hooks'),
+  ];
+  const found = candidates.find((candidate) => existsSync(candidate));
+  return found || candidates[0];
 }
 
 function packageSdkDir(): string {
@@ -162,15 +184,35 @@ const HOOKS_BLOCK = {
       }],
     },
   ],
-  PostToolUse: [{
-    matcher: 'Agent',
-    hooks: [{
-      type: 'command',
-      command: 'node $HOME/.claude/hooks/aria-agent-ledger-merge.mjs',
-      timeout: 8,
-      statusMessage: 'Merging sub-agent ledger...',
-    }],
-  }],
+  PostToolUse: [
+    {
+      matcher: 'Agent',
+      hooks: [{
+        type: 'command',
+        command: 'node $HOME/.claude/hooks/aria-agent-ledger-merge.mjs',
+        timeout: 8,
+        statusMessage: 'Merging sub-agent ledger...',
+      }],
+    },
+    {
+      matcher: 'Bash|Edit|Write|NotebookEdit',
+      hooks: [
+        {
+          type: 'command',
+          command: 'node $HOME/.claude/hooks/aria-repo-doctrine-gate.mjs',
+          timeout: 5,
+        },
+        {
+          // Outcome-record: fires on every state-mutating tool to accumulate the
+          // outcome ledger (Sonnet H's #76 endpoint). Fire-and-forget — HTTP
+          // failures in the hook do not block the tool pipeline.
+          type: 'command',
+          command: 'node $HOME/.claude/hooks/aria-outcome-record.mjs',
+          timeout: 3,
+        },
+      ],
+    },
+  ],
   Stop: [{
     // Stop gate — text-decision boundary. Reflexive replies fail this
     // gate the same way reflexive Bash does. Mirrors PreToolUse
@@ -180,6 +222,11 @@ const HOOKS_BLOCK = {
     // against probe evidence in this turn's tool results. Closes the
     // "WHEN TO LOOK before speaking" gap left open by both existing gates.
     hooks: [
+      {
+        type: 'command',
+        command: 'node $HOME/.claude/hooks/aria-cognition-substrate-binding.mjs',
+        timeout: 3,
+      },
       {
         type: 'command',
         command: 'node $HOME/.claude/hooks/aria-stop-gate.mjs',
@@ -200,6 +247,25 @@ function installHooks(claudeDir: string, logs: string[], opts: { force?: boolean
     mkdirSync(hooksTargetDir, { recursive: true, mode: 0o700 });
   }
   const sourceDir = packageHooksDir();
+  for (const dirName of HOOK_DIRS) {
+    const srcDir = path.join(sourceDir, dirName);
+    if (!existsSync(srcDir)) continue;
+    const dstDir = path.join(hooksTargetDir, dirName);
+    if (!existsSync(dstDir)) {
+      mkdirSync(dstDir, { recursive: true, mode: 0o700 });
+    }
+    for (const child of readdirSync(srcDir)) {
+      const src = path.join(srcDir, child);
+      const stat = statSync(src);
+      if (!stat.isFile()) continue;
+      const dst = path.join(dstDir, child);
+      copyFileSync(src, dst);
+      if (child.endsWith('.mjs') || child.endsWith('.js')) {
+        try { chmodSync(dst, 0o755); } catch {}
+      }
+      logs.push(`Installed hook helper: ${dirName}/${child}`);
+    }
+  }
   for (const name of HOOK_FILES) {
     const src = path.join(sourceDir, name);
     if (!existsSync(src)) {
@@ -277,29 +343,34 @@ function wireHooksBlock(settings: Record<string, unknown>, logs: string[]): void
   }
   const hooks = settings.hooks as Record<string, unknown[]>;
   let mergedEvents = 0;
+
+  const isManagedAriaCommand = (command: string): boolean =>
+    command.includes('$HOME/.claude/hooks/aria-');
+
+  const isSameManagedEntry = (entry: unknown, matcher: string, commands: string[]): boolean => {
+    if (typeof entry !== 'object' || entry === null) return false;
+    const eMatcher = (entry as { matcher?: string }).matcher ?? '';
+    if (eMatcher !== matcher) return false;
+    const eCommands = ((entry as { hooks?: Array<{ command?: string }> }).hooks ?? [])
+      .map((h) => h.command)
+      .filter((c): c is string => typeof c === 'string');
+    if (eCommands.length === 0) return false;
+    return eCommands.every(isManagedAriaCommand) || commands.every((c) => eCommands.includes(c));
+  };
+
   for (const [event, ourEntries] of Object.entries(HOOKS_BLOCK)) {
     const existingEntries = Array.isArray(hooks[event]) ? hooks[event] : [];
+    const normalizedEntries = [...existingEntries];
     for (const ourEntry of ourEntries) {
       const ourMatcher = (ourEntry as { matcher?: string }).matcher ?? '';
       const ourCommands = ((ourEntry as { hooks?: Array<{ command?: string }> }).hooks ?? [])
         .map((h) => h.command)
         .filter((c): c is string => typeof c === 'string');
-      // Idempotent: skip if an entry with the same matcher AND same set
-      // of commands already exists. Re-running connect stays clean.
-      const alreadyPresent = existingEntries.some((e) => {
-        if (typeof e !== 'object' || e === null) return false;
-        const eMatcher = (e as { matcher?: string }).matcher ?? '';
-        if (eMatcher !== ourMatcher) return false;
-        const eCommands = ((e as { hooks?: Array<{ command?: string }> }).hooks ?? [])
-          .map((h) => h.command)
-          .filter((c): c is string => typeof c === 'string');
-        return ourCommands.every((c) => eCommands.includes(c));
-      });
-      if (!alreadyPresent) {
-        existingEntries.push(ourEntry);
-      }
+      const filteredEntries = normalizedEntries.filter((e) => !isSameManagedEntry(e, ourMatcher, ourCommands));
+      normalizedEntries.length = 0;
+      normalizedEntries.push(...filteredEntries, ourEntry);
     }
-    hooks[event] = existingEntries;
+    hooks[event] = normalizedEntries;
     mergedEvents++;
   }
   settings.hooks = hooks;
@@ -307,9 +378,25 @@ function wireHooksBlock(settings: Record<string, unknown>, logs: string[]): void
   if (!settings.$schema) {
     settings.$schema = 'https://json.schemastore.org/claude-code-settings.json';
   }
-  logs.push(`Wired hooks into settings.json (${mergedEvents} events: SessionStart, UserPromptSubmit, PreToolUse [cognition+memory-gate+Agent-handoff], PostToolUse [Agent-ledger-merge], Stop) — merge-safe, preserves third-party entries`);
+  logs.push(`Wired hooks into settings.json (${mergedEvents} events: SessionStart, UserPromptSubmit, PreToolUse [cognition+memory-gate+Agent-handoff], PostToolUse [repo-doctrine-gate + Agent-ledger-merge + outcome-record], Stop) — merge-safe, preserves third-party entries`);
 }
 
+// Layer 2 (#84): hard prefix injected into every Agent dispatch so sub-agents
+// know to load the harness packet before ANY tool call. This text appears in
+// the system-prompt-prefix which Claude Code copies into spawned Agent contexts.
+const ARIA_HARNESS_BINDING_PREFIX = `[ARIA_HARNESS_BINDING — MANDATORY FIRST ACTION]
+Before any tool call, Read the harness packet at: $ARIA_HARNESS_PACKET_PATH
+(path is also in your environment as ARIA_HARNESS_PACKET_PATH variable)
+Cite it in your first cognition block — reference at least one axiom + one frame + one memory class from the packet.
+Without packet-citation in your first cognition block, your output will be rejected by aria-pre-tool-gate.mjs in your sub-process.
+[/ARIA_HARNESS_BINDING]
+
+[ARIA_DISCOVERY_RECORDING — when you find a defect, doctrine violation, or notable observation during work]
+Record findings to your session ledger via:
+  echo '{"text":"<finding>","kind":"defect|observation|principle","refs":["<file:line>"]}' | node $HOME/.claude/hooks/aria-discovery-record.mjs
+This makes findings visible to the parent session's ledger-merge hook + the auto-fix spawner.
+[/ARIA_DISCOVERY_RECORDING]`;
+
 function buildAriaSystemBlock(config: AriaConfig): string {
   const repoList = config.repositories.map((r) => `- ${r.name} (${r.path})`).join('\n');
   const schemaText = Object.entries(config.schemaImages)
@@ -322,6 +409,8 @@ You are augmented with Aria's cognitive harness. This provides:
 - Garden memory: persistent project memory across sessions
 - 8-lens cognition: multi-perspective analysis for every decision
 
+${ARIA_HARNESS_BINDING_PREFIX}
+
 [SELF-GATE PROTOCOL]
 Before emitting any claim, verify against these hard constraints:
 1. Truth over deception — always.

package/src/connectors/codebase-awareness.ts

@@ -0,0 +1,408 @@
+import { execFileSync } from 'child_process';
+import { createHash } from 'crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import * as path from 'path';
+import { fileURLToPath } from 'node:url';
+import type { AriaConfig, LinkedRepo } from '../config.js';
+import { loadConfig, saveConfig } from '../config.js';
+import { scanCodebase, schemaImageToText, watchCodebase } from '../codebase-scanner.js';
+
+const ARIA_DIR = path.join(homedir(), '.aria');
+const BIN_DIR = path.join(ARIA_DIR, 'bin');
+const ENV_PATH = path.join(ARIA_DIR, 'codebase-awareness.env');
+const STATE_PATH = path.join(ARIA_DIR, 'codebase-awareness-state.json');
+const INDEX_PATH = path.join(ARIA_DIR, 'codebase-awareness-index.json');
+
+type AwarenessStatus = 'idle' | 'watching' | 'scanning' | 'error';
+
+interface RepoSnapshot {
+  path: string;
+  name: string;
+  scanHash: string;
+  lastScan: string;
+  fileCount: number;
+  language: string;
+  framework: string | null;
+  packageManager: string | null;
+  database: string | null;
+  orm: string | null;
+  architecture: string | null;
+}
+
+interface AwarenessState {
+  status: AwarenessStatus;
+  watchedRepos: string[];
+  repoSnapshots: RepoSnapshot[];
+  lastError: string | null;
+  updatedAt: string;
+}
+
+function connectorPackageRoot(): string {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    path.resolve(here, '..', '..'),
+    path.resolve(here, '..', '..', '..', '..'),
+  ];
+
+  for (const candidate of candidates) {
+    if (existsSync(path.join(candidate, 'bin', 'aria.js')) && existsSync(path.join(candidate, 'package.json'))) {
+      return candidate;
+    }
+  }
+
+  return candidates[candidates.length - 1];
+}
+
+function writeWrapper(binPath: string, args: string[]): void {
+  const ariaBin = path.join(connectorPackageRoot(), 'bin', 'aria.js');
+  writeFileSync(
+    binPath,
+    `#!/usr/bin/env bash\nexec node "${ariaBin}" ${args.join(' ')} "$@"\n`,
+    { mode: 0o755 },
+  );
+}
+
+function defaultState(): AwarenessState {
+  return {
+    status: 'idle',
+    watchedRepos: [],
+    repoSnapshots: [],
+    lastError: null,
+    updatedAt: new Date(0).toISOString(),
+  };
+}
+
+function readState(): AwarenessState {
+  try {
+    const parsed = JSON.parse(readFileSync(STATE_PATH, 'utf8')) as Partial<AwarenessState>;
+    return {
+      status: parsed.status || 'idle',
+      watchedRepos: Array.isArray(parsed.watchedRepos) ? parsed.watchedRepos : [],
+      repoSnapshots: Array.isArray(parsed.repoSnapshots) ? parsed.repoSnapshots as RepoSnapshot[] : [],
+      lastError: parsed.lastError || null,
+      updatedAt: parsed.updatedAt || new Date(0).toISOString(),
+    };
+  } catch {
+    return defaultState();
+  }
+}
+
+function writeState(update: Partial<AwarenessState>): AwarenessState {
+  const current = readState();
+  const next: AwarenessState = {
+    ...current,
+    ...update,
+    updatedAt: new Date().toISOString(),
+  };
+  mkdirSync(ARIA_DIR, { recursive: true, mode: 0o700 });
+  writeFileSync(STATE_PATH, JSON.stringify(next, null, 2) + '\n', { mode: 0o600 });
+  return next;
+}
+
+function writeIndex(payload: Record<string, unknown>): void {
+  mkdirSync(ARIA_DIR, { recursive: true, mode: 0o700 });
+  writeFileSync(INDEX_PATH, JSON.stringify(payload, null, 2) + '\n', { mode: 0o600 });
+}
+
+function looksLikeRepoRoot(candidate: string): boolean {
+  return existsSync(path.join(candidate, '.git'));
+}
+
+function findRepoRoot(startDir: string): string | null {
+  let current = path.resolve(startDir);
+  while (true) {
+    if (looksLikeRepoRoot(current)) return current;
+    const parent = path.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+
+function resolveRepos(config?: AriaConfig, explicit?: string[], fallbackRepoPath?: string): string[] {
+  if (explicit?.length) return explicit.map((repo) => path.resolve(repo)).filter(looksLikeRepoRoot);
+
+  const envRepos = process.env.ARIA_CODEBASE_AWARENESS_REPOS?.split(path.delimiter)
+    .map((repo) => repo.trim())
+    .filter(Boolean) || [];
+  if (envRepos.length) return envRepos.map((repo) => path.resolve(repo)).filter(looksLikeRepoRoot);
+
+  const loaded = config || loadConfig();
+  const configured = (loaded.repositories || [])
+    .map((repo) => path.resolve(repo.path))
+    .filter(looksLikeRepoRoot);
+  if (configured.length) return configured;
+
+  if (fallbackRepoPath) {
+    const resolvedFallback = findRepoRoot(fallbackRepoPath);
+    if (resolvedFallback) return [resolvedFallback];
+  }
+
+  const cwd = findRepoRoot(process.cwd());
+  return cwd ? [cwd] : [];
+}
+
+function hashSchema(text: string): string {
+  return createHash('sha256').update(text).digest('hex').slice(0, 16);
+}
+
+function architectureSummary(image: {
+  architecture?: unknown;
+}): string | null {
+  if (Array.isArray(image.architecture) && image.architecture.length > 0) {
+    const first = image.architecture[0];
+    if (typeof first === 'string' && first.trim()) return first.trim();
+    if (first && typeof first === 'object' && typeof first.pattern === 'string' && first.pattern.trim()) {
+      return first.pattern.trim();
+    }
+  }
+  if (typeof image.architecture === 'string' && image.architecture.trim()) return image.architecture.trim();
+  return null;
+}
+
+async function applyRepoScan(repoRoot: string): Promise<RepoSnapshot> {
+  const image = await scanCodebase(repoRoot);
+  const schemaText = schemaImageToText(image);
+  const scanHash = hashSchema(schemaText);
+  const lastScan = new Date().toISOString();
+
+  const config = loadConfig();
+  const nextRepo: LinkedRepo = {
+    path: repoRoot,
+    name: image.projectName,
+    scanHash,
+    lastScan,
+  };
+  const repositories = [
+    ...(config.repositories || []).filter((repo) => path.resolve(repo.path) !== repoRoot),
+    nextRepo,
+  ];
+
+  saveConfig({
+    ...config,
+    repositories,
+    schemaImages: {
+      ...(config.schemaImages || {}),
+      [image.projectName]: schemaText,
+    },
+  });
+
+  const snapshot: RepoSnapshot = {
+    path: repoRoot,
+    name: image.projectName,
+    scanHash,
+    lastScan,
+    fileCount: image.fileCount,
+    language: image.language,
+    framework: image.framework || null,
+    packageManager: image.packageManager || null,
+    database: image.database || null,
+    orm: image.orm || null,
+    architecture: architectureSummary(image),
+  };
+
+  const current = readState();
+  const nextSnapshots = [
+    snapshot,
+    ...current.repoSnapshots.filter((entry) => path.resolve(entry.path) !== repoRoot),
+  ];
+  writeState({
+    status: 'watching',
+    watchedRepos: Array.from(new Set([repoRoot, ...current.watchedRepos])),
+    repoSnapshots: nextSnapshots,
+    lastError: null,
+  });
+  writeIndex({
+    generatedAt: new Date().toISOString(),
+    watchedRepos: Array.from(new Set([repoRoot, ...current.watchedRepos])),
+    repoSnapshots: nextSnapshots,
+    schemaImages: loadConfig().schemaImages || {},
+  });
+  return snapshot;
+}
+
+export function readCodebaseAwarenessState(): AwarenessState {
+  return readState();
+}
+
+export async function runCodebaseAwarenessScan(options: {
+  repos?: string[];
+  fallbackRepoPath?: string;
+} = {}): Promise<{ ok: true; repos: RepoSnapshot[] }> {
+  const repos = resolveRepos(undefined, options.repos, options.fallbackRepoPath);
+  if (!repos.length) {
+    writeState({ status: 'error', watchedRepos: [], lastError: 'No git repositories configured for codebase awareness.' });
+    throw new Error('No git repositories configured for codebase awareness.');
+  }
+
+  writeState({ status: 'scanning', watchedRepos: repos, lastError: null });
+  const snapshots: RepoSnapshot[] = [];
+  for (const repo of repos) {
+    snapshots.push(await applyRepoScan(repo));
+  }
+  writeState({ status: 'watching', watchedRepos: repos, repoSnapshots: snapshots, lastError: null });
+  writeIndex({
+    generatedAt: new Date().toISOString(),
+    watchedRepos: repos,
+    repoSnapshots: snapshots,
+    schemaImages: loadConfig().schemaImages || {},
+  });
+  return { ok: true, repos: snapshots };
+}
+
+export async function startCodebaseAwarenessDaemon(options: {
+  repos?: string[];
+  fallbackRepoPath?: string;
+} = {}): Promise<void> {
+  const repos = resolveRepos(undefined, options.repos, options.fallbackRepoPath);
+  if (!repos.length) {
+    writeState({ status: 'error', watchedRepos: [], lastError: 'No git repositories configured for codebase awareness.' });
+    throw new Error('No git repositories configured for codebase awareness.');
+  }
+
+  await runCodebaseAwarenessScan({ repos });
+  writeState({ status: 'watching', watchedRepos: repos, lastError: null });
+
+  for (const repo of repos) {
+    watchCodebase(
+      repo,
+      (image) => {
+        const schemaText = schemaImageToText(image);
+        const scanHash = hashSchema(schemaText);
+        const lastScan = new Date().toISOString();
+        const config = loadConfig();
+        const repositories = [
+          ...(config.repositories || []).filter((entry) => path.resolve(entry.path) !== repo),
+          {
+            path: repo,
+            name: image.projectName,
+            scanHash,
+            lastScan,
+          },
+        ];
+        const nextConfig = {
+          ...config,
+          repositories,
+          schemaImages: {
+            ...(config.schemaImages || {}),
+            [image.projectName]: schemaText,
+          },
+        };
+        saveConfig(nextConfig);
+
+        const current = readState();
+        const snapshot: RepoSnapshot = {
+          path: repo,
+          name: image.projectName,
+          scanHash,
+          lastScan,
+          fileCount: image.fileCount,
+          language: image.language,
+          framework: image.framework || null,
+          packageManager: image.packageManager || null,
+          database: image.database || null,
+          orm: image.orm || null,
+          architecture: architectureSummary(image),
+        };
+        const repoSnapshots = [
+          snapshot,
+          ...current.repoSnapshots.filter((entry) => path.resolve(entry.path) !== repo),
+        ];
+        writeState({
+          status: 'watching',
+          watchedRepos: repos,
+          repoSnapshots,
+          lastError: null,
+        });
+        writeIndex({
+          generatedAt: new Date().toISOString(),
+          watchedRepos: repos,
+          repoSnapshots,
+          schemaImages: nextConfig.schemaImages || {},
+        });
+      },
+      {
+        debounceMs: 800,
+        pollIntervalMs: 4000,
+        onError: ({ error }) => {
+          writeState({
+            status: 'error',
+            watchedRepos: repos,
+            lastError: error.message,
+          });
+        },
+      },
+    );
+  }
+
+  await new Promise(() => {});
+}
+
+function writeEnv(repos: string[]): string {
+  mkdirSync(ARIA_DIR, { recursive: true, mode: 0o700 });
+  writeFileSync(
+    ENV_PATH,
+    [
+      `ARIA_CODEBASE_AWARENESS_REPOS=${repos.join(path.delimiter)}`,
+      '',
+    ].join('\n'),
+    { mode: 0o600 },
+  );
+  return ENV_PATH;
+}
+
+function installSystemdUserService(logs: string[]): void {
+  const systemctlPath = '/bin/systemctl';
+  if (process.platform !== 'linux' || !existsSync(systemctlPath)) return;
+
+  const serviceDir = path.join(homedir(), '.config', 'systemd', 'user');
+  const servicePath = path.join(serviceDir, 'aria-codebase-awareness.service');
+  mkdirSync(serviceDir, { recursive: true, mode: 0o755 });
+
+  const unit = [
+    '[Unit]',
+    'Description=Aria Codebase Awareness',
+    'After=network.target',
+    '',
+    '[Service]',
+    'Type=simple',
+    `EnvironmentFile=-${ENV_PATH}`,
+    `ExecStart=${path.join(BIN_DIR, 'aria-codebase-awareness')} start`,
+    'Restart=always',
+    'RestartSec=2',
+    '',
+    '[Install]',
+    'WantedBy=default.target',
+    '',
+  ].join('\n');
+
+  writeFileSync(servicePath, unit, { mode: 0o644 });
+  logs.push(`Installed systemd user unit → ${servicePath}`);
+
+  try {
+    execFileSync(systemctlPath, ['--user', 'daemon-reload'], { stdio: 'ignore' });
+    execFileSync(systemctlPath, ['--user', 'enable', '--now', 'aria-codebase-awareness.service'], { stdio: 'ignore' });
+    logs.push('Enabled and started systemd user service: aria-codebase-awareness.service');
+  } catch (error) {
+    logs.push(`⚠ codebase awareness service installed but not activated: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+export async function installCodebaseAwarenessDaemon(config?: AriaConfig, fallbackRepoPath?: string): Promise<string[]> {
+  const repos = resolveRepos(config, undefined, fallbackRepoPath);
+  const logs: string[] = [];
+  if (!repos.length) {
+    logs.push('Skipped codebase awareness install: no git repositories configured.');
+    return logs;
+  }
+
+  mkdirSync(BIN_DIR, { recursive: true, mode: 0o755 });
+  const envPath = writeEnv(repos);
+  writeWrapper(path.join(BIN_DIR, 'aria-codebase-awareness'), ['codebase-awareness']);
+  installSystemdUserService(logs);
+
+  logs.push(`Installed codebase awareness wrapper → ${path.join(BIN_DIR, 'aria-codebase-awareness')}`);
+  logs.push(`Installed codebase awareness env → ${envPath}`);
+  logs.push(`Codebase awareness watching ${repos.length} repos`);
+  return logs;
+}