fix: restore execution lock reaper scheduling

Author: Test

server/src/__tests__/execution-lock-acquisition-helper.test.ts

@@ -1,15 +1,26 @@
 import { describe, expect, it } from "vitest";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
-import { executionLockAcquisitionFields } from "../services/issues.js";
+import { ISSUE_EXECUTION_LOCK_TTL_MS, executionLockAcquisitionFields } from "../services/issues.js";
 
 describe("execution lock acquisition helper usage", () => {
-  it("does not create a scheduled review monitor when acquiring an execution lock", () => {
+  it("always schedules the exact execution-lock reaper deadline", () => {
     const now = new Date("2026-08-08T03:15:00.000Z");
 
     expect(executionLockAcquisitionFields("run-1", now)).toEqual({
       executionRunId: "run-1",
       executionLockedAt: now,
+      monitorNextCheckAt: new Date(now.getTime() + ISSUE_EXECUTION_LOCK_TTL_MS),
+      monitorWakeRequestedAt: null,
+    });
+  });
+
+  it("keeps an earlier validated review-monitor deadline ahead of the lock reaper", () => {
+    const now = new Date("2026-08-08T03:15:00.000Z");
+    const reviewDeadline = new Date("2026-08-08T03:17:00.000Z");
+
+    expect(executionLockAcquisitionFields("run-1", now, reviewDeadline)).toMatchObject({
+      monitorNextCheckAt: reviewDeadline,
     });
   });
 
@@ -34,4 +45,22 @@ describe("execution lock acquisition helper usage", () => {
 
     expect(directAcquisitions).toEqual([]);
   });
+
+  it("removes scheduleMonitor option plumbing from every production acquisition path", async () => {
+    const root = process.cwd();
+    const productionFiles = [
+      "server/src/services/issues.ts",
+      "server/src/services/heartbeat.ts",
+    ];
+
+    const optionUses: string[] = [];
+    for (const file of productionFiles) {
+      const source = await readFile(path.join(root, file), "utf8");
+      source.split(/\r?\n/).forEach((line, index) => {
+        if (/scheduleMonitor/.test(line)) optionUses.push(`${file}:${index + 1}:${line.trim()}`);
+      });
+    }
+
+    expect(optionUses).toEqual([]);
+  });
 });

server/src/__tests__/issue-liveness.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from "vitest";
 import { classifyIssueGraphLiveness } from "../services/issue-liveness.ts";
+import { hasScheduledIssueMonitorPath } from "../services/recovery/issue-graph-liveness.ts";
 
 const companyId = "company-1";
 const managerId = "manager-1";
@@ -46,6 +47,43 @@ const manager = agent({
 const blocks = [{ companyId, blockerIssueId: blockerId, blockedIssueId: blockedId }];
 
 describe("issue graph liveness classifier", () => {
+  it("counts only validated future typed review monitors, never a raw lock-reaper timestamp", () => {
+    const now = new Date("2026-08-08T03:15:00.000Z");
+    const future = new Date("2026-08-08T03:20:00.000Z").toISOString();
+    const expired = new Date("2026-08-08T03:10:00.000Z").toISOString();
+    const executionState = (monitor: Record<string, unknown>) => ({
+      status: "idle",
+      currentStageId: null,
+      currentStageIndex: null,
+      currentStageType: null,
+      currentParticipant: null,
+      returnAssignee: null,
+      reviewRequest: null,
+      completedStageIds: [],
+      lastDecisionId: null,
+      lastDecisionOutcome: null,
+      monitor,
+      changesRequestedCount: 0,
+    });
+
+    const scheduled = executionState({
+      status: "scheduled", nextCheckAt: future, lastTriggeredAt: null, attemptCount: 0,
+      notes: null, scheduledBy: "assignee", kind: null, serviceName: null, externalRef: null,
+      timeoutAt: null, maxAttempts: null, recoveryPolicy: null, clearedAt: null, clearReason: null,
+    });
+    const triggered = { ...scheduled, monitor: { ...scheduled.monitor, status: "triggered", nextCheckAt: null, lastTriggeredAt: expired } };
+    const cleared = { ...scheduled, monitor: { ...scheduled.monitor, status: "cleared", nextCheckAt: null, clearedAt: expired, clearReason: "manual" } };
+    const expiredState = { ...scheduled, monitor: { ...scheduled.monitor, timeoutAt: expired } };
+    const exhaustedState = { ...scheduled, monitor: { ...scheduled.monitor, maxAttempts: 1, attemptCount: 1 } };
+    const invalid = { ...scheduled, monitor: { ...scheduled.monitor, nextCheckAt: "not-a-date" } };
+
+    expect(hasScheduledIssueMonitorPath(issue({ status: "in_review", monitorNextCheckAt: future }), now)).toBe(false);
+    expect(hasScheduledIssueMonitorPath(issue({ status: "in_review", monitorNextCheckAt: future, executionState: scheduled }), now)).toBe(true);
+    for (const state of [triggered, cleared, expiredState, exhaustedState, invalid]) {
+      expect(hasScheduledIssueMonitorPath(issue({ status: "in_review", monitorNextCheckAt: future, executionState: state }), now)).toBe(false);
+    }
+  });
+
   it("detects a PAP-1703-style blocked chain with an unassigned blocker and stable incident key", () => {
     const findings = classifyIssueGraphLiveness({
       issues: [

server/src/services/heartbeat.ts

@@ -13617,7 +13617,7 @@ export function heartbeatService(db: Db, options: HeartbeatServiceOptions = {})
       })
     ) {
       try {
-        await issuesSvc.checkout(issueId, agent.id, ["todo", "backlog", "blocked"], run.id, { scheduleMonitor: false });
+        await issuesSvc.checkout(issueId, agent.id, ["todo", "backlog", "blocked"], run.id);
         context[PAPERCLIP_HARNESS_CHECKOUT_KEY] = true;
       } catch (error) {
         if (!isCheckoutConflictError(error)) throw error;

server/src/services/issue-execution-policy.ts

@@ -421,6 +421,39 @@ export function parseIssueExecutionState(input: unknown): IssueExecutionState |
   return parsed.data;
 }
 
+export function activeTypedIssueMonitorDeadline(
+  input: Pick<IssueLike, "executionPolicy" | "executionState">,
+  now: Date | string | number = new Date(),
+): Date | null {
+  const nowMs = now instanceof Date ? now.getTime() : typeof now === "number" ? now : new Date(now).getTime();
+  if (!Number.isFinite(nowMs)) return null;
+  const state = parseIssueExecutionState(input.executionState);
+  const policyResult = issueExecutionPolicySchema.safeParse(input.executionPolicy);
+  const candidates: Array<{ monitor: IssueExecutionMonitorPolicy | IssueExecutionMonitorState; attempts: number }> = [];
+
+  if (policyResult.success && policyResult.data.monitor) {
+    candidates.push({ monitor: policyResult.data.monitor, attempts: state?.monitor?.attemptCount ?? 0 });
+  }
+  if (state?.monitor?.status === "scheduled") {
+    candidates.push({ monitor: state.monitor, attempts: state.monitor.attemptCount });
+  }
+
+  const deadlines = candidates.flatMap(({ monitor, attempts }) => {
+    if (!monitor.nextCheckAt) return [];
+    const nextCheckAt = new Date(monitor.nextCheckAt);
+    const nextCheckAtMs = nextCheckAt.getTime();
+    if (!Number.isFinite(nextCheckAtMs) || nextCheckAtMs <= nowMs) return [];
+    if (monitor.timeoutAt) {
+      const timeoutAtMs = new Date(monitor.timeoutAt).getTime();
+      if (!Number.isFinite(timeoutAtMs) || timeoutAtMs <= nowMs) return [];
+    }
+    if (monitor.maxAttempts != null && attempts >= monitor.maxAttempts) return [];
+    return [nextCheckAt];
+  });
+
+  return deadlines.sort((left, right) => left.getTime() - right.getTime())[0] ?? null;
+}
+
 export function assigneePrincipal(input: AssigneeLike): IssueExecutionStagePrincipal | null {
   if (input.assigneeAgentId) {
     return { type: "agent", agentId: input.assigneeAgentId, userId: null };

server/src/services/issues.ts

@@ -86,7 +86,7 @@ import {
   type ParsedExecutionWorkspaceMode,
 } from "./execution-workspace-policy.js";
 import { mergeExecutionWorkspaceConfig } from "./execution-workspaces.js";
-import { buildInitialIssueMonitorFields, normalizeIssueExecutionPolicy } from "./issue-execution-policy.js";
+import { activeTypedIssueMonitorDeadline, buildInitialIssueMonitorFields, normalizeIssueExecutionPolicy } from "./issue-execution-policy.js";
 import { instanceSettingsService } from "./instance-settings.js";
 import { redactCurrentUserText } from "../log-redaction.js";
 import { redactSensitiveText } from "../redaction.js";
@@ -783,25 +783,18 @@ function issueExecutionLockMonitorNextCheckAt(now: Date) {
 export function executionLockAcquisitionFields(
   runId: string,
   now: Date,
-  options: { scheduleMonitor?: boolean } = {},
+  activeReviewMonitorDeadline: Date | null = null,
 ) {
-  const monitorFields = options.scheduleMonitor
-    ? {
-        monitorNextCheckAt: sql<Date | null>`case
-          when ${issues.monitorNextCheckAt} is null
-            and ${issues.monitorLastTriggeredAt} is null
-            and ${issues.monitorAttemptCount} = 0
-          then ${issueExecutionLockMonitorNextCheckAt(now).toISOString()}::timestamptz
-          else ${issues.monitorNextCheckAt}
-        end`,
-        monitorWakeRequestedAt: null,
-      }
-    : {};
+  const lockDeadline = issueExecutionLockMonitorNextCheckAt(now);
+  const monitorNextCheckAt = activeReviewMonitorDeadline && activeReviewMonitorDeadline.getTime() < lockDeadline.getTime()
+    ? activeReviewMonitorDeadline
+    : lockDeadline;
 
   return {
     executionRunId: runId,
     executionLockedAt: now,
-    ...monitorFields,
+    monitorNextCheckAt,
+    monitorWakeRequestedAt: null,
   };
 }
 
@@ -5111,7 +5104,6 @@ export function issueService(db: Db) {
     actorAgentId: string;
     actorRunId: string;
     expectedCheckoutRunId: string;
-    scheduleMonitor: boolean;
   }) {
     return db.transaction(async (tx) => {
       const lockedIssue = await tx
@@ -5121,6 +5113,8 @@ export function issueService(db: Db) {
           assigneeAgentId: issues.assigneeAgentId,
           checkoutRunId: issues.checkoutRunId,
           executionRunId: issues.executionRunId,
+          executionPolicy: issues.executionPolicy,
+          executionState: issues.executionState,
         })
         .from(issues)
         .where(eq(issues.id, input.issueId))
@@ -5169,7 +5163,7 @@ export function issueService(db: Db) {
         .update(issues)
         .set({
           checkoutRunId: input.actorRunId,
-          ...executionLockAcquisitionFields(input.actorRunId, now, { scheduleMonitor: input.scheduleMonitor }),
+          ...executionLockAcquisitionFields(input.actorRunId, now, activeTypedIssueMonitorDeadline(lockedIssue, now)),
           updatedAt: now,
         })
         .where(
@@ -5211,7 +5205,6 @@ export function issueService(db: Db) {
     issueId: string;
     actorAgentId: string;
     actorRunId: string;
-    scheduleMonitor: boolean;
   }) {
     return db.transaction(async (tx) => {
       await tx.execute(
@@ -5225,11 +5218,16 @@ export function issueService(db: Db) {
       if (!actorRun || heartbeatRunIsDead(actorRun)) return null;
 
       const now = new Date();
+      const issue = await tx
+        .select({ executionPolicy: issues.executionPolicy, executionState: issues.executionState })
+        .from(issues)
+        .where(eq(issues.id, input.issueId))
+        .then((rows) => rows[0] ?? null);
       const adopted = await tx
         .update(issues)
         .set({
           checkoutRunId: input.actorRunId,
-          ...executionLockAcquisitionFields(input.actorRunId, now, { scheduleMonitor: input.scheduleMonitor }),
+          ...executionLockAcquisitionFields(input.actorRunId, now, activeTypedIssueMonitorDeadline(issue ?? {}, now)),
           updatedAt: now,
         })
         .where(
@@ -7992,18 +7990,17 @@ export function issueService(db: Db) {
       agentId: string,
       expectedStatuses: string[],
       checkoutRunId: string | null,
-      options: { scheduleMonitor?: boolean } = {},
     ) => {
       const issueCompany = await db
-        .select({ companyId: issues.companyId })
+        .select({ companyId: issues.companyId, executionPolicy: issues.executionPolicy, executionState: issues.executionState })
         .from(issues)
         .where(eq(issues.id, id))
         .then((rows) => rows[0] ?? null);
       if (!issueCompany) throw notFound("Issue not found");
       await assertAssignableAgent(db, issueCompany.companyId, agentId, { kind: "work" });
 
       const now = new Date();
-      const scheduleMonitor = options.scheduleMonitor ?? true;
+      const initialActiveMonitorDeadline = activeTypedIssueMonitorDeadline(issueCompany, now);
       const activePauseHold = await treeControlSvc.getActivePauseHoldGate(issueCompany.companyId, id);
       if (
         activePauseHold &&
@@ -8053,7 +8050,7 @@ export function issueService(db: Db) {
           assigneeUserId: null,
           checkoutRunId,
           ...(checkoutRunId
-            ? executionLockAcquisitionFields(checkoutRunId, now, { scheduleMonitor })
+            ? executionLockAcquisitionFields(checkoutRunId, now, initialActiveMonitorDeadline)
             : { executionRunId: null }),
           status: "in_progress",
           startedAt: now,
@@ -8082,6 +8079,8 @@ export function issueService(db: Db) {
           assigneeAgentId: issues.assigneeAgentId,
           checkoutRunId: issues.checkoutRunId,
           executionRunId: issues.executionRunId,
+          executionPolicy: issues.executionPolicy,
+          executionState: issues.executionState,
         })
         .from(issues)
         .where(eq(issues.id, id))
@@ -8101,7 +8100,7 @@ export function issueService(db: Db) {
           .set({
             checkoutRunId,
             ...(checkoutRunId
-              ? executionLockAcquisitionFields(checkoutRunId, now, { scheduleMonitor })
+              ? executionLockAcquisitionFields(checkoutRunId, now, activeTypedIssueMonitorDeadline(current, now))
               : { executionRunId: null }),
             updatedAt: new Date(),
           })
@@ -8131,7 +8130,6 @@ export function issueService(db: Db) {
           actorAgentId: agentId,
           actorRunId: checkoutRunId,
           expectedCheckoutRunId: current.checkoutRunId,
-          scheduleMonitor,
         });
         if (staleAdoption.adopted) {
           const row = await db.select().from(issues).where(eq(issues.id, id)).then((rows) => rows[0] ?? null);
@@ -8156,7 +8154,7 @@ export function issueService(db: Db) {
           const adoptionSet: Record<string, unknown> = {
             assigneeAgentId: agentId,
             checkoutRunId,
-            ...executionLockAcquisitionFields(checkoutRunId, now, { scheduleMonitor }),
+            ...executionLockAcquisitionFields(checkoutRunId, now, activeTypedIssueMonitorDeadline(current, now)),
             executionAgentNameKey: null,
             status: "in_progress",
             updatedAt: now,
@@ -8271,7 +8269,6 @@ export function issueService(db: Db) {
             issueId: id,
             actorAgentId,
             actorRunId: actorRunId!,
-            scheduleMonitor: true,
           });
 
           if (adopted) {
@@ -8298,7 +8295,6 @@ export function issueService(db: Db) {
             actorAgentId,
             actorRunId,
             expectedCheckoutRunId: previousCheckoutRunId,
-            scheduleMonitor: true,
           });
 
           if (staleAdoption.adopted) {

server/src/services/recovery/issue-graph-liveness.ts

@@ -1,5 +1,6 @@
 import { getAgentWorkEligibility, isAgentInvokable } from "@paperclipai/shared";
 import { buildIssueGraphLivenessIncidentKey } from "./origins.js";
+import { activeTypedIssueMonitorDeadline } from "../issue-execution-policy.js";
 
 export type IssueLivenessSeverity = "warning" | "critical";
 
@@ -192,20 +193,7 @@ function monitorFromIssue(issue: IssueLivenessIssueInput) {
 }
 
 export function hasScheduledIssueMonitorPath(issue: IssueLivenessIssueInput, now: Date | string | number) {
-  const nowMs = typeof now === "number" ? now : readDateMs(now) ?? Date.now();
-  const nextCheckAtMs = readDateMs(issue.monitorNextCheckAt);
-  if (nextCheckAtMs === null || nextCheckAtMs <= nowMs) return false;
-
-  const { policyMonitor, stateMonitor } = monitorFromIssue(issue);
-  const timeoutAtMs = readDateMs(policyMonitor?.timeoutAt ?? stateMonitor?.timeoutAt);
-  if (timeoutAtMs !== null && timeoutAtMs <= nowMs) return false;
-
-  const maxAttempts = readPositiveInteger(policyMonitor?.maxAttempts ?? stateMonitor?.maxAttempts);
-  const stateAttemptCount = readPositiveInteger(stateMonitor?.attemptCount) ?? 0;
-  const attemptCount = issue.monitorAttemptCount ?? stateAttemptCount;
-  if (maxAttempts !== null && attemptCount >= maxAttempts) return false;
-
-  return true;
+  return activeTypedIssueMonitorDeadline(issue, now) !== null;
 }
 
 export function classifyIssueReviewPaths(

server/src/services/recovery/service.ts

@@ -43,6 +43,7 @@ import { issueTreeControlService } from "../issue-tree-control.js";
 import { ISSUE_EXECUTION_LOCK_TTL_MS, TERMINAL_HEARTBEAT_RUN_STATUSES, issueService } from "../issues.js";
 import {
   applyIssueMonitorPolicyTransition,
+  activeTypedIssueMonitorDeadline,
   normalizeIssueExecutionPolicy,
   parseIssueExecutionState,
 } from "../issue-execution-policy.js";
@@ -942,7 +943,7 @@ export function recoveryService(db: Db, deps: { enqueueWakeup: RecoveryWakeup })
   }
 
   async function hasPersistedDurableWaitPath(issue: typeof issues.$inferSelect) {
-    if (issue.monitorNextCheckAt) return true;
+    if (activeTypedIssueMonitorDeadline(issue)) return true;
 
     return db
       .select({ id: issueRelations.issueId })