The open-source app everyone uses to manage agents at work
TypeScript acpxagent-orchestrationagent-skillsagentic-aiai-agentsai-engineeringai-governanceai-toolsautonomous-agentsclaudeclaude-codeclaude-skillscodexhermesllmmcpmulti-agentopenclawproject-managementworkflow-automation
import { and, desc, eq, isNull } from "drizzle-orm";
import { heartbeatRuns, issueComments, issueThreadInteractions, issues, type Db } from "@paperclipai/db";
import { resolveConfirmationFromCommentSchema, type ResolveConfirmationFromComment } from "@paperclipai/shared";
import { assertAgentRunWriteAllowed } from "../agent-run-cancellation.js";
import { conflict, forbidden, notFound, unprocessable } from "../errors.js";
import { persistActivity, publishActivity, type ActivityPublication } from "./activity-log.js";
import { assertIssueThreadInteractionResolverAudience } from "./issue-thread-interaction-resolution.js";
import { issueThreadInteractionService } from "./issue-thread-interactions.js";
type ResolutionActor = Parameters<ReturnType<typeof issueThreadInteractionService>["acceptInteraction"]>[3];
/**
* Record the agent's interpretation of a reply, using the agent's own authority.
* The message is provenance, not a credential or server-verified proof of consent.
* Never promote its author to the resolver: human-only and independent-review
* gates must still reject this agent, even when the referenced text says yes.
*/
export async function resolveConfirmationFromComment(db: Db, args: {
companyId: string;
issueId: string;
interactionId: string;
input: ResolveConfirmationFromComment;
actor: ResolutionActor & { agentId: string; runId: string };
}) {
const input = resolveConfirmationFromCommentSchema.parse(args.input);
let publication: ActivityPublication | null = null;
const commitEffects: Array<(committedDb: Db) => Promise<void>> = [];
const result = await db.transaction(async (transaction) => {
const tx = transaction as unknown as Db;
// Match task mutation/Stop/reset lock ordering, including replay checks.
const [issue] = await tx.select().from(issues).where(and(
eq(issues.id, args.issueId), eq(issues.companyId, args.companyId),
)).for("update");
if (!issue) throw notFound("Issue not found");
await assertAgentRunWriteAllowed(tx, args.companyId, args.actor);
const [run] = await tx.select().from(heartbeatRuns).where(and(
eq(heartbeatRuns.id, args.actor.runId), eq(heartbeatRuns.companyId, args.companyId),
eq(heartbeatRuns.agentId, args.actor.agentId),
)).for("share");
if (!run || run.status !== "running" || issue.executionRunId !== run.id
|| issue.assigneeAgentId !== args.actor.agentId
|| (run.nativeIssueId ?? run.contextSnapshot?.issueId ?? run.contextSnapshot?.taskId) !== issue.id) {
throw forbidden("Only the active responding run can record a conversational decision");
}
const [card] = await tx.select().from(issueThreadInteractions).where(and(
eq(issueThreadInteractions.id, args.interactionId), eq(issueThreadInteractions.companyId, args.companyId),
eq(issueThreadInteractions.issueId, issue.id),
)).for("update");
if (!card) throw notFound("Interaction not found");
if (card.kind !== "request_confirmation" && card.kind !== "request_checkbox_confirmation") {
throw unprocessable("Only confirmation cards can be answered from a conversation");
}
const payload = card.payload as unknown as Record<string, unknown>;
if (payload.toolAction || payload.secretProposal || payload.connectionAuthorization) {
throw forbidden("Governed actions must use their dedicated approval controls");
}
const [comment] = await tx.select().from(issueComments).where(and(
eq(issueComments.id, input.commentId), eq(issueComments.companyId, args.companyId),
eq(issueComments.issueId, issue.id),
)).for("share");
if (!comment || comment.deletedAt || comment.authorType !== "user"
|| !comment.authorUserId || comment.authorAgentId || comment.createdByRunId
|| comment.sourceTrust?.disposition === "quarantined"
|| comment.createdAt < card.createdAt || comment.body.trim() === "/new") {
throw unprocessable("The answer must be a user message posted after this confirmation on the same task");
}
if ((issue.conversationUserId && comment.authorUserId !== issue.conversationUserId)
|| (run.responsibleUserId && comment.authorUserId !== run.responsibleUserId)) {
throw forbidden("The answer is not from this conversation's user");
}
if (issue.conversationAgentId) {
if (run.contextSnapshot?.conversationSessionGeneration !== issue.conversationSessionGeneration) {
throw conflict("Conversation session changed");
}
if (issue.conversationBoundaryCommentId) {
const [boundary] = await tx.select().from(issueComments).where(and(
eq(issueComments.id, issue.conversationBoundaryCommentId), eq(issueComments.companyId, args.companyId),
eq(issueComments.issueId, issue.id),
));
if (!boundary || card.createdAt <= boundary.createdAt || comment.createdAt <= boundary.createdAt) {
throw conflict("A new conversation cannot answer a previous session's confirmation");
}
}
}
const [latest] = await tx.select({ id: issueComments.id }).from(issueComments).where(and(
eq(issueComments.companyId, args.companyId), eq(issueComments.issueId, issue.id),
eq(issueComments.authorType, "user"), isNull(issueComments.deletedAt),
)).orderBy(desc(issueComments.createdAt), desc(issueComments.id)).limit(1);
if (latest?.id !== comment.id) throw conflict("A newer user message must be considered before resolving this confirmation");
const svc = issueThreadInteractionService(tx);
const current = await svc.getForIssue(issue, card.id);
assertIssueThreadInteractionResolverAudience({
actor: { type: "agent", agentId: args.actor.agentId, runId: args.actor.runId },
interaction: card, additionalRestriction: args.actor.resolverPolicyRestriction,
});
const expected = input.decision === "accept" ? "accepted" : "rejected";
const selected = input.selectedOptionIds;
if (card.kind === "request_checkbox_confirmation" && input.decision === "accept" && selected === undefined) {
throw unprocessable("Record the user's explicit selection; checkbox defaults are not an answer");
}
if (card.kind === "request_confirmation" && selected !== undefined) {
throw unprocessable("Selections apply only to checkbox confirmations");
}
if (card.status !== "pending") {
const prior = current.result as { commentId?: string; selectedOptionIds?: string[]; reason?: string } | null;
const sameSelection = JSON.stringify([...(prior?.selectedOptionIds ?? [])].sort()) === JSON.stringify([...(selected ?? [])].sort());
if (card.status !== expected || prior?.commentId !== comment.id || !sameSelection
|| (input.decision === "reject" && (prior?.reason ?? "") !== (input.reason ?? ""))) {
throw conflict("This confirmation already has a different decision");
}
return { interaction: current, deduplicated: true };
}
// These service methods recheck resolver audience, company review policy,
// target revision, selection bounds and issue lifecycle under the same lock.
const mutationOptions = { deferConfirmationCommitEffects: (effect: (committedDb: Db) => Promise<void>) => { commitEffects.push(effect); } };
const interaction = input.decision === "accept"
? (await svc.acceptInteraction(issue, card.id, { selectedOptionIds: selected }, args.actor, mutationOptions)).interaction
: await svc.rejectInteraction(issue, card.id, { reason: input.reason }, args.actor, mutationOptions);
if ((interaction.kind !== "request_confirmation" && interaction.kind !== "request_checkbox_confirmation") || !interaction.result) {
throw conflict("Confirmation resolution did not persist a result");
}
await tx.update(issueThreadInteractions).set({
result: { ...interaction.result, commentId: comment.id },
}).where(and(eq(issueThreadInteractions.id, card.id), eq(issueThreadInteractions.companyId, args.companyId)));
publication = (await persistActivity(tx, {
companyId: args.companyId, actorType: "agent", actorId: args.actor.agentId,
agentId: args.actor.agentId, runId: args.actor.runId,
action: `issue.thread_interaction_${expected}`, entityType: "issue", entityId: issue.id,
details: { interactionId: card.id, interactionKind: card.kind, interactionStatus: expected,
responseCommentId: comment.id, responseUserId: comment.authorUserId, source: "conversation_reply" },
})).publication;
return { interaction: await svc.getForIssue(issue, card.id), deduplicated: false };
});
if (publication) publishActivity(publication);
for (const effect of commitEffects) await effect(db);
return result;
}