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

package/dist/src/slack/deliberation.js

@@ -5,10 +5,13 @@
  */
 import { compileSoul } from "../agents/soul-compiler.js";
 import { getRepositories } from "../storage/repositories/index.js";
+import { createBoardProvider } from "../board/factory.js";
 const MAX_ROUNDS = 3;
-const MESSAGE_DELAY_MS = 1500; // Rate limit: 1.5s between posts
+const HUMAN_DELAY_MIN_MS = 20_000; // Minimum pause between agent replies (20s)
+const HUMAN_DELAY_MAX_MS = 60_000; // Maximum pause between agent replies (60s)
 const DISCUSSION_RESUME_DELAY_MS = 60_000;
 const DISCUSSION_REPLAY_GUARD_MS = 30 * 60_000;
+const MAX_HUMANIZED_SENTENCES = 2;
 const inFlightDiscussionStarts = new Map();
 function discussionStartKey(trigger) {
     return `${trigger.projectPath}:${trigger.type}:${trigger.ref}`;
@@ -19,6 +22,13 @@ function discussionStartKey(trigger) {
 function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
+/**
+ * Return a random delay in the human-like range so replies don't arrive
+ * in an obviously robotic cadence.
+ */
+function humanDelay() {
+    return HUMAN_DELAY_MIN_MS + Math.random() * (HUMAN_DELAY_MAX_MS - HUMAN_DELAY_MIN_MS);
+}
 /**
  * Determine which Slack channel to use for a trigger type
  */
@@ -36,6 +46,8 @@ function getChannelForTrigger(trigger, config) {
             return slack.channels.incidents;
         case 'prd_kickoff':
             return slack.channels.eng; // Callers should populate trigger.channelId with proj channel
+        case 'code_watch':
+            return slack.channels.eng;
         default:
             return slack.channels.eng;
     }
@@ -87,6 +99,12 @@ function getParticipatingPersonas(triggerType, personas) {
             add(dev);
             add(carlos);
             break;
+        case 'code_watch':
+            add(dev);
+            add(carlos);
+            add(maya);
+            add(priya);
+            break;
         default:
             add(carlos);
             break;
@@ -145,42 +163,71 @@ function resolvePersonaAIConfig(persona, config) {
 function buildOpeningMessage(trigger) {
     switch (trigger.type) {
         case 'pr_review':
-            return `Just opened a PR — ${trigger.ref}${trigger.prUrl ? ` ${trigger.prUrl}` : ''}. Ready for review. 🔨`;
+            return `Opened ${trigger.ref}${trigger.prUrl ? ` — ${trigger.prUrl}` : ''}. Ready for eyes.`;
         case 'build_failure':
-            return `Build failure on ${trigger.ref}. Looking into it now 🔍\n\n${trigger.context.slice(0, 500)}`;
+            return `Build broke on ${trigger.ref}. Looking into it.\n\n${trigger.context.slice(0, 500)}`;
         case 'prd_kickoff':
-            return `Picking up PRD: ${trigger.ref}. Starting implementation. 🚀`;
+            return `Picking up ${trigger.ref}. Going to start carving out the implementation.`;
+        case 'code_watch': {
+            const CODE_WATCH_OPENERS = [
+                'Something caught my eye during a scan — want to get a second opinion on this.',
+                'Quick flag from the latest code scan. Might be nothing, might be worth patching.',
+                'Scanner flagged this one. Thought it was worth surfacing before it bites us.',
+                'Flagging something from the codebase — could be intentional, but it pinged the scanner.',
+                'Spotted this during a scan. Curious if it\'s expected or something we should fix.',
+            ];
+            const hash = trigger.ref.split('').reduce((acc, c) => acc + c.charCodeAt(0), 0);
+            const opener = CODE_WATCH_OPENERS[hash % CODE_WATCH_OPENERS.length];
+            return `${opener}\n\n${trigger.context.slice(0, 600)}`;
+        }
         default:
             return trigger.context.slice(0, 500);
     }
 }
+/**
+ * Parse the structured code_watch context string and derive a git-style issue title.
+ */
+function buildIssueTitleFromTrigger(trigger) {
+    const signalMatch = trigger.context.match(/^Signal: (.+)$/m);
+    const locationMatch = trigger.context.match(/^Location: (.+)$/m);
+    const signal = signalMatch?.[1] ?? 'code signal';
+    const location = locationMatch?.[1] ?? 'unknown location';
+    return `fix: ${signal} at ${location}`;
+}
 /**
  * Build the contribution prompt for an agent's AI call.
  * This is what gets sent to the AI provider to generate the agent's message.
  */
 function buildContributionPrompt(persona, trigger, threadHistory, round) {
-    return `You are ${persona.name}, ${persona.role}, participating in a Slack thread with your team.
+    const isFirstRound = round === 1;
+    const isFinalRound = round >= MAX_ROUNDS;
+    return `You are ${persona.name}, ${persona.role}.
+You're in a Slack thread with your teammates — Dev (implementer), Carlos (tech lead), Maya (security), and Priya (QA). This is a real conversation, not a report.
 
-## Thread Context
 Trigger: ${trigger.type} — ${trigger.ref}
-Round: ${round} of ${MAX_ROUNDS}
+Round: ${round}/${MAX_ROUNDS}${isFinalRound ? ' (final round — wrap up)' : ''}
 
 ## Context
 ${trigger.context.slice(0, 2000)}
 
 ## Thread So Far
-${threadHistory || '(No messages yet)'}
+${threadHistory || '(Thread just started)'}
 
-## Your Task
-Review the above from your specific expertise angle. Post a SHORT Slack message (2-3 sentences max).
-- This is Slack chat, not a document. Be concise.
-- Speak only to your domain — don't repeat what others said.
-- Use your natural emoji style.
-- If everything looks fine from your angle, just say so briefly.
-- If you have a concern, state it clearly with a specific fix suggestion.
-- If you have no concerns and others seem satisfied, you can just react positively.
+## How to respond
+Write a short Slack message — 1 to 2 sentences. This is chat, not documentation.
+${isFirstRound ? '- First round: give your initial take from your angle. Be specific.' : '- Follow-up round: respond to what others said. Agree, push back, or add something new.'}
+- Talk like a teammate, not an assistant. No pleasantries, no filler.
+- Stay in your lane — only comment on your domain unless something crosses into it.
+- You can name-drop teammates when handing off ("Maya should look at the auth here").
+- If nothing concerns you, a brief "nothing from me" or a short acknowledgment is fine.
+- If you have a concern, name it specifically and suggest a direction.
+- No markdown formatting. No bullet lists. No headings. Just a message.
+- Emojis: use one only if it genuinely fits. Default to none.
+- Never start with "Great question", "Of course", "I hope this helps", or similar.
+- Never say "as an AI" or break character.
+${isFinalRound ? '- Final round: be decisive. State your position clearly.' : ''}
 
-Write ONLY your message, nothing else. Do not include your name or any prefix.`;
+Write ONLY your message. No name prefix, no labels.`;
 }
 /**
  * Call the AI provider to generate an agent contribution.
@@ -240,14 +287,106 @@ async function callAIForContribution(persona, config, contributionPrompt) {
     }
     return `[${persona.name}: No AI provider configured]`;
 }
+const CANNED_PHRASE_PREFIXES = [
+    /^great question[,.! ]*/i,
+    /^of course[,.! ]*/i,
+    /^certainly[,.! ]*/i,
+    /^you['’]re absolutely right[,.! ]*/i,
+    /^i hope this helps[,.! ]*/i,
+];
+function limitEmojiCount(text, maxEmojis) {
+    let seen = 0;
+    return text.replace(/[\p{Extended_Pictographic}]/gu, (m) => {
+        seen += 1;
+        return seen <= maxEmojis ? m : '';
+    });
+}
+function isFacialEmoji(char) {
+    return /[\u{1F600}-\u{1F64F}\u{1F910}-\u{1F92F}\u{1F970}-\u{1F97A}]/u.test(char);
+}
+function applyEmojiPolicy(text, allowEmoji, allowNonFacialEmoji) {
+    if (!allowEmoji) {
+        return text.replace(/[\p{Extended_Pictographic}]/gu, '');
+    }
+    const emojis = Array.from(text.matchAll(/[\p{Extended_Pictographic}]/gu)).map((m) => m[0]);
+    if (emojis.length === 0)
+        return text;
+    const chosenFacial = emojis.find((e) => isFacialEmoji(e));
+    const chosen = chosenFacial ?? (allowNonFacialEmoji ? emojis[0] : null);
+    if (!chosen) {
+        return text.replace(/[\p{Extended_Pictographic}]/gu, '');
+    }
+    let kept = false;
+    return text.replace(/[\p{Extended_Pictographic}]/gu, (e) => {
+        if (!kept && e === chosen) {
+            kept = true;
+            return e;
+        }
+        return '';
+    });
+}
+function trimToSentences(text, maxSentences) {
+    const parts = text
+        .split(/(?<=[.!?])\s+/)
+        .map((s) => s.trim())
+        .filter(Boolean);
+    if (parts.length <= maxSentences)
+        return text.trim();
+    return parts.slice(0, maxSentences).join(' ').trim();
+}
+export function humanizeSlackReply(raw, options = {}) {
+    const { allowEmoji = true, allowNonFacialEmoji = true, maxSentences = MAX_HUMANIZED_SENTENCES, } = options;
+    let text = raw.trim();
+    if (!text)
+        return text;
+    // Remove markdown formatting artifacts that look templated in chat.
+    text = text
+        .replace(/^#{1,6}\s+/gm, '')
+        .replace(/^\s*[-*]\s+/gm, '')
+        .replace(/\*\*(.*?)\*\*/g, '$1')
+        .replace(/\s+/g, ' ')
+        .trim();
+    // Strip common assistant-y openers.
+    for (const pattern of CANNED_PHRASE_PREFIXES) {
+        text = text.replace(pattern, '').trim();
+    }
+    text = applyEmojiPolicy(text, allowEmoji, allowNonFacialEmoji);
+    text = limitEmojiCount(text, 1);
+    text = trimToSentences(text, maxSentences);
+    if (text.length > 260) {
+        text = `${text.slice(0, 257).trimEnd()}...`;
+    }
+    return text;
+}
+function buildCurrentCliInvocation(args) {
+    const cliEntry = process.argv[1];
+    if (!cliEntry)
+        return null;
+    return [...process.execArgv, cliEntry, ...args];
+}
+function formatCommandForLog(bin, args) {
+    return [bin, ...args].map((part) => JSON.stringify(part)).join(' ');
+}
 export class DeliberationEngine {
     _slackClient;
     _config;
     _humanResumeTimers = new Map();
+    _emojiCadenceCounter = new Map();
     constructor(slackClient, config) {
         this._slackClient = slackClient;
         this._config = config;
     }
+    _humanizeForPost(channel, threadTs, persona, raw) {
+        const key = `${channel}:${threadTs}:${persona.id}`;
+        const count = (this._emojiCadenceCounter.get(key) ?? 0) + 1;
+        this._emojiCadenceCounter.set(key, count);
+        // Human cadence:
+        // - emoji roughly every 3rd message by same persona in same thread
+        // - non-facial emoji much rarer (roughly every 9th message)
+        const allowEmoji = count % 3 === 0;
+        const allowNonFacialEmoji = count % 9 === 0;
+        return humanizeSlackReply(raw, { allowEmoji, allowNonFacialEmoji, maxSentences: 2 });
+    }
     /**
      * Start a new discussion thread for a trigger event.
      * Posts the opening message and kicks off the first round of contributions.
@@ -305,7 +444,7 @@ export class DeliberationEngine {
         // Post opening message to start the thread
         const openingText = buildOpeningMessage(trigger);
         const openingMsg = await this._slackClient.postAsAgent(channel, openingText, devPersona);
-        await sleep(MESSAGE_DELAY_MS);
+        await sleep(humanDelay());
         // Create discussion record
         const discussion = repos.slackDiscussion.create({
             projectPath: trigger.projectPath,
@@ -352,9 +491,10 @@ export class DeliberationEngine {
             message = `[Contribution from ${persona.name} unavailable — AI provider not configured]`;
         }
         if (message) {
-            await this._slackClient.postAsAgent(discussion.channelId, message, persona, discussion.threadTs);
+            const finalMessage = this._humanizeForPost(discussion.channelId, discussion.threadTs, persona, message);
+            await this._slackClient.postAsAgent(discussion.channelId, finalMessage, persona, discussion.threadTs);
             repos.slackDiscussion.addParticipant(discussionId, persona.id);
-            await sleep(MESSAGE_DELAY_MS);
+            await sleep(humanDelay());
         }
     }
     /**
@@ -383,8 +523,8 @@ export class DeliberationEngine {
                 const updated = innerRepos.slackDiscussion.getById(discussion.id);
                 if (!updated || updated.status !== 'active')
                     return;
-                await this._slackClient.postAsAgent(channel, "Picking back up — let me summarize where we are and continue. 🏗️", carlos, threadTs);
-                await sleep(MESSAGE_DELAY_MS);
+                await this._slackClient.postAsAgent(channel, "Ok, picking this back up. Let me see where we landed.", carlos, threadTs);
+                await sleep(humanDelay());
                 await this._evaluateConsensus(discussion.id, {
                     type: discussion.triggerType,
                     projectPath: discussion.projectPath,
@@ -421,10 +561,11 @@ export class DeliberationEngine {
                 message = '';
             }
             if (message) {
-                await this._slackClient.postAsAgent(discussion.channelId, message, persona, discussion.threadTs);
+                const finalMessage = this._humanizeForPost(discussion.channelId, discussion.threadTs, persona, message);
+                await this._slackClient.postAsAgent(discussion.channelId, finalMessage, persona, discussion.threadTs);
                 repos.slackDiscussion.addParticipant(discussionId, persona.id);
-                historyText = historyText ? `${historyText}\n---\n${message}` : message;
-                await sleep(MESSAGE_DELAY_MS);
+                historyText = historyText ? `${historyText}\n---\n${finalMessage}` : finalMessage;
+                await sleep(humanDelay());
             }
         }
     }
@@ -449,19 +590,21 @@ export class DeliberationEngine {
             // Get thread history and let Carlos evaluate
             const history = await this._slackClient.getChannelHistory(discussion.channelId, discussion.threadTs, 20);
             const historyText = history.map(m => m.text).join('\n---\n');
-            const consensusPrompt = `You are ${carlos.name}, ${carlos.role}.
-
-Review this discussion thread and decide: are we ready to ship, do we need another round of review, or do we need a human?
+            const consensusPrompt = `You are ${carlos.name}, ${carlos.role}. You're wrapping up a team discussion.
 
 Thread:
 ${historyText}
 
-Round: ${discussion.round} of ${MAX_ROUNDS}
+Round: ${discussion.round}/${MAX_ROUNDS}
+
+Make the call. Are we done, do we need another pass, or does a human need to weigh in?
+
+Respond with EXACTLY one of these formats (include the prefix):
+- APPROVE: [short closing message in your voice — e.g., "Clean. Let's ship it."]
+- CHANGES: [what specifically still needs work — be concrete, not vague]
+- HUMAN: [why this needs a human decision — be specific about what's ambiguous]
 
-Respond with ONLY one of:
-- APPROVE: [your short closing message, e.g., "LGTM 👍 Ship it 🚀"]
-- CHANGES: [summary of what still needs to change — be specific]
-- HUMAN: [why you need a human decision]`;
+Write the prefix and your message. Nothing else.`;
             let decision;
             try {
                 decision = await callAIForContribution(carlos, this._config, consensusPrompt);
@@ -470,15 +613,19 @@ Respond with ONLY one of:
                 decision = 'HUMAN: AI evaluation failed — needs manual review';
             }
             if (decision.startsWith('APPROVE')) {
-                const message = decision.replace(/^APPROVE:\s*/, '').trim() || 'Ship it 🚀';
+                const message = decision.replace(/^APPROVE:\s*/, '').trim() || 'Clean. Ship it.';
                 await this._slackClient.postAsAgent(discussion.channelId, message, carlos, discussion.threadTs);
                 repos.slackDiscussion.updateStatus(discussionId, 'consensus', 'approved');
+                if (trigger.type === 'code_watch') {
+                    await this.triggerIssueOpener(discussionId, trigger)
+                        .catch((e) => console.warn('Issue opener failed:', String(e)));
+                }
                 return;
             }
             if (decision.startsWith('CHANGES') && discussion.round < MAX_ROUNDS) {
                 const changes = decision.replace(/^CHANGES:\s*/, '').trim();
-                await this._slackClient.postAsAgent(discussion.channelId, `One more pass needed:\n${changes}`, carlos, discussion.threadTs);
-                await sleep(MESSAGE_DELAY_MS);
+                await this._slackClient.postAsAgent(discussion.channelId, changes, carlos, discussion.threadTs);
+                await sleep(humanDelay());
                 // Increment round and start another contribution round, then loop back.
                 const nextRound = discussion.round + 1;
                 repos.slackDiscussion.updateRound(discussionId, nextRound);
@@ -491,7 +638,7 @@ Respond with ONLY one of:
             if (decision.startsWith('CHANGES') && discussion.round >= MAX_ROUNDS) {
                 // Max rounds reached — set changes_requested and optionally trigger PR refinement
                 const changesSummary = decision.replace(/^CHANGES:\s*/, '').trim();
-                await this._slackClient.postAsAgent(discussion.channelId, "3 rounds in — shipping what we have. Ship it 🚀", carlos, discussion.threadTs);
+                await this._slackClient.postAsAgent(discussion.channelId, `We've been at this for ${MAX_ROUNDS} rounds. Sending it through with the remaining notes — Dev can address them in the next pass.`, carlos, discussion.threadTs);
                 repos.slackDiscussion.updateStatus(discussionId, 'consensus', 'changes_requested');
                 if (discussion.triggerType === 'pr_review') {
                     await this.triggerPRRefinement(discussionId, changesSummary, discussion.triggerRef).catch(e => console.warn('PR refinement trigger failed:', e));
@@ -499,7 +646,10 @@ Respond with ONLY one of:
                 return;
             }
             // HUMAN or fallback
-            await this._slackClient.postAsAgent(discussion.channelId, "This one needs a human call. Flagging for review. 🚩", carlos, discussion.threadTs);
+            const humanReason = decision.replace(/^HUMAN:\s*/, '').trim();
+            await this._slackClient.postAsAgent(discussion.channelId, humanReason
+                ? `Need a human on this one — ${humanReason}`
+                : 'This needs a human call. Flagging it.', carlos, discussion.threadTs);
             repos.slackDiscussion.updateStatus(discussionId, 'blocked', 'human_needed');
             return;
         }
@@ -515,31 +665,36 @@ Respond with ONLY one of:
             return;
         const personas = repos.agentPersona.getActive();
         const carlos = findCarlos(personas) ?? personas[0];
-        const dev = findDev(personas) ?? personas[0];
+        const actor = carlos?.name ?? 'Night Watch';
         if (carlos) {
-            await this._slackClient.postAsAgent(discussion.channelId, `Sending feedback to the reviewer agent. Changes needed:\n${changesSummary}`, carlos, discussion.threadTs);
-            await sleep(MESSAGE_DELAY_MS);
+            await this._slackClient.postAsAgent(discussion.channelId, `Sending PR #${prNumber} back through with the notes.`, carlos, discussion.threadTs);
+            await sleep(humanDelay());
         }
         // Set NW_SLACK_FEEDBACK and trigger reviewer
         const feedback = JSON.stringify({ discussionId, prNumber, changes: changesSummary });
+        const invocationArgs = buildCurrentCliInvocation(['review']);
+        if (!invocationArgs) {
+            console.warn(`[slack][job] triggerPRRefinement reviewer spawn failed via ${actor} pr=${prNumber}: CLI entry path unavailable`);
+            if (carlos) {
+                await this._slackClient.postAsAgent(discussion.channelId, `Can't start the reviewer right now — runtime issue. Will retry.`, carlos, discussion.threadTs);
+            }
+            return;
+        }
+        console.log(`[slack][job] triggerPRRefinement reviewer spawn via ${actor} pr=${prNumber} cmd=${formatCommandForLog(process.execPath, invocationArgs)}`);
         // Spawn the reviewer as a detached process
         const { spawn } = await import('child_process');
-        const reviewer = spawn(process.execPath, [process.argv[1], 'review', '--pr', prNumber], {
+        const reviewer = spawn(process.execPath, invocationArgs, {
             detached: true,
             stdio: 'ignore',
-            env: { ...process.env, NW_SLACK_FEEDBACK: feedback },
+            env: { ...process.env, NW_SLACK_FEEDBACK: feedback, NW_TARGET_PR: prNumber },
         });
         reviewer.unref();
-        // Post update
-        if (dev) {
-            await this._slackClient.postAsAgent(discussion.channelId, `Reviewer agent kicked off for PR #${prNumber} 🔨 Will post back when done.`, dev, discussion.threadTs);
-        }
     }
     /**
      * Reply as a persona in any Slack thread — no formal discussion required.
      * Used when someone @mentions a persona outside of a Night Watch discussion.
      */
-    async replyAsAgent(channel, threadTs, incomingText, persona) {
+    async replyAsAgent(channel, threadTs, incomingText, persona, projectContext) {
         let history = [];
         try {
             history = await this._slackClient.getChannelHistory(channel, threadTs, 10);
@@ -549,10 +704,18 @@ Respond with ONLY one of:
         }
         const historyText = history.map((m) => m.text).join('\n---\n');
         const prompt = `You are ${persona.name}, ${persona.role}.\n` +
-            (persona.soul?.whoIAm ? `About you: ${persona.soul.whoIAm}\n\n` : '') +
-            (historyText ? `Thread context:\n${historyText}\n\n` : '') +
-            `Someone just said: "${incomingText}"\n\n` +
-            `Reply concisely in your own voice. Keep it under 3 sentences unless detail is clearly needed.`;
+            `Your teammates: Dev (implementer), Carlos (tech lead), Maya (security), Priya (QA).\n\n` +
+            (projectContext ? `Project context: ${projectContext}\n\n` : '') +
+            (historyText ? `Thread so far:\n${historyText}\n\n` : '') +
+            `Latest message: "${incomingText}"\n\n` +
+            `Respond in your own voice. This is Slack — keep it to 1-2 sentences.\n` +
+            `- Talk like a colleague, not a bot. No "Great question", "Of course", or "I hope this helps".\n` +
+            `- You can tag teammates by name if someone else should weigh in.\n` +
+            `- No markdown formatting, headings, or bullet lists.\n` +
+            `- Emojis: one max, only if it fits naturally. Default to none.\n` +
+            `- If the question is outside your domain, say so briefly and point to the right person.\n` +
+            `- If you disagree, say why in one line. If you agree, keep it short.\n\n` +
+            `Write only your reply. No name prefix.`;
         let message;
         try {
             message = await callAIForContribution(persona, this._config, prompt);
@@ -561,7 +724,116 @@ Respond with ONLY one of:
             message = `[Reply from ${persona.name} unavailable — AI provider not configured]`;
         }
         if (message) {
-            await this._slackClient.postAsAgent(channel, message, persona, threadTs);
+            await this._slackClient.postAsAgent(channel, this._humanizeForPost(channel, threadTs, persona, message), persona, threadTs);
+        }
+    }
+    /**
+     * Generate and post a proactive message from a persona.
+     * Used by the interaction listener when a channel has been idle.
+     * The persona shares an observation, question, or suggestion based on
+     * project context and roadmap state — in their own voice.
+     */
+    async postProactiveMessage(channel, persona, projectContext, roadmapContext) {
+        const prompt = `You are ${persona.name}, ${persona.role}.\n` +
+            `Your teammates: Dev (implementer), Carlos (tech lead), Maya (security), Priya (QA).\n\n` +
+            `You're posting an unprompted message in the team's Slack channel. ` +
+            `The channel has been quiet — you want to share something useful, not just fill silence.\n\n` +
+            (projectContext ? `Project context: ${projectContext}\n\n` : '') +
+            (roadmapContext ? `Roadmap/PRD status:\n${roadmapContext}\n\n` : '') +
+            `Write a SHORT proactive message (1-2 sentences) that does ONE of these:\n` +
+            `- Question a roadmap priority or ask if something should be reordered\n` +
+            `- Flag something you've been thinking about from your domain (security concern, test gap, architectural question, implementation idea)\n` +
+            `- Suggest an improvement or raise a "have we thought about..." question\n` +
+            `- Share a concrete observation about the current state of the project\n` +
+            `- Offer to kick off a task: "I can run a review on X if nobody's on it"\n\n` +
+            `Rules:\n` +
+            `- Stay in your lane. Only bring up things relevant to your expertise.\n` +
+            `- Be specific — name the feature, file, or concern. No vague "we should think about things."\n` +
+            `- Sound like a teammate dropping a thought in chat, not making an announcement.\n` +
+            `- No markdown, headings, bullets. Just a message.\n` +
+            `- No "Great question", "Just checking in", or "Hope everyone is doing well."\n` +
+            `- Emojis: one max, only if natural. Default to none.\n` +
+            `- If you genuinely have nothing useful to say, write exactly: SKIP\n\n` +
+            `Write only your message. No name prefix.`;
+        let message;
+        try {
+            message = await callAIForContribution(persona, this._config, prompt);
+        }
+        catch {
+            return; // Silently skip — proactive messages are optional
+        }
+        if (!message || message.trim().toUpperCase() === 'SKIP') {
+            return;
+        }
+        const dummyTs = `${Date.now()}`;
+        const finalMessage = this._humanizeForPost(channel, dummyTs, persona, message);
+        if (finalMessage) {
+            await this._slackClient.postAsAgent(channel, finalMessage, persona);
+        }
+    }
+    /**
+     * Generate a structured GitHub issue body written by the Dev persona.
+     */
+    async _generateIssueBody(trigger, devPersona) {
+        const prompt = `You are ${devPersona.name}, ${devPersona.role}.
+Write a concise GitHub issue body for the following code scan finding.
+Use this structure exactly (GitHub Markdown):
+
+## Problem
+One sentence describing what was detected and why it's risky.
+
+## Location
+File and line where the issue exists.
+
+## Code
+\`\`\`
+The offending snippet
+\`\`\`
+
+## Suggested Fix
+2-3 bullet points on how to address it.
+
+## Acceptance Criteria
+- [ ] Checkbox items describing what "done" looks like
+
+Keep it tight — this is a bug report, not a spec. No fluff, no greetings.
+
+Context:
+${trigger.context}`;
+        const raw = await callAIForContribution(devPersona, this._config, prompt);
+        return raw.trim();
+    }
+    /**
+     * Open a GitHub issue from a code_watch finding and post back to the thread.
+     * Called automatically after an approved code_watch consensus.
+     */
+    async triggerIssueOpener(discussionId, trigger) {
+        const repos = getRepositories();
+        const discussion = repos.slackDiscussion.getById(discussionId);
+        if (!discussion)
+            return;
+        const devPersona = findDev(repos.agentPersona.getActive());
+        if (!devPersona)
+            return;
+        // Acknowledge before doing async work
+        await this._slackClient.postAsAgent(discussion.channelId, 'Agreed. Writing up an issue for this.', devPersona, discussion.threadTs);
+        const title = buildIssueTitleFromTrigger(trigger);
+        const body = await this._generateIssueBody(trigger, devPersona);
+        const boardConfig = this._config.boardProvider;
+        if (boardConfig?.enabled) {
+            try {
+                const provider = createBoardProvider(boardConfig, trigger.projectPath);
+                const issue = await provider.createIssue({ title, body, column: 'Ready' });
+                await this._slackClient.postAsAgent(discussion.channelId, `Opened #${issue.number}: *${issue.title}* — ${issue.url}\n\nAnyone want to pick this up, or should I take a pass at it?`, devPersona, discussion.threadTs);
+            }
+            catch (err) {
+                console.warn('[issue_opener] board createIssue failed:', err);
+                await this._slackClient.postAsAgent(discussion.channelId, `Couldn't open the issue automatically — board might not be configured. Here's the writeup:\n\n${body.slice(0, 600)}`, devPersona, discussion.threadTs);
+            }
+        }
+        else {
+            // No board configured — post the writeup in thread so it's not lost
+            await this._slackClient.postAsAgent(discussion.channelId, `No board configured, dropping the writeup here:\n\n${body.slice(0, 600)}`, devPersona, discussion.threadTs);
         }
     }
 }