@jonit-dev/night-watch-cli 1.7.27 → 1.7.30

package/dist/src/slack/interaction-listener.js

@@ -4,7 +4,7 @@
  * and applies loop-protection safeguards.
  */
 import { SocketModeClient } from '@slack/socket-mode';
-import { spawn } from 'child_process';
+import { execFileSync, spawn } from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
 import { getDb } from '../storage/sqlite/client.js';
@@ -21,49 +21,14 @@ const PROACTIVE_IDLE_MS = 20 * 60_000; // 20 min
 const PROACTIVE_MIN_INTERVAL_MS = 90 * 60_000; // per channel
 const PROACTIVE_SWEEP_INTERVAL_MS = 60_000;
 const PROACTIVE_CODEWATCH_MIN_INTERVAL_MS = 3 * 60 * 60_000; // per project
-const PROACTIVE_CODEWATCH_REPEAT_COOLDOWN_MS = 24 * 60 * 60_000; // per issue signature
 const MAX_JOB_OUTPUT_CHARS = 12_000;
 const HUMAN_REACTION_PROBABILITY = 0.65;
+const RANDOM_REACTION_PROBABILITY = 0.25;
 const REACTION_DELAY_MIN_MS = 180;
 const REACTION_DELAY_MAX_MS = 1200;
 const RESPONSE_DELAY_MIN_MS = 700;
 const RESPONSE_DELAY_MAX_MS = 3400;
