From 8725d6ce0900d88bac1bd33a679d7b7a3c5d389d Mon Sep 17 00:00:00 2001 From: Dotta <34892728+cryppadotta@users.noreply.github.com> Date: Tue, 22 Sep 2026 10:35:33 -0500 Subject: [PATCH] fix: make answered Slack conversations idle (#13809) Settle published, successful Slack turns as Idle; resume the same conversation on an admitted message. Preserve unfinished work, delivery errors, and explicit dispositions. Verified through focused lifecycle/API/UI tests, full CI, and a real staging Slack conversation in the embedded browser. Co-Authored-By: Paperclip --- doc/execution-semantics.md | 19 ++ packages/shared/src/types/issue.ts | 3 + packages/shared/src/types/search.ts | 1 + .../chat-channels.integration.test.ts | 46 +++ .../slack-conversation-lifecycle.test.ts | 288 ++++++++++++++++++ server/src/routes/issues.ts | 1 + server/src/services/chat-channels.ts | 12 +- server/src/services/company-search.ts | 10 + server/src/services/heartbeat.ts | 21 +- server/src/services/issue-visibility.ts | 3 +- server/src/services/issues.ts | 40 ++- .../native-runtime/native-run-finalizer.ts | 11 + server/src/services/recovery/service.ts | 8 + .../services/slack-conversation-lifecycle.ts | 103 +++++++ .../src/services/slack-conversation-state.ts | 55 ++++ ui/src/components/ActiveAgentsPanel.test.tsx | 13 + ui/src/components/ActiveAgentsPanel.tsx | 7 +- ui/src/components/ActivityRow.tsx | 3 +- ui/src/components/FeedCard.test.tsx | 7 + ui/src/components/FeedCard.tsx | 2 + ui/src/components/IssueColumns.tsx | 2 +- ui/src/components/IssueRow.tsx | 6 +- ui/src/components/IssueSiblingNavigation.tsx | 2 +- ui/src/components/IssuesList.tsx | 6 +- ui/src/components/LegacyIssuesList.tsx | 4 +- ui/src/components/SidebarRecentTasks.test.tsx | 13 + ui/src/components/SidebarRecentTasks.tsx | 3 + ui/src/components/StatusBadge.tsx | 3 +- ui/src/components/StatusGlyph.tsx | 1 + ui/src/components/StatusIcon.test.tsx | 20 ++ ui/src/components/StatusIcon.tsx | 12 +- .../issue-properties/IssueProperties.tsx | 2 +- ui/src/components/search/SearchResultRow.tsx | 2 +- ui/src/lib/activity-format.test.ts | 7 + ui/src/lib/activity-format.ts | 10 +- ui/src/lib/optimistic-issue-runs.test.ts | 1 + ui/src/lib/optimistic-issue-runs.ts | 3 +- ui/src/lib/recent-tasks.test.ts | 30 ++ ui/src/lib/recent-tasks.ts | 19 +- ui/src/lib/status-colors.ts | 2 + ui/src/pages/Dashboard.tsx | 2 +- ui/src/pages/DesignGuide.tsx | 4 + ui/src/pages/Inbox.tsx | 4 +- ui/src/pages/IssueDetail.tsx | 9 +- ui/src/pages/LegacyInbox.tsx | 4 +- ui/src/pages/MyIssues.tsx | 2 +- .../StatusCards/StatusCardDetailDrawer.tsx | 2 +- 47 files changed, 777 insertions(+), 51 deletions(-) create mode 100644 server/src/__tests__/slack-conversation-lifecycle.test.ts create mode 100644 server/src/services/slack-conversation-lifecycle.ts create mode 100644 server/src/services/slack-conversation-state.ts diff --git a/doc/execution-semantics.md b/doc/execution-semantics.md index 218e1586134..2c53d8024af 100644 --- a/doc/execution-semantics.md +++ b/doc/execution-semantics.md @@ -108,6 +108,25 @@ and review run. The server reads these records from saved review state; it does not depend on the parent session remembering a separate review session. These records are evidence and do not grant permission to resolve another review. +### Answered Slack conversations + +A successful Slack turn with a published final reply and no remaining execution +or decision path settles to `chat_conversations.state = waiting` and issue +`in_review`. This is a server-owned passive conversation state, displayed as +**Idle**, not a request for review. It is excluded from execution counts, work +queues, and generic review attention, while remaining accessible through +Conversations, search, recent history, and unread activity. + +An admitted Slack or board message clears waiting and returns the issue to +`todo` in the message transaction; normal wake admission and checkout resume +execution. Settlement rechecks the +latest run, message cursor, publication receipt, and outstanding work under the +task lock. Failed delivery, a newer message, queued work, monitors, dependencies, +and pending decisions prevent settlement. Reconciliation applies the same rule +to existing answered threads without another model invocation. Slack identity, +permissions, and the ability to execute work in the same thread are unchanged. +Other providers keep their existing lifecycle. + ### `done` The work is complete and terminal. diff --git a/packages/shared/src/types/issue.ts b/packages/shared/src/types/issue.ts index dab04ce8b6e..a22bfc45ef6 100644 --- a/packages/shared/src/types/issue.ts +++ b/packages/shared/src/types/issue.ts @@ -770,6 +770,8 @@ export type IssueChanges = Record; export interface Issue { conversationAgentId?: string | null; conversationUserId?: string | null; + /** Server-owned Slack lifecycle projection; not writable through task updates. */ + externalConversationState?: "active" | "waiting" | null; conversationState?: "active" | "waiting" | null; conversationSessionGeneration?: number; conversationBoundaryCommentId?: string | null; @@ -867,6 +869,7 @@ export interface Issue { export type CompactIssue = Pick< Issue, + | "externalConversationState" | "id" | "companyId" | "projectId" diff --git a/packages/shared/src/types/search.ts b/packages/shared/src/types/search.ts index 481766eca57..825d4d4d1c4 100644 --- a/packages/shared/src/types/search.ts +++ b/packages/shared/src/types/search.ts @@ -38,6 +38,7 @@ export interface CompanySearchIssueSummary { identifier: string | null; title: string; status: IssueStatus; + externalConversationState?: "active" | "waiting" | null; priority: IssuePriority; assigneeAgentId: string | null; assigneeUserId: string | null; diff --git a/server/src/__tests__/chat-channels.integration.test.ts b/server/src/__tests__/chat-channels.integration.test.ts index ca299028d14..4f355995473 100644 --- a/server/src/__tests__/chat-channels.integration.test.ts +++ b/server/src/__tests__/chat-channels.integration.test.ts @@ -28233,6 +28233,52 @@ describeEmbeddedPostgres("chat channel control-plane integration", () => { await resumed.service.shutdown(); }); + it("returns two answered Slack turns to Idle in the same thread", async () => { + const fixture = await seedCompany(); + const { callbacks, endpoint, service } = await configuredSlackEndpoint(fixture); + const thread = makeThread({ channelId: "C-IDLE", id: "slack:C-IDLE:4049.1", name: "idle" }); + let issueId: string | undefined; + let conversationId: string | undefined; + for (const [index, text] of ["@maya are you there?", "what is your name?"].entries()) { + const providerMessageId = `4049.${index + 1}`; + await deliverMessage({ callbacks, endpointId: endpoint.id, thread: thread.thread, + message: makeMessage({ id: providerMessageId, text, mentioned: index === 0 }), + trigger: index === 0 ? "mention" : "subscribed_message" }); + const conversations = await db.select().from(chatConversations).where(eq(chatConversations.endpointId, endpoint.id)); + expect(conversations).toHaveLength(1); + const conversation = conversations[0]!; + expect(conversation.state).toBe("active"); + expect((await issueService(db).getById(conversation.issueId))?.status).toBe("todo"); + if (issueId) expect(conversation.issueId).toBe(issueId); + if (conversationId) expect(conversation.id).toBe(conversationId); + issueId = conversation.issueId; + conversationId = conversation.id; + const runId = randomUUID(); + await db.insert(heartbeatRuns).values({ id: runId, companyId: fixture.companyId, + agentId: fixture.assignedAgentId, status: "succeeded", runtimeMode: "legacy", finishedAt: new Date(), + contextSnapshot: await chatWakeContext({ endpointId: endpoint.id, issueId, provider: "slack", providerMessageId }) }); + // Model execution consuming the admitted wake and committing its checkout. + await db.update(agentWakeupRequests).set({ status: "completed", runId }) + .where(and(eq(agentWakeupRequests.companyId, fixture.companyId), eq(agentWakeupRequests.status, "queued"))); + await db.update(issues).set({ status: "in_progress" }).where(eq(issues.id, issueId)); + await addSelectedChatFinal({ companyId: fixture.companyId, agentId: fixture.assignedAgentId, + issueId, runId, body: index === 0 ? "Yes, I'm here." : "I'm Maya." }); + await service.processPendingPublications(); + await vi.waitFor(async () => { + const issue = await issueService(db).getById(issueId!); + expect(issue?.status).toBe("in_review"); + expect(issue?.externalConversationState).toBe("waiting"); + expect(issue?.conversationAgentId).toBeNull(); + expect(issue?.conversationUserId).toBeNull(); + }); + // A provider replay must not wake or reactivate the completed turn. + await deliverMessage({ callbacks, endpointId: endpoint.id, thread: thread.thread, + message: makeMessage({ id: providerMessageId, text, mentioned: index === 0 }), + trigger: index === 0 ? "mention" : "subscribed_message" }); + expect((await issueService(db).getById(issueId))?.externalConversationState).toBe("waiting"); + } + }); + it("coalesces one Slack run's lifecycle and final response despite an interleaved task control", async () => { const fixture = await seedCompany(); const { callbacks, endpoint, runtime, service } = diff --git a/server/src/__tests__/slack-conversation-lifecycle.test.ts b/server/src/__tests__/slack-conversation-lifecycle.test.ts new file mode 100644 index 00000000000..02d112282c1 --- /dev/null +++ b/server/src/__tests__/slack-conversation-lifecycle.test.ts @@ -0,0 +1,288 @@ +import express from "express"; +import request from "supertest"; +import { issueRoutes } from "../routes/issues.js"; +import { randomUUID } from "node:crypto"; +import { and, eq } from "drizzle-orm"; +import { afterAll, beforeAll, describe, expect, it, vi } from "vitest"; +import { + activityLog, agents, agentWakeupRequests, approvals, chatConversations, chatEndpoints, + chatMessageLinks, chatPublications, companies, createDb, heartbeatRuns, issueApprovals, + issueComments, issueRelations, issueThreadInteractions, issues, nativeRunFinalizations, + toolApplications, toolConnections, +} from "@paperclipai/db"; +import { getEmbeddedPostgresTestSupport, startEmbeddedPostgresTestDatabase } from "./helpers/embedded-postgres.js"; +import { settleSlackConversation } from "../services/slack-conversation-lifecycle.js"; +import { externalConversationStateSql } from "../services/slack-conversation-state.js"; +import { executionIssueCondition } from "../services/issue-visibility.js"; +import { dashboardService } from "../services/dashboard.js"; +import { attentionService } from "../services/attention.js"; +import { companySearchQuerySchema } from "@paperclipai/shared"; +import { companySearchService } from "../services/company-search.js"; +import { recoveryService } from "../services/recovery/service.js"; +import { issueService } from "../services/issues.js"; + +const support = await getEmbeddedPostgresTestSupport(); +(support.supported ? describe : describe.skip)("Slack conversation idle lifecycle", () => { + let database: Awaited>; + let db: ReturnType; + beforeAll(async () => { + database = await startEmbeddedPostgresTestDatabase("paperclip-slack-idle-"); + db = createDb(database.connectionString); + }, 90000); + afterAll(async () => { + await db?.$client.end({ timeout: 0 }); + await database?.cleanup(); + }); + + async function fixture(native = false) { + const companyId = randomUUID(); + const agentId = randomUUID(); + const issueId = randomUUID(); + const endpointId = randomUUID(); + const conversationId = randomUUID(); + const runId = randomUUID(); + const wakeId = randomUUID(); + const responseId = randomUUID(); + const publicationId = randomUUID(); + const applicationId = randomUUID(); + const connectionId = randomUUID(); + const start = new Date(Date.now() - 10000); + await db.insert(companies).values({ id: companyId, name: "Slack", issuePrefix: companyId.slice(0, 8) }); + await db.insert(agents).values({ id: agentId, companyId, name: "Carl", role: "general", adapterType: "codex_local" }); + await db.insert(issues).values({ id: issueId, companyId, title: "you there?", status: "in_progress", assigneeAgentId: agentId, originKind: "chat_channel" }); + await db.insert(toolApplications).values({ id: applicationId, companyId, name: "Slack", type: "native" }); + await db.insert(toolConnections).values({ id: connectionId, companyId, applicationId, name: "Slack", uid: connectionId, transport: "chat_sdk", connectionPurpose: "channel" }); + await db.insert(chatEndpoints).values({ id: endpointId, companyId, connectionId, provider: "slack", publicId: endpointId, assignedAgentId: agentId, status: "active" }); + await db.insert(chatConversations).values({ id: conversationId, companyId, endpointId, issueId, externalConversationId: "channel", externalThreadId: runId, externalLabel: "#test" }); + await db.insert(issueComments).values({ id: wakeId, companyId, issueId, authorType: "user", authorUserId: "local-board", body: "you there?", createdAt: start }); + await db.insert(chatMessageLinks).values({ companyId, endpointId, conversationId, commentId: wakeId, providerMessageId: wakeId, direction: "inbound" }); + await db.insert(heartbeatRuns).values({ id: runId, companyId, agentId, status: "succeeded", runtimeMode: native ? "native" : "legacy", nativeIssueId: native ? issueId : null, + resultJson: native ? { finalizationReasonCode: "external_chat_response_waiting" } : null, + createdAt: new Date(start.getTime() + 1), startedAt: start, finishedAt: new Date(), + contextSnapshot: { issueId, source: "chat:slack", wakeCommentId: wakeId, wakeCommentIds: [wakeId] } }); + if (native) await db.insert(nativeRunFinalizations).values({ companyId, issueId, runId, phase: "committed" }); + await db.insert(issueComments).values({ id: responseId, companyId, issueId, authorType: "agent", authorAgentId: agentId, createdByRunId: runId, body: "Yes, I’m here.", + metadata: { version: 1, authorizationReason: "allow_chat_run_presentation", sections: [] } }); + await db.insert(chatPublications).values({ id: publicationId, companyId, endpointId, conversationId, issueId, commentId: responseId, + idempotencyKey: `comment:${responseId}:${endpointId}`, payload: { text: "Yes, I’m here." }, state: "published", providerMessageId: responseId, publishedAt: new Date() }); + return { companyId, agentId, issueId, endpointId, conversationId, runId, wakeId, responseId, publicationId, start }; + } + async function state(f: Awaited>) { + return (await db.select({ status: issues.status, externalConversationState: externalConversationStateSql() }) + .from(issues).where(eq(issues.id, f.issueId)))[0]; + } + const settle = (f: Awaited>) => settleSlackConversation(db, f.companyId, f.issueId); + + it.each([false, true])("settles a published answered turn once (native=%s)", async (native) => { + const f = await fixture(native); + expect(await settle(f)).toBe(true); + expect(await state(f)).toEqual({ status: "in_review", externalConversationState: "waiting" }); + expect(await settle(f)).toBe(false); + expect(await db.select().from(activityLog).where(and(eq(activityLog.entityId, f.issueId), eq(activityLog.action, "issue.updated")))).toHaveLength(1); + expect(await db.select().from(issues).where(and(eq(issues.id, f.issueId), executionIssueCondition()))).toHaveLength(0); + expect((await issueService(db).getById(f.issueId))?.externalConversationState).toBe("waiting"); + expect(await issueService(db).list(f.companyId)).toHaveLength(0); + expect((await dashboardService(db).summary(f.companyId)).tasks.open).toBe(0); + expect((await attentionService(db).list(f.companyId)).items.filter((item) => item.issueId === f.issueId)).toHaveLength(0); + const results = await companySearchService(db).search(f.companyId, companySearchQuerySchema.parse({ q: "you there" })); + expect(results.results.find((result) => result.issue?.id === f.issueId)?.issue?.externalConversationState).toBe("waiting"); + expect((await issueService(db).list(f.companyId, { q: "you there" }))[0]?.externalConversationState).toBe("waiting"); + expect((await issueService(db).listReviewAttention(f.companyId, [{ id: f.issueId, companyId: f.companyId, status: "in_review" }])).get(f.issueId)?.state).toBe("none"); + }); + + it("preserves waiting state in compact list responses used by the Inbox", async () => { + const f = await fixture(); + await settle(f); + const app = express(); + app.use((req, _res, next) => { + (req as any).actor = { type: "board", userId: "local-board", source: "local_implicit", isInstanceAdmin: true }; + next(); + }); + app.use("/api", issueRoutes(db, {} as any)); + const response = await request(app).get(`/api/companies/${f.companyId}/issues`) + .query({ view: "compact", q: "you there" }); + expect(response.status, JSON.stringify(response.body)).toBe(200); + expect(response.body).toEqual([expect.objectContaining({ id: f.issueId, status: "in_review", externalConversationState: "waiting" })]); + }); + + it("reconciles an already-answered conversation without another model run", async () => { + const f = await fixture(); + const enqueueWakeup = vi.fn(async () => null); + const recovery = recoveryService(db, { enqueueWakeup }); + // Restrict to this newly created fixture, like the rollout reconciler's candidate scan. + const [issue] = await db.select().from(issues).where(eq(issues.id, f.issueId)); + await recovery.reconcileStrandedAssignedIssues({ issueCreatedAtGte: issue.createdAt }); + expect((await state(f))?.externalConversationState).toBe("waiting"); + await recovery.reconcileStrandedAssignedIssues({ issueCreatedAtGte: issue.createdAt }); + expect(enqueueWakeup).not.toHaveBeenCalled(); + }); + + it("waits for both finalization and delivery, regardless of their order", async () => { + for (const first of ["run", "publication"]) { + const f = await fixture(); + if (first === "run") await db.update(chatPublications).set({ state: "pending" }).where(eq(chatPublications.id, f.publicationId)); + else await db.update(heartbeatRuns).set({ status: "running" }).where(eq(heartbeatRuns.id, f.runId)); + expect(await settle(f)).toBe(false); + await db.update(chatPublications).set({ state: "published" }).where(eq(chatPublications.id, f.publicationId)); + await db.update(heartbeatRuns).set({ status: "succeeded" }).where(eq(heartbeatRuns.id, f.runId)); + expect(await settle(f)).toBe(true); + } + }); + + it("a new board message reactivates the same conversation and prevents stale settlement", async () => { + const f = await fixture(); + await settle(f); + const followup = await issueService(db).addComment(f.issueId, "what's your name?", { userId: "local-board" }); + expect((await state(f))?.externalConversationState).toBe("active"); + expect(await settle(f)).toBe(false); + expect((await state(f))?.status).toBe("todo"); + await issueService(db).checkout(f.issueId, f.agentId, ["todo", "backlog", "blocked"], null); + expect((await state(f))?.status).toBe("in_progress"); + const nextRun = randomUUID(); + await db.insert(chatMessageLinks).values({ companyId: f.companyId, endpointId: f.endpointId, conversationId: f.conversationId, commentId: followup.id, providerMessageId: followup.id, direction: "inbound" }); + await db.insert(heartbeatRuns).values({ id: nextRun, companyId: f.companyId, agentId: f.agentId, runtimeMode: "legacy", status: "succeeded", finishedAt: new Date(), + contextSnapshot: { issueId: f.issueId, source: "chat:slack", wakeCommentId: followup.id } }); + const [response] = await db.insert(issueComments).values({ companyId: f.companyId, issueId: f.issueId, authorAgentId: f.agentId, createdByRunId: nextRun, body: "Carl", metadata: { version: 1, authorizationReason: "allow_chat_run_presentation", sections: [] } }).returning(); + await db.insert(chatPublications).values({ companyId: f.companyId, endpointId: f.endpointId, conversationId: f.conversationId, issueId: f.issueId, commentId: response.id, + idempotencyKey: nextRun, payload: { text: "Carl" }, state: "published", providerMessageId: nextRun }); + expect(await settle(f)).toBe(true); + expect((await state(f))?.externalConversationState).toBe("waiting"); + }); + + it("serializes simultaneous finalizers and a new message without losing the message", async () => { + const f = await fixture(); + await Promise.all([settle(f), settle(f), issueService(db).addComment(f.issueId, "another request", { userId: "local-board" })]); + expect((await state(f))?.externalConversationState).toBe("active"); + expect(await settle(f)).toBe(false); + }); + + it("lets an operator explicitly request review instead of keeping Idle", async () => { + const f = await fixture(); + await settle(f); + await issueService(db).update(f.issueId, { status: "in_review", actorUserId: "local-board" }); + expect(await state(f)).toEqual({ status: "in_review", externalConversationState: "active" }); + expect(await settle(f)).toBe(false); + }); + + it("duplicate board delivery does not reactivate an answered turn", async () => { + const f = await fixture(); + const clientRequestId = randomUUID(); + await db.update(issueComments).set({ clientRequestId }).where(eq(issueComments.id, f.wakeId)); + await settle(f); + const duplicate = await issueService(db).addComment(f.issueId, "you there?", { userId: "local-board" }, { clientRequestId }); + expect(duplicate.id).toBe(f.wakeId); + expect((await state(f))?.externalConversationState).toBe("waiting"); + }); + + it("keeps delivery errors visible after a conversation has settled", async () => { + const f = await fixture(); + await settle(f); + await db.update(chatPublications).set({ state: "failed" }).where(eq(chatPublications.id, f.publicationId)); + expect((await state(f))?.externalConversationState).toBe("active"); + expect(await db.select().from(issues).where(and(eq(issues.id, f.issueId), executionIssueCondition()))).toHaveLength(1); + }); + + it("does not settle past an unlinked Slack guest's newer message", async () => { + const f = await fixture(); + const [message] = await db.insert(issueComments).values({ companyId: f.companyId, issueId: f.issueId, authorType: "system", body: "one more thing" }).returning(); + await db.insert(chatMessageLinks).values({ companyId: f.companyId, endpointId: f.endpointId, conversationId: f.conversationId, commentId: message.id, providerMessageId: message.id, direction: "inbound" }); + expect(await settle(f)).toBe(false); + }); + + it("requires committed native response-wait evidence", async () => { + const f = await fixture(true); + await db.update(nativeRunFinalizations).set({ phase: "arbitrating" }).where(eq(nativeRunFinalizations.runId, f.runId)); + expect(await settle(f)).toBe(false); + await db.update(nativeRunFinalizations).set({ phase: "committed" }).where(eq(nativeRunFinalizations.runId, f.runId)); + await db.update(heartbeatRuns).set({ resultJson: { finalizationReasonCode: "governed_response_waiting" } }).where(eq(heartbeatRuns.id, f.runId)); + expect(await settle(f)).toBe(false); + }); + + it("settles an authorized published reply after an interaction continuation", async () => { + const f = await fixture(true); + const [answer] = await db.insert(issueComments).values({ companyId: f.companyId, issueId: f.issueId, + authorType: "user", authorUserId: "local-board", body: "Here is the requested answer", createdAt: new Date(f.start.getTime() + 2) }).returning(); + await db.update(heartbeatRuns).set({ contextSnapshot: { + issueId: f.issueId, source: "issue.interaction.respond", externalChatContinuation: true, wakeCommentId: answer.id, + } }).where(eq(heartbeatRuns.id, f.runId)); + expect(await settle(f)).toBe(true); + }); + + it("waits for execution release before moving the issue to review", async () => { + const f = await fixture(); + await db.update(issues).set({ executionRunId: f.runId }).where(eq(issues.id, f.issueId)); + expect(await settle(f)).toBe(false); + expect((await state(f))?.status).toBe("in_progress"); + await db.update(issues).set({ executionRunId: null }).where(eq(issues.id, f.issueId)); + expect(await settle(f)).toBe(true); + }); + + it.each([ + { status: "pending" }, + { status: "changes_requested" }, + { status: "idle", monitor: { status: "scheduled" } }, + { status: "idle", monitor: { status: "triggered" } }, + ])("preserves governed or monitored unfinished work: %j", async (executionState) => { + const f = await fixture(); + await db.update(issues).set({ executionState }).where(eq(issues.id, f.issueId)); + expect(await settle(f)).toBe(false); + }); + + it("preserves pending interactions and removes Idle if a real review is requested later", async () => { + const f = await fixture(); + await settle(f); + await db.insert(issueThreadInteractions).values({ companyId: f.companyId, issueId: f.issueId, kind: "request_confirmation", payload: { version: 1, prompt: "Approve?" } }); + expect((await state(f))?.externalConversationState).toBe("active"); + await db.update(issues).set({ status: "in_progress" }).where(eq(issues.id, f.issueId)); + await db.update(chatConversations).set({ state: "active" }).where(eq(chatConversations.id, f.conversationId)); + expect(await settle(f)).toBe(false); + }); + + it.each(["failed", "cancelled", "timed_out", "queued", "running", "scheduled_retry"])("does not park a %s run", async (status) => { + const f = await fixture(); + await db.update(heartbeatRuns).set({ status }).where(eq(heartbeatRuns.id, f.runId)); + expect(await settle(f)).toBe(false); + }); + it.each(["pending", "failed", "delivery_unknown", "retry", "streaming", "awaiting_consent"] as const)("does not park %s delivery", async (state) => { + const f = await fixture(); + await db.update(chatPublications).set({ state }).where(eq(chatPublications.id, f.publicationId)); + expect(await settle(f)).toBe(false); + }); + it.each(["done", "blocked", "cancelled", "in_review"])("preserves explicit %s disposition", async (status) => { + const f = await fixture(); + await db.update(issues).set({ status }).where(eq(issues.id, f.issueId)); + expect(await settle(f)).toBe(false); + }); + it.each(["completed", "unavailable", "endpoint_removed"])("does not reactivate a %s conversation", async (state) => { + const f = await fixture(); + await db.update(chatConversations).set({ state }).where(eq(chatConversations.id, f.conversationId)); + expect(await settle(f)).toBe(false); + }); + it("respects company, provider, and connection boundaries", async () => { + const f = await fixture(); + expect(await settleSlackConversation(db, randomUUID(), f.issueId)).toBe(false); + await db.update(chatEndpoints).set({ status: "revoked" }).where(eq(chatEndpoints.id, f.endpointId)); + expect(await settle(f)).toBe(false); + await db.update(chatEndpoints).set({ status: "active", provider: "telegram" }).where(eq(chatEndpoints.id, f.endpointId)); + expect(await settle(f)).toBe(false); + }); + it("preserves scheduled work, newer runs, queued wakes, monitors, blockers, and approvals", async () => { + const monitor = await fixture(); + await db.update(issues).set({ monitorNextCheckAt: new Date(Date.now() + 60000) }).where(eq(issues.id, monitor.issueId)); + expect(await settle(monitor)).toBe(false); + const queued = await fixture(); + await db.insert(agentWakeupRequests).values({ companyId: queued.companyId, agentId: queued.agentId, source: "automation", status: "deferred_issue_execution", payload: { issueId: queued.issueId } }); + expect(await settle(queued)).toBe(false); + const newer = await fixture(); + await db.insert(heartbeatRuns).values({ companyId: newer.companyId, agentId: newer.agentId, status: "scheduled_retry", contextSnapshot: { issueId: newer.issueId } }); + expect(await settle(newer)).toBe(false); + const blocked = await fixture(); + const [blocker] = await db.insert(issues).values({ companyId: blocked.companyId, title: "dependency", status: "todo" }).returning(); + await db.insert(issueRelations).values({ companyId: blocked.companyId, issueId: blocker.id, relatedIssueId: blocked.issueId, type: "blocks" }); + expect(await settle(blocked)).toBe(false); + const review = await fixture(); + const [approval] = await db.insert(approvals).values({ companyId: review.companyId, type: "hire_agent", status: "pending", payload: {} }).returning(); + await db.insert(issueApprovals).values({ companyId: review.companyId, issueId: review.issueId, approvalId: approval.id }); + expect(await settle(review)).toBe(false); + }); +}); diff --git a/server/src/routes/issues.ts b/server/src/routes/issues.ts index 228fc155471..94ec1e0d0f9 100644 --- a/server/src/routes/issues.ts +++ b/server/src/routes/issues.ts @@ -2977,6 +2977,7 @@ class AutoApprovalIssueMissingError extends Error { function toCompactIssue(issue: any): CompactIssue { return { + externalConversationState: issue.externalConversationState ?? null, id: issue.id, companyId: issue.companyId, projectId: issue.projectId, diff --git a/server/src/services/chat-channels.ts b/server/src/services/chat-channels.ts index 89b7c6bce5d..54043571869 100644 --- a/server/src/services/chat-channels.ts +++ b/server/src/services/chat-channels.ts @@ -10,6 +10,8 @@ import { githubChatReviewService } from "./chat-github-reviews.js"; import { githubChatRegistrationService } from "./chat-github-registration.js"; import { githubChatPrincipalAccess } from "./chat-github-access.js"; import { githubAppJwt } from "./chat-github-client.js"; +import { resumeSlackConversation } from "./slack-conversation-state.js"; +import { settleSlackConversation } from "./slack-conversation-lifecycle.js"; import { runtimeCanonicalOrigin } from "./cloud-runtime-identity.js"; import { takePhotonCompanion } from "./photon/attachments.js"; import { writePhotonCheckpoint } from "./photon/receiver.js"; @@ -16248,6 +16250,9 @@ export function chatChannelService(db: Db, options: ChatChannelServiceOptions) { direction: "inbound", }) .onConflictDoNothing(); + if (taskEndpoint.provider === "slack") { + await resumeSlackConversation(taskTx as unknown as Db, endpoint.companyId, conversation.issueId); + } await taskTx .update(chatConversations) .set({ @@ -37958,7 +37963,12 @@ export function chatChannelService(db: Db, options: ChatChannelServiceOptions) { // this cap. Different conversations for one bot keep the existing // endpoint-exclusive credential fence instead of timing out behind it. const task = Promise.resolve() - .then(() => processSelectedPublication(selectedPublication)) + .then(async () => { + await processSelectedPublication(selectedPublication); + await settleSlackConversation(db, selectedPublication.companyId, selectedPublication.issueId).catch((err) => { + logger.warn({ err, publicationId: selectedPublication.id }, "Slack conversation settlement deferred to reconciliation"); + }); + }) .catch((error: unknown) => { if (!failed) { failed = true; diff --git a/server/src/services/company-search.ts b/server/src/services/company-search.ts index 96af85b6aa8..8c6e96bafd4 100644 --- a/server/src/services/company-search.ts +++ b/server/src/services/company-search.ts @@ -1,3 +1,4 @@ +import { externalConversationStateSql } from "./slack-conversation-state.js"; import { and, desc, eq, gte, inArray, isNotNull, isNull, notInArray, or, sql } from "drizzle-orm"; import type { SQL } from "drizzle-orm"; import type { Db } from "@paperclipai/db"; @@ -1108,6 +1109,15 @@ export function companySearchService(db: Db) { : null; const paged = results.slice(offset, offset + limit).map(stripInternalSortFields); + const issueIds = paged.flatMap((result) => result.issue ? [result.issue.id] : []); + if (issueIds.length > 0) { + const states = await db.select({ id: issues.id, state: externalConversationStateSql() }).from(issues) + .where(and(eq(issues.companyId, companyId), inArray(issues.id, issueIds))); + const byId = new Map(states.map((row) => [row.id, row.state])); + for (const result of paged) { + if (result.issue) result.issue.externalConversationState = byId.get(result.issue.id) ?? null; + } + } return { query: query.q, normalizedQuery, diff --git a/server/src/services/heartbeat.ts b/server/src/services/heartbeat.ts index 24e4aafa461..86578694376 100644 --- a/server/src/services/heartbeat.ts +++ b/server/src/services/heartbeat.ts @@ -1,3 +1,5 @@ +import { externalConversationStateSql, nonIdleSlackIssueCondition } from "./slack-conversation-state.js"; +import { settleSlackConversation } from "./slack-conversation-lifecycle.js"; import { publicChatTaskUrl } from "./chat-task-url.js"; import { toolActionDeliveryService } from "./tool-action-delivery.js"; import { githubBotConnectionIdsForRun } from "./chat-github-tools.js"; @@ -10598,6 +10600,7 @@ export function heartbeatService( .select({ chatCommunicationGuidance: chatConversations.communicationGuidance, chatAssignedAgentId: chatEndpoints.assignedAgentId, + externalConversationState: externalConversationStateSql(), conversationAgentId: issues.conversationAgentId, conversationUserId: issues.conversationUserId, conversationState: issues.conversationState, @@ -13058,7 +13061,8 @@ export function heartbeatService( const issueId = readNonEmptyString(context.issueId); if (!issueId) return; - if (isWaitingConversation(await getIssueExecutionContext(run.companyId, issueId))) return; + const waitingContext = await getIssueExecutionContext(run.companyId, issueId); + if (isWaitingConversation(waitingContext) || waitingContext?.externalConversationState === "waiting") return; const [issue, agent] = await Promise.all([ db @@ -13259,7 +13263,8 @@ export function heartbeatService( const issueId = readNonEmptyString(context.issueId) ?? readNonEmptyString(context.taskId); if (!issueId) return; - if (isWaitingConversation(await getIssueExecutionContext(run.companyId, issueId))) return; + const waitingContext = await getIssueExecutionContext(run.companyId, issueId); + if (isWaitingConversation(waitingContext) || waitingContext?.externalConversationState === "waiting") return; if ( readNonEmptyString(context.goalControlRequestId) || context.resumeSessionGoalHeartbeat === true @@ -13577,7 +13582,8 @@ export function heartbeatService( readNonEmptyString(contextSnapshot.issueId) ?? readNonEmptyString(contextSnapshot.taskId); if (!issueId) return; - if (isWaitingConversation(await getIssueExecutionContext(run.companyId, issueId))) return; + const waitingContext = await getIssueExecutionContext(run.companyId, issueId); + if (isWaitingConversation(waitingContext) || waitingContext?.externalConversationState === "waiting") return; const issue = await db .select({ @@ -16734,6 +16740,7 @@ export function heartbeatService( isNull(issues.hiddenAt), inArray(issues.status, [...TIMER_ACTIONABLE_ISSUE_STATUSES]), isNull(issues.conversationAgentId), + nonIdleSlackIssueCondition(), ), ) .limit(1) @@ -26059,6 +26066,14 @@ export function heartbeatService( suppressImmediateRecovery: options.suppressImmediateRecovery, }); await applyWakeQueuePostCommitEffects(postCommitEffects); + const completed = await getRun(run.id); + const issueId = readNonEmptyString(completed?.contextSnapshot?.issueId) + ?? readNonEmptyString(completed?.contextSnapshot?.taskId) ?? completed?.nativeIssueId; + if (completed?.status === "succeeded" && issueId) { + await settleSlackConversation(db, run.companyId, issueId).catch((err) => { + logger.warn({ err, runId: run.id }, "Slack conversation settlement deferred to reconciliation"); + }); + } } catch (error) { if ( error instanceof WakeQueueApplicationError && diff --git a/server/src/services/issue-visibility.ts b/server/src/services/issue-visibility.ts index 23aecebbbc9..44a04a089e6 100644 --- a/server/src/services/issue-visibility.ts +++ b/server/src/services/issue-visibility.ts @@ -1,3 +1,4 @@ +import { nonIdleSlackIssueCondition } from "./slack-conversation-state.js"; import { and, isNull, type SQL } from "drizzle-orm"; import { issues } from "@paperclipai/db"; @@ -11,5 +12,5 @@ export function visibleIssueSql(alias = "issues") { /** Work queues and execution totals omit persistent conversation containers. */ export function executionIssueCondition(): SQL { - return and(visibleIssueCondition(), isNull(issues.conversationAgentId))!; + return and(visibleIssueCondition(), isNull(issues.conversationAgentId), nonIdleSlackIssueCondition())!; } diff --git a/server/src/services/issues.ts b/server/src/services/issues.ts index f2969a029d3..87a36078024 100644 --- a/server/src/services/issues.ts +++ b/server/src/services/issues.ts @@ -1,3 +1,4 @@ +import { externalConversationStateSql, nonIdleSlackIssueCondition, resumeSlackConversation } from "./slack-conversation-state.js"; import { documentService } from "./documents.js"; import { parseTaskSearch, taskSearchCtes, taskSearchScore } from "./task-search.js"; import { createdFromIssueCondition } from "./issue-creation-origin.js"; @@ -11,6 +12,7 @@ import { desc, eq, gt, + getTableColumns, gte, inArray, isNotNull, @@ -1776,7 +1778,7 @@ export interface IssueFilters { updatedSince?: string; } -type IssueRow = typeof issues.$inferSelect; +type IssueRow = typeof issues.$inferSelect & { externalConversationState?: "active" | "waiting" | null }; type IssueLabelRow = typeof labels.$inferSelect; type IssuePlanDecompositionRow = typeof issuePlanDecompositions.$inferSelect; type IssueActiveRunRow = { @@ -4410,7 +4412,7 @@ async function listIssueReviewAttentionMap( .select() .from(issues) .where( - and(eq(issues.companyId, companyId), inArray(issues.id, chunk)), + and(eq(issues.companyId, companyId), inArray(issues.id, chunk), nonIdleSlackIssueCondition()), )), ); } @@ -4777,6 +4779,7 @@ async function listIssueReviewAttentionMap( } const issueListSelect = { + externalConversationState: externalConversationStateSql(), conversationAgentId: issues.conversationAgentId, conversationUserId: issues.conversationUserId, conversationState: issues.conversationState, @@ -6492,7 +6495,7 @@ export function issueService(db: Db) { async function getIssueByUuid(id: string) { const row = await db - .select() + .select({ ...getTableColumns(issues), externalConversationState: externalConversationStateSql() }) .from(issues) .where(eq(issues.id, id)) .then((rows) => rows[0] ?? null); @@ -6503,7 +6506,7 @@ export function issueService(db: Db) { async function getIssueByIdentifier(identifier: string) { const row = await db - .select() + .select({ ...getTableColumns(issues), externalConversationState: externalConversationStateSql() }) .from(issues) .where(eq(issues.identifier, identifier.toUpperCase())) .then((rows) => rows[0] ?? null); @@ -7784,7 +7787,12 @@ export function issueService(db: Db) { eq(issues.companyId, companyId), visibleIssueCondition(), ]; - if (!filters?.q?.trim()) conditions.push(isNull(issues.conversationAgentId)); + if (!filters?.q?.trim()) { + conditions.push(isNull(issues.conversationAgentId)); + if (!filters?.touchedByUserId && !filters?.unreadForUserId && !filters?.inboxArchivedByUserId) { + conditions.push(nonIdleSlackIssueCondition()); + } + } if (filters?.afterId) conditions.push(gt(issues.id, filters.afterId)); const assigneeAgentFilter = parseIssueAssigneeAgentFilter( filters?.assigneeAgentId, @@ -8113,7 +8121,12 @@ export function issueService(db: Db) { } const conditions = [eq(issues.companyId, companyId), visibleIssueCondition()]; - if (!filters?.q?.trim()) conditions.push(isNull(issues.conversationAgentId)); + if (!filters?.q?.trim()) { + conditions.push(isNull(issues.conversationAgentId)); + if (!filters?.touchedByUserId && !filters?.unreadForUserId && !filters?.inboxArchivedByUserId) { + conditions.push(nonIdleSlackIssueCondition()); + } + } const statuses = parseStatusFilter(filters?.status); if (statuses.length === 1) conditions.push(eq(issues.status, statuses[0]!)); @@ -10841,6 +10854,14 @@ export function issueService(db: Db) { .returning() .then((rows: Array) => rows[0] ?? null); if (!updated) return null; + // An operator explicitly choosing a disposition owns that decision, + // including choosing In Review while the conversation is Idle. + if (actorUserId && issueData.status !== undefined) { + await tx.update(chatConversations).set({ state: "active", updatedAt: new Date() }) + .where(and(eq(chatConversations.companyId, updated.companyId), eq(chatConversations.issueId, updated.id), + eq(chatConversations.state, "waiting"), sql`exists (select 1 from chat_endpoints e + where e.id = ${chatConversations.endpointId} and e.company_id = ${chatConversations.companyId} and e.provider = 'slack')`)); + } if (updated.assigneeAgentId !== existing.assigneeAgentId || updated.assigneeUserId !== existing.assigneeUserId) { const { issueThreadInteractionService } = await import("./issue-thread-interactions.js"); await issueThreadInteractionService(tx).expireConnectionIntentsForOwnershipChange(updated); @@ -12025,6 +12046,10 @@ export function issueService(db: Db) { ? retryNativeChatReviewPresentation(append) : append(); } + // Callers supplying a transaction still share the settlement fence. + if (actor.userId && dbOrTx !== db) { + await dbOrTx.select({ id: issues.id }).from(issues).where(eq(issues.id, issueId)).for("update"); + } const issue = await dbOrTx .select({ companyId: issues.companyId, conversationAgentId: issues.conversationAgentId }) .from(issues) @@ -12479,6 +12504,9 @@ export function issueService(db: Db) { if (issue.conversationAgentId && actor.userId) { await dbOrTx.update(issues).set({ conversationState: "active" }).where(eq(issues.id, issueId)); } + if (authorType === "user" || actor.userId) { + await resumeSlackConversation(dbOrTx, issue.companyId, issueId); + } // Update issue's updatedAt so comment activity is reflected in recency sorting await dbOrTx .update(issues) diff --git a/server/src/services/native-runtime/native-run-finalizer.ts b/server/src/services/native-runtime/native-run-finalizer.ts index 8dfc177aef1..afef715688b 100644 --- a/server/src/services/native-runtime/native-run-finalizer.ts +++ b/server/src/services/native-runtime/native-run-finalizer.ts @@ -1,3 +1,4 @@ +import { settleSlackConversation } from "../slack-conversation-lifecycle.js"; import { dismissAutomaticCompletionReviews } from "./automatic-completion-reviews.js"; import { getNativeReviewAssignment, readNativeReviewAssignmentContext } from "./native-review-participant.js"; import { conversationNativeDecision, isConversation } from "../agent-conversations.js"; @@ -1039,6 +1040,11 @@ export async function finalizeNativeRun(input: { issueId: coordinator.issueId, runId: run.id, }); + if (input.projectRunStatus) { + await settleSlackConversation(input.db, run.companyId, coordinator.issueId).catch((err) => { + logger.warn({ err, runId: run.id }, "Slack conversation settlement deferred to reconciliation"); + }); + } return coordinator; } const [resultRow, contractRow] = await Promise.all([ @@ -1363,6 +1369,11 @@ export async function finalizeNativeRun(input: { issueId: coordinator.issueId, runId: run.id, }); + if (input.projectRunStatus && finalizationPhase === "committed") { + await settleSlackConversation(input.db, run.companyId, coordinator.issueId).catch((err) => { + logger.warn({ err, runId: run.id }, "Slack conversation settlement deferred to reconciliation"); + }); + } return { ...coordinator, phase: finalizationPhase, diff --git a/server/src/services/recovery/service.ts b/server/src/services/recovery/service.ts index bbbff367c63..19316440a2a 100644 --- a/server/src/services/recovery/service.ts +++ b/server/src/services/recovery/service.ts @@ -1,3 +1,5 @@ +import { settleSlackConversation } from "../slack-conversation-lifecycle.js"; +import { externalConversationStateSql } from "../slack-conversation-state.js"; import { hasLiveLegacyController } from "../legacy-controller-lease.js"; import { instanceSettingsService } from "../instance-settings.js"; import { isWaitingConversation, settleConversationTurn, deliverConversationComments } from "../agent-conversations.js"; @@ -4208,6 +4210,12 @@ export function recoveryService( } for (const issue of candidates) { + if (issue.originKind === "chat_channel") { + await settleSlackConversation(db, issue.companyId, issue.id); + const [current] = await db.select({ externalConversationState: externalConversationStateSql() }) + .from(issues).where(and(eq(issues.companyId, issue.companyId), eq(issues.id, issue.id))); + if (current?.externalConversationState === "waiting") { result.skipped += 1; continue; } + } if (issue.conversationAgentId) { const lastRun = await getLatestIssueRun(issue.companyId, issue.id); if (lastRun?.status === "succeeded") { diff --git a/server/src/services/slack-conversation-lifecycle.ts b/server/src/services/slack-conversation-lifecycle.ts new file mode 100644 index 00000000000..10157ad13de --- /dev/null +++ b/server/src/services/slack-conversation-lifecycle.ts @@ -0,0 +1,103 @@ +import { and, desc, eq, inArray, sql } from "drizzle-orm"; +import { chatConversations, chatEndpoints, heartbeatRuns, issueComments, issues, type Db } from "@paperclipai/db"; +import { persistActivity, publishActivity, type ActivityPublication } from "./activity-log.js"; + +/** Both run finalization and provider publication can arrive first. Re-read + * durable evidence under the task lock; never infer completion from prose. */ +export async function settleSlackConversation(db: Db, companyId: string, issueId: string): Promise { + let activity: ActivityPublication | null = null; + const settled = await db.transaction(async (tx) => { + // Match chat admission's endpoint -> task lock order. A closed/revoked + // connection must not be resurrected by a late finalizer. + const [binding] = await tx.select({ conversation: chatConversations, endpoint: chatEndpoints }) + .from(chatConversations) + .innerJoin(chatEndpoints, and(eq(chatEndpoints.id, chatConversations.endpointId), eq(chatEndpoints.companyId, chatConversations.companyId))) + .where(and(eq(chatConversations.companyId, companyId), eq(chatConversations.issueId, issueId), + eq(chatEndpoints.provider, "slack"), inArray(chatConversations.state, ["active", "waiting"]), + inArray(chatEndpoints.status, ["active", "verifying"]))) + .orderBy(desc(chatConversations.createdAt)).limit(1) + .for("update", { of: chatEndpoints }); + if (!binding) return false; + const [issue] = await tx.select().from(issues) + .where(and(eq(issues.companyId, companyId), eq(issues.id, issueId))).for("update"); + if (!issue || issue.originKind !== "chat_channel" || issue.conversationAgentId || issue.hiddenAt || + issue.assigneeUserId || issue.assigneeAgentId !== binding.endpoint.assignedAgentId || + issue.status !== "in_progress" || issue.executionRunId || issue.monitorNextCheckAt || + ["pending", "changes_requested"].includes(String(issue.executionState?.status))) return false; + const monitor = issue.executionState?.monitor; + if (monitor && typeof monitor === "object" && "status" in monitor && + ["scheduled", "triggered"].includes(String(monitor.status))) return false; + const [run] = await tx.select().from(heartbeatRuns) + .where(and(eq(heartbeatRuns.companyId, companyId), + sql`coalesce(${heartbeatRuns.contextSnapshot}->>'issueId', ${heartbeatRuns.contextSnapshot}->>'taskId', ${heartbeatRuns.nativeIssueId}::text) = ${issueId}`)) + .orderBy(desc(heartbeatRuns.createdAt), desc(heartbeatRuns.id)).limit(1); + if (!run || run.status !== "succeeded" || run.agentId !== issue.assigneeAgentId || + !run.finishedAt || + run.scheduledRetryAt || ["plan_only", "empty_response"].includes(run.livenessState ?? "")) return false; + if (run.runtimeMode === "native" && run.resultJson?.finalizationReasonCode !== "external_chat_response_waiting") return false; + // The published, server-selected response is the binding proof. Resolved + // questions can use an interaction continuation source and a board comment + // instead of an inbound Slack link; publication already enforced access. + const context = run.contextSnapshot ?? {}; + const commentIds = [...new Set([ + context.wakeCommentId, context.commentId, + ...(Array.isArray(context.wakeCommentIds) ? context.wakeCommentIds : []), + ].filter((id): id is string => typeof id === "string" && /^[a-f0-9-]{36}$/i.test(id)))]; + if (!commentIds.length) return false; + const [wake] = await tx.select().from(issueComments) + .where(and(eq(issueComments.companyId, companyId), eq(issueComments.issueId, issueId), inArray(issueComments.id, commentIds))) + .orderBy(desc(issueComments.createdAt), desc(issueComments.id)).limit(1); + if (!wake) return false; + const [evidence] = await tx.execute<{ ready: boolean }>(sql`select + exists (select 1 from chat_publications p join issue_comments response + on response.id = p.comment_id and response.company_id = p.company_id and response.issue_id = p.issue_id + where p.company_id = ${companyId} and p.issue_id = ${issueId} and p.conversation_id = ${binding.conversation.id} + and p.state = 'published' and p.provider_message_id is not null + and response.created_by_run_id = ${run.id} and response.author_agent_id = ${run.agentId} + and response.deleted_at is null + and response.created_at >= (select original.created_at from issue_comments original + where original.company_id = ${companyId} and original.id = ${wake.id}) + and response.metadata->>'authorizationReason' = 'allow_chat_run_presentation') + and (${run.runtimeMode} <> 'native' or exists (select 1 from native_run_finalizations f + where f.company_id = ${companyId} and f.issue_id = ${issueId} and f.run_id = ${run.id} and f.phase = 'committed')) + and not exists (select 1 from agent_task_sessions session where session.company_id = ${companyId} + and session.task_key = ${issueId} and session.goal_status is not null and session.goal_status <> 'complete') + and not exists (select 1 from issue_comments newer where newer.company_id = ${companyId} and newer.issue_id = ${issueId} + and newer.deleted_at is null and newer.author_agent_id is null + and (coalesce(newer.author_type, 'user') <> 'system' or exists (select 1 from chat_message_links inbound + where inbound.company_id = newer.company_id and inbound.comment_id = newer.id + and inbound.conversation_id = ${binding.conversation.id} and inbound.direction = 'inbound')) + and (newer.created_at, newer.id) > (select original.created_at, original.id from issue_comments original + where original.company_id = ${companyId} and original.id = ${wake.id})) + and not exists (select 1 from heartbeat_runs r where r.company_id = ${companyId} + and coalesce(r.context_snapshot->>'issueId', r.context_snapshot->>'taskId', r.native_issue_id::text) = ${issueId} + and r.status in ('queued', 'running', 'scheduled_retry')) + and not exists (select 1 from agent_wakeup_requests w where w.company_id = ${companyId} + and coalesce(w.payload->>'issueId', w.payload->>'taskId', w.payload->'_paperclipWakeContext'->>'issueId') = ${issueId} + and w.status in ('queued', 'claimed', 'deferred_issue_execution') and w.run_id is distinct from ${run.id}::uuid) + and not exists (select 1 from issue_thread_interactions i where i.company_id = ${companyId} and i.issue_id = ${issueId} and i.status = 'pending') + and not exists (select 1 from issue_approvals ia join approvals a on a.id = ia.approval_id and a.company_id = ia.company_id + where ia.company_id = ${companyId} and ia.issue_id = ${issueId} and a.status in ('pending', 'revision_requested')) + and not exists (select 1 from issue_relations edge join issues blocker on blocker.id = edge.issue_id and blocker.company_id = edge.company_id + where edge.company_id = ${companyId} and edge.related_issue_id = ${issueId} and edge.type = 'blocks' and blocker.status <> 'done') + and not exists (select 1 from chat_publications p where p.company_id = ${companyId} and p.conversation_id = ${binding.conversation.id} + and p.state in ('pending', 'streaming', 'retry', 'delivery_unknown', 'failed', 'awaiting_consent')) + as ready`); + if (!evidence?.ready) return false; + const changed = await tx.update(chatConversations).set({ state: "waiting", updatedAt: new Date() }) + .where(and(eq(chatConversations.id, binding.conversation.id), eq(chatConversations.companyId, companyId), eq(chatConversations.state, "active"))) + .returning({ id: chatConversations.id }); + if (!changed.length) return false; + await tx.update(issues).set({ status: "in_review", updatedAt: new Date() }) + .where(and(eq(issues.id, issueId), eq(issues.companyId, companyId))); + activity = (await persistActivity(tx as unknown as Db, { + companyId, actorType: "system", actorId: "slack-conversation", action: "issue.updated", + entityType: "issue", entityId: issueId, runId: run.id, + details: { status: "in_review", externalConversationState: "waiting", conversationId: binding.conversation.id, + issueTitle: issue.title, issueIdentifier: issue.identifier }, + })).publication; + return true; + }); + if (activity) publishActivity(activity); + return settled; +} diff --git a/server/src/services/slack-conversation-state.ts b/server/src/services/slack-conversation-state.ts new file mode 100644 index 00000000000..ab7f2181642 --- /dev/null +++ b/server/src/services/slack-conversation-state.ts @@ -0,0 +1,55 @@ +import { chatConversations, issues, type Db } from "@paperclipai/db"; +import { and, eq, sql } from "drizzle-orm"; + +/** Read-only projection; Slack threads do not acquire Agent Chat identities. */ +export function externalConversationStateSql() { + return sql<"active" | "waiting" | null>`( + select case when c.state = 'waiting' and "issues"."status" = 'in_review' + and "issues"."execution_run_id" is null + and "issues"."monitor_next_check_at" is null + and coalesce("issues"."execution_state"->>'status', '') not in ('pending', 'changes_requested') + and coalesce("issues"."execution_state"->'monitor'->>'status', '') not in ('scheduled', 'triggered') + and not exists (select 1 from issue_thread_interactions i + where i.company_id = c.company_id and i.issue_id = c.issue_id and i.status = 'pending') + and not exists (select 1 from issue_approvals ia join approvals a on a.id = ia.approval_id and a.company_id = ia.company_id + where ia.company_id = c.company_id and ia.issue_id = c.issue_id and a.status in ('pending', 'revision_requested')) + and not exists (select 1 from chat_publications p + where p.company_id = c.company_id and p.conversation_id = c.id + and p.state in ('pending', 'streaming', 'retry', 'delivery_unknown', 'failed', 'awaiting_consent')) + and not exists (select 1 from heartbeat_runs r where r.company_id = c.company_id + and coalesce(r.context_snapshot->>'issueId', r.context_snapshot->>'taskId', r.native_issue_id::text) = c.issue_id::text + and r.status in ('queued', 'running', 'scheduled_retry')) + and not exists (select 1 from agent_wakeup_requests w where w.company_id = c.company_id + and coalesce(w.payload->>'issueId', w.payload->>'taskId', w.payload->'_paperclipWakeContext'->>'issueId') = c.issue_id::text + and w.status in ('queued', 'claimed', 'deferred_issue_execution') + and not exists (select 1 from heartbeat_runs owner where owner.id = w.run_id + and owner.company_id = w.company_id and owner.status = 'succeeded')) + and not exists (select 1 from agent_task_sessions session where session.company_id = c.company_id + and session.task_key = c.issue_id::text and session.goal_status is not null and session.goal_status <> 'complete') + and not exists (select 1 from issue_relations edge join issues blocker on blocker.id = edge.issue_id and blocker.company_id = edge.company_id + where edge.company_id = c.company_id and edge.related_issue_id = c.issue_id and edge.type = 'blocks' and blocker.status <> 'done') + then 'waiting' else 'active' end + from chat_conversations c join chat_endpoints e on e.id = c.endpoint_id and e.company_id = c.company_id + where c.company_id = "issues"."company_id" and c.issue_id = "issues"."id" + and e.provider = 'slack' and e.assigned_agent_id = "issues"."assignee_agent_id" + and e.status in ('active', 'verifying') and c.state in ('active', 'waiting') + order by c.created_at desc, c.id desc limit 1 + )`; +} + +export function nonIdleSlackIssueCondition() { + return sql`${externalConversationStateSql()} is distinct from 'waiting'`; +} + +/** Called inside message admission while its transaction owns the issue lock. */ +export async function resumeSlackConversation(tx: Db, companyId: string, issueId: string) { + // Only the verified idle convention may leave In Review automatically. + // A real decision or delivery problem keeps the existing review semantics. + await tx.update(issues).set({ status: "todo", updatedAt: new Date() }) + .where(and(eq(issues.companyId, companyId), eq(issues.id, issueId), + sql`${externalConversationStateSql()} = 'waiting'`)); + await tx.update(chatConversations).set({ state: "active", updatedAt: new Date() }) + .where(and(eq(chatConversations.companyId, companyId), eq(chatConversations.issueId, issueId), + eq(chatConversations.state, "waiting"), sql`exists (select 1 from chat_endpoints e + where e.id = ${chatConversations.endpointId} and e.company_id = ${chatConversations.companyId} and e.provider = 'slack')`)); +} diff --git a/ui/src/components/ActiveAgentsPanel.test.tsx b/ui/src/components/ActiveAgentsPanel.test.tsx index 8871a05e248..80a7b2813ff 100644 --- a/ui/src/components/ActiveAgentsPanel.test.tsx +++ b/ui/src/components/ActiveAgentsPanel.test.tsx @@ -261,6 +261,19 @@ describe("ActiveAgentsPanel", () => { await act(async () => root.unmount()); }); + it("shows an answered Slack task as idle without changing the run outcome", async () => { + const root = createRoot(container); + await act(async () => { + root.render(); + }); + expect(container.querySelector('[aria-label="Agent 0 — Succeeded. View run"]')).not.toBeNull(); + expect(container.querySelector('[aria-label="Task idle"]')).not.toBeNull(); + expect(container.querySelector('[aria-label="Task in review"]')).toBeNull(); + await act(async () => root.unmount()); + }); + it("keeps a failed task lookup navigable and shows a clear error", async () => { const root = createRoot(container); await act(async () => { diff --git a/ui/src/components/ActiveAgentsPanel.tsx b/ui/src/components/ActiveAgentsPanel.tsx index ebef8e00845..34e12a65ce6 100644 --- a/ui/src/components/ActiveAgentsPanel.tsx +++ b/ui/src/components/ActiveAgentsPanel.tsx @@ -160,7 +160,7 @@ export const AgentRunCard = memo(function AgentRunCard({ }: { companyId: string; run: LiveRunForIssue; - issue?: Pick; + issue?: Pick; transcript?: TranscriptEntry[]; hasOutput?: boolean; showTranscript?: boolean; @@ -172,6 +172,7 @@ export const AgentRunCard = memo(function AgentRunCard({ const timestamp = run.finishedAt ? `Finished ${relativeTime(run.finishedAt)}` : run.startedAt ? `Started ${relativeTime(run.startedAt)}` : `Queued ${relativeTime(run.createdAt)}`; + const taskStatus = issue?.status === "in_review" && issue.externalConversationState === "waiting" ? "idle" : issue?.status ?? "backlog"; const taskTitle = issue?.title ?? (issueLoadFailed ? "Task unavailable" : "Loading task…"); return ( @@ -202,10 +203,10 @@ export const AgentRunCard = memo(function AgentRunCard({ {taskTitle} diff --git a/ui/src/components/ActivityRow.tsx b/ui/src/components/ActivityRow.tsx index c6e1fa5831d..4cc0526c9c4 100644 --- a/ui/src/components/ActivityRow.tsx +++ b/ui/src/components/ActivityRow.tsx @@ -41,7 +41,8 @@ export function ActivityRow({ event, agentMap, userProfileMap, entityNameMap, en ? (heartbeatAgentId ? entityNameMap.get(`agent:${heartbeatAgentId}`) : null) : entityNameMap.get(`${event.entityType}:${event.entityId}`); - const entityTitle = entityTitleMap?.get(`${event.entityType}:${event.entityId}`); + const entityTitle = entityTitleMap?.get(`${event.entityType}:${event.entityId}`) + ?? (event.entityType === "issue" && typeof event.details?.issueTitle === "string" ? event.details.issueTitle : undefined); const link = isHeartbeatEvent && heartbeatAgentId ? `/agents/${heartbeatAgentId}/runs/${event.entityId}` diff --git a/ui/src/components/FeedCard.test.tsx b/ui/src/components/FeedCard.test.tsx index a63418a8352..05909cae5b0 100644 --- a/ui/src/components/FeedCard.test.tsx +++ b/ui/src/components/FeedCard.test.tsx @@ -43,6 +43,13 @@ describe("FeedCard", () => { container.remove(); }); + it.each([["waiting", "moved to idle"], [null, "moved to in review"]])("distinguishes waiting from review (%s)", (state, verb) => { + const root = createRoot(container); + act(() => root.render()); + expect(container.querySelector('[data-fc="verb"]')?.textContent).toBe(verb); + act(() => root.unmount()); + }); + it("uses the whole visible card as the entity link", () => { const root = createRoot(container); act(() => { diff --git a/ui/src/components/FeedCard.tsx b/ui/src/components/FeedCard.tsx index 91e703848c4..8dd04c65350 100644 --- a/ui/src/components/FeedCard.tsx +++ b/ui/src/components/FeedCard.tsx @@ -46,6 +46,7 @@ function formatVerb( return "opened"; case "issue.updated": { const status = details?.status; + if (status === "in_review" && details?.externalConversationState === "waiting") return "moved to idle"; if (typeof status === "string") return `moved to ${humanize(status)}`; const priority = details?.priority; if (typeof priority === "string") return `set priority to ${humanize(priority)} on`; @@ -141,6 +142,7 @@ function deriveTaskStatus( return "todo"; case "issue.updated": { const status = details?.status; + if (status === "in_review" && details?.externalConversationState === "waiting") return "idle"; return typeof status === "string" ? status : null; } case "issue.document_created": diff --git a/ui/src/components/IssueColumns.tsx b/ui/src/components/IssueColumns.tsx index 324a9d9597b..8aa8e9f92c5 100644 --- a/ui/src/components/IssueColumns.tsx +++ b/ui/src/components/IssueColumns.tsx @@ -202,7 +202,7 @@ export function InboxIssueMetaLeading({ <> {showStatus ? ( - {statusSlot ?? } + {statusSlot ?? } ) : null} {checklistStepNumber !== null ? ( diff --git a/ui/src/components/IssueRow.tsx b/ui/src/components/IssueRow.tsx index c03e83512b0..f98b1e6edb7 100644 --- a/ui/src/components/IssueRow.tsx +++ b/ui/src/components/IssueRow.tsx @@ -285,7 +285,7 @@ export function IssueRow({ {leadingControl} {statusSlot ?? ( Open {identifier}: {issue.title} - {mobileLeading ?? } + {mobileLeading ?? } {parkedBlockerIndicator} @@ -458,7 +458,7 @@ export function IssueRow({ {desktopMetaLeading ?? ( <> - + {checklistStep} diff --git a/ui/src/components/IssueSiblingNavigation.tsx b/ui/src/components/IssueSiblingNavigation.tsx index 2eb80c8a101..aacf9680246 100644 --- a/ui/src/components/IssueSiblingNavigation.tsx +++ b/ui/src/components/IssueSiblingNavigation.tsx @@ -79,7 +79,7 @@ function SiblingLink({ "flex min-w-0 items-center gap-1.5 text-xs font-mono text-muted-foreground transition-colors group-hover:text-foreground", direction === "next" && "sm:justify-end", )}> - + {identifier}
diff --git a/ui/src/components/IssuesList.tsx b/ui/src/components/IssuesList.tsx index 2a947c66db3..25375b02a31 100644 --- a/ui/src/components/IssuesList.tsx +++ b/ui/src/components/IssuesList.tsx @@ -2232,7 +2232,7 @@ function StreamlinedIssuesList({ ) : undefined} statusSlot={rowPresentation === "task" ? ( { e.preventDefault(); e.stopPropagation(); }}> - onUpdateIssue(issue.id, { status: s })} /> + onUpdateIssue(issue.id, { status: s })} /> {hasChildren && isExpanded ? ( : undefined} + trailingLabel={entry.status === "in_review" && entry.externalConversationState === "waiting" ? "Idle" : undefined} className={rail ? undefined : "sidebar-action-link pointer-coarse:pr-8"} liveCount={liveIssueIds.has(entry.id) ? 1 : undefined} /> diff --git a/ui/src/components/StatusBadge.tsx b/ui/src/components/StatusBadge.tsx index 32f20d2d5d5..b514dd9bd7c 100644 --- a/ui/src/components/StatusBadge.tsx +++ b/ui/src/components/StatusBadge.tsx @@ -83,7 +83,8 @@ export function AgentStatusCapsule({ status }: { status: string }) { * Distinct from the generic {@link StatusBadge} so run/goal/approval badges are * unaffected. */ -export function IssueStatusBadge({ status }: { status: string }) { +export function IssueStatusBadge({ status: taskStatus, externalConversationState }: { status: string; externalConversationState?: "active" | "waiting" | null }) { + const status = taskStatus === "in_review" && externalConversationState === "waiting" ? "idle" : taskStatus; const cssVar = taskStatusVar[status] ?? taskStatusVarDefault; return ( = { + idle: Circle, backlog: CircleDashed, todo: Circle, in_progress: TaskProgressSpinner, diff --git a/ui/src/components/StatusIcon.test.tsx b/ui/src/components/StatusIcon.test.tsx index 87fc0a8dcde..8b258b4d93e 100644 --- a/ui/src/components/StatusIcon.test.tsx +++ b/ui/src/components/StatusIcon.test.tsx @@ -3,6 +3,7 @@ import { renderToStaticMarkup } from "react-dom/server"; import { describe, expect, it } from "vitest"; import { StatusIcon } from "./StatusIcon"; +import { IssueStatusBadge } from "./StatusBadge"; /** * StatusIcon renders the unified {@link StatusGlyph} (one shape per status) at @@ -108,3 +109,22 @@ describe("StatusIcon — glyph size (PAP-243a)", () => { expect(html).toContain('height="16"'); }); }); + + +describe("Slack idle status presentation", () => { + it("labels verified waiting conversations Idle in icons, labels, badges and picker triggers", () => { + const props = { status: "in_review", externalConversationState: "waiting" as const }; + expect(renderToStaticMarkup()).toContain(">Idle<"); + expect(renderToStaticMarkup( {}} />)).toContain('current: Idle'); + expect(renderToStaticMarkup()).toContain(">Idle<"); + }); + + it.each(["in_review", "blocked", "done", "cancelled"])("preserves %s without verified waiting", (status) => { + const html = renderToStaticMarkup(); + expect(html).not.toContain("Idle"); + }); + + it("preserves an explicit terminal outcome even with stale waiting data", () => { + expect(renderToStaticMarkup()).toContain(">Done<"); + }); +}); diff --git a/ui/src/components/StatusIcon.tsx b/ui/src/components/StatusIcon.tsx index 39db321c783..e84fb6bf53c 100644 --- a/ui/src/components/StatusIcon.tsx +++ b/ui/src/components/StatusIcon.tsx @@ -13,6 +13,7 @@ function statusLabel(status: string): string { interface StatusIconProps { status: string; + externalConversationState?: "active" | "waiting" | null; blockerAttention?: IssueBlockerAttention | null; onChange?: (status: string) => void; className?: string; @@ -75,11 +76,12 @@ function blockedAttentionLabel(blockerAttention: IssueBlockerAttention | null | * glyph — the blocked shape recoloured blue — while the full blocked reason * still rides on the accessible label. */ -export function StatusIcon({ status, blockerAttention, onChange, className, showLabel, size = "md" }: StatusIconProps) { +export function StatusIcon({ status, externalConversationState, blockerAttention, onChange, className, showLabel, size = "md" }: StatusIconProps) { const [open, setOpen] = useState(false); + const displayStatus = status === "in_review" && externalConversationState === "waiting" ? "idle" : status; const isCoveredBlocked = status === "blocked" && blockerAttention?.state === "covered"; - const ariaLabel = status === "blocked" ? blockedAttentionLabel(blockerAttention) : statusLabel(status); - const glyphStatus = isCoveredBlocked ? "in_queue" : status; + const ariaLabel = status === "blocked" ? blockedAttentionLabel(blockerAttention) : statusLabel(displayStatus); + const glyphStatus = isCoveredBlocked ? "in_queue" : displayStatus; const glyph = ( {glyph} - {statusLabel(status)} + {statusLabel(displayStatus)} ) : ( glyph @@ -108,7 +110,7 @@ export function StatusIcon({ status, blockerAttention, onChange, className, show className="inline-flex min-h-5 items-center gap-1.5 cursor-pointer hover:bg-accent/50 rounded px-1 -mx-1 py-0.5 transition-colors" > {glyph} - {statusLabel(status)} + {statusLabel(displayStatus)} ) : ( ) : ( - + ) ) : undefined} unreadState={isUnread ? "visible" : isFading ? "fading" : "hidden"} diff --git a/ui/src/pages/IssueDetail.tsx b/ui/src/pages/IssueDetail.tsx index eb55512cff0..63a6a6072cc 100644 --- a/ui/src/pages/IssueDetail.tsx +++ b/ui/src/pages/IssueDetail.tsx @@ -3714,13 +3714,14 @@ export function TaskDetailSurface({ conversation, tasksTab }: { tasksTab?: TaskS // from the blocker counts — so the key signs over the full blockerAttention, // not just `state`, to avoid a stale label when counts change. const breadcrumbStatusKey = breadcrumbStatus - ? `${breadcrumbStatus}|${JSON.stringify(breadcrumbBlockerAttention ?? null)}` + ? `${breadcrumbStatus}|${issue?.externalConversationState ?? ""}|${JSON.stringify(breadcrumbBlockerAttention ?? null)}` : undefined; const breadcrumbStatusLeading = useMemo( () => breadcrumbStatus ? ( @@ -6843,7 +6844,7 @@ export function TaskDetailSurface({ conversation, tasksTab }: { tasksTab?: TaskS const issueStatusControl = ( updateIssue.mutate({ status })} @@ -7381,6 +7382,10 @@ export function TaskDetailSurface({ conversation, tasksTab }: { tasksTab?: TaskS issueCacheRefs={issueCacheRefs} /> + {issue.status === "in_review" && issue.externalConversationState === "waiting" && ( +

Reply sent. Send a message to continue.

+ )} + {issue.hiddenAt && (
+ ); return ( ) : ( - + ) } unreadState={isUnread ? "visible" : isFading ? "fading" : "hidden"} diff --git a/ui/src/pages/MyIssues.tsx b/ui/src/pages/MyIssues.tsx index 019ce8ce80d..37a3ff15a5f 100644 --- a/ui/src/pages/MyIssues.tsx +++ b/ui/src/pages/MyIssues.tsx @@ -65,7 +65,7 @@ export function MyIssues() { title={issue.title} to={`/issues/${issue.identifier ?? issue.id}`} leading={ - + } trailing={ diff --git a/ui/src/pages/StatusCards/StatusCardDetailDrawer.tsx b/ui/src/pages/StatusCards/StatusCardDetailDrawer.tsx index 294ef0a4e65..a506c9f0143 100644 --- a/ui/src/pages/StatusCards/StatusCardDetailDrawer.tsx +++ b/ui/src/pages/StatusCards/StatusCardDetailDrawer.tsx @@ -577,7 +577,7 @@ function WatchedIssueRow({ issue }: { issue: CompanySearchIssueSummary }) { > {issue.identifier ?? issue.id.slice(0, 8)} - + {issue.title} {relativeTime(issue.updatedAt)}