Files
PaperClipAI/server/src/services/native-runtime/status-decision-committer.ts
T
DottaandClaude Opus 5.5 aaf76a3ca6 fix(native): start the configured review stage when a native worker reports done (#20882)
## Thinking Path

> - Paperclip is the open source app people use to manage AI agents for
work
> - Tasks can have an execution policy with a review stage that names an
independent human reviewer
> - The issue route starts that stage when the assignee moves the task
to done or in_review
> - Native runs do not use that route. The native finalizer writes the
task status through the issue service, which does not run the stage
transition
> - So a native worker that reports verified work as done closes the
task without the required review. A worker that reports needs_review
moves the task to in_review without the configured stage or its reviewer
> - This pull request makes the native completion path start the
configured review stage, as the route does
> - The benefit is that a configured independent review gates Done for
native workers too

## Linked Issues or Issue Description

**What happened**

A task had an execution policy with one review stage for a human
reviewer. A native worker (OpenCode on the Paperclip runner) finished
the work and reported it. When the worker reported done with verified
evidence, the task became done and the review stage never started. When
the worker reported needs_review, the task became in_review with a
generic review card, `executionState` stayed null, and the configured
reviewer was not assigned. The chat eval `tasks.completion-with-gate`
timed out in setup because the task never reached the pending review
stage.

**Expected behavior**

Verified work on a task with a configured human review stage goes to
in_review with that stage pending, the stage reviewer assigned and the
worker kept as the return assignee. The task becomes done only after the
reviewer approves.

**Steps to reproduce**

1. Create a task assigned to a native agent with `executionPolicy.stages
= [{ type: "review", participants: [{ type: "user", userId: <reviewer>
}] }]`.
2. Let the agent finish the work and report done with verified evidence.
3. Read the task. Before this fix it is `done` and `executionState` is
null.

## What Changed

- `server/src/services/issue-execution-policy.ts`: add
`completionReviewStageEntry`. It applies the full policy transition that
the route applies for `status: "done"` and returns `starts` (with the
stage patch), `none` or `rejected`.
- `native-run-finalizer.ts`: a done decision on a task whose policy
starts a stage becomes in_review with reason
`execution_stage_review_required`. When the policy refuses the
transition, the decision is in_progress with reason
`execution_stage_transition_rejected` and a recovery note. It is never
done. Deliverable checks still run first.
- `status-decision-committer.ts`: for a stage-entry decision, apply the
stale-owner check, start the stage from the locked task in the same
status update (this also clears a monitor that the new assignee cannot
use), and wake an agent participant with `execution_review_requested` or
`execution_approval_requested`, as the route does. If the policy
changed, the saved decision is stale and finalization retries.
- `native-completion-feedback.ts`: on such a task, tell the worker to
report done so the configured stage requests the review. Reject
needs_review with no request or with any review request. Approval
requests keep their own path, because they can be governed action cards.
- New regression test `native-execution-policy-review-stage.test.ts`
(embedded Postgres, 6 tests).

## Verification

- `cd server && npx vitest run
src/services/native-runtime/native-execution-policy-review-stage.test.ts`
(6 tests): no stage (done), human stage (in_review, reviewer assigned,
monitor cleared), agent stage (in_review, reviewer woken), refused live
review cycle (in_progress, not done), and feedback including mixed and
approval requests. The stage tests fail without the finalizer change
(the task becomes done).
- Related suites pass: `historical-task-questions`,
`native-completion-feedback`, `native-run-finalizer-telemetry`,
`native-terminal-status-projection`, `status-arbiter`,
`task-monitor.integration`, `__tests__/issue-execution-policy` (247
tests).
- Server `tsc --noEmit` shows no errors in changed files. The local
worktree has unbuilt packages, so CI supplies the full typecheck.

## Risks

- The agent-reviewer wake is a system workflow wake, like the route's.
Unit tests prove the wake row. An end-to-end native agent review after
this wake is not yet exercised in a paid eval.
- A decision saved with a new reason and resumed by an older release
projects in_review or in_progress without the stage. The task does not
close, so the older release fails safe.
- Agents on tasks with a configured review stage now get a rejection
when they report needs_review with no request or with a review request.

## Model Used

- Anthropic Claude Opus 5.5 (`claude-opus-5-5`), tool use and code
execution in Claude Code.

## Checklist

- [x] I have included a thinking path that traces from project context
to this change
- [x] I have specified the model used (with version and capability
details)
- [x] I have checked ROADMAP.md and confirmed this PR does not duplicate
planned core work
- [x] I have searched GitHub for duplicate or related PRs and linked
them above
- [x] I have either (a) linked existing issues with `Fixes: #` / `Closes
#` / `Refs #` OR (b) described the issue in-PR following the relevant
issue template
- [x] I have not referenced internal/instance-local Paperclip issues or
links (only public GitHub `#NNN` / `github.com/paperclipai/paperclip`
URLs)
- [x] My branch name describes the change (e.g. `docs/...`, `fix/...`)
and contains no internal Paperclip ticket id or instance-derived details
- [x] I have run tests locally and they pass
- [x] I have added or updated tests where applicable
- [x] I have updated relevant documentation to reflect my changes
- [x] I have considered and documented any risks above
- [ ] All Paperclip CI gates are green
- [ ] Greptile is 5/5 with no open P2s, recommendations, or follow-ups
- [x] I will address all Greptile and reviewer comments before
requesting merge

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-11 17:43:58 -06:00

2676 lines
106 KiB
TypeScript

import { notifyNativeStatusWakeWork } from "../deferred-execution-notifications.js";
import { assertAgentInteraction } from "../agent-interaction-policy.js";
import { forbidden, HttpError } from "../../errors.js";
import { agentInteractionDeliveryDenial, agentWakeInteractionTexts, INTERACTION_DELIVERY_DENIED, withInteractionDeliveryOrigin } from "../agent-interaction-delivery.js";
import { notifyExternalAgentSettlement } from "../../modules/external-agents/index.js";
import { lockCurrentNativeWorkAssessmentEvidence } from "./work-assessments.js";
import { hasNativeWorkspaceFinalizationOwner } from "./native-workspace-finalization-recovery-state.js";
import { tryLockNativeWorkspaceFinalization } from "./native-workspace-finalization-ownership.js";
import { lockCurrentNativeCompletionContract } from "./completion-contracts.js";
import { isNativeRunnerOwnershipHeld } from "./native-runner-ownership.js";
import { readPreservedNativeResultFinalization, type PreservedNativeResultFinalization } from "./preserved-native-result-finalization.js";
import { notifyNativeFinalizationWork } from "../native-finalization-notifications.js";
import { notifyUnsafeWorkspaceExportRecovery } from "../unsafe-workspace-export-notifications.js";
import { notifyAutomaticCompletionReviews } from "../automatic-completion-review-notifications.js";
import { notifyObsoletePolicyReviews } from "../obsolete-policy-review-notifications.js";
import { notifyCancelledWorkspacePreservation } from "../cancelled-workspace-preservation-notifications.js";
import { notifyInstructionCollection } from "../instruction-collection-notifications.js";
import { notifyChatRunMilestones } from "../chat-run-milestone-notifications.js";
import { scheduledIssueMonitorWait } from "../issue-monitors.js";
import { onboardingFirstTaskCompletionAllowed } from "../onboarding-first-task-admission.js";
import { NativeDeliverableEvidenceError, validateNativeDeliverableEvidence } from "./native-deliverable-feedback.js";
import { hasPublishedGitHubReview, readInheritedGitHubReviewWait } from "../chat-channels/github/review-wait.js";
import { lockNativeGovernanceSources, pendingNativeGovernance } from "./native-governance.js";
import { findSupersededExternalReviewRequests, supersedeExternalReviewRequestsInTransaction } from "./superseded-external-review-requests.js";
import { normalizePrpResultSignals, type PrpStructuredRunResult } from "../../vendor/paperclip-runner/index.js";
import { readNativeMonitorDelivery, readNativePreservedMonitorWait, readNativeSupersededMonitorWait, type NativeSupersededMonitorWait, type NativeMonitorDelivery, type NativePreservedMonitorWait } from "./native-monitor-delivery.js";
import { readNativePlanWait, type NativePlanWaitSource } from "./native-plan-wait.js";
import { activeIssueInteractionCondition } from "../issue-question-context.js";
import { questionsAwaitedByAgentBlock } from "../blocked-question-answer.js";
import { isConversation } from "../agent-conversations.js";
import { hasPendingNativeChildCompletion, type NativeChildCompletionRecipient } from "./native-child-completion-delivery.js";
import { and, asc, desc, eq, inArray, notInArray, or, sql } from "drizzle-orm";
import type { Db } from "@paperclipai/db";
import type { CreateIssueThreadInteraction } from "@paperclipai/shared";
import {
agentWakeupRequests,
agents,
approvals,
completionContracts,
heartbeatRuns,
issueApprovals,
issueRecoveryActions,
issueThreadInteractions,
issues,
nativeRunFinalizations,
nativeRunResults,
statusDecisionEffects,
statusDecisions,
workAssessments,
workspaceOperations,
} from "@paperclipai/db";
import {
heldByAnotherRun,
NATIVE_STATUS_ARBITER_POLICY_VERSION,
type NativeGovernanceGate,
type NativeStatusDecision,
type NativeStatusEffect,
} from "./status-arbiter.js";
import { nativeSha256 } from "./canonical.js";
import { getNativeReviewAssignment, type NativeReviewAssignmentContext } from "./native-review-participant.js";
import {
readNativeBoardResponseWaitSource,
readNativeBoardResponseWaitOrigin,
type NativeBoardResponseWaitOrigin,
type NativeBoardResponseWaitSource,
} from "./native-board-response-wait.js";
import {
prepareNativeChatReviewPresentationInTransaction,
restoreNativeChatReviewPresentationInTransaction,
} from "./native-chat-review-presentation.js";
import {
readPublishedGitHubReviewCompletionContinuationInTransaction,
isExternalChatWaitAuthorizationContention,
resolveExternalChatResponseWaitAuthorizationInTransaction,
} from "./chat-attachment-reuse.js";
import { issueService } from "../issues.js";
import { COMPLETION_REVIEW_STAGE_REASON, COMPLETION_REVIEW_STAGE_REJECTED_REASON, completionReviewStageEntry } from "../issue-execution-policy.js";
import { companySkillService } from "../company-skills.js";
import { syncRoutineRunStatusForIssue } from "../routine-run-status.js";
import { issueThreadInteractionService } from "../issue-thread-interactions.js";
import { issueRecoveryActionService } from "../issue-recovery-actions.js";
import { buildIssueBlockersResolvedWakeIdempotencyKey } from "../issue-dependency-wakeups.js";
import {
persistActivity,
publishActivity,
type ActivityPublication,
} from "../activity-log.js";
import { emitAgentTaskRun } from "../agent-task-run-telemetry.js";
import { materializeNativeProviderCapacityRetry } from "./native-provider-capacity-retry.js";
import { NATIVE_PROVIDER_OVERLOADED_CODE } from "./native-provider-failure.js";
import { DELIVERY_QUEUES, notifyDeliveryWork } from "../delivery-work-notifications.js";
export class NativeStatusRaceError extends Error {
readonly code = "native_status_race" as const;
constructor() {
super("native_status_race");
this.name = "NativeStatusRaceError";
}
}
export function nativePendingEffectDueAt(coordinator: {
phase: string; resultId: string | null; nextAttemptAt: Date | null;
leaseOwner: string | null; leaseExpiresAt: Date | null;
}): number | null {
if (coordinator.phase === "terminal_failure" || coordinator.resultId === null) return null;
return Math.max(coordinator.nextAttemptAt?.getTime() ?? 0,
coordinator.leaseOwner !== null ? coordinator.leaseExpiresAt?.getTime() ?? 0 : 0);
}
/** Reconciliation delivery resumes ledger work only; it never re-arbitrates. */
export async function dispatchPendingNativeStatusEffects(input: {
db: Db;
companyId: string;
issueId: string;
decisionId: string;
runId: string;
onlyWhenDue?: boolean;
}) {
return input.db.transaction(async (tx) => {
const coordinator = await tx
.select({
decisionId: nativeRunFinalizations.decisionId,
phase: nativeRunFinalizations.phase,
resultId: nativeRunFinalizations.resultId,
nextAttemptAt: nativeRunFinalizations.nextAttemptAt,
leaseOwner: nativeRunFinalizations.leaseOwner,
leaseExpiresAt: nativeRunFinalizations.leaseExpiresAt,
})
.from(nativeRunFinalizations)
.where(
and(
eq(nativeRunFinalizations.runId, input.runId),
eq(nativeRunFinalizations.companyId, input.companyId),
eq(nativeRunFinalizations.issueId, input.issueId),
),
)
.for("update")
.limit(1)
.then((rows) => rows[0] ?? null);
if (!coordinator || coordinator.decisionId !== input.decisionId) {
throw new Error("native_pending_effect_decision_binding_mismatch");
}
if (input.onlyWhenDue) {
const dueAt = nativePendingEffectDueAt(coordinator);
if (dueAt === null || dueAt > Date.now()) return [];
}
const pending = await tx
.select({
id: statusDecisionEffects.id,
effectKind: statusDecisionEffects.effectKind,
targetType: statusDecisionEffects.targetType,
targetId: statusDecisionEffects.targetId,
})
.from(statusDecisionEffects)
.where(
and(
eq(statusDecisionEffects.companyId, input.companyId),
eq(statusDecisionEffects.issueId, input.issueId),
eq(statusDecisionEffects.decisionId, input.decisionId),
inArray(statusDecisionEffects.deliveryState, ["pending", "failed"]),
),
)
.for("update");
if (pending.length === 0) return [];
for (const effect of pending) {
await assertPendingEffectTarget(tx as unknown as Db, {
companyId: input.companyId,
issueId: input.issueId,
effectKind: effect.effectKind,
targetType: effect.targetType,
targetId: effect.targetId,
});
}
await notifyNativeFinalizationWork(tx, input);
await notifyChatRunMilestones(tx, input);
await tx
.update(statusDecisionEffects)
.set({
deliveryState: "delivered",
attemptCount: sql`${statusDecisionEffects.attemptCount} + 1`,
deliveredAt: new Date(),
nextAttemptAt: null,
lastError: null,
updatedAt: new Date(),
})
.where(
inArray(
statusDecisionEffects.id,
pending.map((row) => row.id),
),
);
await updateRunEffectState({
tx: tx as unknown as Db,
companyId: input.companyId,
runId: input.runId,
key: "nativeDispatchedEffectIds",
value: pending.map((row) => row.id),
});
return pending.map((row) => row.id);
});
}
export type NativeStatusCommitFailpoint =
| "governance_materialization"
| "interaction_materialization"
| "continuation_materialization"
| "blocker_materialization"
| "recovery_materialization"
| "status_projection";
export type NativeMaterializedStatusEffect = {
effectKind: string;
targetType: string;
targetId: string | null;
payload: Record<string, unknown>;
deliveryState?: "skipped";
};
function record(value: unknown): Record<string, unknown> {
return value && typeof value === "object" && !Array.isArray(value)
? (value as Record<string, unknown>)
: {};
}
function assertNeverEffect(effect: never): never {
const kind = record(effect).kind;
throw new Error(
`native_status_effect_unimplemented:${String(kind ?? "unknown")}`,
);
}
async function assertPendingEffectTarget(
tx: Db,
input: {
companyId: string;
issueId: string;
effectKind: string;
targetType: string;
targetId: string | null;
},
) {
if (!input.targetId)
throw new Error(`native_pending_effect_target_missing:${input.effectKind}`);
let found = false;
if (input.targetType === "agent_wakeup_request") {
found = await tx
.select({ id: agentWakeupRequests.id })
.from(agentWakeupRequests)
.where(
and(
eq(agentWakeupRequests.id, input.targetId),
eq(agentWakeupRequests.companyId, input.companyId),
),
)
.limit(1)
.then((rows) => rows.length === 1);
} else if (input.targetType === "agent") {
found = await tx
.select({ id: agents.id })
.from(agents)
.where(
and(
eq(agents.id, input.targetId),
eq(agents.companyId, input.companyId),
),
)
.limit(1)
.then((rows) => rows.length === 1);
} else if (
input.targetType === "issue_thread_interaction" ||
input.targetType === "interaction"
) {
found = await tx
.select({ id: issueThreadInteractions.id })
.from(issueThreadInteractions)
.where(
and(
eq(issueThreadInteractions.id, input.targetId),
eq(issueThreadInteractions.companyId, input.companyId),
eq(issueThreadInteractions.issueId, input.issueId),
),
)
.limit(1)
.then((rows) => rows.length === 1);
} else if (
[
"delegated_issue",
"issue",
"issue_checkout",
"issue_unblock_descriptor",
].includes(input.targetType)
) {
found = await tx
.select({ id: issues.id })
.from(issues)
.where(
and(
eq(issues.id, input.targetId),
eq(issues.companyId, input.companyId),
),
)
.limit(1)
.then((rows) => rows.length === 1);
} else if (input.targetType === "issue_recovery_action") {
found = await tx
.select({ id: issueRecoveryActions.id })
.from(issueRecoveryActions)
.where(
and(
eq(issueRecoveryActions.id, input.targetId),
eq(issueRecoveryActions.companyId, input.companyId),
eq(issueRecoveryActions.sourceIssueId, input.issueId),
),
)
.limit(1)
.then((rows) => rows.length === 1);
} else if (input.targetType === "heartbeat_run") {
found = await tx
.select({ id: heartbeatRuns.id })
.from(heartbeatRuns)
.where(
and(
eq(heartbeatRuns.id, input.targetId),
eq(heartbeatRuns.companyId, input.companyId),
),
)
.limit(1)
.then((rows) => rows.length === 1);
} else if (input.targetType === "workspace_operation") {
found = await tx
.select({ id: workspaceOperations.id })
.from(workspaceOperations)
.where(
and(
eq(workspaceOperations.id, input.targetId),
eq(workspaceOperations.companyId, input.companyId),
),
)
.limit(1)
.then((rows) => rows.length === 1);
} else if (input.targetType === "completion_contract") {
found = await tx
.select({ id: completionContracts.id })
.from(completionContracts)
.where(
and(
eq(completionContracts.id, input.targetId),
eq(completionContracts.companyId, input.companyId),
eq(completionContracts.issueId, input.issueId),
),
)
.limit(1)
.then((rows) => rows.length === 1);
} else if (input.targetType === "status_decision") {
found = await tx
.select({ id: statusDecisions.id })
.from(statusDecisions)
.where(
and(
eq(statusDecisions.id, input.targetId),
eq(statusDecisions.companyId, input.companyId),
eq(statusDecisions.issueId, input.issueId),
),
)
.limit(1)
.then((rows) => rows.length === 1);
} else if (input.targetType === "status_decision_effect") {
found = await tx
.select({ id: statusDecisionEffects.id })
.from(statusDecisionEffects)
.where(
and(
eq(statusDecisionEffects.id, input.targetId),
eq(statusDecisionEffects.companyId, input.companyId),
eq(statusDecisionEffects.issueId, input.issueId),
),
)
.limit(1)
.then((rows) => rows.length === 1);
} else if (input.targetType === "approval") {
found = await tx
.select({ id: approvals.id })
.from(issueApprovals)
.innerJoin(approvals, eq(issueApprovals.approvalId, approvals.id))
.where(
and(
eq(approvals.id, input.targetId),
eq(approvals.companyId, input.companyId),
eq(issueApprovals.issueId, input.issueId),
),
)
.limit(1)
.then((rows) => rows.length === 1);
} else if (input.targetType === "execution_stage") {
found = await tx
.select({ executionState: issues.executionState })
.from(issues)
.where(
and(
eq(issues.id, input.issueId),
eq(issues.companyId, input.companyId),
),
)
.limit(1)
.then((rows) => record(rows[0]?.executionState).status === "pending");
} else {
throw new Error(
`native_pending_effect_target_unimplemented:${input.targetType}`,
);
}
if (!found)
throw new Error(`native_pending_effect_target_missing:${input.effectKind}`);
}
async function updateRunEffectState(input: {
tx: Db;
companyId: string;
runId: string;
key: string;
value: unknown;
runnerProfile?: boolean;
}) {
const run = await input.tx
.select({
id: heartbeatRuns.id,
resultJson: heartbeatRuns.resultJson,
runnerProfileJson: heartbeatRuns.runnerProfileJson,
})
.from(heartbeatRuns)
.where(
and(
eq(heartbeatRuns.id, input.runId),
eq(heartbeatRuns.companyId, input.companyId),
),
)
.for("update")
.limit(1)
.then((rows) => rows[0] ?? null);
if (!run) throw new Error("native_status_run_missing");
const target = input.runnerProfile
? record(run.runnerProfileJson)
: record(run.resultJson);
await input.tx
.update(heartbeatRuns)
.set({
...(input.runnerProfile
? { runnerProfileJson: { ...target, [input.key]: input.value } }
: { resultJson: { ...target, [input.key]: input.value } }),
updatedAt: new Date(),
})
.where(eq(heartbeatRuns.id, input.runId));
return run.id;
}
function failAt(
actual: NativeStatusCommitFailpoint,
requested?: NativeStatusCommitFailpoint,
) {
if (actual === requested)
throw new Error(`native_status_failpoint:${actual}`);
}
export async function enqueueWake(input: {
tx: Db;
companyId: string;
issueId: string;
agentId: string;
reason: string;
idempotencyKey: string;
payload: Record<string, unknown>;
contextSnapshot?: Record<string, unknown>;
originRunId?: string;
originOperation?: "assign" | "comment";
}) {
const existing = await input.tx
.select({ id: agentWakeupRequests.id })
.from(agentWakeupRequests)
.where(
and(
eq(agentWakeupRequests.companyId, input.companyId),
eq(agentWakeupRequests.idempotencyKey, input.idempotencyKey),
or(inArray(agentWakeupRequests.status, [
"queued",
"deferred_issue_execution",
"claimed",
"completed",
]), eq(agentWakeupRequests.error, INTERACTION_DELIVERY_DENIED)),
),
)
.limit(1)
.then((rows) => rows[0] ?? null);
if (existing) return existing.id;
const [origin] = input.originRunId ? await input.tx.select({ agentId: heartbeatRuns.agentId }).from(heartbeatRuns)
.where(and(eq(heartbeatRuns.id, input.originRunId), eq(heartbeatRuns.companyId, input.companyId))) : [];
const actorType = origin ? "agent" : "system";
const actorId = origin?.agentId ?? "native-status-committer";
const originPayload = withInteractionDeliveryOrigin({}, actorType, actorId, { actorType, actorId });
if (originPayload.interactionOrigin) {
originPayload.interactionOrigin = { ...record(originPayload.interactionOrigin), operation: input.originOperation ?? "assign" };
}
const denial = origin ? await agentInteractionDeliveryDenial(input.tx, {
companyId: input.companyId, actorAgentId: origin.agentId, targetAgentId: input.agentId, issueId: input.issueId,
operation: input.originOperation ?? "assign", texts: agentWakeInteractionTexts(input.payload), delivery: true, lock: true,
}) : null;
const refusedParentReport = denial && input.reason === "issue_children_completed" && input.originOperation === "comment";
if (denial && !refusedParentReport) throw forbidden("Agent interaction is not permitted.", denial);
if (!denial) await notifyNativeStatusWakeWork(input.tx, { companyId: input.companyId });
const inserted = await input.tx
.insert(agentWakeupRequests)
.values({
companyId: input.companyId,
agentId: input.agentId,
source: "automation",
triggerDetail: "system",
reason: input.reason,
...(denial ? { status: "skipped", error: INTERACTION_DELIVERY_DENIED, finishedAt: new Date() } : {}),
payload: denial ? {
issueId: input.issueId,
taskId: input.issueId,
sourceRunId: input.originRunId,
...originPayload,
interactionPermissionDenials: { assignment: denial },
} : {
issueId: input.issueId,
taskId: input.issueId,
...input.payload,
...originPayload,
_paperclipWakeContext: {
issueId: input.issueId,
taskId: input.issueId,
...(input.contextSnapshot ?? {}),
wakeReason: input.reason,
source: "native_status_decision",
statusDecisionSource: "native_status_decision",
},
},
requestedByActorType: "system",
requestedByActorId: "native-status-committer",
idempotencyKey: input.idempotencyKey,
})
.returning({ id: agentWakeupRequests.id })
.then((rows) => rows[0] ?? null);
if (!inserted) throw new Error("native_status_wake_not_persisted");
return inserted.id;
}
async function refusedWakePolicy(tx: Db, companyId: string, wakeId: string) {
const [wake] = await tx.select({ error: agentWakeupRequests.error, payload: agentWakeupRequests.payload })
.from(agentWakeupRequests).where(and(eq(agentWakeupRequests.id, wakeId), eq(agentWakeupRequests.companyId, companyId)));
return wake?.error === INTERACTION_DELIVERY_DENIED
? record(record(wake.payload).interactionPermissionDenials).assignment : null;
}
async function validateGovernanceGate(
tx: Db,
input: {
companyId: string;
issueId: string;
gate: NonNullable<
Extract<NativeStatusEffect, { kind: "create_interaction" }>["gate"]
>;
executionState: unknown;
runId: string;
conversationMode: boolean;
},
) {
if (input.gate.kind === "execution_stage") {
const state =
input.executionState && typeof input.executionState === "object"
? (input.executionState as Record<string, unknown>)
: {};
if (state.status !== "pending")
throw new Error("native_governance_gate_resolved");
return input.gate.id;
}
if (input.gate.kind === "interaction") {
const interaction = await tx
.select({ id: issueThreadInteractions.id })
.from(issueThreadInteractions)
.where(
and(
eq(issueThreadInteractions.id, input.gate.id),
eq(issueThreadInteractions.companyId, input.companyId),
eq(issueThreadInteractions.issueId, input.issueId),
eq(issueThreadInteractions.status, "pending"),
activeIssueInteractionCondition(input),
),
)
.limit(1)
.then((rows) => rows[0] ?? null);
if (!interaction) throw new Error("native_governance_gate_resolved");
return interaction.id;
}
const approval = await tx
.select({ id: approvals.id })
.from(issueApprovals)
.innerJoin(approvals, eq(issueApprovals.approvalId, approvals.id))
.where(
and(
eq(issueApprovals.companyId, input.companyId),
eq(issueApprovals.issueId, input.issueId),
eq(approvals.companyId, input.companyId),
eq(approvals.id, input.gate.id),
inArray(approvals.status, ["pending", "revision_requested"]),
),
)
.limit(1)
.then((rows) => rows[0] ?? null);
if (!approval) throw new Error("native_governance_gate_resolved");
return approval.id;
}
async function materializeDecisionEffect(input: {
tx: Db;
companyId: string;
issue: typeof issues.$inferSelect;
runId: string;
actorAgentId: string | null;
decisionId: string;
effect: NativeStatusEffect;
failpoint?: NativeStatusCommitFailpoint;
preMaterializedEffects?: ReadonlyMap<string, NativeMaterializedStatusEffect>;
/** Terminal heartbeat_runs rows this effect wrote. The caller emits agent.task_run for each, after its transaction commits. */
terminalRunsToEmit?: (typeof heartbeatRuns.$inferSelect)[];
}): Promise<NativeMaterializedStatusEffect> {
const { effect } = input;
if (effect.kind === "create_interaction") {
failAt("governance_materialization", input.failpoint);
if (effect.gate) {
const targetId = await validateGovernanceGate(input.tx, {
companyId: input.companyId,
issueId: input.issue.id,
gate: effect.gate,
executionState: input.issue.executionState,
runId: input.runId,
conversationMode: isConversation(input.issue),
});
return {
effectKind: effect.kind,
targetType: effect.gate.kind,
targetId,
payload: { gate: effect.gate },
};
}
const interaction = await issueThreadInteractionService(input.tx).create(
input.issue,
{
kind: "ask_user_questions",
idempotencyKey: `native-attention:${input.decisionId}`,
sourceRunId: input.runId,
title: "Native attention request",
summary: "The native runner requires a board response.",
continuationPolicy: "wake_assignee",
payload: {
version: 1,
questions: [
{
id: "response",
prompt: effect.prompt ?? "Provide the required response.",
selectionMode: "single",
options: [{ id: "continue", label: "Continue" }],
},
],
},
},
{ agentId: input.actorAgentId, systemId: "native-status-committer", runId: input.runId },
);
return {
effectKind: effect.kind,
targetType: "issue_thread_interaction",
targetId: interaction.id,
payload: {
interactionId: interaction.id,
interactionKind: interaction.kind,
},
};
}
if (effect.kind === "bind_reviewer") {
failAt("interaction_materialization", input.failpoint);
const reviewInput: Extract<
CreateIssueThreadInteraction,
{ kind: "request_confirmation" }
> = {
kind: "request_confirmation",
idempotencyKey: `native-review:${input.decisionId}${effect.requestKey ? `:${effect.requestKey}` : ""}`,
sourceRunId: input.runId,
resolverPolicy: effect.ownerAgentId ? "anyone" : "human_only",
addresseeAgentId: effect.ownerAgentId ?? null,
addresseeUserId: effect.ownerUserId,
title: "Review requested",
summary:
effect.prompt,
continuationPolicy: "wake_assignee",
payload: {
version: 1,
prompt: effect.prompt,
detailsMarkdown: effect.detailsMarkdown ?? null,
acceptLabel: "Approve completion",
rejectLabel: "Continue work",
allowDeclineReason: true,
rejectRequiresReason: true,
supersedeOnUserComment: false,
target: {
type: "custom",
key: "native_completion_review",
revisionId: input.decisionId,
label: "Completion decision",
},
},
};
const interaction = await issueThreadInteractionService(input.tx).create(
input.issue,
reviewInput,
{ agentId: input.actorAgentId, systemId: "native-status-committer", runId: input.runId },
{ supersedePendingSiblingInteractions: false },
);
// The card and its next actor commit together. The post-commit dispatcher
// revalidates this exact review before granting a scoped reviewer run.
const reviewContext = {
nativeReviewInteractionId: interaction.id,
nativeReviewDecisionId: input.decisionId,
};
const reviewerWakeId = effect.ownerAgentId && interaction.effectiveResolverPolicy !== "human_only"
? await enqueueWake({
tx: input.tx,
originRunId: input.runId,
companyId: input.companyId,
issueId: input.issue.id,
agentId: effect.ownerAgentId,
reason: "native_completion_review",
idempotencyKey: `native-review:${interaction.id}`,
payload: reviewContext,
contextSnapshot: { ...reviewContext, forceFreshSession: true },
})
: null;
return {
effectKind: effect.kind,
targetType: "issue_thread_interaction",
targetId: interaction.id,
payload: {
interactionId: interaction.id,
interactionKind: interaction.kind,
ownerUserId: effect.ownerUserId,
ownerAgentId: effect.ownerAgentId ?? null,
reviewerWakeId,
},
};
}
if (effect.kind === "notify_owner") {
const wakeId = await enqueueWake({
tx: input.tx,
originRunId: input.runId,
companyId: input.companyId,
issueId: input.issue.id,
agentId: effect.agentId,
reason: "issue_status_changed",
idempotencyKey: `native-status:${input.decisionId}:notify-owner`,
payload: {
nativeDecisionId: input.decisionId,
notificationReason: effect.reason,
},
});
return {
effectKind: effect.kind,
targetType: "agent_wakeup_request",
targetId: wakeId,
payload: { reason: effect.reason },
};
}
if (effect.kind === "create_delegated_issue") {
const delegated = await issueService(input.tx).create(input.companyId, {
projectId: input.issue.projectId,
projectWorkspaceId: input.issue.projectWorkspaceId,
goalId: input.issue.goalId,
parentId: input.issue.id,
title: effect.summary,
status: "todo",
priority: input.issue.priority,
assigneeAgentId: effect.agentId,
createdByAgentId: input.actorAgentId,
workMode: "standard",
idempotencyKey: `native-delegation:${input.decisionId}`,
inheritExecutionWorkspaceFromIssueId: input.issue.id,
});
if (!delegated) throw new Error("native_delegated_issue_not_persisted");
return {
effectKind: effect.kind,
targetType: "delegated_issue",
targetId: delegated.id,
payload: { summary: effect.summary, agentId: effect.agentId },
};
}
if (effect.kind === "enqueue_continuation") {
failAt("continuation_materialization", input.failpoint);
if (
effect.idempotencyKey.startsWith(
`connection-intent:tools:${input.runId}:`,
)
) {
const [refresh] = await input.tx
.select({ id: agentWakeupRequests.id })
.from(agentWakeupRequests)
.where(
and(
eq(agentWakeupRequests.companyId, input.companyId),
eq(agentWakeupRequests.agentId, effect.agentId),
eq(agentWakeupRequests.idempotencyKey, effect.idempotencyKey),
notInArray(agentWakeupRequests.status, [
"skipped",
"failed",
"cancelled",
]),
),
)
.limit(1);
if (refresh)
return {
effectKind: effect.kind,
targetType: "agent_wakeup_request",
targetId: refresh.id,
payload: {
continuationKind: effect.continuationKind,
summary: effect.summary,
},
};
}
if (effect.continuationKind === "monitor") throw new Error("Monitor delivery belongs to the issue monitor scheduler");
const wakeId = await enqueueWake({
tx: input.tx,
originRunId: input.runId,
companyId: input.companyId,
issueId: input.issue.id,
agentId: effect.agentId,
reason: "issue_status_changed",
idempotencyKey: `native-status:${input.decisionId}:continuation`,
payload: {
nativeDecisionId: input.decisionId,
continuationKind: effect.continuationKind,
continuationSummary: effect.summary,
continuationIdempotencyKey: effect.idempotencyKey,
},
});
return {
effectKind: effect.kind,
targetType: "agent_wakeup_request",
targetId: wakeId,
payload: {
continuationKind: effect.continuationKind,
summary: effect.summary,
},
};
}
if (effect.kind === "bind_blocker") {
failAt("blocker_materialization", input.failpoint);
await assertAgentInteraction(input.tx, { companyId: input.companyId, actorAgentId: input.actorAgentId,
operation: "assign", issueId: input.issue.id, targetAgentId: typeof effect.owner === "object" ? effect.owner.agentId : null,
texts: [effect.action], lock: true });
const [bound] = await input.tx
.update(issues)
.set({
unblockDescriptor: { owner: effect.owner, action: effect.action },
updatedAt: new Date(),
})
.where(
and(
eq(issues.id, input.issue.id),
eq(issues.companyId, input.companyId),
),
)
.returning({ id: issues.id });
if (!bound) throw new Error("native_blocker_binding_not_persisted");
let wakeId: string | null = null;
if (effect.owner !== "board") {
wakeId = await enqueueWake({
tx: input.tx,
originRunId: input.runId,
companyId: input.companyId,
issueId: input.issue.id,
agentId: effect.owner.agentId,
reason: "issue_status_changed",
idempotencyKey: `native-status:${input.decisionId}:blocker-owner`,
payload: {
nativeDecisionId: input.decisionId,
unblockAction: effect.action,
},
});
}
return {
effectKind: effect.kind,
targetType: "issue_unblock_descriptor",
targetId: bound.id,
payload: { owner: effect.owner, action: effect.action, wakeId },
};
}
if (effect.kind === "schedule_retry") {
failAt("continuation_materialization", input.failpoint);
if (effect.cause === NATIVE_PROVIDER_OVERLOADED_CODE) {
const retryId = await materializeNativeProviderCapacityRetry({
tx: input.tx as unknown as Db, companyId: input.companyId,
issueId: input.issue.id, runId: input.runId, agentId: effect.agentId,
});
return { effectKind: effect.kind, targetType: "heartbeat_run", targetId: retryId,
payload: { cause: effect.cause, summary: effect.summary } };
}
const wakeId = await enqueueWake({
tx: input.tx,
companyId: input.companyId,
issueId: input.issue.id,
agentId: effect.agentId,
reason: "issue_status_changed",
idempotencyKey: `native-status:${input.decisionId}:retry`,
originRunId: input.runId,
payload: {
nativeDecisionId: input.decisionId,
retryCause: effect.cause,
retrySummary: effect.summary,
},
});
return {
effectKind: effect.kind,
targetType: "agent_wakeup_request",
targetId: wakeId,
payload: { cause: effect.cause, summary: effect.summary },
};
}
if (effect.kind === "record_finalization_error") {
failAt("recovery_materialization", input.failpoint);
const recovery = await issueRecoveryActionService(
input.tx,
).upsertSourceScoped({
companyId: input.companyId,
sourceIssueId: input.issue.id,
kind: "active_run_watchdog",
ownerType: "agent",
ownerAgentId: effect.agentId,
cause: effect.cause,
fingerprint: nativeSha256({
runId: input.runId,
decisionId: input.decisionId,
cause: effect.cause,
}),
evidence: { runId: input.runId, decisionId: input.decisionId },
nextAction: effect.nextAction,
wakePolicy: null,
maxAttempts: 3,
});
return {
effectKind: effect.kind,
targetType: "issue_recovery_action",
targetId: recovery.id,
payload: { cause: effect.cause, nextAction: effect.nextAction },
};
}
if (effect.kind === "release_run_resources") {
failAt("recovery_materialization", input.failpoint);
const [released] = await input.tx
.update(heartbeatRuns)
.set({
processPid: null,
processGroupId: null,
processStartedAt: null,
nativePhase: "committed",
nativePhaseUpdatedAt: new Date(),
updatedAt: new Date(),
})
.where(
and(
eq(heartbeatRuns.id, input.runId),
eq(heartbeatRuns.companyId, input.companyId),
),
)
.returning({ id: heartbeatRuns.id });
if (!released) throw new Error("native_run_resources_not_released");
return {
effectKind: effect.kind,
targetType: "heartbeat_run",
targetId: released.id,
payload: { processReleased: true },
};
}
if (effect.kind === "record_expiry") {
failAt("recovery_materialization", input.failpoint);
if (!input.issue.assigneeAgentId)
throw new Error("native_recovery_owner_missing");
const interaction = await input.tx
.select({ id: issueThreadInteractions.id })
.from(issueThreadInteractions)
.where(
and(
eq(issueThreadInteractions.companyId, input.companyId),
eq(issueThreadInteractions.issueId, input.issue.id),
inArray(issueThreadInteractions.status, ["pending", "expired"]),
),
)
.for("update")
.limit(1)
.then((rows) => rows[0] ?? null);
if (!interaction) throw new Error("native_attention_expiry_target_missing");
await input.tx
.update(issueThreadInteractions)
.set({
status: "expired",
resolvedAt: new Date(),
updatedAt: new Date(),
})
.where(eq(issueThreadInteractions.id, interaction.id));
const cause = "attention_expired";
const recovery = await issueRecoveryActionService(
input.tx,
).upsertSourceScoped({
companyId: input.companyId,
sourceIssueId: input.issue.id,
kind: "active_run_watchdog",
ownerType: "agent",
ownerAgentId: input.issue.assigneeAgentId,
cause,
fingerprint: nativeSha256({
runId: input.runId,
decisionId: input.decisionId,
cause,
}),
evidence: { runId: input.runId, decisionId: input.decisionId },
nextAction:
"Review the expired attention route and choose a new authorized path.",
wakePolicy: null,
maxAttempts: 3,
});
return {
effectKind: effect.kind,
targetType: "issue_thread_interaction",
targetId: interaction.id,
payload: { cause, recoveryActionId: recovery.id },
};
}
if (effect.kind === "schedule_reconciliation") {
failAt("recovery_materialization", input.failpoint);
if (!input.issue.assigneeAgentId)
throw new Error("native_recovery_owner_missing");
const cause = "native_reconciliation_required";
const recovery = await issueRecoveryActionService(
input.tx,
).upsertSourceScoped({
companyId: input.companyId,
sourceIssueId: input.issue.id,
kind: "active_run_watchdog",
ownerType: "agent",
ownerAgentId: input.issue.assigneeAgentId,
cause,
fingerprint: nativeSha256({
runId: input.runId,
decisionId: input.decisionId,
cause,
}),
evidence: { runId: input.runId, decisionId: input.decisionId },
nextAction:
"Reconcile the native decision against the latest issue status version.",
wakePolicy: null,
maxAttempts: 3,
});
return {
effectKind: effect.kind,
targetType: "issue_recovery_action",
targetId: recovery.id,
payload: { cause },
};
}
if (effect.kind === "accept_replacement_turn") {
const [run] = await input.tx
.update(heartbeatRuns)
.set({
status: "running",
continuationAttempt: sql`${heartbeatRuns.continuationAttempt} + 1`,
nextAction: "Accept a replacement native turn on the existing run.",
updatedAt: new Date(),
})
.where(
and(
eq(heartbeatRuns.id, input.runId),
eq(heartbeatRuns.companyId, input.companyId),
),
)
.returning({
id: heartbeatRuns.id,
continuationAttempt: heartbeatRuns.continuationAttempt,
});
if (!run) throw new Error("native_replacement_turn_not_accepted");
return {
effectKind: effect.kind,
targetType: "heartbeat_run",
targetId: run.id,
payload: { continuationAttempt: run.continuationAttempt },
};
}
if (effect.kind === "cancel_continuations") {
const wakeRows = await input.tx
.select({ id: agentWakeupRequests.id })
.from(agentWakeupRequests)
.where(
and(
eq(agentWakeupRequests.companyId, input.companyId),
inArray(agentWakeupRequests.status, [
"queued",
"deferred_issue_execution",
"claimed",
]),
sql`coalesce(
${agentWakeupRequests.payload} ->> 'issueId',
${agentWakeupRequests.payload} ->> 'taskId',
${agentWakeupRequests.payload} -> '_paperclipWakeContext' ->> 'issueId',
${agentWakeupRequests.payload} -> '_paperclipWakeContext' ->> 'taskId'
) = ${input.issue.id}`,
),
);
if (wakeRows.length > 0) {
await input.tx
.update(agentWakeupRequests)
.set({
status: "cancelled",
finishedAt: new Date(),
error: "Cancelled by native issue cancellation",
updatedAt: new Date(),
})
.where(
inArray(
agentWakeupRequests.id,
wakeRows.map((row) => row.id),
),
);
}
const interactionRows = await input.tx
.select({ id: issueThreadInteractions.id })
.from(issueThreadInteractions)
.where(
and(
eq(issueThreadInteractions.companyId, input.companyId),
eq(issueThreadInteractions.issueId, input.issue.id),
eq(issueThreadInteractions.status, "pending"),
),
);
if (interactionRows.length > 0) {
await input.tx
.update(issueThreadInteractions)
.set({
status: "cancelled",
resolvedAt: new Date(),
updatedAt: new Date(),
})
.where(
inArray(
issueThreadInteractions.id,
interactionRows.map((row) => row.id),
),
);
}
await notifyExternalAgentSettlement(input.tx, { companyId: input.companyId, runId: input.runId });
await notifyInstructionCollection(input.tx, { companyId: input.companyId, runId: input.runId });
await notifyCancelledWorkspacePreservation(input.tx, { companyId: input.companyId, runId: input.runId });
await notifyUnsafeWorkspaceExportRecovery(input.tx, { companyId: input.companyId, issueId: input.issue.id });
await notifyDeliveryWork(input.tx, DELIVERY_QUEUES.accounting, input.companyId);
const [run] = await input.tx
.update(heartbeatRuns)
.set({
status: "cancelled",
finishedAt: new Date(),
updatedAt: new Date(),
})
.where(
and(
eq(heartbeatRuns.id, input.runId),
eq(heartbeatRuns.companyId, input.companyId),
),
)
.returning();
if (!run) throw new Error("native_continuation_cancellation_run_missing");
input.terminalRunsToEmit?.push(run);
return {
effectKind: effect.kind,
targetType: "heartbeat_run",
targetId: run.id,
payload: {
cancelledWakeIds: wakeRows.map((row) => row.id),
cancelledInteractionIds: interactionRows.map((row) => row.id),
},
};
}
if (effect.kind === "append_superseding_assessment") {
const lineage = await input.tx
.select({
currentAssessmentId: statusDecisions.assessmentId,
})
.from(statusDecisions)
.where(
and(
eq(statusDecisions.id, input.decisionId),
eq(statusDecisions.companyId, input.companyId),
),
)
.limit(1)
.then((rows) => rows[0] ?? null);
if (!lineage) throw new Error("native_superseded_assessment_missing");
if (!input.issue.lastStatusDecisionId) {
const assessment = await input.tx
.select({
id: workAssessments.id,
supersedesAssessmentId: workAssessments.supersedesAssessmentId,
})
.from(workAssessments)
.where(
and(
eq(workAssessments.id, lineage.currentAssessmentId),
eq(workAssessments.companyId, input.companyId),
eq(workAssessments.issueId, input.issue.id),
),
)
.limit(1)
.then((rows) => rows[0] ?? null);
if (!assessment?.supersedesAssessmentId) {
throw new Error("native_superseding_assessment_not_linked");
}
return {
effectKind: effect.kind,
targetType: "status_decision",
targetId: input.decisionId,
payload: {
supersedesDecisionId: null,
assessmentId: assessment.id,
supersedesAssessmentId: assessment.supersedesAssessmentId,
},
};
}
const prior = await input.tx
.select({
id: statusDecisions.id,
})
.from(statusDecisions)
.where(
and(
eq(statusDecisions.id, input.issue.lastStatusDecisionId),
eq(statusDecisions.companyId, input.companyId),
),
)
.limit(1)
.then((rows) => rows[0] ?? null);
if (!prior) throw new Error("native_superseded_assessment_missing");
const assessment = await input.tx
.select({
id: workAssessments.id,
supersedesAssessmentId: workAssessments.supersedesAssessmentId,
})
.from(workAssessments)
.where(
and(
eq(workAssessments.id, lineage.currentAssessmentId),
eq(workAssessments.companyId, input.companyId),
eq(workAssessments.issueId, input.issue.id),
eq(workAssessments.runId, input.runId),
),
)
.limit(1)
.then((rows) => rows[0] ?? null);
if (!assessment?.supersedesAssessmentId) {
throw new Error("native_superseding_assessment_not_linked");
}
// Status decisions form one issue-wide sequence and may supersede a
// decision from another run. Work-assessment lineage is deliberately
// run-local, so retain the parent recorded when this reassessment was
// created instead of replacing it with the prior decision's assessment.
const [decision] = await input.tx
.update(statusDecisions)
.set({
supersedesDecisionId: input.issue.lastStatusDecisionId,
})
.where(
and(
eq(statusDecisions.id, input.decisionId),
eq(statusDecisions.companyId, input.companyId),
),
)
.returning({ id: statusDecisions.id });
if (!decision) throw new Error("native_superseding_assessment_not_linked");
return {
effectKind: effect.kind,
targetType: "status_decision",
targetId: decision.id,
payload: {
supersedesDecisionId: input.issue.lastStatusDecisionId,
assessmentId: assessment.id,
supersedesAssessmentId: assessment.supersedesAssessmentId,
},
};
}
if (effect.kind === "dispatch_pending_effect") {
const pending = await input.tx
.select({ id: statusDecisionEffects.id })
.from(statusDecisionEffects)
.where(
and(
eq(statusDecisionEffects.companyId, input.companyId),
eq(statusDecisionEffects.issueId, input.issue.id),
inArray(statusDecisionEffects.deliveryState, ["pending", "failed"]),
),
)
.for("update");
if (pending.length === 0) throw new Error("native_pending_effect_missing");
await notifyNativeFinalizationWork(input.tx, { companyId: input.companyId, issueId: input.issue.id });
await input.tx
.update(statusDecisionEffects)
.set({
deliveryState: "delivered",
attemptCount: sql`${statusDecisionEffects.attemptCount} + 1`,
deliveredAt: new Date(),
nextAttemptAt: null,
lastError: null,
updatedAt: new Date(),
})
.where(
inArray(
statusDecisionEffects.id,
pending.map((row) => row.id),
),
);
await updateRunEffectState({
tx: input.tx,
companyId: input.companyId,
runId: input.runId,
key: "nativeDispatchedEffectIds",
value: pending.map((row) => row.id),
});
return {
effectKind: effect.kind,
targetType: "heartbeat_run",
targetId: input.runId,
payload: { dispatchedEffectIds: pending.map((row) => row.id) },
};
}
if (effect.kind === "increment_status_version") {
const updated = await issueService(input.tx).update(
input.issue.id,
{
statusVersion: Number(input.issue.statusVersion) + 1,
actorAgentId: null,
actorUserId: null,
},
input.tx,
);
if (!updated) throw new Error("native_status_version_not_incremented");
return {
effectKind: effect.kind,
targetType: "issue",
targetId: updated.id,
payload: { statusVersion: updated.statusVersion },
};
}
if (effect.kind === "record_shadow_decision") {
const targetId = await updateRunEffectState({
tx: input.tx,
companyId: input.companyId,
runId: input.runId,
key: "nativeShadowDecision",
value: { decisionId: input.decisionId, applicationState: "shadow" },
});
return {
effectKind: effect.kind,
targetType: "heartbeat_run",
targetId,
payload: { decisionId: input.decisionId, applicationState: "shadow" },
};
}
if (effect.kind === "render_four_layers") {
const targetId = await updateRunEffectState({
tx: input.tx,
companyId: input.companyId,
runId: input.runId,
key: "nativeOutcomeLayers",
value: {
runStatus: "persisted",
issueStatus: input.issue.status,
claim: "preserved",
decisionId: input.decisionId,
},
});
return {
effectKind: effect.kind,
targetType: "heartbeat_run",
targetId,
payload: { layerCount: 4 },
};
}
if (effect.kind === "materialize_contract") {
const contract = await input.tx
.select({
id: completionContracts.id,
canonicalSha256: completionContracts.canonicalSha256,
})
.from(completionContracts)
.where(
and(
eq(completionContracts.companyId, input.companyId),
eq(completionContracts.issueId, input.issue.id),
),
)
.orderBy(desc(completionContracts.revision))
.limit(1)
.then((rows) => rows[0] ?? null);
if (!contract) throw new Error("native_completion_contract_missing");
await input.tx
.update(heartbeatRuns)
.set({
completionContractId: contract.id,
completionContractSha256: contract.canonicalSha256,
updatedAt: new Date(),
})
.where(
and(
eq(heartbeatRuns.id, input.runId),
eq(heartbeatRuns.companyId, input.companyId),
),
);
return {
effectKind: effect.kind,
targetType: "completion_contract",
targetId: contract.id,
payload: { canonicalSha256: contract.canonicalSha256 },
};
}
if (effect.kind === "record_mode_labeled_divergence") {
const targetId = await updateRunEffectState({
tx: input.tx,
companyId: input.companyId,
runId: input.runId,
key: "nativeLegacyDivergence",
value: { mode: "native", decisionId: input.decisionId, classified: true },
});
return {
effectKind: effect.kind,
targetType: "heartbeat_run",
targetId,
payload: { mode: "native", classified: true },
};
}
if (effect.kind === "record_mode_native") {
const [run] = await input.tx
.update(heartbeatRuns)
.set({
runtimeMode: "native",
runtimeModeResolvedAt: new Date(),
updatedAt: new Date(),
})
.where(
and(
eq(heartbeatRuns.id, input.runId),
eq(heartbeatRuns.companyId, input.companyId),
),
)
.returning({ id: heartbeatRuns.id });
if (!run) throw new Error("native_runtime_mode_not_recorded");
return {
effectKind: effect.kind,
targetType: "heartbeat_run",
targetId: run.id,
payload: { runtimeMode: "native" },
};
}
if (effect.kind === "record_policy_version") {
const targetId = await updateRunEffectState({
tx: input.tx,
companyId: input.companyId,
runId: input.runId,
key: "nativeStatusPolicyVersion",
value: NATIVE_STATUS_ARBITER_POLICY_VERSION,
runnerProfile: true,
});
return {
effectKind: effect.kind,
targetType: "heartbeat_run",
targetId,
payload: { policyVersion: NATIVE_STATUS_ARBITER_POLICY_VERSION },
};
}
if (effect.kind === "finish_as_native") {
const targetId = await updateRunEffectState({
tx: input.tx,
companyId: input.companyId,
runId: input.runId,
key: "nativeKillSwitchDisposition",
value: "finish_as_native",
});
await input.tx
.update(heartbeatRuns)
.set({ runtimeMode: "native", updatedAt: new Date() })
.where(eq(heartbeatRuns.id, input.runId));
return {
effectKind: effect.kind,
targetType: "heartbeat_run",
targetId,
payload: { runtimeMode: "native" },
};
}
if (effect.kind === "resume_workspace_operation") {
const resumed = input.preMaterializedEffects?.get(effect.kind);
if (
!resumed ||
resumed.targetType !== "workspace_operation" ||
!resumed.targetId
) {
throw new Error("native_workspace_operation_not_executed");
}
const operation = await input.tx
.select({ status: workspaceOperations.status })
.from(workspaceOperations)
.where(
and(
eq(workspaceOperations.id, resumed.targetId),
eq(workspaceOperations.companyId, input.companyId),
eq(workspaceOperations.heartbeatRunId, input.runId),
eq(workspaceOperations.issueId, input.issue.id),
eq(workspaceOperations.phase, "workspace_finalize"),
),
)
.limit(1)
.then((rows) => rows[0] ?? null);
if (operation?.status !== "succeeded")
throw new Error("native_workspace_operation_not_succeeded");
return resumed;
}
if (effect.kind === "record_stale_response") {
const interaction = await input.tx
.select({ id: issueThreadInteractions.id })
.from(issueThreadInteractions)
.where(
and(
eq(issueThreadInteractions.companyId, input.companyId),
eq(issueThreadInteractions.issueId, input.issue.id),
inArray(issueThreadInteractions.status, [
"answered",
"accepted",
"rejected",
"expired",
]),
),
)
.orderBy(desc(issueThreadInteractions.updatedAt))
.limit(1)
.then((rows) => rows[0] ?? null);
if (!interaction) throw new Error("native_stale_response_missing");
await input.tx
.update(issueThreadInteractions)
.set({
summary: "Response retained for audit after native supersession.",
updatedAt: new Date(),
})
.where(eq(issueThreadInteractions.id, interaction.id));
return {
effectKind: effect.kind,
targetType: "issue_thread_interaction",
targetId: interaction.id,
payload: { status: "superseded" },
};
}
if (effect.kind === "link_canonical_request") {
const interactions = await input.tx
.select({ id: issueThreadInteractions.id })
.from(issueThreadInteractions)
.where(
and(
eq(issueThreadInteractions.companyId, input.companyId),
eq(issueThreadInteractions.issueId, input.issue.id),
),
)
.orderBy(asc(issueThreadInteractions.createdAt))
.limit(2);
if (interactions.length < 2)
throw new Error("native_attention_canonical_pair_missing");
const canonical = interactions[0]!;
const duplicate = interactions[1]!;
await input.tx
.update(issueThreadInteractions)
.set({
summary: `Canonical native attention request: ${canonical.id}`,
updatedAt: new Date(),
})
.where(eq(issueThreadInteractions.id, duplicate.id));
return {
effectKind: effect.kind,
targetType: "issue_thread_interaction",
targetId: duplicate.id,
payload: { canonicalRequestId: canonical.id },
};
}
if (effect.kind === "release_checkout") {
await notifyUnsafeWorkspaceExportRecovery(input.tx, { companyId: input.companyId, issueId: input.issue.id });
// Release only this run's own locks. A successor can claim execution
// without changing statusVersion, so a preserve decision committed after
// that claim must not clear it. Each SET reads the pre-update row.
const ownsExecution = sql`${issues.executionRunId} = ${input.runId}::uuid`;
const [released] = await input.tx
.update(issues)
.set({
checkoutRunId: sql`case when ${issues.checkoutRunId} = ${input.runId}::uuid then null else ${issues.checkoutRunId} end`,
executionRunId: sql`case when ${ownsExecution} then null else ${issues.executionRunId} end`,
executionAgentNameKey: sql`case when ${ownsExecution} then null else ${issues.executionAgentNameKey} end`,
executionLockedAt: sql`case when ${ownsExecution} then null else ${issues.executionLockedAt} end`,
updatedAt: new Date(),
})
.where(
and(
eq(issues.id, input.issue.id),
eq(issues.companyId, input.companyId),
),
)
.returning({
id: issues.id,
checkoutRunId: issues.checkoutRunId,
executionRunId: issues.executionRunId,
});
if (!released) throw new Error("native_checkout_not_released");
return {
effectKind: effect.kind,
targetType: "issue_checkout",
targetId: released.id,
payload: {
checkoutRunId: released.checkoutRunId,
executionRunId: released.executionRunId,
},
};
}
if (effect.kind === "record_recovery") {
failAt("recovery_materialization", input.failpoint);
const recovery = await issueRecoveryActionService(
input.tx,
).upsertSourceScoped({
companyId: input.companyId,
sourceIssueId: input.issue.id,
kind: "active_run_watchdog",
ownerType: "agent",
ownerAgentId: effect.agentId,
cause: effect.cause,
fingerprint: nativeSha256({
runId: input.runId,
decisionId: input.decisionId,
cause: effect.cause,
}),
evidence: { runId: input.runId, decisionId: input.decisionId },
nextAction: effect.nextAction,
wakePolicy: { kind: "resume_native_run", runId: input.runId },
maxAttempts: 3,
});
return {
effectKind: effect.kind,
targetType: "issue_recovery_action",
targetId: recovery.id,
payload: { cause: effect.cause, nextAction: effect.nextAction },
};
}
return assertNeverEffect(effect);
}
export async function commitNativeStatusDecision(input: {
db: Db;
companyId: string;
issueId: string;
runId: string;
assessmentId: string;
priorStatus: string;
priorStatusVersion: number;
priorDecisionId: string | null;
decision: NativeStatusDecision;
failpoint?: NativeStatusCommitFailpoint;
preMaterializedEffects?: NativeMaterializedStatusEffect[];
supersedesCommittedDecisionId?: string;
supersededExternalReviewRequests?: { agentId: string; resultId: string; interactionIds: string[] };
requireExternalChatResponseWaitAuthorization?: { agentId: string; completionContinuationKey?: string };
requirePreservedResultFinalization?: PreservedNativeResultFinalization;
requirePlanWaitSource?: NativePlanWaitSource;
requireMonitorWait?: { agentId: string; nextCheckAt: string };
requireMonitorDelivery?: NativeMonitorDelivery;
requirePreservedMonitorWait?: NativePreservedMonitorWait;
requireSupersededMonitorWait?: NativeSupersededMonitorWait;
requireNoPendingChildCompletion?: NativeChildCompletionRecipient;
requireReassessmentSource?: {
phase: string; resultId: string; assessmentId: string; decisionId: string | null; agentId: string;
retiredAutomaticReview: { contractId: string; governanceGate: NativeGovernanceGate | null; hasUnresolvedIssueBlockers: boolean } | null;
};
requireModelRejectionOwner?: { agentId: string; reviewContext: NativeReviewAssignmentContext | null };
requireProviderFailureOwner?: { agentId: string; reviewContext: NativeReviewAssignmentContext | null };
requireBoardResponseWaitSource?: NativeBoardResponseWaitSource;
requireBoardResponseWaitOrigin?: NativeBoardResponseWaitOrigin;
reviewResponsePresentation?: {
agentId: string;
resultId: string;
gateId: string;
};
}) {
if (input.decision.reasonCode === null) {
throw new Error("native_status_reason_code_required");
}
const reasonCode = input.decision.reasonCode;
if (reasonCode === "native_provider_model_rejected" && !input.requireModelRejectionOwner) {
throw new Error("native_model_rejection_owner_required");
}
if ((reasonCode.startsWith("native_provider_overloaded") || reasonCode === "native_run_failed_continuation_exhausted")
&& !input.requireProviderFailureOwner) {
throw new Error("native_provider_failure_owner_required");
}
const publications: ActivityPublication[] = [];
const terminalRunsToEmit: (typeof heartbeatRuns.$inferSelect)[] = [];
const committed = await input.db.transaction(async (tx) => {
const retiredReview = input.requireReassessmentSource?.retiredAutomaticReview;
if (retiredReview && !await lockCurrentNativeCompletionContract(tx as unknown as Db, {
companyId: input.companyId, issueId: input.issueId, contractId: retiredReview.contractId,
})) throw new NativeStatusRaceError();
if (retiredReview && !await tryLockNativeWorkspaceFinalization(tx as unknown as Db, input)) throw new NativeStatusRaceError();
const coordinator = await tx
.select()
.from(nativeRunFinalizations)
.where(
and(
eq(nativeRunFinalizations.runId, input.runId),
eq(nativeRunFinalizations.companyId, input.companyId),
eq(nativeRunFinalizations.issueId, input.issueId),
),
)
.for("update")
.limit(1)
.then((rows) => rows[0] ?? null);
if (!coordinator)
throw new Error("native_finalization_coordinator_missing");
if (coordinator.failureCode === "agent_interaction_denied") {
throw forbidden("This native interaction was permanently refused by agent permissions.",
record(record(coordinator.failureDetail).interactionDenial));
}
const issue = await tx
.select()
.from(issues)
.where(
and(
eq(issues.id, input.issueId),
eq(issues.companyId, input.companyId),
),
)
.for("update")
.limit(1)
.then((rows) => rows[0] ?? null);
if (!issue) throw new NativeStatusRaceError();
const [originRun] = await tx.select({ agentId: heartbeatRuns.agentId }).from(heartbeatRuns)
.where(and(eq(heartbeatRuns.id, input.runId), eq(heartbeatRuns.companyId, input.companyId)));
if (input.requireReassessmentSource) {
const expected = input.requireReassessmentSource;
const now = Date.now();
if (coordinator.phase === "terminal_failure" || coordinator.phase !== expected.phase ||
coordinator.resultId !== expected.resultId || coordinator.assessmentId !== expected.assessmentId ||
coordinator.decisionId !== expected.decisionId ||
(coordinator.nextAttemptAt !== null && coordinator.nextAttemptAt.getTime() > now) ||
(coordinator.leaseOwner !== null &&
(coordinator.leaseExpiresAt === null || coordinator.leaseExpiresAt.getTime() > now))) {
throw new NativeStatusRaceError();
}
const run = await tx.select().from(heartbeatRuns).where(and(
eq(heartbeatRuns.id, input.runId), eq(heartbeatRuns.companyId, input.companyId),
eq(heartbeatRuns.nativeIssueId, input.issueId), eq(heartbeatRuns.agentId, expected.agentId),
)).for("update").limit(1).then(rows => rows[0]);
if (!run || run.runtimeMode !== "native" || isNativeRunnerOwnershipHeld(run)) throw new NativeStatusRaceError();
if (expected.retiredAutomaticReview && (run.status !== "succeeded" ||
hasNativeWorkspaceFinalizationOwner(run.runnerProfileJson) ||
(issue.executionRunId !== null && issue.executionRunId !== input.runId))) {
throw new NativeStatusRaceError();
}
if (expected.retiredAutomaticReview) {
try {
const [barrier] = await tx.select({ status: workspaceOperations.status }).from(workspaceOperations)
.where(and(eq(workspaceOperations.companyId, input.companyId),
eq(workspaceOperations.heartbeatRunId, input.runId), eq(workspaceOperations.phase, "workspace_finalize")))
.orderBy(desc(workspaceOperations.createdAt)).limit(1).for("share", { noWait: true });
if (barrier && barrier.status !== "succeeded") throw new NativeStatusRaceError();
const executionState = record(issue.executionState);
if (executionState.status !== "pending") await lockNativeGovernanceSources({ db: tx as unknown as Db,
companyId: input.companyId, issueId: input.issueId });
const gate = await pendingNativeGovernance({ db: tx as unknown as Db, companyId: input.companyId,
issueId: input.issueId, runId: input.runId, executionState });
const expectedGate = expected.retiredAutomaticReview.governanceGate;
if (gate?.kind !== expectedGate?.kind || gate?.id !== expectedGate?.id) throw new NativeStatusRaceError();
const readiness = await issueService(tx as unknown as Db).getDependencyReadiness(input.issueId, tx, { lockSources: true });
if ((readiness.unresolvedBlockerCount > 0) !== expected.retiredAutomaticReview.hasUnresolvedIssueBlockers) {
throw new NativeStatusRaceError();
}
} catch (error) {
if (record(error).code === "55P03" || record(record(error).cause).code === "55P03") throw new NativeStatusRaceError();
throw error;
}
}
const pendingEffect = expected.decisionId ? await tx.select({ id: statusDecisionEffects.id })
.from(statusDecisionEffects).where(and(
eq(statusDecisionEffects.companyId, input.companyId), eq(statusDecisionEffects.issueId, input.issueId),
eq(statusDecisionEffects.decisionId, expected.decisionId),
inArray(statusDecisionEffects.deliveryState, ["pending", "failed"]),
)).limit(1).then(rows => rows[0]) : null;
if (pendingEffect) throw new NativeStatusRaceError();
try {
if (!await lockCurrentNativeWorkAssessmentEvidence(tx as unknown as Db, {
companyId: input.companyId, issueId: input.issueId, runId: input.runId,
resultId: expected.resultId, assessmentId: input.assessmentId,
})) throw new NativeStatusRaceError();
} catch (error) {
if (record(error).code === "55P03" || record(record(error).cause).code === "55P03") throw new NativeStatusRaceError();
throw error;
}
}
// A completed model turn cannot close a persistent conversation. Preserve
// the task here; the response finalizer records its durable waiting state.
if (issue.conversationAgentId && input.decision.statusAction === "done") {
input = { ...input, decision: { ...input.decision, statusAction: "preserve", toStatus: issue.status as NativeStatusDecision["toStatus"], effects: [] } };
}
if (coordinator.phase === "committed" && coordinator.decisionId) {
if (input.supersedesCommittedDecisionId) {
if (
coordinator.decisionId !== input.supersedesCommittedDecisionId ||
coordinator.assessmentId === input.assessmentId
) {
throw new NativeStatusRaceError();
}
} else {
const existingDecision = await tx
.select()
.from(statusDecisions)
.where(
and(
eq(statusDecisions.id, coordinator.decisionId),
eq(statusDecisions.companyId, input.companyId),
eq(statusDecisions.issueId, input.issueId),
),
)
.limit(1)
.then((rows) => rows[0] ?? null);
if (!existingDecision)
throw new Error("native_committed_decision_missing");
return { decision: existingDecision, issue, replayed: true };
}
}
if (
issue.status !== input.priorStatus ||
Number(issue.statusVersion) !== input.priorStatusVersion ||
issue.lastStatusDecisionId !== input.priorDecisionId
) {
throw new NativeStatusRaceError();
}
// Recheck under the issue lock, retaining run/proposal/document proof until
// commit. A newer decision cannot race an earlier first-task Done assessment.
if (input.decision.statusAction === "done" && !await onboardingFirstTaskCompletionAllowed(tx as unknown as Db, {
companyId: input.companyId, issueId: input.issueId, runId: input.runId,
})) throw new NativeStatusRaceError();
if ((input.decision.statusAction === "done" || input.decision.reasonCode === COMPLETION_REVIEW_STAGE_REASON ||
input.decision.reasonCode === COMPLETION_REVIEW_STAGE_REJECTED_REASON) &&
!isConversation(issue) && heldByAnotherRun(issue, input.runId)) {
throw new NativeStatusRaceError();
}
// Every Done path (finalizer, reassessment, retired review) passes this
// lock. A policy that now requires or refuses review cannot be closed by a
// decision made without it; the finalizer recomputes against the policy.
if (input.decision.statusAction === "done" && !isConversation(issue) &&
completionReviewStageEntry(issue, originRun?.agentId ?? "").kind !== "none") {
throw new NativeStatusRaceError();
}
if (input.decision.statusAction === "done") {
try {
const [saved] = await tx.select({ context: heartbeatRuns.contextSnapshot, receipts: heartbeatRuns.resultJson,
envelope: nativeRunResults.resultJson }).from(heartbeatRuns)
.innerJoin(nativeRunResults, and(eq(nativeRunResults.runId, heartbeatRuns.id),
eq(nativeRunResults.id, coordinator.resultId!), eq(nativeRunResults.companyId, input.companyId),
eq(nativeRunResults.issueId, input.issueId), eq(nativeRunResults.schemaStatus, "accepted")))
.where(and(eq(heartbeatRuns.id, input.runId), eq(heartbeatRuns.companyId, input.companyId),
eq(heartbeatRuns.nativeIssueId, input.issueId), eq(heartbeatRuns.runtimeMode, "native")))
.limit(1).for("share", { of: [heartbeatRuns, nativeRunResults], noWait: true });
if (!saved) throw new NativeStatusRaceError();
const continuation = record(saved.context?.executionContinuation);
const objective = typeof continuation.objective === "string" ? continuation.objective
: [issue.title, issue.description].filter(Boolean).join("\n");
await validateNativeDeliverableEvidence(tx as unknown as Db, { companyId: input.companyId, issueId: input.issueId,
runId: input.runId, objective, semanticToolReceipts: saved.receipts?.semanticToolReceipts, lockSources: true,
authoritativeDone: true }, record(saved.envelope).result);
} catch (error) {
if (error instanceof NativeDeliverableEvidenceError || record(error).code === "55P03" ||
record(record(error).cause).code === "55P03") throw new NativeStatusRaceError();
throw error;
}
}
if (reasonCode === "scheduled_monitor_waiting") {
const expected = input.requireMonitorWait;
const inReview = input.decision.statusAction === "in_review" && input.decision.toStatus === "in_review";
let publishedReviewWait = inReview && await hasPublishedGitHubReview(tx as unknown as Db, input);
if (expected && inReview && !publishedReviewWait) {
// Arbitration may reuse a previous publication. Prove that same source
// here, while retaining the independently saved monitor and its owner.
const [run] = await tx.select({
id: heartbeatRuns.id, companyId: heartbeatRuns.companyId, agentId: heartbeatRuns.agentId,
responsibleUserId: heartbeatRuns.responsibleUserId,
activeIdentityContextId: heartbeatRuns.activeIdentityContextId,
nativeIssueId: heartbeatRuns.nativeIssueId, issueId: heartbeatRuns.issueId,
}).from(heartbeatRuns).where(and(
eq(heartbeatRuns.id, input.runId), eq(heartbeatRuns.companyId, input.companyId),
eq(heartbeatRuns.nativeIssueId, input.issueId), eq(heartbeatRuns.agentId, expected.agentId),
)).limit(1);
publishedReviewWait = !!run && (await readInheritedGitHubReviewWait(tx as unknown as Db,
{ ...run, contextSnapshot: null }))?.kind === "published";
}
if (!expected || issue.workMode !== "standard" || issue.executionRunId !== input.runId ||
(input.decision.statusAction !== "preserve" && !publishedReviewWait) || input.decision.effects.length !== 1 ||
input.decision.effects[0]?.kind !== "release_checkout" ||
scheduledIssueMonitorWait(issue, expected.agentId) !== expected.nextCheckAt) {
throw new NativeStatusRaceError();
}
}
if (reasonCode === "scheduled_monitor_dispatched") {
const expected = input.requireMonitorDelivery;
const actual = expected ? await readNativeMonitorDelivery(tx as unknown as Db, input) : null;
if (!expected || !actual || actual.wakeId !== expected.wakeId ||
actual.successorRunId !== expected.successorRunId ||
issue.executionRunId === input.runId || issue.checkoutRunId === input.runId ||
input.decision.statusAction !== "preserve" || input.decision.toStatus !== issue.status ||
input.decision.effects.length !== 0) throw new NativeStatusRaceError();
}
if (reasonCode === "scheduled_monitor_superseded") {
const expected = input.requireSupersededMonitorWait;
let actual: Awaited<ReturnType<typeof readNativeSupersededMonitorWait>> = null;
try {
actual = expected ? await readNativeSupersededMonitorWait(tx as unknown as Db, {
companyId: input.companyId, issueId: input.issueId, runId: input.runId, agentId: expected.agentId,
}, issue, true) : null;
} catch (error) {
if (record(error).code === "55P03" || record(record(error).cause).code === "55P03") throw new NativeStatusRaceError();
throw error;
}
if (!expected || !actual || actual.resultId !== expected.resultId || actual.wakeId !== expected.wakeId ||
actual.commentId !== expected.commentId || actual.successorRunId !== expected.successorRunId ||
input.decision.statusAction !== "preserve" || input.decision.toStatus !== issue.status ||
input.decision.effects.length !== 0) throw new NativeStatusRaceError();
}
if (reasonCode === "scheduled_monitor_preserved") {
const expected = input.requirePreservedMonitorWait;
const actual = expected ? await readNativePreservedMonitorWait(tx as unknown as Db, {
companyId: input.companyId, issueId: input.issueId, runId: input.runId, agentId: expected.agentId,
}, issue) : null;
if (!expected || !actual || actual.nextCheckAt !== expected.nextCheckAt || actual.resultId !== expected.resultId ||
input.decision.statusAction !== "preserve" || input.decision.toStatus !== issue.status ||
input.decision.effects.length !== 0 || await pendingNativeGovernance({ db: tx as unknown as Db,
companyId: input.companyId, issueId: input.issueId, runId: input.runId, executionState: record(issue.executionState),
})) throw new NativeStatusRaceError();
await notifyDeliveryWork(tx, DELIVERY_QUEUES.issueMonitors);
}
// Recheck under the parent status lock: a child can finish between the
// finalizer's read and this commit. Re-arbitrate instead of discarding its wake.
if (input.requireNoPendingChildCompletion && await hasPendingNativeChildCompletion(
tx as unknown as Db, input.requireNoPendingChildCompletion,
)) throw new NativeStatusRaceError();
if (input.requireModelRejectionOwner || input.requireProviderFailureOwner) {
const owner = (input.requireProviderFailureOwner ?? input.requireModelRejectionOwner)!;
// A successor can claim execution without changing statusVersion. Keep
// this new blocking authority behind the same locked issue snapshot.
if (issue.executionRunId && issue.executionRunId !== input.runId) throw new NativeStatusRaceError();
if (owner.reviewContext) {
const review = await getNativeReviewAssignment(tx as unknown as Db, {
companyId: input.companyId, issueId: input.issueId, agentId: owner.agentId, contextSnapshot: owner.reviewContext,
});
if (review?.interaction.status !== "pending") throw new NativeStatusRaceError();
} else if (issue.assigneeAgentId !== owner.agentId || issue.assigneeUserId) {
throw new NativeStatusRaceError();
}
}
if (input.requirePreservedResultFinalization) {
let current;
try {
current = await readPreservedNativeResultFinalization(tx as unknown as Db, input.requirePreservedResultFinalization, true);
} catch (error) {
if (isExternalChatWaitAuthorizationContention(error)) throw new NativeStatusRaceError();
throw error;
}
if (!current || current.fingerprint !== input.requirePreservedResultFinalization.fingerprint) throw new NativeStatusRaceError();
}
if (input.requireExternalChatResponseWaitAuthorization) {
let authorization;
try {
authorization =
await resolveExternalChatResponseWaitAuthorizationInTransaction(
tx as unknown as Db,
{
companyId: input.companyId,
issueId: input.issueId,
runId: input.runId,
agentId:
input.requireExternalChatResponseWaitAuthorization.agentId,
},
"nonblocking",
);
} catch (error) {
if (isExternalChatWaitAuthorizationContention(error)) {
throw new NativeStatusRaceError();
}
throw error;
}
if (authorization !== "authorized") {
throw new NativeStatusRaceError();
}
if (input.requireExternalChatResponseWaitAuthorization.completionContinuationKey) {
const current = await readPublishedGitHubReviewCompletionContinuationInTransaction(tx as unknown as Db,
{ companyId: input.companyId, issueId: input.issueId, runId: input.runId,
agentId: input.requireExternalChatResponseWaitAuthorization.agentId }, "nonblocking");
if (current?.idempotencyKey !== input.requireExternalChatResponseWaitAuthorization.completionContinuationKey)
throw new NativeStatusRaceError();
}
}
const passiveBoardResponseWait =
reasonCode === "board_response_waiting" ||
reasonCode === "board_response_wait_superseded";
let planWait: Awaited<ReturnType<typeof readNativePlanWait>> = null;
let planWaitResult: { resultId: string; resultSha256: string } | null = null;
if (reasonCode === "native_plan_accepted_waiting_for_continuation") {
const expected = input.requirePlanWaitSource;
if (!expected || expected.companyId !== input.companyId || expected.issueId !== input.issueId || expected.runId !== input.runId || input.decision.effects.length !== 0 || input.decision.statusAction !== "in_progress" || input.decision.toStatus !== "in_progress") throw new NativeStatusRaceError();
try {
planWait = await readNativePlanWait(tx as unknown as Db, expected, true);
if (!planWait || nativeSha256(planWait.source) !== nativeSha256(expected)) throw new NativeStatusRaceError();
// Recheck the committed semantic result too: an arbitrary caller cannot
// use a genuine plan receipt to authorize a different finalization.
const [accepted] = await tx.select().from(nativeRunResults).where(and(
eq(nativeRunResults.id, coordinator!.resultId!), eq(nativeRunResults.companyId, input.companyId),
eq(nativeRunResults.issueId, input.issueId), eq(nativeRunResults.runId, input.runId), eq(nativeRunResults.schemaStatus, "accepted"),
)).for("share", { noWait: true });
const envelope = record(accepted?.resultJson), terminal = record(envelope.terminal);
if (!accepted || accepted.completionContractId !== planWait.source.contractId || accepted.turnId !== planWait.source.turnId ||
nativeSha256(envelope.result) !== nativeSha256(planWait.result) ||
terminal.schema !== "paperclip.prp.terminal.v1" || terminal.runTerminalState !== "succeeded" || terminal.turnTerminalState !== "completed" || terminal.reportedWorkDisposition !== "yielded") throw new NativeStatusRaceError();
// completeRun hashes its full private binding, not the stored resultJson.
// Preserve that accepted identity instead of inventing a new digest.
planWaitResult = { resultId: accepted.id, resultSha256: accepted.canonicalSha256 };
} catch (error) {
if (isExternalChatWaitAuthorizationContention(error)) throw new NativeStatusRaceError();
throw error;
}
}
let boardResponseWaitOrigin: NativeBoardResponseWaitOrigin | null = null;
if (
passiveBoardResponseWait ||
input.requireBoardResponseWaitOrigin
) {
const expected = input.requireBoardResponseWaitOrigin;
if (
!expected ||
expected.companyId !== input.companyId ||
expected.issueId !== input.issueId ||
expected.runId !== input.runId ||
(passiveBoardResponseWait && input.decision.effects.length !== 0)
)
throw new NativeStatusRaceError();
try {
boardResponseWaitOrigin = await readNativeBoardResponseWaitOrigin(
tx as unknown as Db,
{
companyId: input.companyId,
issueId: input.issueId,
runId: input.runId,
agentId: expected.agentId,
},
true,
);
} catch (error) {
if (isExternalChatWaitAuthorizationContention(error))
throw new NativeStatusRaceError();
throw error;
}
if (
!boardResponseWaitOrigin ||
nativeSha256(boardResponseWaitOrigin) !== nativeSha256(expected)
)
throw new NativeStatusRaceError();
}
let boardResponseWait: Awaited<
ReturnType<typeof readNativeBoardResponseWaitSource>
> = null;
// Corrective continuations also carry this precondition. Revalidate it
// under the same locks before any decision effects can restart old work.
if (reasonCode === "board_response_waiting" || input.requireBoardResponseWaitSource) {
const expected = input.requireBoardResponseWaitSource;
if (
!expected ||
(passiveBoardResponseWait && input.decision.effects.length !== 0) ||
expected.companyId !== input.companyId ||
expected.issueId !== input.issueId ||
expected.runId !== input.runId
)
throw new NativeStatusRaceError();
try {
boardResponseWait = await readNativeBoardResponseWaitSource(
tx as unknown as Db,
{
companyId: input.companyId,
issueId: input.issueId,
runId: input.runId,
agentId: expected.agentId,
},
true,
);
} catch (error) {
if (isExternalChatWaitAuthorizationContention(error))
throw new NativeStatusRaceError();
throw error;
}
if (
!boardResponseWait ||
nativeSha256(boardResponseWait.source) !== nativeSha256(expected)
) {
throw new NativeStatusRaceError();
}
}
let externalChatReviewPresentation = null;
if (
reasonCode === "governed_response_waiting" &&
input.reviewResponsePresentation &&
input.decision.effects.length === 1 &&
input.decision.effects[0]?.kind === "create_interaction" &&
input.decision.effects[0].gate?.kind === "interaction" &&
input.decision.effects[0].gate.id ===
input.reviewResponsePresentation.gateId
) {
try {
externalChatReviewPresentation =
await prepareNativeChatReviewPresentationInTransaction(
tx as unknown as Db,
{
companyId: input.companyId,
issueId: input.issueId,
runId: input.runId,
assessmentId: input.assessmentId,
...input.reviewResponsePresentation,
},
);
} catch (error) {
if (isExternalChatWaitAuthorizationContention(error))
throw new NativeStatusRaceError();
throw error;
}
}
const recordCoordinatorDecision = async (decisionId: string) => {
const finalizationError = input.decision.effects.find(
effect => effect.kind === "record_finalization_error",
);
await notifyDeliveryWork(tx, DELIVERY_QUEUES.accounting, input.companyId);
await notifyNativeFinalizationWork(tx, input);
await tx
.update(nativeRunFinalizations)
.set({
phase: finalizationError ? "retryable_failure" : "committed",
assessmentId: input.assessmentId,
decisionId,
leaseOwner: null,
leaseExpiresAt: null,
recoveryState: null,
recoveryRequestId: null,
failureCode: finalizationError?.cause ?? null,
failureDetail: finalizationError
? {
originalFailureCode: finalizationError.cause,
recoveryOwner: {
kind: "agent",
agentId: finalizationError.agentId,
},
nextAction: finalizationError.nextAction,
}
: null,
nextAttemptAt: finalizationError ? new Date(Date.now() + 30_000) : null,
updatedAt: new Date(),
})
.where(eq(nativeRunFinalizations.runId, input.runId));
};
const awaitingInteractionIds = await questionsAwaitedByAgentBlock(tx as unknown as Db, {
companyId: input.companyId, issueId: input.issueId, agentId: originRun?.agentId, reasonCode,
toStatus: input.decision.toStatus, unblockOwner: input.decision.unblockDescriptor?.owner,
});
const decisionJson = {
statusAction: input.decision.statusAction,
toStatus: input.decision.toStatus,
reasonCode,
unblockDescriptor: input.decision.unblockDescriptor,
effects: input.decision.effects,
...(awaitingInteractionIds.length ? { awaitingInteractionIds } : {}),
...(externalChatReviewPresentation
? { externalChatReviewPresentation }
: {}),
...(boardResponseWait
? { boardResponseWait: boardResponseWait.source }
: {}),
...(boardResponseWaitOrigin ? { boardResponseWaitOrigin } : {}),
...(planWait ? { planWait: planWait.source, planWaitResult } : {}),
...(reasonCode === "scheduled_monitor_dispatched" ? { monitorDelivery: input.requireMonitorDelivery } : {}),
priorStatusVersion: input.priorStatusVersion,
projectedStatusVersion:
input.decision.statusAction === "preserve"
? input.priorStatusVersion
: input.priorStatusVersion + 1,
};
const decisionDigest = nativeSha256({
issueId: input.issueId,
assessmentId: input.assessmentId,
policyVersion: input.decision.policyVersion,
fromStatus: issue.status,
priorStatusVersion: input.priorStatusVersion,
priorDecisionId: input.priorDecisionId,
decision: decisionJson,
});
let decisionRow = await tx
.select()
.from(statusDecisions)
.where(
and(
eq(statusDecisions.issueId, input.issueId),
eq(statusDecisions.decisionDigest, decisionDigest),
),
)
.limit(1)
.then((rows) => rows[0] ?? null);
if (
decisionRow?.applicationState === "applied" ||
decisionRow?.applicationState === "proposed"
) {
// The effects already committed, but this retry owns a fresh coordinator
// lease. Release it and restore the retry deadline without replaying effects.
await recordCoordinatorDecision(decisionRow.id);
return { decision: decisionRow, issue, replayed: true };
}
await notifyChatRunMilestones(tx, input);
await notifyObsoletePolicyReviews(tx, input);
await notifyAutomaticCompletionReviews(tx, input);
if (!decisionRow) {
const latestDecisionVersion = await tx
.select({
decisionVersion: statusDecisions.decisionVersion,
})
.from(statusDecisions)
.where(
and(
eq(statusDecisions.companyId, input.companyId),
eq(statusDecisions.issueId, input.issueId),
),
)
.orderBy(desc(statusDecisions.decisionVersion))
.limit(1)
.then((rows) => Number(rows[0]?.decisionVersion ?? 0));
[decisionRow] = await tx
.insert(statusDecisions)
.values({
companyId: input.companyId,
issueId: input.issueId,
runId: input.runId,
assessmentId: input.assessmentId,
decisionVersion:
Math.max(input.priorStatusVersion, latestDecisionVersion) + 1,
policyVersion: input.decision.policyVersion,
fromStatus: issue.status,
toStatus: input.decision.toStatus,
reasonCode,
decisionJson,
decisionDigest,
applicationState: "proposed",
})
.returning();
}
if (!decisionRow) throw new Error("native_status_decision_not_persisted");
if (planWait) {
await issueService(tx as unknown as Db).addComment(
input.issueId, planWait.result.summary,
{ agentId: planWait.source.agentId, runId: input.runId }, undefined, tx,
);
}
if (boardResponseWait && reasonCode === "board_response_waiting") {
// The answer and passive-wait receipt commit together. In particular,
// no chat presentation authorization is supplied: this is Board-only.
await issueService(tx as unknown as Db).addComment(
input.issueId,
boardResponseWait.summary,
{ agentId: boardResponseWait.source.agentId, runId: input.runId },
undefined,
tx,
);
}
if (input.decision.statusAction === "done" && issue.status !== "done" &&
issue.parentId && issue.originKind !== "task_watchdog") {
// Serialize child notification creation with the parent's final pending-
// result check. Lock before child writes can acquire an implicit parent
// foreign-key lock, so concurrent siblings never upgrade shared locks.
await tx.select({ id: issues.id }).from(issues).where(and(
eq(issues.id, issue.parentId), eq(issues.companyId, input.companyId),
)).for("update");
}
if (input.supersededExternalReviewRequests) {
const expected = input.supersededExternalReviewRequests;
const binding = { companyId: input.companyId, issueId: input.issueId, runId: input.runId, agentId: expected.agentId };
const candidates = await findSupersededExternalReviewRequests(tx as unknown as Db, binding);
const ids = candidates.map(({ interaction }) => interaction.id);
const [accepted] = await tx.select().from(nativeRunResults).where(and(
eq(nativeRunResults.id, coordinator.resultId!), eq(nativeRunResults.companyId, input.companyId),
eq(nativeRunResults.issueId, input.issueId), eq(nativeRunResults.runId, input.runId), eq(nativeRunResults.schemaStatus, "accepted"),
));
const result = record(accepted?.resultJson.result), terminal = record(accepted?.resultJson.terminal);
if (ids.length !== expected.interactionIds.length || expected.interactionIds.some(id => !ids.includes(id)) ||
terminal.runTerminalState !== "succeeded" || terminal.turnTerminalState !== "completed" ||
!["done", "yielded"].includes(String(result.reportedWorkDisposition)) ||
!accepted || accepted.id !== expected.resultId || normalizePrpResultSignals(accepted.resultJson.result as PrpStructuredRunResult).actionableAttentionRequests.length !== 0 ||
!["completion_claim_policy_accepted", "completion_contract_satisfied", "external_chat_response_waiting", "scheduled_monitor_waiting"].includes(reasonCode) ||
await pendingNativeGovernance({ db: tx as unknown as Db, ...binding, executionState: record(issue.executionState), ignoredInteractionIds: ids })) {
throw new NativeStatusRaceError();
}
await supersedeExternalReviewRequestsInTransaction(tx as unknown as Db, binding, candidates, publications);
}
const materialized: NativeMaterializedStatusEffect[] = [];
const preMaterializedEffects = new Map(
(input.preMaterializedEffects ?? []).map((effect) => [
effect.effectKind,
effect,
]),
);
for (const effect of input.decision.effects) {
materialized.push(
await materializeDecisionEffect({
tx: tx as unknown as Db,
companyId: input.companyId,
issue,
runId: input.runId,
decisionId: decisionRow.id,
actorAgentId: originRun?.agentId ?? null,
effect,
failpoint: input.failpoint,
preMaterializedEffects,
terminalRunsToEmit,
}),
);
}
let updated: typeof issues.$inferSelect;
if (input.decision.statusAction === "preserve") {
updated = (await tx
.select()
.from(issues)
.where(
and(
eq(issues.id, input.issueId),
eq(issues.companyId, input.companyId),
),
)
.limit(1)
.then((rows) => rows[0] ?? null)) as typeof issues.$inferSelect;
if (!updated) throw new NativeStatusRaceError();
} else {
failAt("status_projection", input.failpoint);
// Start the configured review stage from the locked task, as the issue
// route does; a changed policy makes the saved decision stale.
const reviewStage = input.decision.reasonCode === COMPLETION_REVIEW_STAGE_REASON
? completionReviewStageEntry(issue, originRun?.agentId ?? "") : null;
if (reviewStage && reviewStage.kind !== "starts") throw new NativeStatusRaceError();
const projected = await issueService(tx as unknown as Db).update(
input.issueId,
{
...(reviewStage?.kind === "starts" ? reviewStage.patch : {}),
status: input.decision.toStatus,
statusVersion: input.priorStatusVersion + 1,
lastStatusDecisionId: decisionRow.id,
unblockDescriptor: input.decision.unblockDescriptor,
actorAgentId: originRun?.agentId ?? null,
actorUserId: null,
},
tx,
publications,
);
if (!projected) throw new NativeStatusRaceError();
updated = projected;
// The route wakes an agent participant when its stage starts; a person
// acts from the task. This is a workflow wake, not the worker's message.
const participant = reviewStage?.kind === "starts" ? reviewStage.state.currentParticipant : null;
if (reviewStage?.kind === "starts" && participant?.type === "agent" && participant.agentId) {
const state = reviewStage.state;
const reason = state.currentStageType === "approval" ? "execution_approval_requested" : "execution_review_requested";
const executionStage = { wakeRole: state.currentStageType === "approval" ? "approver" : "reviewer",
stageId: state.currentStageId, stageType: state.currentStageType, currentParticipant: participant,
returnAssignee: state.returnAssignee, reviewRequest: state.reviewRequest ?? null,
lastDecisionOutcome: state.lastDecisionOutcome, allowedActions: ["approve", "request_changes"] };
await enqueueWake({ tx: tx as unknown as Db, companyId: input.companyId, issueId: input.issueId,
agentId: participant.agentId, reason, idempotencyKey: `native-status:${decisionRow.id}:execution-stage`,
payload: { mutation: "update", executionStage },
contextSnapshot: { executionStage, executionStageSource: "issue.execution_stage" } });
}
if (updated.originKind === "routine_execution") {
await syncRoutineRunStatusForIssue(tx as unknown as Db, input.issueId);
}
// Native task completion bypasses the REST issue route. Commit the Studio
// output with the authoritative task status so restart cannot lose it.
// The durable test row, not a mutable task mode, identifies the obligation.
if (issue.status !== updated.status && (updated.status === "done" || updated.status === "cancelled")) {
const testRun = await companySkillService(tx as unknown as Db).completeTestRunForIssue({
companyId: input.companyId,
issueId: input.issueId,
outcome: updated.status === "done" ? "succeeded" : "cancelled",
error: updated.status === "cancelled" ? "Harness issue was cancelled" : null,
});
if (testRun) {
const { publication } = await persistActivity(tx as unknown as Db, {
companyId: input.companyId,
actorType: "system",
actorId: "native-status-committer",
runId: input.runId,
action: "company.skill_test_run_completed",
entityType: "company_skill_test_run",
entityId: testRun.id,
issueId: input.issueId,
details: { issueId: input.issueId, status: testRun.status, outputDocumentKey: testRun.outputDocumentKey },
});
publications.push(publication);
}
}
materialized.unshift({
effectKind: "issue_status_projection",
targetType: "issue",
targetId: input.issueId,
payload: {
fromStatus: issue.status,
toStatus: input.decision.toStatus,
reasonCode,
},
});
}
if (input.decision.statusAction === "done" && issue.status !== "done") {
const issueSvc = issueService(tx as unknown as Db);
const dependents = await issueSvc.listWakeableBlockedDependents(
input.issueId,
);
const completedResultSummary = await tx
.select({ resultJson: nativeRunResults.resultJson })
.from(nativeRunResults)
.where(
and(
eq(nativeRunResults.companyId, input.companyId),
eq(nativeRunResults.runId, input.runId),
),
)
.limit(1)
.then((rows) => {
const summary = record(record(rows[0]?.resultJson).result).summary;
return typeof summary === "string" && summary.trim().length > 0
? summary.trim()
: null;
});
const parent = issue.parentId
? await issueSvc.getWakeableParentAfterChildCompletion(issue.parentId, {
issueId: input.issueId,
summary: completedResultSummary,
})
: null;
const parentIsDependent = parent
? dependents.some((dependent) => dependent.id === parent.id)
: false;
// Ordinary children can finish new work after reopening. Key that wake to
// the committed decision; replaying the decision still shares its identity.
// Watchdog children retain their stable key to avoid feedback loops.
const childCompletionDecisionId = issue.originKind === "task_watchdog" ? null : decisionRow.id;
const childCompletionRevision = childCompletionDecisionId ? `:${childCompletionDecisionId}` : "";
// The dispatcher must retain this new input until a fresh parent turn can
// read it. Watchdog handoffs keep their existing coalescing semantics.
const childCompletionDelivery = childCompletionDecisionId
? { nativeChildCompletionDecisionId: childCompletionDecisionId }
: {};
for (const dependent of dependents) {
const isCompletedChildParent = parent?.id === dependent.id;
const idempotencyKey = isCompletedChildParent
? `issue_children_completed:${dependent.id}:${input.issueId}${childCompletionRevision}`
: buildIssueBlockersResolvedWakeIdempotencyKey({
dependentIssueId: dependent.id,
resolvedBlockerIssueId: input.issueId,
});
const childCompletionContext =
isCompletedChildParent && parent
? {
completedChildIssueId: input.issueId,
...childCompletionDelivery,
childIssueIds: parent.childIssueIds,
childIssueSummaries: parent.childIssueSummaries,
onboardingCompletion: parent.onboardingCompletion,
childIssueSummaryTruncated: parent.childIssueSummaryTruncated,
}
: null;
const wakeId = await enqueueWake({
tx: tx as unknown as Db,
originRunId: isCompletedChildParent ? input.runId : undefined,
originOperation: isCompletedChildParent ? "comment" : undefined,
companyId: input.companyId,
issueId: dependent.id,
agentId: dependent.assigneeAgentId,
reason: isCompletedChildParent
? "issue_children_completed"
: "issue_blockers_resolved",
idempotencyKey,
payload: {
resolvedBlockerIssueId: input.issueId,
blockerIssueIds: dependent.blockerIssueIds,
...(childCompletionContext ?? {}),
},
contextSnapshot: childCompletionContext ?? undefined,
});
const reportDenial = isCompletedChildParent ? await refusedWakePolicy(tx as unknown as Db, input.companyId, wakeId) : null;
materialized.push({
effectKind: isCompletedChildParent
? "parent_dependency_wake"
: "dependency_wake",
targetType: "agent_wakeup_request",
targetId: wakeId,
...(reportDenial ? { deliveryState: "skipped" as const } : {}),
payload: {
dependentIssueId: dependent.id,
resolvedBlockerIssueId: input.issueId,
...(reportDenial ? { interactionPermissionDenials: { assignment: reportDenial } } : childCompletionContext ?? {}),
},
});
if (reportDenial) {
const dependencyWakeId = await enqueueWake({ tx: tx as unknown as Db, companyId: input.companyId,
issueId: dependent.id, agentId: dependent.assigneeAgentId, reason: "issue_blockers_resolved",
idempotencyKey: buildIssueBlockersResolvedWakeIdempotencyKey({ dependentIssueId: dependent.id, resolvedBlockerIssueId: input.issueId }),
payload: { resolvedBlockerIssueId: input.issueId, blockerIssueIds: dependent.blockerIssueIds },
});
materialized.push({ effectKind: "dependency_wake", targetType: "agent_wakeup_request", targetId: dependencyWakeId,
payload: { dependentIssueId: dependent.id, resolvedBlockerIssueId: input.issueId } });
}
}
if (parent && !parentIsDependent) {
const wakeId = await enqueueWake({
tx: tx as unknown as Db,
originRunId: input.runId,
originOperation: "comment",
companyId: input.companyId,
issueId: parent.id,
agentId: parent.assigneeAgentId,
reason: "issue_children_completed",
idempotencyKey: `issue_children_completed:${parent.id}:${input.issueId}${childCompletionRevision}`,
payload: {
completedChildIssueId: input.issueId,
...childCompletionDelivery,
childIssueIds: parent.childIssueIds,
childIssueSummaries: parent.childIssueSummaries,
onboardingCompletion: parent.onboardingCompletion,
childIssueSummaryTruncated: parent.childIssueSummaryTruncated,
},
contextSnapshot: {
completedChildIssueId: input.issueId,
...childCompletionDelivery,
childIssueIds: parent.childIssueIds,
childIssueSummaries: parent.childIssueSummaries,
onboardingCompletion: parent.onboardingCompletion,
childIssueSummaryTruncated: parent.childIssueSummaryTruncated,
},
});
const reportDenial = await refusedWakePolicy(tx as unknown as Db, input.companyId, wakeId);
materialized.push({
effectKind: "parent_wake",
targetType: "agent_wakeup_request",
targetId: wakeId,
...(reportDenial ? { deliveryState: "skipped" as const } : {}),
payload: {
parentIssueId: parent.id,
completedChildIssueId: input.issueId,
...childCompletionDelivery,
...(reportDenial ? { interactionPermissionDenials: { assignment: reportDenial } } : {
childIssueSummaries: parent.childIssueSummaries,
onboardingCompletion: parent.onboardingCompletion,
childIssueSummaryTruncated: parent.childIssueSummaryTruncated,
}),
},
});
}
}
for (const [index, effect] of materialized.entries()) {
await tx
.insert(statusDecisionEffects)
.values({
companyId: input.companyId,
issueId: input.issueId,
decisionId: decisionRow.id,
ordinal: index + 1,
effectKind: effect.effectKind,
targetType: effect.targetType,
targetId: effect.targetId,
idempotencyKey: `native-status:${decisionRow.id}:${index + 1}`,
payload: effect.payload,
deliveryState: effect.deliveryState ?? "delivered",
attemptCount: 1,
deliveredAt: effect.deliveryState === "skipped" ? null : new Date(),
lastError: effect.deliveryState === "skipped" ? INTERACTION_DELIVERY_DENIED : null,
})
.onConflictDoNothing();
}
const shadowOnly = input.decision.effects.some(
(effect) => effect.kind === "record_shadow_decision",
);
const applicationState = shadowOnly ? "proposed" : "applied";
await tx
.update(statusDecisions)
.set({
applicationState,
appliedAt: shadowOnly ? null : new Date(),
})
.where(eq(statusDecisions.id, decisionRow.id));
await recordCoordinatorDecision(decisionRow.id);
if (externalChatReviewPresentation && input.reviewResponsePresentation) {
await restoreNativeChatReviewPresentationInTransaction(
tx as unknown as Db,
{
companyId: input.companyId,
issueId: input.issueId,
runId: input.runId,
decisionId: decisionRow.id,
resultId: input.reviewResponsePresentation.resultId,
assessmentId: input.assessmentId,
},
);
}
const { publication } = await persistActivity(tx as unknown as Db, {
companyId: input.companyId,
actorType: "system",
actorId: "native-status-committer",
action:
input.decision.statusAction === "preserve"
? "issue.status_decision_recorded"
: "issue.updated",
entityType: "issue",
entityId: input.issueId,
issueId: input.issueId,
runId: input.runId,
details: {
source: "native_status_decision",
assessmentId: input.assessmentId,
decisionId: decisionRow.id,
fromStatus: issue.status,
toStatus: input.decision.toStatus,
reasonCode,
effectCount: materialized.length,
},
});
publications.push(publication);
return {
decision: { ...decisionRow, applicationState },
issue: updated,
replayed: false,
};
}).catch(async (error: unknown) => {
if (error instanceof HttpError && error.status === 403 && record(error.details).code === "agent_interaction_denied") {
await input.db.transaction(async tx => {
const [coordinator] = await tx.select().from(nativeRunFinalizations).where(and(
eq(nativeRunFinalizations.runId, input.runId), eq(nativeRunFinalizations.companyId, input.companyId),
eq(nativeRunFinalizations.issueId, input.issueId))).for("update");
if (!coordinator || coordinator.phase === "committed" || coordinator.failureCode === "agent_interaction_denied") return;
await notifyNativeFinalizationWork(tx, { companyId: input.companyId, runId: input.runId });
await tx.update(nativeRunFinalizations).set({ phase: "terminal_failure", failureCode: "agent_interaction_denied",
failureDetail: { ...record(coordinator.failureDetail), interactionDenial: error.details,
recoveryOwner: { kind: "none", reason: "agent_interaction_denied" } },
nextAttemptAt: null, leaseOwner: null, leaseExpiresAt: null, updatedAt: new Date() })
.where(and(eq(nativeRunFinalizations.runId, input.runId), eq(nativeRunFinalizations.companyId, input.companyId)));
});
}
throw error;
});
for (const publication of publications) publishActivity(publication);
for (const terminalRun of terminalRunsToEmit)
await emitAgentTaskRun(input.db, terminalRun);
return committed;
}