@urateam/core 0.1.31 → 0.1.33

package/dist/pm/slack-interface.js

@@ -7,19 +7,37 @@
  *
  * Outbound helpers (call from PM scheduler):
  *   notifyAssigned, notifySkipped, askForClarification, postDailySummary
+ *
+ * This file retains: types, request parsing, Slack signature verification, the
+ * notifier class, and the Hono router factory.  Command execution logic was
+ * extracted to `slack-commands.ts` (BEC-195) and bulk-create analysis to
+ * `slack-bulk.ts` (BEC-195).  Both are re-exported here for backward
+ * compatibility so existing import sites do not need to change.
  */
 import { Hono } from "hono";
 import { createLogger } from "../logger.js";
 import { sanitize } from "../executor/prompt/sanitizer.js";
 import { parseJsonObject } from "../executor/agent-stream.js";
 import { makeCallClaude, makeCallClaudeSonnet } from "./call-claude.js";
-import { postSlackMessage } from "./slack-helpers.js";
-import { createLazyLinearClient } from "./linear-helpers.js";
+import { postSlackMessage, reactToSlackMessage } from "./slack-helpers.js";
+import { executePmCommand } from "./slack-commands.js";
 const log = createLogger({ component: "PmAgent:slack-interface" });
 // ---------------------------------------------------------------------------
+// Re-exports for backward compatibility
+// ---------------------------------------------------------------------------
+// Consumers that previously imported directly from slack-interface.ts continue
+// to work without changing their import statements.
+export { isPmPaused, setPmPaused } from "./pause-state.js";
+export { analyzeBulkCreateRequest } from "./slack-bulk.js";
+export { executePmCommand } from "./slack-commands.js";
+// ---------------------------------------------------------------------------
 // Module-level constants
 // ---------------------------------------------------------------------------
