@paperclipai/server 2026.817.0 → 2026.818.0-beta.1

package/dist/services/issue-thread-interactions.js

@@ -1,13 +1,15 @@
 import { isDeepStrictEqual } from "node:util";
 import { and, asc, desc, eq, inArray, isNotNull, isNull, ne } from "drizzle-orm";
 import { agents, companies, documents, heartbeatRuns, issueComments, issueDocuments, issueThreadInteractions, issues, toolActionRequests, } from "@paperclipai/db";
-import { trackInteractionResolved } from "@paperclipai/shared/telemetry";
-import { acceptIssueThreadInteractionSchema, askUserQuestionsPayloadSchema, askUserQuestionsResultSchema, cancelIssueThreadInteractionSchema, createIssueThreadInteractionSchema, rejectIssueThreadInteractionSchema, requestCheckboxConfirmationPayloadSchema, requestCheckboxConfirmationResultSchema, requestConfirmationPayloadSchema, requestConfirmationResultSchema, requestItemVerdictsPayloadSchema, requestItemVerdictsResultSchema, suggestTasksPayloadSchema, suggestTasksResultSchema, submitIssueThreadInteractionVerdictsSchema, withdrawIssueThreadInteractionSchema, } from "@paperclipai/shared";
+import { trackInteractionCreated, trackInteractionResolved } from "@paperclipai/shared/telemetry";
+import { acceptIssueThreadInteractionSchema, askUserQuestionsPayloadSchema, askUserQuestionsResultSchema, cancelIssueThreadInteractionSchema, createIssueThreadInteractionSchema, legacyIssueThreadInteractionResolverPolicyAlias, normalizeIssueThreadInteractionResolverPolicy, rejectIssueThreadInteractionSchema, requestCheckboxConfirmationPayloadSchema, requestCheckboxConfirmationResultSchema, requestConfirmationPayloadSchema, requestConfirmationResultSchema, requestItemVerdictsPayloadSchema, requestItemVerdictsResultSchema, suggestTasksPayloadSchema, suggestTasksResultSchema, submitIssueThreadInteractionVerdictsSchema, withdrawIssueThreadInteractionSchema, } from "@paperclipai/shared";
 import { conflict, forbidden, notFound, unprocessable } from "../errors.js";
 import { getTelemetryClient } from "../telemetry.js";
 import { logActivity } from "./activity-log.js";
 import { evaluateAgentInvokabilityFromDb } from "./agent-invokability.js";
+import { assertIssueReviewVerdictActorAllowed, isIssueReviewVerdictInteraction, } from "./issue-review-policy.js";
 import { issueService, runWorkspaceIsFinalized } from "./issues.js";
