fix: slack command latency

package.json

@@ -22,6 +22,7 @@
     "@octokit/rest": "^22.0.1",
     "@t3-oss/env-core": "^0.13.10",
     "@upstash/redis": "^1.37.0",
+    "@vercel/functions": "^3.5.0",
     "@vercel/sandbox": "^1.8.1",
     "chat": "^4.20.2",
     "h3": "^1",

src/lib/adapters.ts

@@ -6,13 +6,16 @@ import { createVCS } from "./create-vcs.js";
 import type { IssueTrackerAdapter } from "../adapters/issue-tracker/types.js";
 import type { VCSAdapter } from "../adapters/vcs/types.js";
 import type { MessagingAdapter } from "../adapters/messaging/types.js";
-import type { RunRegistryAdapter } from "../adapters/run-registry/types.js";
+import type {
+  RunRegistryAdapter,
+  ThreadStore,
+} from "../adapters/run-registry/types.js";
 
 export interface Adapters {
   issueTracker: IssueTrackerAdapter;
   vcs: VCSAdapter;
   messaging: MessagingAdapter;
-  runRegistry: RunRegistryAdapter;
+  runRegistry: RunRegistryAdapter & ThreadStore;
 }
 
 export function createAdapters(): Adapters {

src/lib/cancel-run.ts

@@ -1,17 +1,24 @@
 import { getRun } from "workflow/api";
 import { logger } from "./logger.js";
 import type { RunRegistryAdapter } from "../adapters/run-registry/types.js";
+import type { IssueTrackerAdapter } from "../adapters/issue-tracker/types.js";
 import { stopTicketSandboxes } from "../sandbox/stop-ticket-sandboxes.js";
 
 /**
  * Cancel a workflow run and unregister it from the registry.
  * Idempotent: safe to call multiple times for the same ticket.
  * Returns true if cancel succeeded, false if it errored (still unregisters).
+ *
+ * If `issueTracker` and `targetColumn` are provided, also transitions the
+ * ticket out of its current column. Without this, the cron sees the ticket
+ * still in COLUMN_AI on the next tick and re-dispatches a fresh run.
  */
 export async function cancelRun(
   ticketKey: string,
   runId: string,
   runRegistry: RunRegistryAdapter,
+  issueTracker?: IssueTrackerAdapter,
+  targetColumn?: string,
 ): Promise<boolean> {
   let cancelled = false;
   try {
@@ -32,5 +39,17 @@ export async function cancelRun(
   const sandboxId = await runRegistry.getSandboxId(ticketKey).catch(() => null);
   await stopTicketSandboxes(ticketKey, sandboxId).catch(() => {});
   await runRegistry.unregister(ticketKey).catch(() => {});
+
+  if (issueTracker && targetColumn) {
+    try {
+      await issueTracker.moveTicket(ticketKey, targetColumn);
+    } catch (err) {
+      logger.warn(
+        { ticketKey, targetColumn, error: (err as Error).message },
+        "cancel_run_move_ticket_failed",
+      );
+    }
+  }
+
   return cancelled;
 }

src/lib/dispatch.test.ts

@@ -95,6 +95,9 @@ function makeAdapters(
       isTicketFailed: overrides.isTicketFailed ?? vi.fn().mockResolvedValue(false),
       listAllFailed: vi.fn().mockResolvedValue([]),
       clearFailedMark: vi.fn().mockResolvedValue(undefined),
+      getParent: vi.fn().mockResolvedValue(null),
+      setParent: vi.fn().mockResolvedValue(undefined),
+      clearParent: vi.fn().mockResolvedValue(undefined),
     },
   };
 }
@@ -451,6 +454,9 @@ describe("failed-ticket safeguard full loop", () => {
       clearFailedMark: vi.fn().mockImplementation(async (key: string) => {
         failedMarkers.delete(key);
       }),
+      getParent: vi.fn().mockResolvedValue(null),
+      setParent: vi.fn().mockResolvedValue(undefined),
+      clearParent: vi.fn().mockResolvedValue(undefined),
     };
 
     const adapters = makeAdapters();

src/lib/slack/commands.ts

@@ -4,6 +4,8 @@ export type ParsedCommand =
   | { kind: "list" }
   | { kind: "status"; ticketKey: string }
   | { kind: "cancel"; ticketKey: string }
+  | { kind: "inspect"; ticketKey: string | null }
+  | { kind: "reset"; ticketKey: string }
   | { kind: "help" }
   | { kind: "unknown"; raw: string };
 
@@ -18,12 +20,18 @@ export function parseCommand(text: string): ParsedCommand {
   if (verb === "help") return { kind: "help" };
   if (verb === "list") return { kind: "list" };
 
-  if (verb === "status" || verb === "cancel") {
+  if (verb === "status" || verb === "cancel" || verb === "reset") {
     if (arg && TICKET_KEY_RE.test(arg)) {
       return { kind: verb, ticketKey: arg };
     }
     return { kind: "unknown", raw: trimmed };
   }
 
+  if (verb === "inspect") {
+    if (!arg) return { kind: "inspect", ticketKey: null };
+    if (TICKET_KEY_RE.test(arg)) return { kind: "inspect", ticketKey: arg };
+    return { kind: "unknown", raw: trimmed };
+  }
+
   return { kind: "unknown", raw: trimmed };
 }

src/lib/slack/format.ts

@@ -1,3 +1,5 @@
+import type { FailedTicketMeta } from "../../adapters/run-registry/types.js";
+
 export interface RunRow {
   ticketKey: string;
   runId: string;
@@ -8,6 +10,14 @@ export interface RunStatusSnapshot {
   sandboxId: string | null;
 }
 
+export interface InspectTicketSnapshot {
+  runId: string | null;
+  sandboxId: string | null;
+  entryCreatedAt: number | null;
+  threadParent: string | null;
+  isFailed: boolean;
+}
+
 export function formatRunList(rows: RunRow[], jiraBaseUrl: string): string {
   if (rows.length === 0) return "No active workflows.";
   return rows
@@ -26,11 +36,57 @@ export function formatRunStatus(
   return `${link}: runId \`${snapshot.runId}\`, sandbox: ${sandbox}`;
 }
 
+export function formatInspectTicket(
+  ticketKey: string,
+  jiraBaseUrl: string,
+  snap: InspectTicketSnapshot,
+): string {
+  const link = jiraLink(ticketKey, jiraBaseUrl);
+  const lines: string[] = [`*Inspect ${link}*`];
+  lines.push(`• runId: ${snap.runId ? `\`${snap.runId}\`` : "_none_"}`);
+  lines.push(`• sandboxId: ${snap.sandboxId ? `\`${snap.sandboxId}\`` : "_none_"}`);
+  lines.push(
+    `• entryCreatedAt: ${snap.entryCreatedAt ? new Date(snap.entryCreatedAt).toISOString() : "_none_"}`,
+  );
+  lines.push(`• threadParent: ${snap.threadParent ? `\`${snap.threadParent}\`` : "_none_"}`);
+  lines.push(`• failed: ${snap.isFailed ? "yes" : "no"}`);
+  return lines.join("\n");
+}
+
+export function formatInspectAll(
+  active: RunRow[],
+  failed: Array<{ ticketKey: string; meta: FailedTicketMeta }>,
+  jiraBaseUrl: string,
+): string {
+  const lines: string[] = ["*Redis snapshot*"];
+  lines.push(`*Active runs (${active.length}):*`);
+  if (active.length === 0) {
+    lines.push("• _none_");
+  } else {
+    for (const { ticketKey, runId } of active) {
+      lines.push(`• ${jiraLink(ticketKey, jiraBaseUrl)} — \`${runId}\``);
+    }
+  }
+  lines.push(`*Failed markers (${failed.length}):*`);
+  if (failed.length === 0) {
+    lines.push("• _none_");
+  } else {
+    for (const { ticketKey, meta } of failed) {
+      lines.push(
+        `• ${jiraLink(ticketKey, jiraBaseUrl)} — \`${meta.runId}\` (${meta.failedAt})`,
+      );
+    }
+  }
+  return lines.join("\n");
+}
+
 export const HELP_TEXT = [
   "*Blazebot commands*",
   "• `/ai-workflow list` — show every tracked workflow",
   "• `/ai-workflow status <KEY>` — show the run + sandbox tied to a ticket",
-  "• `/ai-workflow cancel <KEY>` — cancel the workflow run for a ticket",
+  "• `/ai-workflow cancel <KEY>` — cancel the workflow run + move ticket to backlog",
+  "• `/ai-workflow inspect [KEY]` — dump Redis state for a ticket, or summary across all hashes",
+  "• `/ai-workflow reset <KEY>` — clear Redis entries for a ticket (does NOT cancel the run)",
 ].join("\n");
 
 function jiraLink(ticketKey: string, jiraBaseUrl: string): string {

src/lib/slack/handlers.test.ts

@@ -133,7 +133,13 @@ describe("handleCancel", () => {
       cancelRunFn,
       stopSandboxes,
     );
-    expect(cancelRunFn).toHaveBeenCalledWith("AWT-1", "run_a", registry);
+    expect(cancelRunFn).toHaveBeenCalledWith(
+      "AWT-1",
+      "run_a",
+      registry,
+      undefined,
+      undefined,
+    );
     expect(out).toContain("Cancelled");
     expect(out).toContain("AWT-1");
   });