-/** Valid PM command type names — kept in sync with the PmCommand union type. */
+/**
+ * Regex that matches Slack user-mention tokens like `<@U01ABC>`.
+ * Used to strip @-mentions from incoming Events API messages before NL processing.
+ */
+const SLACK_MENTION_RE = /<@[A-Z0-9]+>/g;
 const VALID_PM_COMMAND_TYPES = [
     "prioritize",
     "create",
@@ -28,18 +46,17 @@ const VALID_PM_COMMAND_TYPES = [
     "pause",
     "resume",
     "assign",
+    "cancel",
+    "stop",
+    "halt",
     "unknown",
 ];
-/** Linear workflow state name for the Triage column. */
-const LINEAR_STATE_TRIAGE = "Triage";
-/** Linear workflow state name for the Todo column. */
-const LINEAR_STATE_TODO = "Todo";
-/** Linear label name that triggers the auto-implement pipeline. */
-const LINEAR_LABEL_AUTO_IMPLEMENT = "auto-implement";
-/** Valid numeric priority values accepted by Linear (1=Urgent … 4=Low). */
-const VALID_PRIORITIES = [1, 2, 3, 4];
-/** Default priority used when a generated issue omits or has an invalid value. */
-const DEFAULT_PRIORITY = 3;
+// Compile-time exhaustiveness guard: TypeScript reports an error on the next line
+// when a new `PmCommand` variant is added to `slack-commands.ts` without also
+// adding it to `VALID_PM_COMMAND_TYPES` above.  The conditional type resolves to
+// `true` when the array is complete and `false` otherwise; assigning `true` to a
+// `false`-typed slot triggers "Type 'boolean' is not assignable to type 'false'".
+const _cmdExhaustiveCheck = true;
 /** Lazy singleton for the `crypto` built-in — avoids repeated dynamic import on every Slack request. */
 let _cryptoModule = null;
 async function getCrypto() {
@@ -55,28 +72,6 @@ async function getCrypto() {
     return _cryptoModule;
 }
 // ---------------------------------------------------------------------------
-// Shared pause state — single-process only; use Redis for multi-process
-// ---------------------------------------------------------------------------
-let paused = false;
-/**
- * Returns `true` if the PM Agent is currently paused.
- *
- * Pause is active when EITHER of the following is true (OR logic):
- * - `process.env.PM_AGENT_PAUSED === "true"` — env-var path for no-Slack incident
- *   response. Toggling requires a container restart (env vars are read at each
- *   tick invocation, not at module load time).
- * - `setPmPaused(true)` has been called via the Slack `/pm pause` command.
- *
- * The env-var takes priority: setting `PM_AGENT_PAUSED=true` keeps the agent
- * paused even if `setPmPaused(false)` is subsequently called via Slack.
- */
-export function isPmPaused() {
-    return process.env.PM_AGENT_PAUSED === "true" || paused;
-}
-export function setPmPaused(value) {
-    paused = value;
-}
-// ---------------------------------------------------------------------------
 // Slack request verification
 // ---------------------------------------------------------------------------
 /**
@@ -165,6 +160,17 @@ export function parsePmCommand(text) {
         return { type: "pause" };
     if (/^resume$/i.test(trimmed))
         return { type: "resume" };
+    if (/^halt$/i.test(trimmed))
+        return { type: "halt" };
+    // `cancel <runId>` and `stop <runId>` — runId is a nanoid (URL-safe chars,
+    // 8+ in practice). Not validated against the DB here; the executor reports
+    // "not found" for invalid ids so the operator sees a clear failure.
+    const cancelMatch = trimmed.match(/^cancel\s+([A-Za-z0-9_-]{6,})$/i);
+    if (cancelMatch)
+        return { type: "cancel", runId: cancelMatch[1] };
+    const stopMatch = trimmed.match(/^stop\s+([A-Za-z0-9_-]{6,})$/i);
+    if (stopMatch)
+        return { type: "stop", runId: stopMatch[1] };
     return { type: "unknown", original: text };
 }
 // ---------------------------------------------------------------------------
@@ -176,7 +182,7 @@ export function parsePmCommand(text) {
  */
 export async function interpretNaturalLanguage(message, callClaude) {
     const safe = sanitize(message);
-    const prompt = `You are a PM Agent assistant. The following Slack message was sent to you:\n\n"${safe}"\n\nClassify it as exactly ONE of these JSON responses (no other text):\n{"type":"prioritize","issueId":"<id>"}\n{"type":"create","title":"<t>","description":"<d>"}\n{"type":"bulk_create","request":"<original request>"}\n{"type":"status"}\n{"type":"pause"}\n{"type":"resume"}\n{"type":"assign","issueId":"<id>"}\n{"type":"unknown","original":"${safe}"}\n\nRules:\n- Issue IDs look like BEC-25, ENG-42, etc.\n- "more urgent" / "higher priority" → prioritize\n- "add", "open a ticket", "create" → create (single issue with clear title)\n- "create issues for", "find gaps and create", "generate issues", "analyze and create multiple", "create tickets for all" → bulk_create (multiple issues from analysis)\n- "what's running", "show queue" → status\n- "stop", "pause" → pause\n- "start again", "unpause", "resume" → resume\n- "move to todo", "assign" → assign\n- Use bulk_create when the request implies analysis or generating multiple issues, not a single specific issue\n\nRespond ONLY with the JSON object.`;
+    const prompt = `You are a PM Agent assistant. The following Slack message was sent to you:\n\n"${safe}"\n\nClassify it as exactly ONE of these JSON responses (no other text):\n{"type":"prioritize","issueId":"<id>"}\n{"type":"create","title":"<t>","description":"<d>"}\n{"type":"bulk_create","request":"<original request>"}\n{"type":"status"}\n{"type":"pause"}\n{"type":"resume"}\n{"type":"assign","issueId":"<id>"}\n{"type":"cancel","runId":"<runId>"}\n{"type":"stop","runId":"<runId>"}\n{"type":"halt"}\n{"type":"unknown","original":"${safe}"}\n\nRules:\n- Issue IDs look like BEC-25, ENG-42, etc. Run IDs are longer alphanumeric (nanoid).\n- "more urgent" / "higher priority" → prioritize\n- "add", "open a ticket", "create" → create (single issue with clear title)\n- "create issues for", "find gaps and create", "generate issues", "analyze and create multiple", "create tickets for all" → bulk_create (multiple issues from analysis)\n- "what's running", "show queue" → status\n- "pause the agent" / "stop assigning" → pause\n- "start again", "unpause", "resume" → resume\n- "move to todo", "assign" → assign\n- "cancel run <id>", "kill run <id>", "abort run <id>" → cancel (mid-stream interrupt)\n- "stop run <id>", "graceful stop <id>", "wind down run <id>" → stop (finish current stage, then quit)\n- "halt everything", "stop everything", "emergency stop", "pause all and cancel" → halt\n- Use bulk_create when the request implies analysis or generating multiple issues, not a single specific issue\n- Treat \`pause\` (single-word, no runId) as the PM-agent pause, NOT halt. Halt is the explicit "halt the whole container" intent.\n\nRespond ONLY with the JSON object.`;
     try {
         const raw = await callClaude(prompt);
         const parsed = parseJsonObject(raw);
@@ -193,199 +199,6 @@ export async function interpretNaturalLanguage(message, callClaude) {
         return { type: "unknown", original: message };
     }
 }
-/**
- * Executes a parsed `PmCommand` against Linear and returns a human-readable
- * response string suitable for posting back to Slack.
- */
-export async function executePmCommand(cmd, deps) {
-    const { getClient: getLinear } = createLazyLinearClient(deps.linearApiKey);
-    /**
-     * Searches Linear for an issue by its identifier (e.g. "BEC-25") and returns
-     * the first match, or `null` when not found. Shared by prioritize + assign.
-     */
-    async function findIssueByIdentifier(linear, issueId) {
-        const results = await linear.searchIssues(issueId);
-        return results.nodes?.[0] ?? null;
-    }
-    switch (cmd.type) {
-        case "status": {
-            const state = isPmPaused() ? "⏸ *Paused*" : "▶️ *Running*";
-            return `PM Agent is ${state}.\nUse \`/pm pause\` or \`/pm resume\` to control autonomous assignment.`;
-        }
-        case "pause": {
-            setPmPaused(true);
-            log.info("PM Agent paused via Slack");
-            return "⏸ PM Agent autonomous assignment has been *paused*. Use `/pm resume` to restart.";
-        }
-        case "resume": {
-            setPmPaused(false);
-            log.info("PM Agent resumed via Slack");
-            return "▶️ PM Agent autonomous assignment has been *resumed*.";
-        }
-        case "prioritize": {
-            if (!deps.linearApiKey) {
-                return `⚠️ No Linear API key configured — cannot prioritize *${cmd.issueId}*.`;
-            }
-            try {
-                const linear = await getLinear();
-                if (!linear)
-                    return `⚠️ No Linear API key configured — cannot prioritize *${cmd.issueId}*.`;
-                const issue = await findIssueByIdentifier(linear, cmd.issueId);
-                if (!issue)
-                    return `⚠️ Issue *${cmd.issueId}* not found in Linear.`;
-                // updateIssue and createComment are independent — run in parallel
-                await Promise.all([
-                    linear.updateIssue(issue.id, { priority: 1 }),
-                    linear.createComment({
-                        issueId: issue.id,
-                        body: "🤖 **PM Agent** — Bumped to top of queue via Slack command.",
-                    }),
-                ]);
-                log.info({ issueId: cmd.issueId }, "prioritized via Slack");
-                return `✅ *${cmd.issueId}* has been bumped to top priority (Urgent).`;
-            }
-            catch (err) {
-                log.error({ err, issueId: cmd.issueId }, "prioritize failed");
-                return `❌ Failed to prioritize *${cmd.issueId}*: ${err.message}`;
-            }
-        }
-        case "assign": {
-            if (!deps.linearApiKey) {
-                return `⚠️ No Linear API key configured — cannot assign *${cmd.issueId}*.`;
-            }
-            try {
-                const linear = await getLinear();
-                if (!linear)
-                    return `⚠️ No Linear API key configured — cannot assign *${cmd.issueId}*.`;
-                const issue = await findIssueByIdentifier(linear, cmd.issueId);
-                if (!issue)
-                    return `⚠️ Issue *${cmd.issueId}* not found in Linear.`;
-                const team = await issue.team;
-                const allStates = await linear.workflowStates({
-                    filter: { team: { id: { eq: team?.id } } },
-                    first: 50,
-                });
-                const todoState = allStates.nodes?.find((s) => s.name === LINEAR_STATE_TODO);
-                if (!todoState)
-                    return `⚠️ No "${LINEAR_STATE_TODO}" state found for *${cmd.issueId}*'s team.`;
-                await linear.updateIssue(issue.id, { stateId: todoState.id });
-                await linear.createComment({
-                    issueId: issue.id,
-                    body: "🤖 **PM Agent** — Manually assigned to Todo via Slack command.",
-                });
-                log.info({ issueId: cmd.issueId }, "manually assigned to Todo via Slack");
-                return `✅ *${cmd.issueId}* has been moved to Todo.`;
-            }
-            catch (err) {
-                log.error({ err, issueId: cmd.issueId }, "assign failed");
-                return `❌ Failed to assign *${cmd.issueId}*: ${err.message}`;
-            }
-        }
-        case "create": {
-            if (!deps.linearApiKey) {
-                return `⚠️ No Linear API key configured — cannot create issue.`;
-            }
-            if (!deps.teamIds || deps.teamIds.length === 0) {
-                return `⚠️ No team IDs configured — cannot create issue.`;
-            }
-            try {
-                const linear = await getLinear();
-                if (!linear)
-                    return `⚠️ No Linear API key configured — cannot create issue.`;
-                const created = await linear.createIssue({
-                    teamId: deps.teamIds[0],
-                    title: cmd.title,
-                    description: cmd.description || undefined,
-                });
-                const issue = await created.issue;
-                const url = issue?.url ?? "";
-                log.info({ title: cmd.title, issueId: issue?.identifier }, "issue created via Slack");
-                return `✅ Created <${url}|${issue?.identifier ?? "new issue"}>: *${cmd.title}*`;
-            }
-            catch (err) {
-                log.error({ err, title: cmd.title }, "create issue failed");
-                return `❌ Failed to create issue: ${err.message}`;
-            }
-        }
-        case "bulk_create": {
-            if (!deps.linearApiKey) {
-                return `⚠️ No Linear API key configured — cannot create issues.`;
-            }
-            if (!deps.teamIds || deps.teamIds.length === 0) {
-                return `⚠️ No team IDs configured — cannot create issues.`;
-            }
-            if (!deps.callClaudeSonnet) {
-                return `⚠️ Bulk create requires a Sonnet model caller — not configured.`;
-            }
-            try {
-                const specs = await analyzeBulkCreateRequest(cmd.request, deps.callClaudeSonnet);
-                if (specs.length === 0) {
-                    return `🤔 Could not generate any issues from your request. Try being more specific.`;
-                }
-                const linear = await getLinear();
-                if (!linear)
-                    return `⚠️ No Linear API key configured — cannot create issues.`;
-                // Resolve the Triage state and auto-implement label IDs
-                const teamId = deps.teamIds[0];
-                const [allStatesRes, allLabelsRes] = await Promise.all([
-                    linear.workflowStates({ filter: { team: { id: { eq: teamId } } }, first: 50 }),
-                    linear.issueLabels({ first: 100 }),
-                ]);
-                const triageState = allStatesRes.nodes?.find((s) => s.name === LINEAR_STATE_TRIAGE);
-                const labelMap = new Map();
-                for (const label of allLabelsRes.nodes ?? []) {
-                    labelMap.set(label.name.toLowerCase(), label.id);
-                }
-                const autoImplementLabelId = labelMap.get(LINEAR_LABEL_AUTO_IMPLEMENT);
-                // Build all payloads first, then create all issues in parallel
-                const payloads = specs.map((spec) => {
-                    const descWithCriteria = spec.acceptanceCriteria.length > 0
-                        ? `${spec.description}\n\n**Acceptance Criteria:**\n${spec.acceptanceCriteria.map((c) => `- [ ] ${c}`).join("\n")}`
-                        : spec.description;
-                    const payload = {
-                        teamId,
-                        title: spec.title,
-                        description: descWithCriteria || undefined,
-                        priority: spec.priority,
-                    };
-                    if (triageState)
-                        payload.stateId = triageState.id;
-                    if (autoImplementLabelId)
-                        payload.labelIds = [autoImplementLabelId];
-                    return payload;
-                });
-                const results = await Promise.all(payloads.map((p) => linear.createIssue(p)));
-                const issueObjects = await Promise.all(results.map((r) => r.issue));
-                const created = [];
-                for (let i = 0; i < issueObjects.length; i++) {
-                    const issue = issueObjects[i];
-                    if (issue) {
-                        const title = specs[i].title;
-                        created.push({ identifier: issue.identifier ?? "", url: issue.url ?? "", title });
-                        log.info({ issueId: issue.identifier, title }, "bulk issue created via Slack");
-                    }
-                }
-                if (created.length === 0) {
-                    return `❌ Failed to create any issues.`;
-                }
-                const lines = [`✅ Created ${created.length} issue${created.length === 1 ? "" : "s"}:`];
-                for (const issue of created) {
-                    const link = issue.url ? `<${issue.url}|${issue.identifier}>` : `*${issue.identifier}*`;
-                    lines.push(`• ${link}: *${issue.title}*`);
-                }
-                return lines.join("\n");
-            }
-            catch (err) {
-                log.error({ err, request: cmd.request }, "bulk create failed");
-                return `❌ Failed to create issues: ${err.message}`;
-            }
-        }
-        case "unknown":
-            return `🤔 I didn't understand that. Try:\n• \`/pm status\`\n• \`/pm prioritize BEC-25\`\n• \`/pm create "title" "description"\`\n• \`/pm assign BEC-13\`\n• \`/pm pause\` / \`/pm resume\``;
-        default:
-            return `Unknown command.`;
-    }
-}
 // ---------------------------------------------------------------------------
 // Outbound notifications (PM Agent → Slack)
 // ---------------------------------------------------------------------------
@@ -401,18 +214,18 @@ export class SlackInterfaceNotifier {
         const urlPart = n.issueUrl ? `<${n.issueUrl}|${n.issueId}>` : `*${n.issueId}*`;
         const text = `🤖 *PM Agent assigned* ${urlPart}: ${n.issueTitle}\n` +
             `*Reasoning:* ${n.reasoning}`;
-        await this.postMessage({ channel: this.channelId, blocks: [{ type: "section", text: { type: "mrkdwn", text } }] });
+        await this.postMarkdownMessage(text);
     }
     /** Called when PM Agent skips/deprioritizes an issue. */
     async notifySkipped(n) {
         const text = `⏭ *PM Agent skipped* *${n.issueId}*: ${n.issueTitle}\n` +
             `*Reason:* ${n.reasoning}`;
-        await this.postMessage({ channel: this.channelId, blocks: [{ type: "section", text: { type: "mrkdwn", text } }] });
+        await this.postMarkdownMessage(text);
     }
     /** Ask a human for input when priority is ambiguous. */
     async askForClarification(question) {
         const text = `❓ *PM Agent needs your input:*\n${question}`;
-        await this.postMessage({ channel: this.channelId, blocks: [{ type: "section", text: { type: "mrkdwn", text } }] });
+        await this.postMarkdownMessage(text);
     }
     /** Post a daily summary of assigned, completed, and blocked issues. */
     async postDailySummary(entries, date) {
@@ -444,6 +257,17 @@ export class SlackInterfaceNotifier {
             blocks: [{ type: "section", text: { type: "mrkdwn", text: lines.join("\n") } }],
         });
     }
+    /**
+     * Posts a single Slack Block Kit section containing mrkdwn-formatted `text`
+     * to the configured channel. All three simple notification methods delegate
+     * here to avoid repeating the identical blocks structure.
+     */
+    async postMarkdownMessage(text) {
+        await this.postMessage({
+            channel: this.channelId,
+            blocks: [{ type: "section", text: { type: "mrkdwn", text } }],
+        });
+    }
     async postMessage(payload) {
         await postSlackMessage(this.botToken, payload);
     }
@@ -468,11 +292,18 @@ export function createSlackInterface(config) {
     const notifier = new SlackInterfaceNotifier(config);
     const callClaude = config.callClaude ?? makeCallClaude();
     const callClaudeSonnet = config.callClaudeSonnet ?? makeCallClaudeSonnet();
-    const executorDeps = {
+    const baseExecutorDeps = {
         linearApiKey: config.linearApiKey,
         teamIds: config.teamIds,
         callClaudeSonnet,
+        runner: config.runner,
+        db: config.db,
     };
+    // Per-request deps thread the Slack user id through for audit attribution.
+    const withSlackUser = (slackUserId) => ({
+        ...baseExecutorDeps,
+        slackUserId,
+    });
     // Helper: verify Slack signature and return 401 on failure
     async function checkSignature(c) {
         const rawBody = await c.req.text();
@@ -512,18 +343,44 @@ export function createSlackInterface(config) {
             }
             return c.json({ response_type: r.responseType, text: r.text });
         }
-        // Default: /pm path (preserves existing behavior).
+        // Default: /pm path. When a response_url is present (the normal case in
+        // production), ack immediately with a :thinking_face: line and post the
+        // real reply asynchronously — this lets slow commands (bulk_create,
+        // anything that hits Linear/Sonnet) take their time without tripping
+        // Slack's 3s slash-command timeout. When no response_url is available
+        // (rare; only legacy/non-production callers), fall back to the
+        // synchronous path so the operator still sees a result.
+        if (responseUrl) {
+            void (async () => {
+                try {
+                    let cmd = parsePmCommand(commandText);
+                    if (cmd.type === "unknown" && commandText.length > 0) {
+                        cmd = await interpretNaturalLanguage(commandText, callClaude);
+                    }
+                    const replyText = await executePmCommand(cmd, withSlackUser(userId));
+                    await postToResponseUrl(responseUrl, replyText);
+                }
+                catch (err) {
+                    log.error({ err }, "async slash command processing failed");
+                    try {
+                        await postToResponseUrl(responseUrl, ":warning: Something went wrong while processing that command. Check the urateam logs.");
+                    }
+                    catch {
+                        // already logged above
+                    }
+                }
+            })();
+            return c.json({
+                response_type: "ephemeral",
+                text: ":thinking_face: Working on it…",
+            });
+        }
+        // No response_url — process synchronously.
         let cmd = parsePmCommand(commandText);
-        // Fall back to NL interpretation if command is unknown
         if (cmd.type === "unknown" && commandText.length > 0) {
             cmd = await interpretNaturalLanguage(commandText, callClaude);
         }
-        const replyText = await executePmCommand(cmd, executorDeps);
-        // If a response_url is provided, post back asynchronously
-        if (responseUrl) {
-            postToResponseUrl(responseUrl, replyText).catch((err) => log.error({ err }, "failed to post to Slack response_url"));
-        }
-        // Immediate acknowledgement (required within 3s)
+        const replyText = await executePmCommand(cmd, withSlackUser(userId));
         return c.json({ response_type: "ephemeral", text: replyText });
     });
     // ------------------------------------------------------------------
@@ -562,13 +419,23 @@ export function createSlackInterface(config) {
                 if (event.bot_id || event.subtype === "bot_message") {
                     return c.json({ ok: true });
                 }
-                const messageText = (event.text ?? "").replace(/<@[A-Z0-9]+>/g, "").trim();
+                const messageText = (event.text ?? "").replace(SLACK_MENTION_RE, "").trim();
                 if (!messageText)
                     return c.json({ ok: true });
                 log.info({ messageText }, "received Slack message event");
-                // Process asynchronously — acknowledge immediately
-                processMessageAsync(messageText, event.channel ?? config.channelId, config.botToken, callClaude, executorDeps)
-                    .catch((err) => log.error({ err }, "async message processing failed"));
+                // UX: react with :thinking_face: immediately so the user sees the bot
+                // picked up the mention. processMessageAsync swaps it for
+                // :white_check_mark: on success or :warning: on failure. The reaction
+                // is best-effort — failure logs but never blocks the actual work.
+                const channelForReact = event.channel ?? config.channelId;
+                const ts = typeof event.ts === "string" ? event.ts : null;
+                if (ts) {
+                    void reactToSlackMessage(config.botToken, channelForReact, ts, "thinking_face");
+                }
+                // Process asynchronously — acknowledge immediately. Use the Slack
+                // event's user id for audit attribution (mentions in the PM channel).
+                const eventUserId = typeof event.user === "string" ? event.user : "";
+                processMessageAsync(messageText, channelForReact, config.botToken, callClaude, withSlackUser(eventUserId), ts).catch((err) => log.error({ err }, "async message processing failed"));
             }
         }
         return c.json({ ok: true });
@@ -578,77 +445,6 @@ export function createSlackInterface(config) {
 // ---------------------------------------------------------------------------
 // Internal helpers
 // ---------------------------------------------------------------------------
-/**
- * Uses a capable Claude model (Sonnet) to analyze a bulk create request and
- * produce a structured list of issue specifications.
- */
-export async function analyzeBulkCreateRequest(request, callClaudeSonnet) {
-    const safe = sanitize(request);
-    const prompt = `You are a software PM Agent. A user asked: "${safe}"\n\n` +
-        `Analyze this request and generate a list of concrete, actionable software issues to create.\n` +
-        `Each issue must have a clear title, description, priority (1=urgent, 2=high, 3=medium, 4=low), and acceptance criteria.\n\n` +
-        `Respond ONLY with a JSON array (no other text), e.g.:\n` +
-        `[\n` +
-        `  {\n` +
-        `    "title": "Issue title",\n` +
-        `    "description": "Clear description of what needs to be done",\n` +
-        `    "priority": 2,\n` +
-        `    "acceptanceCriteria": ["Criterion 1", "Criterion 2"]\n` +
-        `  }\n` +
-        `]\n\n` +
-        `Rules:\n` +
-        `- Generate between 1 and 10 issues\n` +
-        `- Each issue must be specific and actionable\n` +
-        `- Priority must be 1, 2, 3, or 4\n` +
-        `- acceptanceCriteria must be a non-empty array of strings\n` +
-        `- Respond ONLY with the JSON array, no markdown fences or explanation`;
-    try {
-        const raw = await callClaudeSonnet(prompt);
-        // Parse the array — look for a JSON array in the response
-        const arrayMatch = raw.match(/\[[\s\S]*\]/);
-        if (!arrayMatch) {
-            log.warn({ responsePreview: raw.slice(0, 200) }, "bulk create: no JSON array in Claude response");
-            return [];
-        }
-        let parsed;
-        try {
-            parsed = JSON.parse(arrayMatch[0]);
-        }
-        catch {
-            log.warn({ responsePreview: raw.slice(0, 200) }, "bulk create: failed to parse JSON array");
-            return [];
-        }
-        if (!Array.isArray(parsed))
-            return [];
-        const specs = [];
-        for (const item of parsed) {
-            if (typeof item !== "object" || item === null)
-                continue;
-            const title = typeof item.title === "string" ? item.title.trim() : "";
-            const description = typeof item.description === "string" ? item.description.trim() : "";
-            const priority = typeof item.priority === "number" && VALID_PRIORITIES.includes(item.priority)
-                ? item.priority
-                : DEFAULT_PRIORITY;
-            const acceptanceCriteria = Array.isArray(item.acceptanceCriteria)
-                ? item.acceptanceCriteria.filter((c) => typeof c === "string" && c.trim().length > 0)
-                : [];
-            if (!title)
-                continue;
-            // Cap title/description length to prevent excessively large issues
-            specs.push({
-                title: title.slice(0, 200),
-                description: description.slice(0, 5000),
-                priority,
-                acceptanceCriteria: acceptanceCriteria.slice(0, 10),
-            });
-        }
-        return specs.slice(0, 10);
-    }
-    catch (err) {
-        log.warn({ err }, "bulk create: failed to analyze request");
-        return [];
-    }
-}
 async function postToResponseUrl(responseUrl, text, responseType = "ephemeral") {
     await fetch(responseUrl, {
         method: "POST",
@@ -656,9 +452,43 @@ async function postToResponseUrl(responseUrl, text, responseType = "ephemeral")
         body: JSON.stringify({ response_type: responseType, text }),
     });
 }
-async function processMessageAsync(text, channel, botToken, callClaude, deps) {
-    const cmd = await interpretNaturalLanguage(text, callClaude);
-    const replyText = await executePmCommand(cmd, deps);
-    await postSlackMessage(botToken, { channel, text: replyText });
+async function processMessageAsync(text, channel, botToken, callClaude, deps, 
+/** Optional message ts so reactions can be swapped after processing completes. */
+ts = null) {
+    let success = false;
+    try {
+        const cmd = await interpretNaturalLanguage(text, callClaude);
+        const replyText = await executePmCommand(cmd, deps);
+        await postSlackMessage(botToken, { channel, text: replyText });
+        success = true;
+    }
+    finally {
+        if (ts) {
+            // Best-effort reaction swap. Removing :thinking_face: is non-fatal: if
+            // the remove fails (e.g. someone manually removed it), the add still
+            // runs — the user just sees one more reaction than expected.
+            void removeReaction(botToken, channel, ts, "thinking_face");
+            void reactToSlackMessage(botToken, channel, ts, success ? "white_check_mark" : "warning");
+        }
+    }
+}
+async function removeReaction(botToken, channel, ts, emoji) {
+    try {
+        const resp = await fetch("https://slack.com/api/reactions.remove", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${botToken}`,
+            },
+            body: JSON.stringify({ channel, timestamp: ts, name: emoji }),
+        });
+        const data = (await resp.json());
+        if (!data?.ok && data?.error !== "no_reaction") {
+            log.info({ error: data?.error, channel, ts, emoji }, "Slack reactions.remove returned ok:false");
+        }
+    }
+    catch (err) {
+        log.info({ err, channel, ts, emoji }, "Slack reactions.remove failed (non-fatal)");
+    }
 }
 //# sourceMappingURL=slack-interface.js.map