+import { assertIssueThreadInteractionResolverAudience, canonicalizeStoredResolverPolicy, issueThreadInteractionResolutionError, } from "./issue-thread-interaction-resolution.js";
 import { createPullRequestMergeStateResolver, extractGitHubPullRequestReferences, setBoundedPullRequestCacheEntry, } from "./github-pull-request-merge.js";
 export { extractGitHubPullRequestReferences } from "./github-pull-request-merge.js";
 const GITHUB_PULL_REQUEST_URL_PATTERN = /https:\/\/(?:www\.)?github\.com\/([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)\/pull\/([1-9][0-9]*)/gi;
@@ -106,54 +108,91 @@ export function getMergeConfirmationPullRequestReferences(row) {
     return extractGitHubPullRequestReferences(trustedTextValues);
 }
 const ISSUE_THREAD_INTERACTION_IDEMPOTENCY_CONSTRAINT = "issue_thread_interactions_company_issue_idempotency_uq";
-const DEFAULT_RESOLVER_POLICY_BY_KIND = {
-    suggest_tasks: "board_only",
-    ask_user_questions: "board_or_agents",
-    request_confirmation: "board_only",
-    request_checkbox_confirmation: "board_only",
-    request_item_verdicts: "board_only",
+export const DEFAULT_RESOLVER_POLICY_BY_KIND = {
+    suggest_tasks: "anyone",
+    ask_user_questions: "anyone",
+    request_confirmation: "anyone",
+    request_checkbox_confirmation: "anyone",
+    request_item_verdicts: "anyone",
+};
+const RESOLVER_POLICY_RESTRICTION_RANK = {
+    anyone: 0,
+    not_creator: 1,
+    human_only: 2,
 };
 export function resolveInteractionPolicy(args) {
     const kindGovernance = args.governance[args.kind];
-    const requestedResolverPolicy = args.requested
+    const requestedPolicyInput = args.requested
         ?? kindGovernance?.defaultPolicy
         ?? DEFAULT_RESOLVER_POLICY_BY_KIND[args.kind];
-    const effectiveResolverPolicy = args.hasToolAction || kindGovernance?.cap === "board_only"
-        ? "board_only"
-        : requestedResolverPolicy;
-    return { requestedResolverPolicy, effectiveResolverPolicy };
-}
-function assertAgentResolutionAllowed(current, actor) {
-    if (!actor.agentId)
-        return;
-    if (!actor.runId)
-        throw forbidden("Agent run id required to resolve an issue-thread interaction");
-    if (current.kind === "request_confirmation"
-        && current.payload
-        && typeof current.payload === "object"
-        && "toolAction" in current.payload
-        && current.payload.toolAction !== undefined) {
-        throw forbidden("Tool-action confirmations are always board-only");
-    }
-    if (actor.reviewVerdictAuthorized && isRequestConfirmationLikeKind(current.kind)) {
-        assertAgentInteractionActorAllowed(current, actor);
-        return;
+    const requestedResolverPolicy = normalizeIssueThreadInteractionResolverPolicy(requestedPolicyInput);
+    const resolverPolicyProvenance = args.requested === undefined ? "inherited" : "explicit";
+    let effectiveResolverPolicy = requestedResolverPolicy;
+    let effectiveResolverPolicySource = "requested";
+    if (args.hasToolAction) {
+        effectiveResolverPolicy = "human_only";
+        effectiveResolverPolicySource = "governed_action";
     }
-    if (current.effectiveResolverPolicy !== "board_or_agents") {
-        throw forbidden("This issue-thread interaction is board-only");
+    else if (kindGovernance?.cap) {
+        const cap = normalizeIssueThreadInteractionResolverPolicy(kindGovernance.cap);
+        if (RESOLVER_POLICY_RESTRICTION_RANK[cap] > RESOLVER_POLICY_RESTRICTION_RANK[effectiveResolverPolicy]) {
+            effectiveResolverPolicy = cap;
+            effectiveResolverPolicySource = "company_cap";
+        }
     }
-    assertAgentInteractionActorAllowed(current, actor);
+    return {
+        requestedResolverPolicy,
+        effectiveResolverPolicy,
+        resolverPolicyProvenance,
+        effectiveResolverPolicySource,
+    };
 }
-function assertAgentInteractionActorAllowed(current, actor) {
-    if (current.addresseeAgentId && current.addresseeAgentId !== actor.agentId) {
-        throw forbidden("Only the addressed agent or a board user may resolve this issue-thread interaction");
+function resolverActor(actor) {
+    if (actor.systemId)
+        return { type: "system", systemId: actor.systemId };
+    if (actor.agentId) {
+        return { type: "agent", agentId: actor.agentId, runId: actor.runId };
     }
-    if (current.createdByAgentId === actor.agentId) {
-        throw forbidden("Agents cannot resolve interactions they created");
+    if (actor.userId)
+        return { type: "user", userId: actor.userId };
+    // Missing principals must fail closed. Internal maintenance paths that are
+    // intentionally system-owned provide an explicit systemId.
+    return { type: "agent", agentId: null, runId: null };
+}
+function assertInteractionResolutionAllowed(current, actor) {
+    return assertIssueThreadInteractionResolverAudience({
+        actor: resolverActor(actor),
+        interaction: current,
+        additionalRestriction: actor.resolverPolicyRestriction,
+        governedAction: current.kind === "request_confirmation"
+            && current.payload !== null
+            && typeof current.payload === "object"
+            && "toolAction" in current.payload
+            && current.payload.toolAction !== undefined,
+    });
+}
+async function assertRequestConfirmationResolutionAllowedUnderLock(tx, issue, interaction, actor) {
+    if (isTerminalIssueStatus(issue.status)) {
+        throw conflict("Interaction is no longer actionable because the issue is closed");
     }
-    if (current.sourceRunId && current.sourceRunId === actor.runId) {
-        throw forbidden("Agents cannot resolve interactions created by the same run");
+    const isReviewVerdict = issue.status === "in_review"
+        && isRequestConfirmationLikeKind(interaction.kind)
+        && await isIssueReviewVerdictInteraction(tx, { issue, interaction });
+    assertInteractionResolutionAllowed(interaction, actor);
+    if (!isReviewVerdict)
+        return;
+    const verdictActor = actor.agentId
+        ? { type: "agent", id: actor.agentId }
+        : actor.userId
+            ? { type: "user", id: actor.userId }
+            : null;
+    if (!verdictActor) {
+        throw forbidden("A review verdict requires an authenticated agent or user");
     }
+    await assertIssueReviewVerdictActorAllowed(tx, {
+        issue,
+        actor: verdictActor,
+    });
 }
 const REQUEST_CONFIRMATION_INTERACTION_KINDS = [
     "request_confirmation",
@@ -218,15 +257,30 @@ function parseStoredInteractionResult(schema, raw, row) {
     return null;
 }
 function hydrateInteraction(row) {
+    const storedRequestedResolverPolicy = row.requestedResolverPolicy;
+    const storedEffectiveResolverPolicy = row.effectiveResolverPolicy;
+    const resolverPolicyProvenance = row.resolverPolicyProvenance
+        ?? (storedRequestedResolverPolicy === "board_only" || storedRequestedResolverPolicy === "board_or_agents"
+            ? "legacy_inherited_restriction"
+            : "inherited");
+    const canonicalizeStoredPolicy = (policy) => canonicalizeStoredResolverPolicy(policy, resolverPolicyProvenance);
+    const requestedResolverPolicy = canonicalizeStoredPolicy(storedRequestedResolverPolicy);
+    const effectiveResolverPolicy = canonicalizeStoredPolicy(storedEffectiveResolverPolicy);
     const base = {
         ...row,
         idempotencyKey: row.idempotencyKey ?? null,
         addresseeAgentId: row.addresseeAgentId ?? null,
         status: row.status,
         continuationPolicy: row.continuationPolicy,
-        resolverPolicy: row.requestedResolverPolicy,
-        requestedResolverPolicy: row.requestedResolverPolicy,
-        effectiveResolverPolicy: row.effectiveResolverPolicy,
+        resolverPolicy: requestedResolverPolicy,
+        requestedResolverPolicy,
+        effectiveResolverPolicy,
+        resolverPolicyProvenance,
+        effectiveResolverPolicySource: row.effectiveResolverPolicySource ?? "requested",
+        legacyResolverPolicyAliases: {
+            requested: legacyIssueThreadInteractionResolverPolicyAlias(requestedResolverPolicy),
+            effective: legacyIssueThreadInteractionResolverPolicyAlias(effectiveResolverPolicy),
+        },
     };
     switch (row.kind) {
         case "suggest_tasks":
@@ -277,6 +331,29 @@ async function touchIssue(db, issueId) {
 function isTerminalIssueStatus(status) {
     return status === "done" || status === "cancelled";
 }
+function interactionNotFoundError() {
+    return notFound("Interaction not found", { code: "interaction_not_found" });
+}
+function interactionIssueClosedError() {
+    return issueThreadInteractionResolutionError(409, "interaction_issue_closed", "Interaction is no longer actionable because the issue is closed");
+}
+function interactionAlreadyResolvedError() {
+    return issueThreadInteractionResolutionError(409, "interaction_already_resolved", "Interaction has already been resolved");
+}
+function interactionTerminalError(row) {
+    const result = row.result && typeof row.result === "object" && !Array.isArray(row.result)
+        ? row.result
+        : null;
+    if (result?.outcome === "stale_target") {
+        return issueThreadInteractionResolutionError(409, "interaction_stale_target", "Interaction target is stale");
+    }
+    if (result?.outcome === "superseded_by_comment" || result?.outcome === "superseded_by_newer_request") {
+        return issueThreadInteractionResolutionError(409, "interaction_superseded", "Interaction has been superseded");
+    }
+    if (result?.outcome === "issue_closed")
+        return interactionIssueClosedError();
+    return issueThreadInteractionResolutionError(409, "interaction_already_resolved", "Interaction has already been resolved");
+}
 function shouldReturnAcceptedConfirmationToCreatorAgent(args) {
     if (!isRequestConfirmationLikeKind(args.current.kind))
         return false;
@@ -383,6 +460,20 @@ function buildSupersededByNewerRequestResult(replacementInteractionId) {
         supersededByInteractionId: replacementInteractionId,
     };
 }
+// An agent that posts a fresh ask_user_questions while its own earlier ones on
+// the same issue are still pending has replaced them — the newer card carries
+// the real ask, so the stale siblings auto-expire (PAP-437). Mirrors the
+// `superseded_by_comment` shape (ask_user_questions results key expiry off
+// `expirationReason`, not `outcome`) so the UI can hide them cleanly.
+function buildSupersededByNewerInteractionResult(replacementInteractionId) {
+    return {
+        version: 1,
+        answers: [],
+        expirationReason: "superseded_by_newer_interaction",
+        supersededByInteractionId: replacementInteractionId,
+        summaryMarkdown: null,
+    };
+}
 function buildAdministrativeOutcomeResult(row, outcome, reason = null) {
     if (row.kind === "ask_user_questions") {
         return { version: 1, outcome, reason, answers: [], summaryMarkdown: null };
@@ -554,12 +645,24 @@ async function emitInteractionResolvedTelemetry(db, interaction, args) {
             ...buildInteractionResolvedCounts(interaction, {
                 createdTaskCount: args?.createdTaskCount,
             }),
+            legacyInheritedRestriction: interaction.resolverPolicyProvenance === "legacy_inherited_restriction",
         });
     }
     catch (error) {
         console.error("[paperclip] Failed to emit interaction.resolved telemetry", error);
     }
 }
+function emitInteractionCreatedTelemetry(args) {
+    const telemetryClient = getTelemetryClient();
+    if (!telemetryClient)
+        return;
+    try {
+        trackInteractionCreated(telemetryClient, args);
+    }
+    catch (error) {
+        console.error("[paperclip] Failed to emit interaction.created telemetry", error);
+    }
+}
 async function emitResolvedInteractionsTelemetry(db, interactions) {
     if (interactions.length === 0 || !getTelemetryClient())
         return;
@@ -606,7 +709,7 @@ function buildTaskCreationOrder(tasks) {
     }
     return ordered;
 }
-function resolveSelectedSuggestedTasks(args) {
+export function resolveSelectedSuggestedTasks(args) {
     const taskByClientKey = new Map(args.interaction.payload.tasks.map((task) => [task.clientKey, task]));
     const selectedClientKeys = args.selectedClientKeys ?? args.interaction.payload.tasks.map((task) => task.clientKey);
     const selectedClientKeySet = new Set();
@@ -660,9 +763,6 @@ function resolveSelectedCheckboxConfirmationOptions(args) {
         .map((option) => option.id);
 }
 function resolveRequestItemVerdictSubmissions(args) {
-    if (!args.actor.userId) {
-        throw unprocessable("request_item_verdicts submissions require a user actor");
-    }
     const existingItems = args.interaction.result?.items ?? [];
     const existingById = new Map(existingItems.map((item) => [item.id, item]));
     const payloadItemIds = new Set(args.interaction.payload.items.map((item) => item.id));
@@ -691,7 +791,9 @@ function resolveRequestItemVerdictSubmissions(args) {
             id: submitted.id,
             verdict: submitted.verdict,
             ...(reason ? { reason } : {}),
-            resolvedByUserId: args.actor.userId,
+            ...(args.actor.userId ? { resolvedByUserId: args.actor.userId } : {}),
+            ...(args.actor.agentId ? { resolvedByAgentId: args.actor.agentId } : {}),
+            ...(args.actor.runId ? { resolvedByRunId: args.actor.runId } : {}),
             resolvedAt: args.now,
         });
         newlyResolvedItemIds.push(submitted.id);
@@ -859,7 +961,7 @@ async function expireStaleRequestConfirmationTarget(db, args) {
         .where(and(eq(issueThreadInteractions.id, args.row.id), eq(issueThreadInteractions.status, "pending")))
         .returning();
     if (!updated) {
-        throw conflict("Interaction has already been resolved");
+        throw issueThreadInteractionResolutionError(409, "interaction_already_resolved", "Interaction has already been resolved");
     }
     await touchIssue(db, args.row.issueId);
     const expired = hydrateInteraction(updated);
@@ -906,7 +1008,7 @@ export function issueThreadInteractionService(db, opts = {}) {
             .where(eq(issueThreadInteractions.id, interactionId))
             .then((rows) => rows[0] ?? null);
         if (!current || current.companyId !== issue.companyId || current.issueId !== issue.id) {
-            throw notFound("Interaction not found");
+            throw interactionNotFoundError();
         }
         return hydrateInteraction(current);
     }
@@ -938,32 +1040,75 @@ export function issueThreadInteractionService(db, opts = {}) {
             .where(eq(issueThreadInteractions.id, args.interactionId))
             .then((rows) => rows[0] ?? null);
         if (!current)
-            throw notFound("Interaction not found");
+            throw interactionNotFoundError();
         if (current.companyId !== args.issue.companyId || current.issueId !== args.issue.id) {
-            throw notFound("Interaction not found");
+            throw interactionNotFoundError();
+        }
+        if (args.issue.status && isTerminalIssueStatus(args.issue.status)) {
+            throw interactionIssueClosedError();
         }
         if (current.status !== "pending") {
-            throw conflict("Interaction has already been resolved");
+            throw interactionTerminalError(current);
         }
         return current;
     }
+    function assertIssueOpenForInteractionResolution(issue) {
+        if (issue.status && isTerminalIssueStatus(issue.status)) {
+            throw interactionIssueClosedError();
+        }
+    }
     async function acceptRequestConfirmation(args) {
         const expired = await expireStaleRequestConfirmationTarget(db, {
             row: args.current,
             actor: args.actor,
         });
-        if (expired) {
-            return { interaction: expired, continuationIssue: null };
-        }
-        const interaction = hydrateInteraction(args.current);
-        const selectedOptionIds = interaction.kind === "request_checkbox_confirmation"
-            ? resolveSelectedCheckboxConfirmationOptions({
-                interaction,
-                selectedOptionIds: args.input.selectedOptionIds,
-            })
-            : undefined;
+        if (expired)
+            throw interactionTerminalError({ status: expired.status, result: expired.result });
         const now = new Date();
         const result = await db.transaction(async (tx) => {
+            // Lock the issue before claiming the interaction. Policy mutations and
+            // review transitions use the same issue-row lock, so the authoritative
+            // review policy and requester are stable through the verdict write.
+            const issueContext = await tx
+                .select({
+                id: issues.id,
+                companyId: issues.companyId,
+                status: issues.status,
+                assigneeAgentId: issues.assigneeAgentId,
+                assigneeUserId: issues.assigneeUserId,
+                reviewPolicy: issues.reviewPolicy,
+                createdByAgentId: issues.createdByAgentId,
+                createdByUserId: issues.createdByUserId,
+            })
+                .from(issues)
+                .where(eq(issues.id, args.issue.id))
+                .for("update")
+                .then((rows) => rows[0] ?? null);
+            if (!issueContext || issueContext.companyId !== args.issue.companyId) {
+                throw notFound("Issue not found");
+            }
+            const lockedCurrent = await tx
+                .select()
+                .from(issueThreadInteractions)
+                .where(eq(issueThreadInteractions.id, args.current.id))
+                .for("update")
+                .then((rows) => rows[0] ?? null);
+            if (!lockedCurrent
+                || lockedCurrent.companyId !== args.issue.companyId
+                || lockedCurrent.issueId !== args.issue.id) {
+                throw notFound("Interaction not found");
+            }
+            if (lockedCurrent.status !== "pending") {
+                throw issueThreadInteractionResolutionError(409, "interaction_already_resolved", "Interaction has already been resolved");
+            }
+            await assertRequestConfirmationResolutionAllowedUnderLock(tx, issueContext, lockedCurrent, args.actor);
+            const interaction = hydrateInteraction(lockedCurrent);
+            const selectedOptionIds = interaction.kind === "request_checkbox_confirmation"
+                ? resolveSelectedCheckboxConfirmationOptions({
+                    interaction,
+                    selectedOptionIds: args.input.selectedOptionIds,
+                })
+                : undefined;
             const [updated] = await tx
                 .update(issueThreadInteractions)
                 .set({
@@ -979,35 +1124,21 @@ export function issueThreadInteractionService(db, opts = {}) {
                 resolvedAt: now,
                 updatedAt: now,
             })
-                .where(and(eq(issueThreadInteractions.id, args.current.id), eq(issueThreadInteractions.status, "pending")))
+                .where(and(eq(issueThreadInteractions.id, lockedCurrent.id), eq(issueThreadInteractions.status, "pending")))
                 .returning();
             if (!updated) {
-                throw conflict("Interaction has already been resolved");
-            }
-            const issueContext = await tx
-                .select({
-                id: issues.id,
-                companyId: issues.companyId,
-                status: issues.status,
-                assigneeAgentId: issues.assigneeAgentId,
-                assigneeUserId: issues.assigneeUserId,
-            })
-                .from(issues)
-                .where(eq(issues.id, args.issue.id))
-                .then((rows) => rows[0] ?? null);
-            if (!issueContext || issueContext.companyId !== args.issue.companyId) {
-                throw notFound("Issue not found");
+                throw issueThreadInteractionResolutionError(409, "interaction_already_resolved", "Interaction has already been resolved");
             }
             let continuationIssue = null;
             if (shouldReturnAcceptedConfirmationToCreatorAgent({
                 issue: issueContext,
-                current: args.current,
+                current: lockedCurrent,
                 actor: args.actor,
             })) {
                 const returnStatus = issueContext.status === "blocked" ? "blocked" : "todo";
                 const returnedIssue = await issueService(db).update(args.issue.id, {
                     status: returnStatus,
-                    assigneeAgentId: args.current.createdByAgentId,
+                    assigneeAgentId: lockedCurrent.createdByAgentId,
                     assigneeUserId: null,
                     actorAgentId: args.actor.agentId ?? null,
                     actorUserId: args.actor.userId ?? null,
@@ -1035,12 +1166,12 @@ export function issueThreadInteractionService(db, opts = {}) {
                     entityType: "issue",
                     entityId: args.issue.id,
                     details: {
-                        interactionId: args.current.id,
-                        interactionKind: args.current.kind,
+                        interactionId: lockedCurrent.id,
+                        interactionKind: lockedCurrent.kind,
                         interactionStatus: "accepted",
                         resolutionActorKind: "system",
-                        requestedResolverPolicy: args.current.requestedResolverPolicy,
-                        effectiveResolverPolicy: args.current.effectiveResolverPolicy,
+                        requestedResolverPolicy: lockedCurrent.requestedResolverPolicy,
+                        effectiveResolverPolicy: lockedCurrent.effectiveResolverPolicy,
                         ...(args.actor.resolutionDetails ?? {}),
                     },
                 });
@@ -1058,36 +1189,71 @@ export function issueThreadInteractionService(db, opts = {}) {
             row: args.current,
             actor: args.actor,
         });
-        if (expired) {
-            return expired;
-        }
+        if (expired)
+            throw interactionTerminalError({ status: expired.status, result: expired.result });
         const interaction = hydrateInteraction(args.current);
         const reason = args.input.reason?.trim() ?? "";
         if (interaction.payload.rejectRequiresReason === true && reason.length === 0) {
             throw unprocessable("A decline reason is required for this confirmation");
         }
         const now = new Date();
-        const [updated] = await db
-            .update(issueThreadInteractions)
-            .set({
-            status: "rejected",
-            result: {
-                version: 1,
-                outcome: "rejected",
-                reason: reason || null,
-            },
-            resolvedByAgentId: args.actor.agentId ?? null,
-            resolvedByRunId: args.actor.runId ?? null,
-            resolvedByUserId: args.actor.userId ?? null,
-            resolvedAt: now,
-            updatedAt: now,
-        })
-            .where(and(eq(issueThreadInteractions.id, args.current.id), eq(issueThreadInteractions.status, "pending")))
-            .returning();
-        if (!updated) {
-            throw conflict("Interaction has already been resolved");
-        }
-        await touchIssue(db, args.issue.id);
+        const updated = await db.transaction(async (tx) => {
+            const issueContext = await tx
+                .select({
+                id: issues.id,
+                companyId: issues.companyId,
+                status: issues.status,
+                assigneeAgentId: issues.assigneeAgentId,
+                assigneeUserId: issues.assigneeUserId,
+                reviewPolicy: issues.reviewPolicy,
+                createdByAgentId: issues.createdByAgentId,
+                createdByUserId: issues.createdByUserId,
+            })
+                .from(issues)
+                .where(eq(issues.id, args.issue.id))
+                .for("update")
+                .then((rows) => rows[0] ?? null);
+            if (!issueContext || issueContext.companyId !== args.issue.companyId) {
+                throw notFound("Issue not found");
+            }
+            const lockedCurrent = await tx
+                .select()
+                .from(issueThreadInteractions)
+                .where(eq(issueThreadInteractions.id, args.current.id))
+                .for("update")
+                .then((rows) => rows[0] ?? null);
+            if (!lockedCurrent
+                || lockedCurrent.companyId !== args.issue.companyId
+                || lockedCurrent.issueId !== args.issue.id) {
+                throw notFound("Interaction not found");
+            }
+            if (lockedCurrent.status !== "pending") {
+                throw issueThreadInteractionResolutionError(409, "interaction_already_resolved", "Interaction has already been resolved");
+            }
+            await assertRequestConfirmationResolutionAllowedUnderLock(tx, issueContext, lockedCurrent, args.actor);
+            const [resolved] = await tx
+                .update(issueThreadInteractions)
+                .set({
+                status: "rejected",
+                result: {
+                    version: 1,
+                    outcome: "rejected",
+                    reason: reason || null,
+                },
+                resolvedByAgentId: args.actor.agentId ?? null,
+                resolvedByRunId: args.actor.runId ?? null,
+                resolvedByUserId: args.actor.userId ?? null,
+                resolvedAt: now,
+                updatedAt: now,
+            })
+                .where(and(eq(issueThreadInteractions.id, lockedCurrent.id), eq(issueThreadInteractions.status, "pending")))
+                .returning();
+            if (!resolved) {
+                throw issueThreadInteractionResolutionError(409, "interaction_already_resolved", "Interaction has already been resolved");
+            }
+            await touchIssue(tx, args.issue.id);
+            return resolved;
+        });
         const rejected = hydrateInteraction(updated);
         await emitInteractionResolvedTelemetry(db, rejected);
         return rejected;
@@ -1212,12 +1378,26 @@ export function issueThreadInteractionService(db, opts = {}) {
             return { checked: rows.length, candidates: eligible.length, accepted, woken };
         },
         listForIssue: async (issueId) => {
-            const rows = await db
-                .select()
-                .from(issueThreadInteractions)
-                .where(eq(issueThreadInteractions.issueId, issueId))
-                .orderBy(asc(issueThreadInteractions.createdAt), asc(issueThreadInteractions.id));
-            return rows.map((row) => hydrateInteraction(row));
+            const [rows, issueStatus] = await Promise.all([
+                db
+                    .select()
+                    .from(issueThreadInteractions)
+                    .where(eq(issueThreadInteractions.issueId, issueId))
+                    .orderBy(asc(issueThreadInteractions.createdAt), asc(issueThreadInteractions.id)),
+                db
+                    .select({ status: issues.status })
+                    .from(issues)
+                    .where(eq(issues.id, issueId))
+                    .then((issueRows) => issueRows[0]?.status ?? null),
+            ]);
+            return rows.map((row) => hydrateInteraction(issueStatus && isTerminalIssueStatus(issueStatus) && row.status === "pending"
+                ? {
+                    ...row,
+                    status: "expired",
+                    result: buildAdministrativeOutcomeResult(row, "issue_closed"),
+                    resolvedAt: row.updatedAt,
+                }
+                : row));
         },
         getById: async (interactionId) => {
             const row = await db
@@ -1320,6 +1500,7 @@ export function issueThreadInteractionService(db, opts = {}) {
         },
         create: async (issue, input, actor) => {
             const data = normalizeCreateInteractionInput(createIssueThreadInteractionSchema.parse(input));
+            const usedDeprecatedResolverPolicyAlias = data.resolverPolicy === "board_or_agents" || data.resolverPolicy === "board_only";
             const governance = await db
                 .select({ interactionResolverGovernance: companies.interactionResolverGovernance })
                 .from(companies)
@@ -1444,6 +1625,8 @@ export function issueThreadInteractionService(db, opts = {}) {
                         continuationPolicy: data.continuationPolicy,
                         requestedResolverPolicy: policy.requestedResolverPolicy,
                         effectiveResolverPolicy: policy.effectiveResolverPolicy,
+                        resolverPolicyProvenance: policy.resolverPolicyProvenance,
+                        effectiveResolverPolicySource: policy.effectiveResolverPolicySource,
                         idempotencyKey: data.idempotencyKey ?? null,
                         sourceCommentId: data.sourceCommentId ?? null,
                         sourceRunId: data.sourceRunId ?? null,
@@ -1455,15 +1638,25 @@ export function issueThreadInteractionService(db, opts = {}) {
                         payload: data.payload,
                     })
                         .returning();
-                    if (data.kind !== "request_confirmation" || !actor.agentId) {
+                    // An agent replacing its own still-pending card supersedes the older
+                    // one so the thread never accumulates stale sibling cards. This covers
+                    // request_confirmation drafts and ask_user_questions (PAP-437: probe
+                    // question cards that agents never withdrew). Each kind keeps its own
+                    // result shape. Scoped strictly to the same agent + issue + kind, so
+                    // other agents' or other kinds' pending cards are untouched.
+                    const canSupersedeSiblingCards = data.kind === "request_confirmation" || data.kind === "ask_user_questions";
+                    if (!actor.agentId || !canSupersedeSiblingCards) {
                         return { row, supersededRows: [] };
                     }
                     const now = new Date();
+                    const supersededResult = data.kind === "ask_user_questions"
+                        ? buildSupersededByNewerInteractionResult(row.id)
+                        : buildSupersededByNewerRequestResult(row.id);
                     const supersededRows = await tx
                         .update(issueThreadInteractions)
                         .set({
                         status: "expired",
-                        result: buildSupersededByNewerRequestResult(row.id),
+                        result: supersededResult,
                         resolvedByAgentId: actor.agentId,
                         resolvedByUserId: actor.userId ?? null,
                         resolvedAt: now,
@@ -1506,12 +1699,17 @@ export function issueThreadInteractionService(db, opts = {}) {
             if (superseded.length > 0) {
                 await emitResolvedInteractionsTelemetry(db, superseded.map(hydrateInteraction));
             }
-            return hydrateInteraction(created);
+            const interaction = hydrateInteraction(created);
+            emitInteractionCreatedTelemetry({
+                interactionKind: interaction.kind,
+                usedDeprecatedResolverPolicyAlias,
+            });
+            return interaction;
         },
         acceptInteraction: async (issue, interactionId, input, actor) => {
             const data = acceptIssueThreadInteractionSchema.parse(input);
             const current = await getPendingInteractionForResolution({ issue, interactionId });
-            assertAgentResolutionAllowed(current, actor);
+            assertInteractionResolutionAllowed(current, actor);
             switch (current.kind) {
                 case "suggest_tasks":
                     // Accepting suggest_tasks only creates follow-up issues; it does not
@@ -1551,22 +1749,26 @@ export function issueThreadInteractionService(db, opts = {}) {
             }
         },
         acceptSuggestedTasks: async (issue, interactionId, input, actor) => {
+            assertIssueOpenForInteractionResolution(issue);
             const current = await db
                 .select()
                 .from(issueThreadInteractions)
                 .where(eq(issueThreadInteractions.id, interactionId))
                 .then((rows) => rows[0] ?? null);
             if (!current)
-                throw notFound("Interaction not found");
+                throw interactionNotFoundError();
             if (current.companyId !== issue.companyId || current.issueId !== issue.id) {
-                throw notFound("Interaction not found");
+                throw interactionNotFoundError();
             }
-            assertAgentResolutionAllowed(current, actor);
+            assertInteractionResolutionAllowed(current, actor);
             if (current.kind !== "suggest_tasks") {
                 throw unprocessable("Only suggest_tasks interactions can be accepted");
             }
             if (current.status !== "pending") {
-                throw conflict("Interaction has already been resolved");
+                throw interactionTerminalError(current);
+            }
+            if (actor.agentId && actor.suggestedTaskEffectsAuthorized !== true) {
+                throw issueThreadInteractionResolutionError(403, "interaction_governed_action_denied", "Suggested-task creation requires independent task-creation authorization");
             }
             const interaction = hydrateInteraction(current);
             const { selectedTasks, skippedClientKeys } = resolveSelectedSuggestedTasks({
@@ -1612,7 +1814,7 @@ export function issueThreadInteractionService(db, opts = {}) {
                     .where(and(eq(issueThreadInteractions.id, interactionId), eq(issueThreadInteractions.status, "pending")))
                     .returning();
                 if (!claimed) {
-                    throw conflict("Interaction has already been resolved");
+                    throw interactionAlreadyResolvedError();
                 }
                 for (const task of orderedTasks) {
                     const parentIssueId = task.parentClientKey
@@ -1686,7 +1888,7 @@ export function issueThreadInteractionService(db, opts = {}) {
         rejectInteraction: async (issue, interactionId, input, actor) => {
             const data = rejectIssueThreadInteractionSchema.parse(input);
             const current = await getPendingInteractionForResolution({ issue, interactionId });
-            assertAgentResolutionAllowed(current, actor);
+            assertInteractionResolutionAllowed(current, actor);
             switch (current.kind) {
                 case "suggest_tasks":
                     return issueThreadInteractionService(db).rejectSuggestedTasks(issue, interactionId, data, actor, current);
@@ -1703,6 +1905,7 @@ export function issueThreadInteractionService(db, opts = {}) {
             }
         },
         submitItemVerdicts: async (issue, interactionId, input, actor) => {
+            assertIssueOpenForInteractionResolution(issue);
             const data = submitIssueThreadInteractionVerdictsSchema.parse(input);
             const submission = await db.transaction(async (tx) => {
                 const current = await tx
@@ -1712,13 +1915,14 @@ export function issueThreadInteractionService(db, opts = {}) {
                     .for("update")
                     .then((rows) => rows[0] ?? null);
                 if (!current)
-                    throw notFound("Interaction not found");
+                    throw interactionNotFoundError();
                 if (current.companyId !== issue.companyId || current.issueId !== issue.id) {
-                    throw notFound("Interaction not found");
+                    throw interactionNotFoundError();
                 }
                 if (current.kind !== "request_item_verdicts") {
                     throw unprocessable("Only request_item_verdicts interactions can receive item verdicts");
                 }
+                assertInteractionResolutionAllowed(current, actor);
                 const interaction = hydrateInteraction(current);
                 if (current.status !== "pending") {
                     if (current.status === "answered") {
@@ -1729,19 +1933,24 @@ export function issueThreadInteractionService(db, opts = {}) {
                                 throw unprocessable(`Unknown item verdict id: ${submitted.id}`);
                             }
                             if (!resolvedIds.has(submitted.id)) {
-                                throw conflict("Interaction has already been resolved");
+                                throw interactionTerminalError(current);
                             }
                         }
                         return { interaction, newlyResolvedItemIds: [], resolved: false };
                     }
-                    throw conflict("Interaction has already been resolved");
+                    throw interactionTerminalError(current);
                 }
                 const expired = await expireStaleRequestConfirmationTarget(tx, {
                     row: current,
                     actor,
                 });
                 if (expired) {
-                    return { interaction: expired, newlyResolvedItemIds: [], resolved: false };
+                    return {
+                        interaction: expired,
+                        newlyResolvedItemIds: [],
+                        resolved: false,
+                        terminalError: interactionTerminalError({ status: expired.status, result: expired.result }),
+                    };
                 }
                 const now = new Date();
                 const { items, complete, newlyResolvedItemIds } = resolveRequestItemVerdictSubmissions({
@@ -1773,7 +1982,7 @@ export function issueThreadInteractionService(db, opts = {}) {
                     .where(and(eq(issueThreadInteractions.id, interactionId), eq(issueThreadInteractions.status, "pending")))
                     .returning();
                 if (!updated) {
-                    throw conflict("Interaction has already been resolved");
+                    throw interactionAlreadyResolvedError();
                 }
                 await touchIssue(tx, issue.id);
                 return {
@@ -1782,20 +1991,23 @@ export function issueThreadInteractionService(db, opts = {}) {
                     resolved: complete,
                 };
             });
+            if ("terminalError" in submission)
+                throw submission.terminalError;
             if (submission.resolved) {
                 await emitInteractionResolvedTelemetry(db, submission.interaction);
             }
             return submission;
         },
         rejectSuggestedTasks: async (issue, interactionId, input, actor, current) => {
+            assertIssueOpenForInteractionResolution(issue);
             if (current.companyId !== issue.companyId || current.issueId !== issue.id) {
-                throw notFound("Interaction not found");
+                throw interactionNotFoundError();
             }
             if (current.kind !== "suggest_tasks") {
                 throw unprocessable("Only suggest_tasks interactions can be rejected");
             }
             if (current.status !== "pending") {
-                throw conflict("Interaction has already been resolved");
+                throw interactionTerminalError(current);
             }
             const [updated] = await db
                 .update(issueThreadInteractions)
@@ -1814,7 +2026,7 @@ export function issueThreadInteractionService(db, opts = {}) {
                 .where(and(eq(issueThreadInteractions.id, interactionId), eq(issueThreadInteractions.status, "pending")))
                 .returning();
             if (!updated) {
-                throw conflict("Interaction has already been resolved");
+                throw interactionAlreadyResolvedError();
             }
             await touchIssue(db, issue.id);
             const rejected = hydrateInteraction(updated);
@@ -2099,6 +2311,7 @@ export function issueThreadInteractionService(db, opts = {}) {
             return expired;
         },
         withdrawInteraction: async (issue, interactionId, input, actor) => {
+            assertIssueOpenForInteractionResolution(issue);
             const data = withdrawIssueThreadInteractionSchema.parse(input);
             const current = await db
                 .select()
@@ -2106,10 +2319,10 @@ export function issueThreadInteractionService(db, opts = {}) {
                 .where(eq(issueThreadInteractions.id, interactionId))
                 .then((rows) => rows[0] ?? null);
             if (!current || current.companyId !== issue.companyId || current.issueId !== issue.id) {
-                throw notFound("Interaction not found");
+                throw interactionNotFoundError();
             }
             if (current.status !== "pending")
-                throw conflict("Interaction has already been resolved");
+                throw interactionTerminalError(current);
             const reason = data.reason?.trim() || null;
             const now = new Date();
             // One transaction, linked tool action first: revoking pending/approved
@@ -2150,7 +2363,7 @@ export function issueThreadInteractionService(db, opts = {}) {
                     .where(and(eq(issueThreadInteractions.id, interactionId), eq(issueThreadInteractions.status, "pending")))
                     .returning();
                 if (!row)
-                    throw conflict("Interaction has already been resolved");
+                    throw interactionAlreadyResolvedError();
                 return row;
             });
             await touchIssue(db, issue.id);
@@ -2159,22 +2372,23 @@ export function issueThreadInteractionService(db, opts = {}) {
             return withdrawn;
         },
         answerQuestions: async (issue, interactionId, input, actor) => {
+            assertIssueOpenForInteractionResolution(issue);
             const current = await db
                 .select()
                 .from(issueThreadInteractions)
                 .where(eq(issueThreadInteractions.id, interactionId))
                 .then((rows) => rows[0] ?? null);
             if (!current)
-                throw notFound("Interaction not found");
+                throw interactionNotFoundError();
             if (current.companyId !== issue.companyId || current.issueId !== issue.id) {
-                throw notFound("Interaction not found");
+                throw interactionNotFoundError();
             }
-            assertAgentResolutionAllowed(current, actor);
+            assertInteractionResolutionAllowed(current, actor);
             if (current.kind !== "ask_user_questions") {
                 throw unprocessable("Only ask_user_questions interactions can be answered");
             }
             if (current.status !== "pending") {
-                throw conflict("Interaction has already been resolved");
+                throw interactionTerminalError(current);
             }
             const interaction = hydrateInteraction(current);
             const normalizedAnswers = normalizeQuestionAnswers({
@@ -2199,7 +2413,7 @@ export function issueThreadInteractionService(db, opts = {}) {
                 .where(and(eq(issueThreadInteractions.id, interactionId), eq(issueThreadInteractions.status, "pending")))
                 .returning();
             if (!updated) {
-                throw conflict("Interaction has already been resolved");
+                throw interactionAlreadyResolvedError();
             }
             await touchIssue(db, issue.id);
             const answered = hydrateInteraction(updated);
@@ -2207,6 +2421,7 @@ export function issueThreadInteractionService(db, opts = {}) {
             return answered;
         },
         cancelQuestions: async (issue, interactionId, input, actor) => {
+            assertIssueOpenForInteractionResolution(issue);
             const data = cancelIssueThreadInteractionSchema.parse(input);
             const current = await db
                 .select()
@@ -2214,15 +2429,15 @@ export function issueThreadInteractionService(db, opts = {}) {
                 .where(eq(issueThreadInteractions.id, interactionId))
                 .then((rows) => rows[0] ?? null);
             if (!current)
-                throw notFound("Interaction not found");
+                throw interactionNotFoundError();
             if (current.companyId !== issue.companyId || current.issueId !== issue.id) {
-                throw notFound("Interaction not found");
+                throw interactionNotFoundError();
             }
             if (current.kind !== "ask_user_questions") {
                 throw unprocessable("Only ask_user_questions interactions can be cancelled");
             }
             if (current.status !== "pending") {
-                throw conflict("Interaction has already been resolved");
+                throw interactionTerminalError(current);
             }
             const reason = data.reason?.trim() || null;
             const [updated] = await db
@@ -2245,7 +2460,7 @@ export function issueThreadInteractionService(db, opts = {}) {
                 .where(and(eq(issueThreadInteractions.id, interactionId), eq(issueThreadInteractions.status, "pending")))
                 .returning();
             if (!updated) {
-                throw conflict("Interaction has already been resolved");
+                throw interactionAlreadyResolvedError();
             }
             await touchIssue(db, issue.id);
             const cancelled = hydrateInteraction(updated);