-const CODEWATCH_MAX_FILES = 250;
-const CODEWATCH_MAX_FILE_BYTES = 256_000;
-const CODEWATCH_INCLUDE_EXTENSIONS = new Set([
-    '.ts',
-    '.tsx',
-    '.js',
-    '.jsx',
-    '.mjs',
-    '.cjs',
-    '.py',
-    '.go',
-    '.rb',
-    '.java',
-    '.kt',
-    '.rs',
-    '.php',
-    '.cs',
-    '.swift',
-    '.scala',
-    '.sh',
-]);
-const CODEWATCH_IGNORE_DIRS = new Set([
-    '.git',
-    'node_modules',
-    'dist',
-    'build',
-    '.next',
-    'coverage',
-    '.turbo',
-    '.cache',
-    'logs',
-    '.yarn',
-    'vendor',
-    'tmp',
-    'temp',
-]);
+const SOCKET_DISCONNECT_TIMEOUT_MS = 5_000;
 const JOB_STOPWORDS = new Set([
     'and',
     'or',
@@ -128,126 +93,6 @@ function normalizeForParsing(text) {
         .replace(/\s+/g, ' ')
         .trim();
 }
-function isCodeWatchSourceFile(filePath) {
-    return CODEWATCH_INCLUDE_EXTENSIONS.has(path.extname(filePath).toLowerCase());
-}
-function lineNumberAt(content, index) {
-    if (index <= 0)
-        return 1;
-    let line = 1;
-    for (let i = 0; i < index && i < content.length; i += 1) {
-        if (content.charCodeAt(i) === 10) {
-            line += 1;
-        }
-    }
-    return line;
-}
-function extractLineSnippet(content, index) {
-    const clamped = Math.max(0, Math.min(index, content.length));
-    const before = content.lastIndexOf('\n', clamped);
-    const after = content.indexOf('\n', clamped);
-    const start = before === -1 ? 0 : before + 1;
-    const end = after === -1 ? content.length : after;
-    return content.slice(start, end).trim().slice(0, 220);
-}
-function walkProjectFilesForCodeWatch(projectPath) {
-    const files = [];
-    const stack = [projectPath];
-    while (stack.length > 0 && files.length < CODEWATCH_MAX_FILES) {
-        const dir = stack.pop();
-        if (!dir)
-            break;
-        let entries;
-        try {
-            entries = fs.readdirSync(dir, { withFileTypes: true });
-        }
-        catch {
-            continue;
-        }
-        for (const entry of entries) {
-            if (files.length >= CODEWATCH_MAX_FILES)
-                break;
-            const fullPath = path.join(dir, entry.name);
-            if (entry.isDirectory()) {
-                if (CODEWATCH_IGNORE_DIRS.has(entry.name)) {
-                    continue;
-                }
-                stack.push(fullPath);
-                continue;
-            }
-            if (!entry.isFile()) {
-                continue;
-            }
-            if (isCodeWatchSourceFile(fullPath)) {
-                files.push(fullPath);
-            }
-        }
-    }
-    return files;
-}
-export function findCodeWatchSignal(content) {
-    if (!content || content.trim().length === 0)
-        return null;
-    const emptyCatchMatch = /catch\s*(?:\([^)]*\))?\s*\{\s*(?:(?:\/\/[^\n]*|\/\*[\s\S]*?\*\/)\s*)*\}/gm.exec(content);
-    const criticalTodoMatch = /\b(?:TODO|FIXME|HACK)\b[^\n]{0,140}\b(?:bug|security|race|leak|crash|hotfix|rollback|unsafe)\b/gi.exec(content);
-    const emptyCatchIndex = emptyCatchMatch?.index ?? Number.POSITIVE_INFINITY;
-    const criticalTodoIndex = criticalTodoMatch?.index ?? Number.POSITIVE_INFINITY;
-    if (!Number.isFinite(emptyCatchIndex) && !Number.isFinite(criticalTodoIndex)) {
-        return null;
-    }
-    if (emptyCatchIndex <= criticalTodoIndex) {
-        return {
-            type: 'empty_catch',
-            index: emptyCatchIndex,
-            summary: 'empty catch block may hide runtime failures',
-            snippet: extractLineSnippet(content, emptyCatchIndex),
-        };
-    }
-    return {
-        type: 'critical_todo',
-        index: criticalTodoIndex,
-        summary: 'high-risk TODO/FIXME likely indicates unresolved bug or security concern',
-        snippet: (criticalTodoMatch?.[0] ?? extractLineSnippet(content, criticalTodoIndex)).trim().slice(0, 220),
-    };
-}
-function detectCodeWatchCandidate(projectPath) {
-    const files = walkProjectFilesForCodeWatch(projectPath);
-    for (const filePath of files) {
-        let stat;
-        try {
-            stat = fs.statSync(filePath);
-        }
-        catch {
-            continue;
-        }
-        if (stat.size <= 0 || stat.size > CODEWATCH_MAX_FILE_BYTES) {
-            continue;
-        }
-        let content;
-        try {
-            content = fs.readFileSync(filePath, 'utf-8');
-        }
-        catch {
-            continue;
-        }
-        if (content.includes('\u0000')) {
-            continue;
-        }
-        const signal = findCodeWatchSignal(content);
-        if (!signal)
-            continue;
-        const relativePath = path.relative(projectPath, filePath).replace(/\\/g, '/');
-        const line = lineNumberAt(content, signal.index);
-        const signature = `${signal.type}:${relativePath}:${line}`;
-        return {
-            ...signal,
-            relativePath,
-            line,
-            signature,
-        };
-    }
-    return null;
-}
 export function isAmbientTeamMessage(text) {
     const normalized = normalizeForParsing(stripSlackUserMentions(text));
     if (!normalized)
@@ -294,6 +139,78 @@ export function parseSlackJobRequest(text) {
         request.fixConflicts = true;
     return request;
 }
+export function parseSlackIssuePickupRequest(text) {
+    const withoutMentions = stripSlackUserMentions(text);
+    const normalized = normalizeForParsing(withoutMentions);
+    if (!normalized)
+        return null;
+    // Extract GitHub issue URL — NOT pull requests (those handled by parseSlackJobRequest)
+    const compactForUrl = withoutMentions.replace(/\s+/g, '');
+    let issueUrl;
+    let issueNumber;
+    let repo;
+    // Standard format: github.com/{owner}/{repo}/issues/{number}
+    const directIssueMatch = compactForUrl.match(/https?:\/\/github\.com\/([^/\s<>]+)\/([^/\s<>]+)\/issues\/(\d+)/i);
+    if (directIssueMatch) {
+        [issueUrl, , repo, issueNumber] = directIssueMatch;
+        repo = repo.toLowerCase();
+    }
+    else {
+        // Project board format: github.com/...?...&issue={owner}%7C{repo}%7C{number}
+        // e.g. github.com/users/jonit-dev/projects/41/views/2?pane=issue&issue=jonit-dev%7Cnight-watch-cli%7C12
+        const boardMatch = compactForUrl.match(/https?:\/\/github\.com\/[^<>\s]*[?&]issue=([^<>\s&]+)/i);
+        if (!boardMatch)
+            return null;
+        const rawParam = boardMatch[1].replace(/%7[Cc]/g, '|');
+        const parts = rawParam.split('|');
+        if (parts.length < 3 || !/^\d+$/.test(parts[parts.length - 1]))
+            return null;
+        issueNumber = parts[parts.length - 1];
+        repo = parts[parts.length - 2].toLowerCase();
+        issueUrl = boardMatch[0];
+    }
+    // Requires pickup-intent language or "this issue" + request language
+    // "pickup" (one word) is also accepted alongside "pick up" (two words)
+    const pickupSignal = /\b(pick\s+up|pickup|work\s+on|implement|tackle|start\s+on|grab|handle\s+this|ship\s+this)\b/i.test(normalized);
+    const requestSignal = /\b(please|can\s+someone|anyone)\b/i.test(normalized) && /\bthis\s+issue\b/i.test(normalized);
+    if (!pickupSignal && !requestSignal)
+        return null;
+    return {
+        issueNumber,
+        issueUrl,
+        repoHint: repo,
+    };
+}
+export function parseSlackProviderRequest(text) {
+    const withoutMentions = stripSlackUserMentions(text);
+    if (!withoutMentions.trim())
+        return null;
+    // Explicit direct-provider invocation from Slack, e.g.:
+    // "claude fix the flaky tests", "run codex on repo-x: investigate CI failures"
+    const prefixMatch = withoutMentions.match(/^\s*(?:can\s+(?:you|someone|anyone)\s+)?(?:please\s+)?(?:(?:run|use|invoke|trigger|ask)\s+)?(claude|codex)\b[\s:,-]*/i);
+    if (!prefixMatch)
+        return null;
+    const provider = prefixMatch[1].toLowerCase();
+    let remainder = withoutMentions.slice(prefixMatch[0].length).trim();
+    if (!remainder)
+        return null;
+    let projectHint;
+    const projectMatch = remainder.match(/^(?:for|on)\s+([a-z0-9./_-]+)\b[\s:,-]*/i);
+    if (projectMatch) {
+        const candidate = projectMatch[1].toLowerCase();
+        if (!JOB_STOPWORDS.has(candidate)) {
+            projectHint = candidate;
+        }
+        remainder = remainder.slice(projectMatch[0].length).trim();
+    }
+    if (!remainder)
+        return null;
+    return {
+        provider,
+        prompt: remainder,
+        ...(projectHint ? { projectHint } : {}),
+    };
+}
 function getPersonaDomain(persona) {
     const role = persona.role.toLowerCase();
     const expertise = (persona.soul?.expertise ?? []).join(' ').toLowerCase();
@@ -442,6 +359,46 @@ export function shouldIgnoreInboundSlackEvent(event, botUserId) {
         return true;
     return false;
 }
+/**
+ * Extract GitHub issue or PR URLs from a message string.
+ */
+export function extractGitHubIssueUrls(text) {
+    const matches = text.match(/https?:\/\/github\.com\/[^\s<>]+/g) ?? [];
+    return matches.filter((u) => /\/(issues|pull)\/\d+/.test(u));
+}
+/**
+ * Fetch GitHub issue/PR content via `gh api` for agent context.
+ * Returns a formatted string, or '' on failure.
+ */
+async function fetchGitHubIssueContext(urls) {
+    if (urls.length === 0)
+        return '';
+    const parts = [];
+    for (const url of urls.slice(0, 3)) {
+        const match = url.match(/github\.com\/([^/]+)\/([^/]+)\/(issues|pull)\/(\d+)/);
+        if (!match)
+            continue;
+        const [, owner, repo, type, number] = match;
+        const endpoint = type === 'pull'
+            ? `/repos/${owner}/${repo}/pulls/${number}`
+            : `/repos/${owner}/${repo}/issues/${number}`;
+        try {
+            const raw = execFileSync('gh', ['api', endpoint, '--jq', '{title: .title, state: .state, body: .body, labels: [.labels[].name]}'], {
+                timeout: 10_000,
+                encoding: 'utf-8',
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            const data = JSON.parse(raw);
+            const labelStr = data.labels.length > 0 ? ` [${data.labels.join(', ')}]` : '';
+            const body = (data.body ?? '').trim().slice(0, 1200);
+            parts.push(`GitHub ${type === 'pull' ? 'PR' : 'Issue'} #${number}${labelStr}: ${data.title} (${data.state})\n${body}`);
+        }
+        catch {
+            // gh not available or not authenticated — skip
+        }
+    }
+    return parts.join('\n\n---\n\n');
+}
 export class SlackInteractionListener {
     _config;
     _slackClient;
@@ -455,7 +412,6 @@ export class SlackInteractionListener {
     _lastChannelActivityAt = new Map();
     _lastProactiveAt = new Map();
     _lastCodeWatchAt = new Map();
-    _lastCodeWatchSignatureAt = new Map();
     _proactiveTimer = null;
     constructor(config) {
         this._config = config;
@@ -513,14 +469,21 @@ export class SlackInteractionListener {
         const socket = this._socketClient;
         this._socketClient = null;
         try {
-            socket.removeAllListeners();
-            await socket.disconnect();
+            await Promise.race([
+                socket.disconnect(),
+                sleep(SOCKET_DISCONNECT_TIMEOUT_MS).then(() => {
+                    throw new Error(`timed out after ${SOCKET_DISCONNECT_TIMEOUT_MS}ms`);
+                }),
+            ]);
             console.log('Slack interaction listener stopped');
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
             console.warn(`Slack interaction listener shutdown failed: ${msg}`);
         }
+        finally {
+            socket.removeAllListeners();
+        }
     }
     /**
      * Join all configured channels, generate avatars for personas that need them,
@@ -672,6 +635,27 @@ export class SlackInteractionListener {
             expiresAt: Date.now() + AD_HOC_THREAD_MEMORY_MS,
         });
     }
+    /**
+     * After an agent posts a reply, check if the text mentions other personas by plain name.
+     * If so, trigger those personas to respond once (no further cascading — depth 1 only).
+     * This enables natural agent-to-agent handoffs like "Carlos, what's the priority here?"
+     */
+    async _followAgentMentions(postedText, channel, threadTs, personas, projectContext, skipPersonaId) {
+        if (!postedText)
+            return;
+        const mentioned = resolvePersonasByPlainName(postedText, personas).filter((p) => p.id !== skipPersonaId && !this._isPersonaOnCooldown(channel, threadTs, p.id));
+        if (mentioned.length === 0)
+            return;
+        console.log(`[slack] agent mention follow-up: ${mentioned.map((p) => p.name).join(', ')}`);
+        for (const persona of mentioned) {
+            // Small human-like delay before the tagged persona responds
+            await sleep(this._randomInt(RESPONSE_DELAY_MIN_MS * 2, RESPONSE_DELAY_MAX_MS * 3));
+            // replyAsAgent fetches thread history internally so Carlos sees Dev's message
+            await this._engine.replyAsAgent(channel, threadTs, postedText, persona, projectContext);
+            this._markPersonaReply(channel, threadTs, persona.id);
+            this._rememberAdHocThreadPersona(channel, threadTs, persona.id);
+        }
+    }
     /**
      * Recover the persona that last replied in a thread by scanning its history.
      * Used as a fallback when in-memory state was lost (e.g. after a server restart).
@@ -844,6 +828,7 @@ export class SlackInteractionListener {
                 ...process.env,
                 NW_EXECUTION_CONTEXT: 'agent',
                 ...(opts?.prNumber ? { NW_TARGET_PR: opts.prNumber } : {}),
+                ...(opts?.issueNumber ? { NW_TARGET_ISSUE: opts.issueNumber } : {}),
                 ...(opts?.fixConflicts
                     ? {
                         NW_SLACK_FEEDBACK: JSON.stringify({
@@ -903,6 +888,96 @@ export class SlackInteractionListener {
             this._markPersonaReply(channel, threadTs, persona.id);
         });
     }
+    async _spawnDirectProviderRequest(request, project, channel, threadTs, persona) {
+        const providerLabel = request.provider === 'claude' ? 'Claude' : 'Codex';
+        const args = request.provider === 'claude'
+            ? ['-p', request.prompt, '--dangerously-skip-permissions']
+            : ['--quiet', '--yolo', '--prompt', request.prompt];
+        console.log(`[slack][provider] persona=${persona.name} provider=${request.provider} project=${project.name} spawn=${formatCommandForLog(request.provider, args)}`);
+        const child = spawn(request.provider, args, {
+            cwd: project.path,
+            env: {
+                ...process.env,
+                ...(this._config.providerEnv ?? {}),
+                NW_EXECUTION_CONTEXT: 'agent',
+            },
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        console.log(`[slack][provider] ${persona.name} spawned ${request.provider} for ${project.name} pid=${child.pid ?? 'unknown'}`);
+        let output = '';
+        let errored = false;
+        const appendOutput = (chunk) => {
+            output += chunk.toString();
+            if (output.length > MAX_JOB_OUTPUT_CHARS) {
+                output = output.slice(-MAX_JOB_OUTPUT_CHARS);
+            }
+        };
+        child.stdout?.on('data', appendOutput);
+        child.stderr?.on('data', appendOutput);
+        child.on('error', async (err) => {
+            errored = true;
+            console.warn(`[slack][provider] ${persona.name} ${request.provider} spawn error for ${project.name}: ${err.message}`);
+            await this._slackClient.postAsAgent(channel, `Couldn't start ${providerLabel}. Error logged — looking into it.`, persona, threadTs);
+            this._markChannelActivity(channel);
+            this._markPersonaReply(channel, threadTs, persona.id);
+        });
+        child.on('close', async (code) => {
+            if (errored)
+                return;
+            console.log(`[slack][provider] ${persona.name} ${request.provider} finished for ${project.name} exit=${code ?? 'unknown'}`);
+            const detail = extractLastMeaningfulLines(output);
+            if (code === 0) {
+                await this._slackClient.postAsAgent(channel, `${providerLabel} command finished.`, persona, threadTs);
+            }
+            else {
+                if (detail) {
+                    console.warn(`[slack][provider] ${persona.name} ${request.provider} failure detail: ${detail}`);
+                }
+                await this._slackClient.postAsAgent(channel, `${providerLabel} hit a snag. Logged the details — looking into it.`, persona, threadTs);
+            }
+            this._markChannelActivity(channel);
+            this._markPersonaReply(channel, threadTs, persona.id);
+        });
+    }
+    async _triggerDirectProviderIfRequested(event, channel, threadTs, messageTs, personas) {
+        const request = parseSlackProviderRequest(event.text ?? '');
+        if (!request)
+            return false;
+        const addressedToBot = this._isMessageAddressedToBot(event);
+        const normalized = normalizeForParsing(stripSlackUserMentions(event.text ?? ''));
+        const startsWithProviderCommand = /^(?:can\s+(?:you|someone|anyone)\s+)?(?:please\s+)?(?:(?:run|use|invoke|trigger|ask)\s+)?(?:claude|codex)\b/i.test(normalized);
+        if (!addressedToBot && !startsWithProviderCommand) {
+            return false;
+        }
+        const repos = getRepositories();
+        const projects = repos.projectRegistry.getAll();
+        const persona = this._findPersonaByName(personas, 'Dev')
+            ?? this._pickRandomPersona(personas, channel, threadTs)
+            ?? personas[0];
+        if (!persona)
+            return false;
+        const targetProject = this._resolveTargetProject(channel, projects, request.projectHint);
+        if (!targetProject) {
+            const projectNames = projects.map((p) => p.name).join(', ') || '(none registered)';
+            await this._slackClient.postAsAgent(channel, `Which project? Registered: ${projectNames}.`, persona, threadTs);
+            this._markChannelActivity(channel);
+            this._markPersonaReply(channel, threadTs, persona.id);
+            return true;
+        }
+        console.log(`[slack][provider] routing provider=${request.provider} to persona=${persona.name} project=${targetProject.name}`);
+        const providerLabel = request.provider === 'claude' ? 'Claude' : 'Codex';
+        const compactPrompt = request.prompt.replace(/\s+/g, ' ').trim();
+        const promptPreview = compactPrompt.length > 120
+            ? `${compactPrompt.slice(0, 117)}...`
+            : compactPrompt;
+        await this._applyHumanResponseTiming(channel, messageTs, persona);
+        await this._slackClient.postAsAgent(channel, `Running ${providerLabel} directly${request.projectHint ? ` on ${targetProject.name}` : ''}: "${promptPreview}"`, persona, threadTs);
+        this._markChannelActivity(channel);
+        this._markPersonaReply(channel, threadTs, persona.id);
+        this._rememberAdHocThreadPersona(channel, threadTs, persona.id);
+        await this._spawnDirectProviderRequest(request, targetProject, channel, threadTs, persona);
+        return true;
+    }
     async _triggerSlackJobIfRequested(event, channel, threadTs, messageTs, personas) {
         const request = parseSlackJobRequest(event.text ?? '');
         if (!request)
@@ -950,12 +1025,145 @@ export class SlackInteractionListener {
         await this._spawnNightWatchJob(request.job, targetProject, channel, threadTs, persona, { prNumber: request.prNumber, fixConflicts: request.fixConflicts });
         return true;
     }
+    async _triggerIssuePickupIfRequested(event, channel, threadTs, messageTs, personas) {
+        const request = parseSlackIssuePickupRequest(event.text ?? '');
+        if (!request)
+            return false;
+        const addressedToBot = this._isMessageAddressedToBot(event);
+        const normalized = normalizeForParsing(stripSlackUserMentions(event.text ?? ''));
+        const teamRequestLanguage = /\b(can someone|someone|anyone|please|need)\b/i.test(normalized);
+        if (!addressedToBot && !teamRequestLanguage)
+            return false;
+        const repos = getRepositories();
+        const projects = repos.projectRegistry.getAll();
+        const persona = this._findPersonaByName(personas, 'Dev')
+            ?? this._pickRandomPersona(personas, channel, threadTs)
+            ?? personas[0];
+        if (!persona)
+            return false;
+        const targetProject = this._resolveTargetProject(channel, projects, request.repoHint);
+        if (!targetProject) {
+            const projectNames = projects.map((p) => p.name).join(', ') || '(none registered)';
+            await this._slackClient.postAsAgent(channel, `Which project? Registered: ${projectNames}.`, persona, threadTs);
+            this._markChannelActivity(channel);
+            this._markPersonaReply(channel, threadTs, persona.id);
+            return true;
+        }
+        console.log(`[slack][issue-pickup] routing issue=#${request.issueNumber} to persona=${persona.name} project=${targetProject.name}`);
+        await this._applyHumanResponseTiming(channel, messageTs, persona);
+        await this._slackClient.postAsAgent(channel, `On it — picking up #${request.issueNumber}. Starting the run now.`, persona, threadTs);
+        this._markChannelActivity(channel);
+        this._markPersonaReply(channel, threadTs, persona.id);
+        this._rememberAdHocThreadPersona(channel, threadTs, persona.id);
+        // Move issue to In Progress on board (best-effort, spawn via CLI subprocess)
+        const boardArgs = buildCurrentCliInvocation([
+            'board', 'move-issue', request.issueNumber, '--column', 'In Progress',
+        ]);
+        if (boardArgs) {
+            try {
+                execFileSync(process.execPath, boardArgs, {
+                    cwd: targetProject.path,
+                    timeout: 15_000,
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                });
+                console.log(`[slack][issue-pickup] moved #${request.issueNumber} to In Progress`);
+            }
+            catch {
+                console.warn(`[slack][issue-pickup] failed to move #${request.issueNumber} to In Progress`);
+            }
+        }
+        console.log(`[slack][issue-pickup] spawning run for #${request.issueNumber}`);
+        await this._spawnNightWatchJob('run', targetProject, channel, threadTs, persona, {
+            issueNumber: request.issueNumber,
+        });
+        return true;
+    }
     _resolveProactiveChannelForProject(project) {
         const slack = this._config.slack;
         if (!slack)
             return null;
         return project.slackChannelId || slack.channels.eng || null;
     }
+    _spawnCodeWatchAudit(project, channel) {
+        if (!fs.existsSync(project.path)) {
+            console.warn(`[slack][codewatch] audit skipped for ${project.name}: missing project path ${project.path}`);
+            return;
+        }
+        const invocationArgs = buildCurrentCliInvocation(['audit']);
+        if (!invocationArgs) {
+            console.warn(`[slack][codewatch] audit spawn failed for ${project.name}: CLI entry path unavailable`);
+            return;
+        }
+        console.log(`[slack][codewatch] spawning audit for ${project.name} → ${channel} cmd=${formatCommandForLog(process.execPath, invocationArgs)}`);
+        const startedAt = Date.now();
+        const child = spawn(process.execPath, invocationArgs, {
+            cwd: project.path,
+            env: { ...process.env, NW_EXECUTION_CONTEXT: 'agent' },
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        console.log(`[slack][codewatch] audit spawned for ${project.name} pid=${child.pid ?? 'unknown'}`);
+        let output = '';
+        const appendOutput = (chunk) => {
+            output += chunk.toString();
+            if (output.length > MAX_JOB_OUTPUT_CHARS) {
+                output = output.slice(-MAX_JOB_OUTPUT_CHARS);
+            }
+        };
+        child.stdout?.on('data', appendOutput);
+        child.stderr?.on('data', appendOutput);
+        let spawnErrored = false;
+        child.on('error', (err) => {
+            spawnErrored = true;
+            console.warn(`[slack][codewatch] audit spawn error for ${project.name}: ${err.message}`);
+        });
+        child.on('close', async (code) => {
+            console.log(`[slack][codewatch] audit finished for ${project.name} exit=${code ?? 'unknown'}`);
+            if (spawnErrored) {
+                return;
+            }
+            if (code !== 0) {
+                const detail = extractLastMeaningfulLines(output);
+                if (detail) {
+                    console.warn(`[slack][codewatch] audit failure detail for ${project.name}: ${detail}`);
+                }
+                return;
+            }
+            const reportPath = path.join(project.path, 'logs', 'audit-report.md');
+            let reportStat;
+            let report;
+            try {
+                reportStat = fs.statSync(reportPath);
+                report = fs.readFileSync(reportPath, 'utf-8').trim();
+            }
+            catch {
+                const parsed = parseScriptResult(output);
+                if (parsed?.status?.startsWith('skip_')) {
+                    console.log(`[slack][codewatch] audit skipped for ${project.name} (${parsed.status})`);
+                }
+                else {
+                    console.log(`[slack][codewatch] no audit report found at ${reportPath}`);
+                }
+                return;
+            }
+            // Ignore old reports when an audit exits early without producing a fresh output.
+            if (reportStat.mtimeMs + 1000 < startedAt) {
+                console.log(`[slack][codewatch] stale audit report ignored at ${reportPath}`);
+                return;
+            }
+            if (!report) {
+                console.log(`[slack][codewatch] empty audit report ignored at ${reportPath}`);
+                return;
+            }
+            try {
+                await this._engine.handleAuditReport(report, project.name, project.path, channel);
+                this._markChannelActivity(channel);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                console.warn(`[slack][codewatch] handleAuditReport failed for ${project.name}: ${msg}`);
+            }
+        });
+    }
     async _runProactiveCodeWatch(projects, now) {
         for (const project of projects) {
             const channel = this._resolveProactiveChannelForProject(project);
@@ -966,38 +1174,7 @@ export class SlackInteractionListener {
                 continue;
             }
             this._lastCodeWatchAt.set(project.path, now);
-            const candidate = detectCodeWatchCandidate(project.path);
-            if (!candidate) {
-                continue;
-            }
-            const signatureKey = `${project.path}:${candidate.signature}`;
-            const lastSeen = this._lastCodeWatchSignatureAt.get(signatureKey) ?? 0;
-            if (now - lastSeen < PROACTIVE_CODEWATCH_REPEAT_COOLDOWN_MS) {
-                continue;
-            }
-            const ref = `codewatch-${candidate.signature}`;
-            const context = `Project: ${project.name}\n` +
-                `Signal: ${candidate.summary}\n` +
-                `Location: ${candidate.relativePath}:${candidate.line}\n` +
-                `Snippet: ${candidate.snippet}\n` +
-                `Question: Is this intentional, or should we patch it now?`;
-            console.log(`[slack][codewatch] project=${project.name} location=${candidate.relativePath}:${candidate.line} signal=${candidate.type}`);
-            try {
-                await this._engine.startDiscussion({
-                    type: 'code_watch',
-                    projectPath: project.path,
-                    ref,
-                    context,
-                    channelId: channel,
-                });
-                this._lastCodeWatchSignatureAt.set(signatureKey, now);
-                this._markChannelActivity(channel);
-                return;
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                console.warn(`[slack][codewatch] failed for ${project.name}: ${msg}`);
-            }
+            this._spawnCodeWatchAudit(project, channel);
         }
     }
     _startProactiveLoop() {
@@ -1072,9 +1249,20 @@ export class SlackInteractionListener {
         const personas = repos.agentPersona.getActive();
         const projects = repos.projectRegistry.getAll();
         const projectContext = this._buildProjectContext(channel, projects);
+        // Fetch GitHub issue/PR content from URLs in the message so agents can inspect them.
+        const githubUrls = extractGitHubIssueUrls(text);
+        console.log(`[slack] processing message channel=${channel} thread=${threadTs} urls=${githubUrls.length}`);
+        const githubContext = githubUrls.length > 0 ? await fetchGitHubIssueContext(githubUrls) : '';
+        const fullContext = githubContext ? `${projectContext}\n\nReferenced GitHub content:\n${githubContext}` : projectContext;
+        if (await this._triggerDirectProviderIfRequested(event, channel, threadTs, ts, personas)) {
+            return;
+        }
         if (await this._triggerSlackJobIfRequested(event, channel, threadTs, ts, personas)) {
             return;
         }
+        if (await this._triggerIssuePickupIfRequested(event, channel, threadTs, ts, personas)) {
+            return;
+        }
         // @mention matching: "@maya ..."
         let mentionedPersonas = resolveMentionedPersonas(text, personas);
         // Also try plain-name matching (e.g. "Carlos, are you there?").
@@ -1092,6 +1280,8 @@ export class SlackInteractionListener {
                 .slackDiscussion
                 .getActive('')
                 .find((d) => d.channelId === channel && d.threadTs === threadTs);
+            let lastPosted = '';
+            let lastPersonaId = '';
             for (const persona of mentionedPersonas) {
                 if (this._isPersonaOnCooldown(channel, threadTs, persona.id)) {
                     console.log(`[slack] ${persona.name} is on cooldown — skipping`);
@@ -1102,13 +1292,19 @@ export class SlackInteractionListener {
                     await this._engine.contributeAsAgent(discussion.id, persona);
                 }
                 else {
-                    await this._engine.replyAsAgent(channel, threadTs, text, persona, projectContext);
+                    console.log(`[slack] replying as ${persona.name} in ${channel}`);
+                    lastPosted = await this._engine.replyAsAgent(channel, threadTs, text, persona, fullContext);
+                    lastPersonaId = persona.id;
                 }
                 this._markPersonaReply(channel, threadTs, persona.id);
             }
             if (!discussion && mentionedPersonas[0]) {
                 this._rememberAdHocThreadPersona(channel, threadTs, mentionedPersonas[0].id);
             }
+            // Follow up if the last agent reply mentions other teammates by name.
+            if (lastPosted && lastPersonaId) {
+                await this._followAgentMentions(lastPosted, channel, threadTs, personas, fullContext, lastPersonaId);
+            }
             return;
         }
         console.log(`[slack] no persona match — checking for active discussion in ${channel}:${threadTs}`);
@@ -1132,9 +1328,11 @@ export class SlackInteractionListener {
                 console.log(`[slack] continuing ad-hoc thread with ${rememberedPersona.name}`);
             }
             await this._applyHumanResponseTiming(channel, ts, followUpPersona);
-            await this._engine.replyAsAgent(channel, threadTs, text, followUpPersona, projectContext);
+            console.log(`[slack] replying as ${followUpPersona.name} in ${channel}`);
+            const postedText = await this._engine.replyAsAgent(channel, threadTs, text, followUpPersona, fullContext);
             this._markPersonaReply(channel, threadTs, followUpPersona.id);
             this._rememberAdHocThreadPersona(channel, threadTs, followUpPersona.id);
+            await this._followAgentMentions(postedText, channel, threadTs, personas, fullContext, followUpPersona.id);
             return;
         }
         // In-memory state was lost (e.g. server restart) — recover persona from thread history.
@@ -1144,25 +1342,44 @@ export class SlackInteractionListener {
                 const followUpPersona = selectFollowUpPersona(recoveredPersona, personas, text);
                 console.log(`[slack] recovered ad-hoc thread persona ${recoveredPersona.name} from history, replying as ${followUpPersona.name}`);
                 await this._applyHumanResponseTiming(channel, ts, followUpPersona);
-                await this._engine.replyAsAgent(channel, threadTs, text, followUpPersona, projectContext);
+                console.log(`[slack] replying as ${followUpPersona.name} in ${channel}`);
+                const postedText = await this._engine.replyAsAgent(channel, threadTs, text, followUpPersona, fullContext);
                 this._markPersonaReply(channel, threadTs, followUpPersona.id);
                 this._rememberAdHocThreadPersona(channel, threadTs, followUpPersona.id);
+                await this._followAgentMentions(postedText, channel, threadTs, personas, fullContext, followUpPersona.id);
                 return;
             }
         }
-        // Keep the channel alive: direct mentions and ambient greetings get a random responder.
-        const shouldAutoEngage = event.type === 'app_mention' || isAmbientTeamMessage(text);
-        if (shouldAutoEngage) {
+        // Direct bot mentions always get a reply.
+        if (event.type === 'app_mention') {
             const randomPersona = this._pickRandomPersona(personas, channel, threadTs);
             if (randomPersona) {
-                console.log(`[slack] auto-engaging via ${randomPersona.name}`);
+                console.log(`[slack] app_mention auto-engaging via ${randomPersona.name}`);
                 await this._applyHumanResponseTiming(channel, ts, randomPersona);
-                await this._engine.replyAsAgent(channel, threadTs, text, randomPersona, projectContext);
+                const postedText = await this._engine.replyAsAgent(channel, threadTs, text, randomPersona, fullContext);
                 this._markPersonaReply(channel, threadTs, randomPersona.id);
                 this._rememberAdHocThreadPersona(channel, threadTs, randomPersona.id);
+                await this._followAgentMentions(postedText, channel, threadTs, personas, fullContext, randomPersona.id);
                 return;
             }
         }
+        // Any human message: agents independently decide whether to react.
+        for (const persona of personas) {
+            if (!this._isPersonaOnCooldown(channel, threadTs, persona.id) && Math.random() < RANDOM_REACTION_PROBABILITY) {
+                void this._maybeReactToHumanMessage(channel, ts, persona);
+            }
+        }
+        // Guaranteed fallback reply — someone always responds.
+        const randomPersona = this._pickRandomPersona(personas, channel, threadTs);
+        if (randomPersona) {
+            console.log(`[slack] fallback engage via ${randomPersona.name}`);
+            await this._applyHumanResponseTiming(channel, ts, randomPersona);
+            const postedText = await this._engine.replyAsAgent(channel, threadTs, text, randomPersona, fullContext);
+            this._markPersonaReply(channel, threadTs, randomPersona.id);
+            this._rememberAdHocThreadPersona(channel, threadTs, randomPersona.id);
+            await this._followAgentMentions(postedText, channel, threadTs, personas, fullContext, randomPersona.id);
+            return;
+        }
         console.log(`[slack] no active discussion found — ignoring message`);
     }
 }