diff --git a/server/src/__tests__/ownership-reconciliation-report.test.ts b/server/src/__tests__/ownership-reconciliation-report.test.ts
index 84372b632f4..402706d8841 100644
--- a/server/src/__tests__/ownership-reconciliation-report.test.ts
+++ b/server/src/__tests__/ownership-reconciliation-report.test.ts
@@ -10,6 +10,7 @@ import {
   agents,
   budgetPolicies,
   companies,
+  completionContracts,
   createDb,
   environmentLeases,
   environments,
@@ -19,7 +20,10 @@ import {
   issueComments,
   issues,
   nativeRunFinalizations,
+  nativeRunResults,
   sandboxCreationOperations,
+  statusDecisions,
+  workAssessments,
   workspaceOperations,
 } from "@paperclipai/db";
 import { startEmbeddedPostgresTestDatabase } from "./helpers/embedded-postgres.js";
@@ -959,6 +963,41 @@ describe("report-only ownership reconciliation", () => {
     expect(report.violations.filter(violation => violation.rule === "I7_visible_next_action")).toEqual([]);
   });
 
+  it("treats a current committed response-wake wait as a next action until a user answers it", async () => {
+    const issueId = randomUUID(), runId = randomUUID(), contractId = randomUUID(), resultId = randomUUID();
+    const assessmentId = randomUUID(), decisionId = randomUUID(), startedAt = minutesAgo(40);
+    await db.insert(issues).values({ id: issueId, companyId, title: "Waiting for the board", status: "in_progress",
+      assigneeAgentId: agentId, updatedAt: minutesAgo(30) });
+    await db.insert(completionContracts).values({ id: contractId, companyId, issueId, revision: 1,
+      schemaVersion: "paperclip.completion-contract.v1", policyVersion: "test", risk: "standard",
+      completionAuthority: "server_arbiter", incompleteCriteriaPolicy: "preserve_non_terminal",
+      contractJson: { revision: "test", objective: "Wait", criteria: [{ id: "objective", requirement: "Wait" }] },
+      canonicalSha256: contractId, createdByActorType: "system", createdByActorId: "test" });
+    await db.insert(heartbeatRuns).values({ id: runId, companyId, agentId, runtimeMode: "native", status: "succeeded",
+      nativeIssueId: issueId, nativeSessionId: runId, completionContractId: contractId, completionContractSha256: contractId,
+      contextSnapshot: { issueId }, startedAt, finishedAt: minutesAgo(35) });
+    await db.insert(nativeRunResults).values({ id: resultId, companyId, issueId, runId, completionContractId: contractId,
+      serverFingerprint: "test", schemaStatus: "accepted", resultJson: {}, canonicalSha256: resultId });
+    await db.insert(workAssessments).values({ id: assessmentId, companyId, issueId, runId, contractId, resultId,
+      triggerKind: "turn_finished", triggerActorCompanyId: companyId, priorIssueStatus: "in_progress", priorStatusVersion: 1,
+      policyVersion: "test", assessmentJson: {}, inputDigest: assessmentId });
+    await db.insert(statusDecisions).values({ id: decisionId, companyId, issueId, runId, assessmentId, decisionVersion: 1,
+      policyVersion: "test", fromStatus: "in_progress", toStatus: "in_progress", reasonCode: "response_wake_waiting_for_input",
+      decisionJson: {}, decisionDigest: decisionId, applicationState: "applied", appliedAt: minutesAgo(35) });
+    await db.insert(nativeRunFinalizations).values({ companyId, issueId, runId, phase: "committed", resultId, assessmentId, decisionId });
+    await db.update(issues).set({ lastStatusDecisionId: decisionId, updatedAt: minutesAgo(30) }).where(eq(issues.id, issueId));
+    const visible = async () => (await runOwnershipReconciliationPass(db, { state: createOwnershipReportState(), record: false }))
+      .violations.filter(violation => violation.rule === "I7_visible_next_action").map(violation => violation.recordId);
+
+    expect(await visible()).toEqual([]);
+    await db.insert(issueComments).values({ companyId, issueId, authorType: "user", authorUserId: "board",
+      body: "Go ahead.", createdAt: minutesAgo(20) });
+    expect(await visible()).toEqual([issueId]);
+    await db.delete(issueComments).where(eq(issueComments.issueId, issueId));
+    await db.update(issues).set({ lastStatusDecisionId: null, updatedAt: minutesAgo(30) }).where(eq(issues.id, issueId));
+    expect(await visible()).toEqual([issueId]);
+  });
+
   it("returns the end of the next-action grace window for an issue still inside it", async () => {
     const updatedAt = minutesAgo(2);
     await db.insert(issues).values({ companyId, title: "Fresh", status: "in_progress", assigneeAgentId: agentId, updatedAt });
diff --git a/server/src/services/recovery/ownership-invariant-report.ts b/server/src/services/recovery/ownership-invariant-report.ts
index 6b03087e3ac..0287180fc2c 100644
--- a/server/src/services/recovery/ownership-invariant-report.ts
+++ b/server/src/services/recovery/ownership-invariant-report.ts
@@ -2,10 +2,14 @@ import { and, asc, eq, inArray, isNotNull, isNull, lt, notExists, or, sql, type
 import {
   agentWakeupRequests,
   heartbeatRuns,
+  issueComments,
   issueRecoveryActions,
   issues,
+  nativeRunFinalizations,
+  statusDecisions,
   type Db,
 } from "@paperclipai/db";
+import { NATIVE_RESPONSE_WAKE_WAITING_REASON } from "../native-runtime/status-arbiter.js";
 import { taskClosedByAgentSql, TEMPORARY_REFUSAL_TRIGGERS } from "../work-intent-outbox.js";
 import { deliveredQueuedCommentIds } from "../queued-comment-delivery.js";
 import { logger } from "../../middleware/logger.js";
@@ -579,6 +583,23 @@ async function checkExactlyOnceIntents(db: Db, state: OwnershipReportState, now:
   return violations;
 }
 
+function parkedResponseWakeWait(db: Db) {
+  return db.select({ one: sql`1` }).from(statusDecisions)
+    .innerJoin(nativeRunFinalizations, and(eq(nativeRunFinalizations.runId, statusDecisions.runId),
+      eq(nativeRunFinalizations.companyId, statusDecisions.companyId), eq(nativeRunFinalizations.issueId, statusDecisions.issueId),
+      eq(nativeRunFinalizations.decisionId, statusDecisions.id), eq(nativeRunFinalizations.phase, "committed")))
+    .innerJoin(heartbeatRuns, and(eq(heartbeatRuns.id, statusDecisions.runId), eq(heartbeatRuns.companyId, statusDecisions.companyId),
+      eq(heartbeatRuns.nativeIssueId, statusDecisions.issueId), eq(heartbeatRuns.agentId, issues.assigneeAgentId),
+      eq(heartbeatRuns.runtimeMode, "native"), eq(heartbeatRuns.status, "succeeded"), isNotNull(heartbeatRuns.startedAt)))
+    .where(and(eq(statusDecisions.id, issues.lastStatusDecisionId), eq(statusDecisions.companyId, issues.companyId),
+      eq(statusDecisions.issueId, issues.id), eq(statusDecisions.applicationState, "applied"),
+      eq(statusDecisions.reasonCode, NATIVE_RESPONSE_WAKE_WAITING_REASON), isNull(issues.assigneeUserId), isNull(issues.hiddenAt),
+      notExists(db.select({ one: sql`1` }).from(issueComments).where(and(
+        eq(issueComments.companyId, issues.companyId), eq(issueComments.issueId, issues.id),
+        eq(issueComments.authorType, "user"), isNull(issueComments.createdByRunId), isNull(issueComments.deletedAt),
+        sql`${issueComments.createdAt} > ${heartbeatRuns.startedAt}`)))));
+}
+
 /** An agent-assigned in-progress issue with no live run, no pending wake and
  * no open recovery action has no next action (invariant 7). Issues still in
  * their grace window return the time they become checkable. */
@@ -600,6 +621,7 @@ async function checkVisibleNextAction(db: Db, now: Date, limit: number): Promise
       notExists(db.select({ one: sql`1` }).from(issueRecoveryActions).where(and(
         eq(issueRecoveryActions.companyId, issues.companyId), eq(issueRecoveryActions.sourceIssueId, issues.id),
         isNull(issueRecoveryActions.resolvedAt)))),
+      notExists(parkedResponseWakeWait(db)),
     )).orderBy(asc(issues.updatedAt), asc(issues.id)).limit(limit).offset(offset);
     rows.push(...page);
     if (page.length < limit) break;