@knpkv/control-center 0.3.0 → 0.5.0

package/dist/server/server/persistence/repositories/agentJobRepository.d.ts

@@ -8,17 +8,18 @@ import type { Success } from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import * as Schema from "effect/Schema";
-import { PrReviewSuggestionRevision } from "../../../domain/prReviewRevision.js";
+import { PrReviewSuggestionAgentAuthor, PrReviewSuggestionRevision } from "../../../domain/prReviewRevision.js";
 import { Database } from "../Database.js";
 import { PersistedRecordError, PersistenceOperationError, RecordNotFoundError } from "../errors.js";
 import { AgentJobInputError } from "./agentJobModels.js";
+export declare const PROCESS_RESTART_INTERRUPTION_MESSAGE = "Review interrupted because the Control Center process restarted.";
 declare const makeAgentJobRepository: Effect.Effect<{
     appendReviewSuggestionRevision: (input: {
-        readonly suggestionId: string & import("effect/Brand").Brand<"PrReviewSuggestionId">;
+        readonly author: import("../../../domain/prReviewRevision.js").PrReviewSuggestionOperatorAuthor | PrReviewSuggestionAgentAuthor;
+        readonly workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">;
         readonly jobId: string & import("effect/Brand").Brand<"JobId">;
-        readonly author: import("../../../domain/prReviewRevision.js").PrReviewSuggestionOperatorAuthor | import("../../../domain/prReviewRevision.js").PrReviewSuggestionAgentAuthor;
+        readonly suggestionId: string & import("effect/Brand").Brand<"PrReviewSuggestionId">;
         readonly createdAt: DateTime.Utc;
-        readonly workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">;
         readonly expectedRevisionId: string & import("effect/Brand").Brand<"PrReviewSuggestionRevisionId">;
         readonly expectedSequence: number & import("effect/Brand").Brand<"PrReviewSuggestionRevisionSequence">;
         readonly edit: {
@@ -41,14 +42,14 @@ declare const makeAgentJobRepository: Effect.Effect<{
                 readonly _tag: Schema.Literal<"changes">;
             }, "Type">;
             readonly impact: string;
-            readonly severity: "P1" | "P2" | "P3" | "P4";
-            readonly problem: string;
             readonly evidence: Schema.Struct.ReadonlySide<{
                 readonly excerpt: Schema.String;
                 readonly path: Schema.brand<Schema.String, "PrReviewPath">;
                 readonly startLine: Schema.Int;
                 readonly endLine: Schema.Int;
             }, "Type">;
+            readonly severity: "P1" | "P2" | "P3" | "P4";
+            readonly problem: string;
             readonly recommendation: string;
             readonly relatedLocations: readonly Schema.Struct.ReadonlySide<{
                 readonly label: Schema.String;
@@ -78,8 +79,99 @@ declare const makeAgentJobRepository: Effect.Effect<{
                 readonly explanation: Schema.String;
             }, "Type">;
         };
-        readonly state?: "dismissed";
+        readonly state?: "stale" | "dismissed";
+        readonly dismissalReason?: "false-positive" | "not-applicable" | "accepted-risk" | "duplicate" | "other";
+        readonly validation?: "validated";
+        readonly leaseFence?: Schema.Struct.ReadonlySide<{
+            readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+            readonly attemptSequence: Schema.brand<Schema.Int, "AgentAttemptSequence">;
+            readonly leaseToken: Schema.brand<Schema.String, "AgentLeaseToken">;
+        }, "Type">;
     }) => Effect.Effect<PrReviewSuggestionRevision, RecordNotFoundError | PersistenceOperationError | import("../errors.js").RevisionConflictError | PersistedRecordError | AgentJobInputError, never>;
+    completeTargetedReview: (input: Schema.Struct.ReadonlySide<{
+        readonly source: Schema.Struct<{
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+            readonly suggestionId: Schema.brand<Schema.String, "PrReviewSuggestionId">;
+            readonly expectedRevisionId: Schema.brand<Schema.String, "PrReviewSuggestionRevisionId">;
+            readonly expectedSequence: Schema.brand<Schema.Int, "PrReviewSuggestionRevisionSequence">;
+            readonly edit: Schema.Struct<{
+                title: Schema.String;
+                severity: Schema.Literals<readonly ["P1", "P2", "P3", "P4"]>;
+                problem: Schema.String;
+                impact: Schema.String;
+                evidence: Schema.Struct<{
+                    readonly excerpt: Schema.String;
+                    readonly path: Schema.brand<Schema.String, "PrReviewPath">;
+                    readonly startLine: Schema.Int;
+                    readonly endLine: Schema.Int;
+                }>;
+                recommendation: Schema.String;
+                confidence: Schema.Struct<{
+                    readonly level: Schema.Literals<readonly ["low", "medium", "high"]>;
+                    readonly reason: Schema.String;
+                }>;
+                relatedLocations: Schema.$Array<Schema.Struct<{
+                    readonly label: Schema.String;
+                    readonly path: Schema.brand<Schema.String, "PrReviewPath">;
+                    readonly startLine: Schema.Int;
+                    readonly endLine: Schema.Int;
+                }>>;
+                prevention: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+                    readonly summary: Schema.String;
+                    readonly enforcement: Schema.Literals<readonly ["ast-grep", "ESLint", "type-check", "test", "instruction"]>;
+                    readonly existingRuleOrConfig: Schema.String;
+                    readonly recurrenceEvidence: Schema.String;
+                    readonly targetFile: Schema.brand<Schema.String, "PrReviewPath">;
+                    readonly sourcePaths: Schema.$Array<Schema.brand<Schema.String, "PrReviewPath">>;
+                    readonly matcherOrInvariant: Schema.String;
+                    readonly invalidFixture: Schema.String;
+                    readonly validFixture: Schema.String;
+                    readonly boundary: Schema.String;
+                }>, Schema.Struct<{
+                    readonly summary: Schema.String;
+                    readonly enforcement: Schema.Literal<"none">;
+                    readonly rationale: Schema.String;
+                }>]>>;
+                replacement: Schema.optionalKey<Schema.Struct<{
+                    readonly reviewedHead: Schema.String;
+                    readonly unifiedDiff: Schema.String;
+                    readonly explanation: Schema.String;
+                }>>;
+                anchor: Schema.Union<readonly [Schema.Struct<{
+                    readonly _tag: Schema.Literal<"line">;
+                    readonly path: Schema.brand<Schema.String, "PrReviewPath">;
+                    readonly line: Schema.Int;
+                    readonly relativeFileVersion: Schema.withDecodingDefaultTypeKey<Schema.Literal<"AFTER">, never>;
+                }>, Schema.Struct<{
+                    readonly _tag: Schema.Literal<"file">;
+                    readonly path: Schema.brand<Schema.String, "PrReviewPath">;
+                    readonly line: Schema.Int;
+                    readonly relativeFileVersion: Schema.withDecodingDefaultTypeKey<Schema.Literals<readonly ["BEFORE", "AFTER"]>, never>;
+                }>, Schema.Struct<{
+                    readonly _tag: Schema.Literal<"changes">;
+                }>]>;
+            }>;
+            readonly state: Schema.optionalKey<Schema.Literals<readonly ["dismissed", "stale"]>>;
+            readonly dismissalReason: Schema.optionalKey<Schema.optionalKey<Schema.Literals<readonly ["false-positive", "not-applicable", "accepted-risk", "duplicate", "other"]>>>;
+            readonly validation: Schema.optionalKey<Schema.Literal<"validated">>;
+            readonly author: Schema.toTaggedUnion<"_tag", readonly [typeof import("../../../domain/prReviewRevision.js").PrReviewSuggestionOperatorAuthor, typeof PrReviewSuggestionAgentAuthor]>;
+            readonly createdAt: Schema.DateTimeUtcFromString;
+            readonly leaseFence: Schema.optionalKey<Schema.Struct<{
+                readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+                readonly attemptSequence: Schema.brand<Schema.Int, "AgentAttemptSequence">;
+                readonly leaseToken: Schema.brand<Schema.String, "AgentLeaseToken">;
+            }>>;
+        }>;
+        readonly target: Schema.Struct<{
+            readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+            readonly attemptSequence: Schema.brand<Schema.Int, "AgentAttemptSequence">;
+            readonly leaseToken: Schema.brand<Schema.String, "AgentLeaseToken">;
+            readonly report: Schema.Unknown;
+            readonly completedAt: Schema.DateTimeUtcFromString;
+        }>;
+    }, "Type">) => Effect.Effect<PrReviewSuggestionRevision, unknown, never>;
     enqueue: (input: Schema.Struct.ReadonlySide<{
         readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
         readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
@@ -107,6 +199,18 @@ declare const makeAgentJobRepository: Effect.Effect<{
                 readonly networkAccess: Schema.Literals<readonly ["blocked", "provider-enabled"]>;
                 readonly sandbox: Schema.Literal<"sbx">;
             }>;
+            intent: Schema.optionalKey<Schema.Literals<readonly ["full-review", "suggestion-edit", "suggestion-revalidation"]>>;
+            target: Schema.optionalKey<Schema.Struct<{
+                readonly sourceJobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+                readonly suggestionId: Schema.brand<Schema.String, "PrReviewSuggestionId">;
+                readonly selectedRevisionId: Schema.brand<Schema.String, "PrReviewSuggestionRevisionId">;
+                readonly history: Schema.Struct<{
+                    readonly current: typeof PrReviewSuggestionRevision;
+                    readonly revisions: Schema.$Array<typeof PrReviewSuggestionRevision>;
+                    readonly hasMore: Schema.Boolean;
+                    readonly nextBeforeSequence: Schema.NullOr<Schema.brand<Schema.Int, "PrReviewSuggestionRevisionSequence">>;
+                }>;
+            }>>;
         }>]>;
         readonly createdAt: Schema.DateTimeUtcFromString;
     }, "Type">) => Effect.Effect<string & import("effect/Brand").Brand<"AgentThreadId">, Schema.SchemaError | RecordNotFoundError | import("../errors.js").RecordAlreadyExistsError | PersistenceOperationError | PersistedRecordError | AgentJobInputError, never>;
@@ -117,20 +221,15 @@ declare const makeAgentJobRepository: Effect.Effect<{
         readonly leaseToken: Schema.brand<Schema.String, "AgentLeaseToken">;
         readonly claimedAt: Schema.DateTimeUtcFromString;
         readonly leaseExpiresAt: Schema.DateTimeUtcFromString;
-    }, "Type">) => Effect.Effect<Option.Option<Schema.Struct.ReadonlySide<{
-        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
-        readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
-        readonly threadId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentThreadId">;
-        readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
-        readonly attemptSequence: Schema.brand<Schema.Int, "AgentAttemptSequence">;
-        readonly leaseOwner: Schema.brand<Schema.String, "AgentLeaseOwner">;
-        readonly leaseToken: Schema.brand<Schema.String, "AgentLeaseToken">;
-        readonly leaseExpiresAt: Schema.DateTimeUtcFromString;
-        readonly providerId: Schema.brand<Schema.String, "AgentProviderId">;
-        readonly model: Schema.NullOr<Schema.String>;
-        readonly access: Schema.Literals<readonly ["read-only", "workspace-write"]>;
-        readonly prompt: Schema.String;
-        readonly context: Schema.Struct<{
+    }, "Type">) => Effect.Effect<Option.Option<{
+        readonly providerId: string & import("effect/Brand").Brand<"AgentProviderId">;
+        readonly workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">;
+        readonly releaseId: string & import("effect/Brand").Brand<"ReleaseId">;
+        readonly jobId: string & import("effect/Brand").Brand<"JobId">;
+        readonly model: string | null;
+        readonly prompt: string;
+        readonly access: "read-only" | "workspace-write";
+        readonly context: Schema.Struct.ReadonlySide<{
             readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
             readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
             readonly subjectRevision: Schema.String;
@@ -152,7 +251,7 @@ declare const makeAgentJobRepository: Effect.Effect<{
                             readonly baseRevision: Schema.String;
                             readonly headRevision: Schema.String;
                         }>;
-                        readonly state: Schema.Literals<readonly ["cancelled", "failed", "succeeded", "unknown"]>;
+                        readonly state: Schema.Literals<readonly ["cancelled", "failed", "interrupted", "succeeded", "unknown"]>;
                         readonly requestedAt: Schema.DateTimeUtcFromString;
                         readonly suggestionTitles: Schema.$Array<Schema.String>;
                         readonly suggestionsTruncated: Schema.Boolean;
@@ -177,11 +276,30 @@ declare const makeAgentJobRepository: Effect.Effect<{
                     readonly networkAccess: Schema.Literals<readonly ["blocked", "provider-enabled"]>;
                     readonly sandbox: Schema.Literal<"sbx">;
                 }>;
+                readonly intent: Schema.optionalKey<Schema.Literals<readonly ["full-review", "suggestion-edit", "suggestion-revalidation"]>>;
+                readonly target: Schema.optionalKey<Schema.Struct<{
+                    readonly sourceJobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+                    readonly suggestionId: Schema.brand<Schema.String, "PrReviewSuggestionId">;
+                    readonly selectedRevisionId: Schema.brand<Schema.String, "PrReviewSuggestionRevisionId">;
+                    readonly history: Schema.Struct<{
+                        readonly current: typeof PrReviewSuggestionRevision;
+                        readonly revisions: Schema.$Array<typeof PrReviewSuggestionRevision>;
+                        readonly hasMore: Schema.Boolean;
+                        readonly nextBeforeSequence: Schema.NullOr<Schema.brand<Schema.Int, "PrReviewSuggestionRevisionSequence">>;
+                    }>;
+                }>>;
             }>]>;
-        }>;
-        readonly sessionRef: Schema.NullOr<Schema.brand<Schema.String, "AgentSessionRef">>;
-        readonly cancellationRequested: Schema.Boolean;
-    }, "Type">>, Schema.SchemaError | PersistenceOperationError | PersistedRecordError | AgentJobInputError, never>;
+        }, "Type">;
+        readonly sessionRef: (string & import("effect/Brand").Brand<"AgentSessionRef">) | null;
+        readonly threadId: string & import("effect/Brand").Brand<"AgentThreadId">;
+        readonly attemptSequence: number & import("effect/Brand").Brand<"AgentAttemptSequence">;
+        readonly leaseOwner: string & import("effect/Brand").Brand<"AgentLeaseOwner">;
+        readonly leaseToken: string & import("effect/Brand").Brand<"AgentLeaseToken">;
+        readonly leaseExpiresAt: DateTime.Utc;
+        readonly cancellationRequested: boolean;
+        readonly reviewBudgetMillis?: number;
+        readonly reviewBudgetExtensionCount?: number;
+    }>, Schema.SchemaError | PersistenceOperationError | PersistedRecordError | AgentJobInputError, never>;
     isLeaseActive: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">, jobId: string & import("effect/Brand").Brand<"JobId">) => Effect.Effect<boolean, PersistenceOperationError | PersistedRecordError, never>;
     heartbeat: (input: Schema.Struct.ReadonlySide<{
         readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
@@ -217,35 +335,160 @@ declare const makeAgentJobRepository: Effect.Effect<{
         }>]>;
         readonly occurredAt: Schema.DateTimeUtcFromString;
     }, "Type">) => Effect.Effect<{
-        readonly payload: unknown;
-        readonly jobId: string & import("effect/Brand").Brand<"JobId">;
         readonly workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">;
-        readonly eventSequence: number & import("effect/Brand").Brand<"AgentEventCursor">;
+        readonly jobId: string & import("effect/Brand").Brand<"JobId">;
         readonly occurredAt: DateTime.Utc;
+        readonly payload: unknown;
+        readonly eventSequence: number & import("effect/Brand").Brand<"AgentEventCursor">;
         readonly threadId: string & import("effect/Brand").Brand<"AgentThreadId">;
         readonly attemptSequence: (number & import("effect/Brand").Brand<"AgentAttemptSequence">) | null;
-        readonly eventKind: "progress" | "user-message" | "job-queued" | "job-started" | "assistant-output" | "usage" | "job-completed" | "job-failed" | "cancel-requested" | "review-report" | "review-suggestion-revised" | "review-suggestion-published";
+        readonly eventKind: "cancel-requested" | "progress" | "user-message" | "job-queued" | "job-started" | "assistant-output" | "usage" | "job-completed" | "job-failed" | "review-report" | "review-suggestion-revised" | "review-suggestion-published";
         readonly task?: Schema.Struct.ReadonlySide<{
             readonly _tag: Schema.tag<"release-chat">;
-        }, "Type"> | Schema.Struct.ReadonlySide<{
-            readonly _tag: Schema.tag<"pr-review">;
-            pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
-            subject: Schema.Struct<{
+        }, "Type"> | {
+            readonly pluginConnectionId: string & import("effect/Brand").Brand<"PluginConnectionId">;
+            readonly _tag: "pr-review";
+            readonly subject: Schema.Struct.ReadonlySide<{
                 readonly providerId: Schema.Literal<"codecommit">;
                 readonly repository: Schema.String;
                 readonly pullRequestId: Schema.String;
                 readonly baseRevision: Schema.String;
                 readonly headRevision: Schema.String;
-            }>;
-            reviewProfile: Schema.Struct<{
+            }, "Type">;
+            readonly reviewProfile: Schema.Struct.ReadonlySide<{
                 readonly profileId: Schema.brand<Schema.String, "ReviewAgentProfileId">;
                 readonly label: Schema.String;
                 readonly budgetMillis: Schema.Int;
                 readonly networkAccess: Schema.Literals<readonly ["blocked", "provider-enabled"]>;
                 readonly sandbox: Schema.Literal<"sbx">;
-            }>;
-        }, "Type">;
+            }, "Type">;
+            readonly target?: Schema.Struct.ReadonlySide<{
+                readonly sourceJobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+                readonly suggestionId: Schema.brand<Schema.String, "PrReviewSuggestionId">;
+                readonly selectedRevisionId: Schema.brand<Schema.String, "PrReviewSuggestionRevisionId">;
+                readonly history: Schema.Struct<{
+                    readonly current: typeof PrReviewSuggestionRevision;
+                    readonly revisions: Schema.$Array<typeof PrReviewSuggestionRevision>;
+                    readonly hasMore: Schema.Boolean;
+                    readonly nextBeforeSequence: Schema.NullOr<Schema.brand<Schema.Int, "PrReviewSuggestionRevisionSequence">>;
+                }>;
+            }, "Type">;
+            readonly intent?: "suggestion-edit" | "suggestion-revalidation" | "full-review";
+        };
     }, unknown, never>;
+    recordReviewProgress: (input: Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+        readonly attemptSequence: Schema.brand<Schema.Int, "AgentAttemptSequence">;
+        readonly leaseToken: Schema.brand<Schema.String, "AgentLeaseToken">;
+        readonly report: Schema.Unknown;
+        readonly occurredAt: Schema.DateTimeUtcFromString;
+    }, "Type">) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+        readonly attemptSequence: Schema.brand<Schema.Int, "AgentAttemptSequence">;
+        readonly report: Schema.Struct<{
+            readonly schemaVersion: Schema.Literal<3>;
+            readonly subject: Schema.Struct<{
+                readonly providerId: Schema.Literal<"codecommit">;
+                readonly repository: Schema.String;
+                readonly pullRequestId: Schema.String;
+                readonly baseRevision: Schema.String;
+                readonly headRevision: Schema.String;
+            }>;
+            readonly completion: Schema.Union<readonly [Schema.Struct<{
+                readonly status: Schema.Literal<"complete">;
+            }>, Schema.Struct<{
+                readonly status: Schema.Literal<"unable-to-conclude">;
+                readonly reason: Schema.String;
+            }>]>;
+            readonly suggestions: Schema.$Array<Schema.Struct<{
+                readonly anchor: Schema.Union<readonly [Schema.Struct<{
+                    readonly _tag: Schema.Literal<"line">;
+                    readonly path: Schema.brand<Schema.String, "PrReviewPath">;
+                    readonly line: Schema.Int;
+                    readonly relativeFileVersion: Schema.withDecodingDefaultTypeKey<Schema.Literal<"AFTER">, never>;
+                }>, Schema.Struct<{
+                    readonly _tag: Schema.Literal<"file">;
+                    readonly path: Schema.brand<Schema.String, "PrReviewPath">;
+                    readonly line: Schema.Int;
+                    readonly relativeFileVersion: Schema.withDecodingDefaultTypeKey<Schema.Literals<readonly ["BEFORE", "AFTER"]>, never>;
+                }>, Schema.Struct<{
+                    readonly _tag: Schema.Literal<"changes">;
+                }>]>;
+                readonly title: Schema.String;
+                readonly severity: Schema.Literals<readonly ["P1", "P2", "P3", "P4"]>;
+                readonly problem: Schema.String;
+                readonly impact: Schema.String;
+                readonly evidence: Schema.Struct<{
+                    readonly excerpt: Schema.String;
+                    readonly path: Schema.brand<Schema.String, "PrReviewPath">;
+                    readonly startLine: Schema.Int;
+                    readonly endLine: Schema.Int;
+                }>;
+                readonly recommendation: Schema.String;
+                readonly confidence: Schema.Struct<{
+                    readonly level: Schema.Literals<readonly ["low", "medium", "high"]>;
+                    readonly reason: Schema.String;
+                }>;
+                readonly relatedLocations: Schema.$Array<Schema.Struct<{
+                    readonly label: Schema.String;
+                    readonly path: Schema.brand<Schema.String, "PrReviewPath">;
+                    readonly startLine: Schema.Int;
+                    readonly endLine: Schema.Int;
+                }>>;
+                readonly prevention: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+                    readonly summary: Schema.String;
+                    readonly enforcement: Schema.Literals<readonly ["ast-grep", "ESLint", "type-check", "test", "instruction"]>;
+                    readonly existingRuleOrConfig: Schema.String;
+                    readonly recurrenceEvidence: Schema.String;
+                    readonly targetFile: Schema.brand<Schema.String, "PrReviewPath">;
+                    readonly sourcePaths: Schema.$Array<Schema.brand<Schema.String, "PrReviewPath">>;
+                    readonly matcherOrInvariant: Schema.String;
+                    readonly invalidFixture: Schema.String;
+                    readonly validFixture: Schema.String;
+                    readonly boundary: Schema.String;
+                }>, Schema.Struct<{
+                    readonly summary: Schema.String;
+                    readonly enforcement: Schema.Literal<"none">;
+                    readonly rationale: Schema.String;
+                }>]>>;
+                readonly replacement: Schema.optionalKey<Schema.Struct<{
+                    readonly reviewedHead: Schema.String;
+                    readonly unifiedDiff: Schema.String;
+                    readonly explanation: Schema.String;
+                }>>;
+                readonly suggestionId: Schema.brand<Schema.String, "PrReviewSuggestionId">;
+                readonly state: Schema.Literals<readonly ["draft", "published", "stale", "resolved", "dismissed", "reopened"]>;
+                readonly dismissalReason: Schema.optionalKey<Schema.Literals<readonly ["false-positive", "not-applicable", "accepted-risk", "duplicate", "other"]>>;
+            }>>;
+            readonly notes: Schema.$Array<Schema.Struct<{
+                readonly reason: Schema.Literals<readonly ["low-confidence", "pre-existing"]>;
+                readonly title: Schema.String;
+                readonly observation: Schema.String;
+                readonly confidence: Schema.Struct<{
+                    readonly level: Schema.Literals<readonly ["low", "medium", "high"]>;
+                    readonly reason: Schema.String;
+                }>;
+                readonly location: Schema.optionalKey<Schema.Struct<{
+                    readonly path: Schema.brand<Schema.String, "PrReviewPath">;
+                    readonly startLine: Schema.Int;
+                    readonly endLine: Schema.Int;
+                }>>;
+                readonly noteId: Schema.brand<Schema.String, "PrReviewNoteId">;
+            }>>;
+            readonly transitions: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                readonly suggestionId: Schema.brand<Schema.String, "PrReviewSuggestionId">;
+                readonly transition: Schema.Literals<readonly ["new", "still-present", "resolved", "reopened"]>;
+                readonly previousState: Schema.NullOr<Schema.Literals<readonly ["draft", "published", "stale", "resolved", "dismissed", "reopened"]>>;
+                readonly currentState: Schema.NullOr<Schema.Literals<readonly ["draft", "published", "stale", "resolved", "dismissed", "reopened"]>>;
+                readonly previousDismissalReason: Schema.optionalKey<Schema.Literals<readonly ["false-positive", "not-applicable", "accepted-risk", "duplicate", "other"]>>;
+                readonly previousHead: Schema.NullOr<Schema.String>;
+                readonly currentHead: Schema.String;
+            }>>>;
+        }>;
+        readonly completedAt: Schema.DateTimeUtcFromString;
+    }, "Type">, Schema.SchemaError | RecordNotFoundError | PersistenceOperationError | PersistedRecordError | AgentJobInputError, never>;
     completeReview: (input: Schema.Struct.ReadonlySide<{
         readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
         readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
@@ -330,6 +573,7 @@ declare const makeAgentJobRepository: Effect.Effect<{
                 }>>;
                 readonly suggestionId: Schema.brand<Schema.String, "PrReviewSuggestionId">;
                 readonly state: Schema.Literals<readonly ["draft", "published", "stale", "resolved", "dismissed", "reopened"]>;
+                readonly dismissalReason: Schema.optionalKey<Schema.Literals<readonly ["false-positive", "not-applicable", "accepted-risk", "duplicate", "other"]>>;
             }>>;
             readonly notes: Schema.$Array<Schema.Struct<{
                 readonly reason: Schema.Literals<readonly ["low-confidence", "pre-existing"]>;
@@ -346,31 +590,56 @@ declare const makeAgentJobRepository: Effect.Effect<{
                 }>>;
                 readonly noteId: Schema.brand<Schema.String, "PrReviewNoteId">;
             }>>;
+            readonly transitions: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                readonly suggestionId: Schema.brand<Schema.String, "PrReviewSuggestionId">;
+                readonly transition: Schema.Literals<readonly ["new", "still-present", "resolved", "reopened"]>;
+                readonly previousState: Schema.NullOr<Schema.Literals<readonly ["draft", "published", "stale", "resolved", "dismissed", "reopened"]>>;
+                readonly currentState: Schema.NullOr<Schema.Literals<readonly ["draft", "published", "stale", "resolved", "dismissed", "reopened"]>>;
+                readonly previousDismissalReason: Schema.optionalKey<Schema.Literals<readonly ["false-positive", "not-applicable", "accepted-risk", "duplicate", "other"]>>;
+                readonly previousHead: Schema.NullOr<Schema.String>;
+                readonly currentHead: Schema.String;
+            }>>>;
         }>;
         readonly completedAt: Schema.DateTimeUtcFromString;
     }, "Type">, unknown, never>;
-    reserveReviewSuggestionPublication: (input: Schema.Struct.ReadonlySide<{
+    readReviewSuggestionPublication: (input: Schema.Struct.ReadonlySide<{
         readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
         readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
         readonly suggestionId: Schema.brand<Schema.String, "PrReviewSuggestionId">;
         readonly revisionId: Schema.brand<Schema.String, "PrReviewSuggestionRevisionId">;
-        readonly contentDigest: Schema.brand<Schema.String, "ReviewSuggestionPublicationDigest">;
-        readonly reservationId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReviewSuggestionPublicationReservationId">;
-        readonly reservedAt: Schema.DateTimeUtcFromString;
     }, "Type">) => Effect.Effect<Schema.Struct.ReadonlySide<{
-        readonly _tag: Schema.tag<"acquired">;
-    }, "Type"> | Schema.Struct.ReadonlySide<{
-        readonly _tag: Schema.tag<"in-progress">;
-    }, "Type"> | Schema.Struct.ReadonlySide<{
-        readonly _tag: Schema.tag<"recoverable">;
+        readonly state: Schema.Literal<"published">;
         readonly publicationId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
-        readonly publishedAt: Schema.DateTimeUtcFromString;
-        readonly reservationId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReviewSuggestionPublicationReservationId">;
-    }, "Type"> | Schema.Struct.ReadonlySide<{
-        readonly _tag: Schema.tag<"published">;
-        readonly publicationId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "GovernedActionId">;
-        readonly publishedAt: Schema.DateTimeUtcFromString;
-    }, "Type">, unknown, never>;
+        readonly commentId: Schema.brand<Schema.String, "ReviewSuggestionPublicationCommentId">;
+    }, "Type"> | null, Schema.SchemaError | PersistedRecordError | import("effect/unstable/sql/SqlError").SqlError, never>;
+    reserveReviewSuggestionPublication: (input: {
+        readonly workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">;
+        readonly jobId: string & import("effect/Brand").Brand<"JobId">;
+        readonly suggestionId: string & import("effect/Brand").Brand<"PrReviewSuggestionId">;
+        readonly revisionId: string & import("effect/Brand").Brand<"PrReviewSuggestionRevisionId">;
+        readonly contentDigest: string & import("effect/Brand").Brand<"ReviewSuggestionPublicationDigest">;
+        readonly reservationId: string & import("effect/Brand").Brand<"ReviewSuggestionPublicationReservationId">;
+        readonly reservedAt: DateTime.Utc;
+        readonly operation?: "reply" | "create" | "update";
+        readonly commentId?: string & import("effect/Brand").Brand<"ReviewSuggestionPublicationCommentId">;
+    }) => Effect.Effect<{
+        readonly _tag: "acquired";
+        readonly commentId?: string & import("effect/Brand").Brand<"ReviewSuggestionPublicationCommentId">;
+    } | {
+        readonly _tag: "in-progress";
+        readonly commentId?: string & import("effect/Brand").Brand<"ReviewSuggestionPublicationCommentId">;
+    } | {
+        readonly _tag: "recoverable";
+        readonly publishedAt: DateTime.Utc;
+        readonly publicationId: string & import("effect/Brand").Brand<"GovernedActionId">;
+        readonly reservationId: string & import("effect/Brand").Brand<"ReviewSuggestionPublicationReservationId">;
+        readonly commentId?: string & import("effect/Brand").Brand<"ReviewSuggestionPublicationCommentId">;
+    } | {
+        readonly _tag: "published";
+        readonly publishedAt: DateTime.Utc;
+        readonly publicationId: string & import("effect/Brand").Brand<"GovernedActionId">;
+        readonly commentId?: string & import("effect/Brand").Brand<"ReviewSuggestionPublicationCommentId">;
+    }, unknown, never>;
     releaseReviewSuggestionPublication: (input: Schema.Struct.ReadonlySide<{
         readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
         readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
@@ -378,16 +647,18 @@ declare const makeAgentJobRepository: Effect.Effect<{
         readonly revisionId: Schema.brand<Schema.String, "PrReviewSuggestionRevisionId">;
         readonly contentDigest: Schema.brand<Schema.String, "ReviewSuggestionPublicationDigest">;
         readonly reservationId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReviewSuggestionPublicationReservationId">;
-    }, "Type">) => Effect.Effect<void, Schema.SchemaError | PersistenceOperationError, never>;
+    }, "Type">) => Effect.Effect<void, unknown, never>;
     recordReviewSuggestionPublication: (input: {
-        readonly suggestionId: string & import("effect/Brand").Brand<"PrReviewSuggestionId">;
+        readonly workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">;
         readonly jobId: string & import("effect/Brand").Brand<"JobId">;
+        readonly suggestionId: string & import("effect/Brand").Brand<"PrReviewSuggestionId">;
         readonly revisionId: string & import("effect/Brand").Brand<"PrReviewSuggestionRevisionId">;
-        readonly workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">;
         readonly publishedAt: DateTime.Utc;
         readonly publicationId: string & import("effect/Brand").Brand<"GovernedActionId">;
         readonly contentDigest: string & import("effect/Brand").Brand<"ReviewSuggestionPublicationDigest">;
         readonly reservationId: string & import("effect/Brand").Brand<"ReviewSuggestionPublicationReservationId">;
+        readonly operation?: "reply" | "create" | "update";
+        readonly commentId?: string & import("effect/Brand").Brand<"ReviewSuggestionPublicationCommentId">;
         readonly finalize?: boolean;
     }) => Effect.Effect<undefined, unknown, never>;
     failAttempt: (input: Schema.Struct.ReadonlySide<{
@@ -398,99 +669,217 @@ declare const makeAgentJobRepository: Effect.Effect<{
         readonly error: typeof AgentProviderError;
         readonly failedAt: Schema.DateTimeUtcFromString;
     }, "Type">) => Effect.Effect<{
-        readonly payload: unknown;
-        readonly jobId: string & import("effect/Brand").Brand<"JobId">;
         readonly workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">;
-        readonly eventSequence: number & import("effect/Brand").Brand<"AgentEventCursor">;
+        readonly jobId: string & import("effect/Brand").Brand<"JobId">;
         readonly occurredAt: DateTime.Utc;
+        readonly payload: unknown;
+        readonly eventSequence: number & import("effect/Brand").Brand<"AgentEventCursor">;
         readonly threadId: string & import("effect/Brand").Brand<"AgentThreadId">;
         readonly attemptSequence: (number & import("effect/Brand").Brand<"AgentAttemptSequence">) | null;
-        readonly eventKind: "progress" | "user-message" | "job-queued" | "job-started" | "assistant-output" | "usage" | "job-completed" | "job-failed" | "cancel-requested" | "review-report" | "review-suggestion-revised" | "review-suggestion-published";
+        readonly eventKind: "cancel-requested" | "progress" | "user-message" | "job-queued" | "job-started" | "assistant-output" | "usage" | "job-completed" | "job-failed" | "review-report" | "review-suggestion-revised" | "review-suggestion-published";
         readonly task?: Schema.Struct.ReadonlySide<{
             readonly _tag: Schema.tag<"release-chat">;
-        }, "Type"> | Schema.Struct.ReadonlySide<{
-            readonly _tag: Schema.tag<"pr-review">;
-            pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
-            subject: Schema.Struct<{
+        }, "Type"> | {
+            readonly pluginConnectionId: string & import("effect/Brand").Brand<"PluginConnectionId">;
+            readonly _tag: "pr-review";
+            readonly subject: Schema.Struct.ReadonlySide<{
+                readonly providerId: Schema.Literal<"codecommit">;
+                readonly repository: Schema.String;
+                readonly pullRequestId: Schema.String;
+                readonly baseRevision: Schema.String;
+                readonly headRevision: Schema.String;
+            }, "Type">;
+            readonly reviewProfile: Schema.Struct.ReadonlySide<{
+                readonly profileId: Schema.brand<Schema.String, "ReviewAgentProfileId">;
+                readonly label: Schema.String;
+                readonly budgetMillis: Schema.Int;
+                readonly networkAccess: Schema.Literals<readonly ["blocked", "provider-enabled"]>;
+                readonly sandbox: Schema.Literal<"sbx">;
+            }, "Type">;
+            readonly target?: Schema.Struct.ReadonlySide<{
+                readonly sourceJobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+                readonly suggestionId: Schema.brand<Schema.String, "PrReviewSuggestionId">;
+                readonly selectedRevisionId: Schema.brand<Schema.String, "PrReviewSuggestionRevisionId">;
+                readonly history: Schema.Struct<{
+                    readonly current: typeof PrReviewSuggestionRevision;
+                    readonly revisions: Schema.$Array<typeof PrReviewSuggestionRevision>;
+                    readonly hasMore: Schema.Boolean;
+                    readonly nextBeforeSequence: Schema.NullOr<Schema.brand<Schema.Int, "PrReviewSuggestionRevisionSequence">>;
+                }>;
+            }, "Type">;
+            readonly intent?: "suggestion-edit" | "suggestion-revalidation" | "full-review";
+        };
+    }, unknown, never>;
+    listRunningPrReviewAttempts: (workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">) => Effect.Effect<Schema.Struct.ReadonlySide<{
+        readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+        readonly attemptSequence: Schema.brand<Schema.Int, "AgentAttemptSequence">;
+        readonly attemptId: Schema.String;
+        readonly sessionRef: Schema.NullOr<Schema.brand<Schema.String, "AgentSessionRef">>;
+    }, "Type">[], RecordNotFoundError | PersistenceOperationError | PersistedRecordError | import("effect/unstable/sql/SqlError").SqlError, never>;
+    attachRunningPrReviewSession: (input: Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+        readonly attemptSequence: Schema.brand<Schema.Int, "AgentAttemptSequence">;
+        readonly sessionRef: Schema.brand<Schema.String, "AgentSessionRef">;
+    }, "Type">) => Effect.Effect<undefined, Schema.SchemaError | import("effect/unstable/sql/SqlError").SqlError, never>;
+    interruptRunningReviews: (input: {
+        readonly workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">;
+        readonly interruptedAt: DateTime.Utc;
+        readonly preservedAttempts?: readonly Schema.Struct.ReadonlySide<{
+            readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+            readonly attemptSequence: Schema.brand<Schema.Int, "AgentAttemptSequence">;
+        }, "Type">[];
+    }) => Effect.Effect<{
+        interrupted: number;
+    }, unknown, never>;
+    reviewBudget: (input: Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+        readonly task: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"release-chat", {}>, Schema.TaggedStruct<"pr-review", {
+            readonly context: Schema.Struct<{
+                readonly recentRequests: Schema.$Array<Schema.Struct<{
+                    readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+                    readonly prompt: Schema.String;
+                    readonly subjectRevision: Schema.String;
+                    readonly requestedAt: Schema.DateTimeUtcFromString;
+                }>>;
+                readonly priorRuns: Schema.$Array<Schema.Struct<{
+                    readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+                    readonly subject: Schema.Struct<{
+                        readonly providerId: Schema.Literal<"codecommit">;
+                        readonly repository: Schema.String;
+                        readonly pullRequestId: Schema.String;
+                        readonly baseRevision: Schema.String;
+                        readonly headRevision: Schema.String;
+                    }>;
+                    readonly state: Schema.Literals<readonly ["cancelled", "failed", "interrupted", "succeeded", "unknown"]>;
+                    readonly requestedAt: Schema.DateTimeUtcFromString;
+                    readonly suggestionTitles: Schema.$Array<Schema.String>;
+                    readonly suggestionsTruncated: Schema.Boolean;
+                    readonly noteTitles: Schema.$Array<Schema.String>;
+                    readonly notesTruncated: Schema.Boolean;
+                    readonly limitation: Schema.NullOr<Schema.String>;
+                }>>;
+                readonly historyTruncated: Schema.Boolean;
+            }>;
+            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+            readonly subject: Schema.Struct<{
                 readonly providerId: Schema.Literal<"codecommit">;
                 readonly repository: Schema.String;
                 readonly pullRequestId: Schema.String;
                 readonly baseRevision: Schema.String;
                 readonly headRevision: Schema.String;
             }>;
-            reviewProfile: Schema.Struct<{
+            readonly reviewProfile: Schema.Struct<{
                 readonly profileId: Schema.brand<Schema.String, "ReviewAgentProfileId">;
                 readonly label: Schema.String;
                 readonly budgetMillis: Schema.Int;
                 readonly networkAccess: Schema.Literals<readonly ["blocked", "provider-enabled"]>;
                 readonly sandbox: Schema.Literal<"sbx">;
             }>;
-        }, "Type">;
-    }, unknown, never>;
+            readonly intent: Schema.optionalKey<Schema.Literals<readonly ["full-review", "suggestion-edit", "suggestion-revalidation"]>>;
+            readonly target: Schema.optionalKey<Schema.Struct<{
+                readonly sourceJobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+                readonly suggestionId: Schema.brand<Schema.String, "PrReviewSuggestionId">;
+                readonly selectedRevisionId: Schema.brand<Schema.String, "PrReviewSuggestionRevisionId">;
+                readonly history: Schema.Struct<{
+                    readonly current: typeof PrReviewSuggestionRevision;
+                    readonly revisions: Schema.$Array<typeof PrReviewSuggestionRevision>;
+                    readonly hasMore: Schema.Boolean;
+                    readonly nextBeforeSequence: Schema.NullOr<Schema.brand<Schema.Int, "PrReviewSuggestionRevisionSequence">>;
+                }>;
+            }>>;
+        }>]>;
+    }, "Type">) => Effect.Effect<{
+        reviewBudgetMillis: undefined;
+        reviewBudgetExtensionCount: number;
+    } | {
+        reviewBudgetMillis: number;
+        reviewBudgetExtensionCount: number;
+    }, Schema.SchemaError | PersistenceOperationError | PersistedRecordError, never>;
+    extendReviewBudget: (input: Schema.Struct.ReadonlySide<{
+        readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+        readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+        readonly extendedAt: Schema.DateTimeUtcFromString;
+    }, "Type">) => Effect.Effect<{
+        reviewBudgetMillis: number;
+        reviewBudgetExtensionCount: number;
+    }, Schema.SchemaError | RecordNotFoundError | PersistenceOperationError | PersistedRecordError | AgentJobInputError, never>;
     requestCancellation: (input: Schema.Struct.ReadonlySide<{
         readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
         readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
         readonly requestedAt: Schema.DateTimeUtcFromString;
     }, "Type">) => Effect.Effect<void, unknown, never>;
-    latestReview: (input: any) => Effect.Effect<Option.Option<Schema.Struct.ReadonlySide<{
-        readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
-        readonly threadId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentThreadId">;
-        readonly providerId: Schema.brand<Schema.String, "AgentProviderId">;
-        readonly model: Schema.NullOr<Schema.String>;
-        readonly state: Schema.Literals<readonly ["queued", "running", "cancel-requested", "succeeded", "failed", "cancelled"]>;
-        readonly createdAt: Schema.DateTimeUtcFromString;
-        readonly terminalAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
-        readonly report: Schema.NullOr<Schema.Struct<{
-            readonly schemaVersion: Schema.Literal<3>;
-            readonly subject: Schema.Struct<{
+    latestReview: (input: any) => Effect.Effect<Option.Option<{
+        readonly providerId: string & import("effect/Brand").Brand<"AgentProviderId">;
+        readonly jobId: string & import("effect/Brand").Brand<"JobId">;
+        readonly state: "succeeded" | "failed" | "cancelled" | "cancel-requested" | "queued" | "running" | "interrupted";
+        readonly model: string | null;
+        readonly createdAt: DateTime.Utc;
+        readonly reviewProfile: Schema.Struct.ReadonlySide<{
+            readonly profileId: Schema.brand<Schema.String, "ReviewAgentProfileId">;
+            readonly label: Schema.String;
+            readonly budgetMillis: Schema.Int;
+            readonly networkAccess: Schema.Literals<readonly ["blocked", "provider-enabled"]>;
+            readonly sandbox: Schema.Literal<"sbx">;
+        }, "Type">;
+        readonly activity: Schema.Struct.ReadonlySide<{
+            readonly events: Schema.$Array<Schema.String>;
+            readonly truncated: Schema.Boolean;
+        }, "Type">;
+        readonly report: {
+            readonly schemaVersion: 3;
+            readonly subject: Schema.Struct.ReadonlySide<{
                 readonly providerId: Schema.Literal<"codecommit">;
                 readonly repository: Schema.String;
                 readonly pullRequestId: Schema.String;
                 readonly baseRevision: Schema.String;
                 readonly headRevision: Schema.String;
-            }>;
-            readonly completion: Schema.Union<readonly [Schema.Struct<{
+            }, "Type">;
+            readonly completion: Schema.Struct.ReadonlySide<{
                 readonly status: Schema.Literal<"complete">;
-            }>, Schema.Struct<{
+            }, "Type"> | Schema.Struct.ReadonlySide<{
                 readonly status: Schema.Literal<"unable-to-conclude">;
                 readonly reason: Schema.String;
-            }>]>;
-            readonly suggestions: Schema.$Array<Schema.Struct<{
-                readonly anchor: Schema.Union<readonly [Schema.Struct<{
+            }, "Type">;
+            readonly suggestions: readonly {
+                readonly title: string;
+                readonly confidence: Schema.Struct.ReadonlySide<{
+                    readonly level: Schema.Literals<readonly ["low", "medium", "high"]>;
+                    readonly reason: Schema.String;
+                }, "Type">;
+                readonly anchor: Schema.Struct.ReadonlySide<{
                     readonly _tag: Schema.Literal<"line">;
                     readonly path: Schema.brand<Schema.String, "PrReviewPath">;
                     readonly line: Schema.Int;
                     readonly relativeFileVersion: Schema.withDecodingDefaultTypeKey<Schema.Literal<"AFTER">, never>;
-                }>, Schema.Struct<{
+                }, "Type"> | Schema.Struct.ReadonlySide<{
                     readonly _tag: Schema.Literal<"file">;
                     readonly path: Schema.brand<Schema.String, "PrReviewPath">;
                     readonly line: Schema.Int;
                     readonly relativeFileVersion: Schema.withDecodingDefaultTypeKey<Schema.Literals<readonly ["BEFORE", "AFTER"]>, never>;
-                }>, Schema.Struct<{
+                }, "Type"> | Schema.Struct.ReadonlySide<{
                     readonly _tag: Schema.Literal<"changes">;
-                }>]>;
-                readonly title: Schema.String;
-                readonly severity: Schema.Literals<readonly ["P1", "P2", "P3", "P4"]>;
-                readonly problem: Schema.String;
-                readonly impact: Schema.String;
-                readonly evidence: Schema.Struct<{
+                }, "Type">;
+                readonly impact: string;
+                readonly evidence: Schema.Struct.ReadonlySide<{
                     readonly excerpt: Schema.String;
                     readonly path: Schema.brand<Schema.String, "PrReviewPath">;
                     readonly startLine: Schema.Int;
                     readonly endLine: Schema.Int;
-                }>;
-                readonly recommendation: Schema.String;
-                readonly confidence: Schema.Struct<{
-                    readonly level: Schema.Literals<readonly ["low", "medium", "high"]>;
-                    readonly reason: Schema.String;
-                }>;
-                readonly relatedLocations: Schema.$Array<Schema.Struct<{
+                }, "Type">;
+                readonly state: "stale" | "draft" | "published" | "resolved" | "dismissed" | "reopened";
+                readonly suggestionId: string & import("effect/Brand").Brand<"PrReviewSuggestionId">;
+                readonly severity: "P1" | "P2" | "P3" | "P4";
+                readonly problem: string;
+                readonly recommendation: string;
+                readonly relatedLocations: readonly Schema.Struct.ReadonlySide<{
                     readonly label: Schema.String;
                     readonly path: Schema.brand<Schema.String, "PrReviewPath">;
                     readonly startLine: Schema.Int;
                     readonly endLine: Schema.Int;
-                }>>;
-                readonly prevention: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+                }, "Type">[];
+                readonly prevention?: Schema.Struct.ReadonlySide<{
                     readonly summary: Schema.String;
                     readonly enforcement: Schema.Literals<readonly ["ast-grep", "ESLint", "type-check", "test", "instruction"]>;
                     readonly existingRuleOrConfig: Schema.String;
@@ -501,47 +890,50 @@ declare const makeAgentJobRepository: Effect.Effect<{
                     readonly invalidFixture: Schema.String;
                     readonly validFixture: Schema.String;
                     readonly boundary: Schema.String;
-                }>, Schema.Struct<{
+                }, "Type"> | Schema.Struct.ReadonlySide<{
                     readonly summary: Schema.String;
                     readonly enforcement: Schema.Literal<"none">;
                     readonly rationale: Schema.String;
-                }>]>>;
-                readonly replacement: Schema.optionalKey<Schema.Struct<{
+                }, "Type">;
+                readonly replacement?: Schema.Struct.ReadonlySide<{
                     readonly reviewedHead: Schema.String;
                     readonly unifiedDiff: Schema.String;
                     readonly explanation: Schema.String;
-                }>>;
-                readonly suggestionId: Schema.brand<Schema.String, "PrReviewSuggestionId">;
-                readonly state: Schema.Literals<readonly ["draft", "published", "stale", "resolved", "dismissed", "reopened"]>;
-            }>>;
-            readonly notes: Schema.$Array<Schema.Struct<{
-                readonly reason: Schema.Literals<readonly ["low-confidence", "pre-existing"]>;
-                readonly title: Schema.String;
-                readonly observation: Schema.String;
-                readonly confidence: Schema.Struct<{
+                }, "Type">;
+                readonly dismissalReason?: "false-positive" | "not-applicable" | "accepted-risk" | "duplicate" | "other";
+            }[];
+            readonly notes: readonly {
+                readonly reason: "low-confidence" | "pre-existing";
+                readonly title: string;
+                readonly confidence: Schema.Struct.ReadonlySide<{
                     readonly level: Schema.Literals<readonly ["low", "medium", "high"]>;
                     readonly reason: Schema.String;
-                }>;
-                readonly location: Schema.optionalKey<Schema.Struct<{
+                }, "Type">;
+                readonly observation: string;
+                readonly noteId: string & import("effect/Brand").Brand<"PrReviewNoteId">;
+                readonly location?: Schema.Struct.ReadonlySide<{
                     readonly path: Schema.brand<Schema.String, "PrReviewPath">;
                     readonly startLine: Schema.Int;
                     readonly endLine: Schema.Int;
-                }>>;
-                readonly noteId: Schema.brand<Schema.String, "PrReviewNoteId">;
-            }>>;
-        }>>;
-        readonly reviewProfile: Schema.Struct<{
-            readonly profileId: Schema.brand<Schema.String, "ReviewAgentProfileId">;
-            readonly label: Schema.String;
-            readonly budgetMillis: Schema.Int;
-            readonly networkAccess: Schema.Literals<readonly ["blocked", "provider-enabled"]>;
-            readonly sandbox: Schema.Literal<"sbx">;
-        }>;
-        readonly activity: Schema.Struct<{
-            readonly events: Schema.$Array<Schema.String>;
-            readonly truncated: Schema.Boolean;
-        }>;
-    }, "Type">>, Schema.SchemaError | RecordNotFoundError | PersistenceOperationError | PersistedRecordError, never>;
+                }, "Type">;
+            }[];
+            readonly transitions?: readonly {
+                readonly transition: "resolved" | "reopened" | "new" | "still-present";
+                readonly previousState: "stale" | "draft" | "published" | "resolved" | "dismissed" | "reopened" | null;
+                readonly currentState: "stale" | "draft" | "published" | "resolved" | "dismissed" | "reopened" | null;
+                readonly previousHead: string | null;
+                readonly suggestionId: string & import("effect/Brand").Brand<"PrReviewSuggestionId">;
+                readonly currentHead: string;
+                readonly previousDismissalReason?: "false-positive" | "not-applicable" | "accepted-risk" | "duplicate" | "other";
+            }[];
+        } | null;
+        readonly threadId: string & import("effect/Brand").Brand<"AgentThreadId">;
+        readonly terminalAt: DateTime.Utc | null;
+        readonly startedAt?: DateTime.Utc | null;
+        readonly reviewBudgetMillis?: number;
+        readonly reviewBudgetExtensionCount?: number;
+        readonly taskIntent?: "suggestion-edit" | "suggestion-revalidation" | null;
+    }>, Schema.SchemaError | PersistenceOperationError | PersistedRecordError, never>;
     reviewResult: (input: Schema.Struct.ReadonlySide<{
         readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
         readonly jobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
@@ -622,6 +1014,7 @@ declare const makeAgentJobRepository: Effect.Effect<{
                 }>>;
                 readonly suggestionId: Schema.brand<Schema.String, "PrReviewSuggestionId">;
                 readonly state: Schema.Literals<readonly ["draft", "published", "stale", "resolved", "dismissed", "reopened"]>;
+                readonly dismissalReason: Schema.optionalKey<Schema.Literals<readonly ["false-positive", "not-applicable", "accepted-risk", "duplicate", "other"]>>;
             }>>;
             readonly notes: Schema.$Array<Schema.Struct<{
                 readonly reason: Schema.Literals<readonly ["low-confidence", "pre-existing"]>;
@@ -638,6 +1031,15 @@ declare const makeAgentJobRepository: Effect.Effect<{
                 }>>;
                 readonly noteId: Schema.brand<Schema.String, "PrReviewNoteId">;
             }>>;
+            readonly transitions: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                readonly suggestionId: Schema.brand<Schema.String, "PrReviewSuggestionId">;
+                readonly transition: Schema.Literals<readonly ["new", "still-present", "resolved", "reopened"]>;
+                readonly previousState: Schema.NullOr<Schema.Literals<readonly ["draft", "published", "stale", "resolved", "dismissed", "reopened"]>>;
+                readonly currentState: Schema.NullOr<Schema.Literals<readonly ["draft", "published", "stale", "resolved", "dismissed", "reopened"]>>;
+                readonly previousDismissalReason: Schema.optionalKey<Schema.Literals<readonly ["false-positive", "not-applicable", "accepted-risk", "duplicate", "other"]>>;
+                readonly previousHead: Schema.NullOr<Schema.String>;
+                readonly currentHead: Schema.String;
+            }>>>;
         }>;
         readonly completedAt: Schema.DateTimeUtcFromString;
     }, "Type">, Schema.SchemaError | RecordNotFoundError | PersistenceOperationError | PersistedRecordError, never>;
@@ -660,34 +1062,46 @@ declare const makeAgentJobRepository: Effect.Effect<{
         readonly limit: Schema.brand<Schema.Int, "AgentThreadEventPageSize">;
     }, "Type">) => Effect.Effect<{
         events: {
-            readonly payload: unknown;
-            readonly jobId: string & import("effect/Brand").Brand<"JobId">;
             readonly workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">;
-            readonly eventSequence: number & import("effect/Brand").Brand<"AgentEventCursor">;
+            readonly jobId: string & import("effect/Brand").Brand<"JobId">;
             readonly occurredAt: DateTime.Utc;
+            readonly payload: unknown;
+            readonly eventSequence: number & import("effect/Brand").Brand<"AgentEventCursor">;
             readonly threadId: string & import("effect/Brand").Brand<"AgentThreadId">;
             readonly attemptSequence: (number & import("effect/Brand").Brand<"AgentAttemptSequence">) | null;
-            readonly eventKind: "progress" | "user-message" | "job-queued" | "job-started" | "assistant-output" | "usage" | "job-completed" | "job-failed" | "cancel-requested" | "review-report" | "review-suggestion-revised" | "review-suggestion-published";
+            readonly eventKind: "cancel-requested" | "progress" | "user-message" | "job-queued" | "job-started" | "assistant-output" | "usage" | "job-completed" | "job-failed" | "review-report" | "review-suggestion-revised" | "review-suggestion-published";
             readonly task?: Schema.Struct.ReadonlySide<{
                 readonly _tag: Schema.tag<"release-chat">;
-            }, "Type"> | Schema.Struct.ReadonlySide<{
-                readonly _tag: Schema.tag<"pr-review">;
-                pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
-                subject: Schema.Struct<{
+            }, "Type"> | {
+                readonly pluginConnectionId: string & import("effect/Brand").Brand<"PluginConnectionId">;
+                readonly _tag: "pr-review";
+                readonly subject: Schema.Struct.ReadonlySide<{
                     readonly providerId: Schema.Literal<"codecommit">;
                     readonly repository: Schema.String;
                     readonly pullRequestId: Schema.String;
                     readonly baseRevision: Schema.String;
                     readonly headRevision: Schema.String;
-                }>;
-                reviewProfile: Schema.Struct<{
+                }, "Type">;
+                readonly reviewProfile: Schema.Struct.ReadonlySide<{
                     readonly profileId: Schema.brand<Schema.String, "ReviewAgentProfileId">;
                     readonly label: Schema.String;
                     readonly budgetMillis: Schema.Int;
                     readonly networkAccess: Schema.Literals<readonly ["blocked", "provider-enabled"]>;
                     readonly sandbox: Schema.Literal<"sbx">;
-                }>;
-            }, "Type">;
+                }, "Type">;
+                readonly target?: Schema.Struct.ReadonlySide<{
+                    readonly sourceJobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+                    readonly suggestionId: Schema.brand<Schema.String, "PrReviewSuggestionId">;
+                    readonly selectedRevisionId: Schema.brand<Schema.String, "PrReviewSuggestionRevisionId">;
+                    readonly history: Schema.Struct<{
+                        readonly current: typeof PrReviewSuggestionRevision;
+                        readonly revisions: Schema.$Array<typeof PrReviewSuggestionRevision>;
+                        readonly hasMore: Schema.Boolean;
+                        readonly nextBeforeSequence: Schema.NullOr<Schema.brand<Schema.Int, "PrReviewSuggestionRevisionSequence">>;
+                    }>;
+                }, "Type">;
+                readonly intent?: "suggestion-edit" | "suggestion-revalidation" | "full-review";
+            };
         }[];
         nextCursor: number & import("effect/Brand").Brand<"AgentEventCursor">;
     }, Schema.SchemaError | RecordNotFoundError | PersistenceOperationError | PersistedRecordError, never>;
@@ -703,34 +1117,46 @@ declare const makeAgentJobRepository: Effect.Effect<{
         readonly limit: Schema.brand<Schema.Int, "AgentThreadEventPageSize">;
     }, "Type">) => Effect.Effect<{
         events: {
-            readonly payload: unknown;
-            readonly jobId: string & import("effect/Brand").Brand<"JobId">;
             readonly workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">;
-            readonly eventSequence: number & import("effect/Brand").Brand<"AgentEventCursor">;
+            readonly jobId: string & import("effect/Brand").Brand<"JobId">;
             readonly occurredAt: DateTime.Utc;
+            readonly payload: unknown;
+            readonly eventSequence: number & import("effect/Brand").Brand<"AgentEventCursor">;
             readonly threadId: string & import("effect/Brand").Brand<"AgentThreadId">;
             readonly attemptSequence: (number & import("effect/Brand").Brand<"AgentAttemptSequence">) | null;
-            readonly eventKind: "progress" | "user-message" | "job-queued" | "job-started" | "assistant-output" | "usage" | "job-completed" | "job-failed" | "cancel-requested" | "review-report" | "review-suggestion-revised" | "review-suggestion-published";
+            readonly eventKind: "cancel-requested" | "progress" | "user-message" | "job-queued" | "job-started" | "assistant-output" | "usage" | "job-completed" | "job-failed" | "review-report" | "review-suggestion-revised" | "review-suggestion-published";
             readonly task?: Schema.Struct.ReadonlySide<{
                 readonly _tag: Schema.tag<"release-chat">;
-            }, "Type"> | Schema.Struct.ReadonlySide<{
-                readonly _tag: Schema.tag<"pr-review">;
-                pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
-                subject: Schema.Struct<{
+            }, "Type"> | {
+                readonly pluginConnectionId: string & import("effect/Brand").Brand<"PluginConnectionId">;
+                readonly _tag: "pr-review";
+                readonly subject: Schema.Struct.ReadonlySide<{
                     readonly providerId: Schema.Literal<"codecommit">;
                     readonly repository: Schema.String;
                     readonly pullRequestId: Schema.String;
                     readonly baseRevision: Schema.String;
                     readonly headRevision: Schema.String;
-                }>;
-                reviewProfile: Schema.Struct<{
+                }, "Type">;
+                readonly reviewProfile: Schema.Struct.ReadonlySide<{
                     readonly profileId: Schema.brand<Schema.String, "ReviewAgentProfileId">;
                     readonly label: Schema.String;
                     readonly budgetMillis: Schema.Int;
                     readonly networkAccess: Schema.Literals<readonly ["blocked", "provider-enabled"]>;
                     readonly sandbox: Schema.Literal<"sbx">;
-                }>;
-            }, "Type">;
+                }, "Type">;
+                readonly target?: Schema.Struct.ReadonlySide<{
+                    readonly sourceJobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+                    readonly suggestionId: Schema.brand<Schema.String, "PrReviewSuggestionId">;
+                    readonly selectedRevisionId: Schema.brand<Schema.String, "PrReviewSuggestionRevisionId">;
+                    readonly history: Schema.Struct<{
+                        readonly current: typeof PrReviewSuggestionRevision;
+                        readonly revisions: Schema.$Array<typeof PrReviewSuggestionRevision>;
+                        readonly hasMore: Schema.Boolean;
+                        readonly nextBeforeSequence: Schema.NullOr<Schema.brand<Schema.Int, "PrReviewSuggestionRevisionSequence">>;
+                    }>;
+                }, "Type">;
+                readonly intent?: "suggestion-edit" | "suggestion-revalidation" | "full-review";
+            };
         }[];
         nextCursor: number & import("effect/Brand").Brand<"AgentEventCursor">;
     }, Schema.SchemaError | RecordNotFoundError | PersistenceOperationError | PersistedRecordError, never>;
@@ -746,34 +1172,46 @@ declare const makeAgentJobRepository: Effect.Effect<{
         readonly limit: Schema.brand<Schema.Int, "AgentThreadEventPageSize">;
     }, "Type">) => Effect.Effect<{
         events: {
-            readonly payload: unknown;
-            readonly jobId: string & import("effect/Brand").Brand<"JobId">;
             readonly workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">;
-            readonly eventSequence: number & import("effect/Brand").Brand<"AgentEventCursor">;
+            readonly jobId: string & import("effect/Brand").Brand<"JobId">;
             readonly occurredAt: DateTime.Utc;
+            readonly payload: unknown;
+            readonly eventSequence: number & import("effect/Brand").Brand<"AgentEventCursor">;
             readonly threadId: string & import("effect/Brand").Brand<"AgentThreadId">;
             readonly attemptSequence: (number & import("effect/Brand").Brand<"AgentAttemptSequence">) | null;
-            readonly eventKind: "progress" | "user-message" | "job-queued" | "job-started" | "assistant-output" | "usage" | "job-completed" | "job-failed" | "cancel-requested" | "review-report" | "review-suggestion-revised" | "review-suggestion-published";
+            readonly eventKind: "cancel-requested" | "progress" | "user-message" | "job-queued" | "job-started" | "assistant-output" | "usage" | "job-completed" | "job-failed" | "review-report" | "review-suggestion-revised" | "review-suggestion-published";
             readonly task?: Schema.Struct.ReadonlySide<{
                 readonly _tag: Schema.tag<"release-chat">;
-            }, "Type"> | Schema.Struct.ReadonlySide<{
-                readonly _tag: Schema.tag<"pr-review">;
-                pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
-                subject: Schema.Struct<{
+            }, "Type"> | {
+                readonly pluginConnectionId: string & import("effect/Brand").Brand<"PluginConnectionId">;
+                readonly _tag: "pr-review";
+                readonly subject: Schema.Struct.ReadonlySide<{
                     readonly providerId: Schema.Literal<"codecommit">;
                     readonly repository: Schema.String;
                     readonly pullRequestId: Schema.String;
                     readonly baseRevision: Schema.String;
                     readonly headRevision: Schema.String;
-                }>;
-                reviewProfile: Schema.Struct<{
+                }, "Type">;
+                readonly reviewProfile: Schema.Struct.ReadonlySide<{
                     readonly profileId: Schema.brand<Schema.String, "ReviewAgentProfileId">;
                     readonly label: Schema.String;
                     readonly budgetMillis: Schema.Int;
                     readonly networkAccess: Schema.Literals<readonly ["blocked", "provider-enabled"]>;
                     readonly sandbox: Schema.Literal<"sbx">;
-                }>;
-            }, "Type">;
+                }, "Type">;
+                readonly target?: Schema.Struct.ReadonlySide<{
+                    readonly sourceJobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+                    readonly suggestionId: Schema.brand<Schema.String, "PrReviewSuggestionId">;
+                    readonly selectedRevisionId: Schema.brand<Schema.String, "PrReviewSuggestionRevisionId">;
+                    readonly history: Schema.Struct<{
+                        readonly current: typeof PrReviewSuggestionRevision;
+                        readonly revisions: Schema.$Array<typeof PrReviewSuggestionRevision>;
+                        readonly hasMore: Schema.Boolean;
+                        readonly nextBeforeSequence: Schema.NullOr<Schema.brand<Schema.Int, "PrReviewSuggestionRevisionSequence">>;
+                    }>;
+                }, "Type">;
+                readonly intent?: "suggestion-edit" | "suggestion-revalidation" | "full-review";
+            };
         }[];
         nextCursor: number & import("effect/Brand").Brand<"AgentEventCursor">;
     }, Schema.SchemaError | RecordNotFoundError | PersistenceOperationError | PersistedRecordError, never>;
@@ -785,34 +1223,46 @@ declare const makeAgentJobRepository: Effect.Effect<{
         readonly limit: Schema.brand<Schema.Int, "AgentThreadEventPageSize">;
     }, "Type">) => Effect.Effect<{
         events: {
-            readonly payload: unknown;
-            readonly jobId: string & import("effect/Brand").Brand<"JobId">;
             readonly workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">;
-            readonly eventSequence: number & import("effect/Brand").Brand<"AgentEventCursor">;
+            readonly jobId: string & import("effect/Brand").Brand<"JobId">;
             readonly occurredAt: DateTime.Utc;
+            readonly payload: unknown;
+            readonly eventSequence: number & import("effect/Brand").Brand<"AgentEventCursor">;
             readonly threadId: string & import("effect/Brand").Brand<"AgentThreadId">;
             readonly attemptSequence: (number & import("effect/Brand").Brand<"AgentAttemptSequence">) | null;
-            readonly eventKind: "progress" | "user-message" | "job-queued" | "job-started" | "assistant-output" | "usage" | "job-completed" | "job-failed" | "cancel-requested" | "review-report" | "review-suggestion-revised" | "review-suggestion-published";
+            readonly eventKind: "cancel-requested" | "progress" | "user-message" | "job-queued" | "job-started" | "assistant-output" | "usage" | "job-completed" | "job-failed" | "review-report" | "review-suggestion-revised" | "review-suggestion-published";
             readonly task?: Schema.Struct.ReadonlySide<{
                 readonly _tag: Schema.tag<"release-chat">;
-            }, "Type"> | Schema.Struct.ReadonlySide<{
-                readonly _tag: Schema.tag<"pr-review">;
-                pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
-                subject: Schema.Struct<{
+            }, "Type"> | {
+                readonly pluginConnectionId: string & import("effect/Brand").Brand<"PluginConnectionId">;
+                readonly _tag: "pr-review";
+                readonly subject: Schema.Struct.ReadonlySide<{
                     readonly providerId: Schema.Literal<"codecommit">;
                     readonly repository: Schema.String;
                     readonly pullRequestId: Schema.String;
                     readonly baseRevision: Schema.String;
                     readonly headRevision: Schema.String;
-                }>;
-                reviewProfile: Schema.Struct<{
+                }, "Type">;
+                readonly reviewProfile: Schema.Struct.ReadonlySide<{
                     readonly profileId: Schema.brand<Schema.String, "ReviewAgentProfileId">;
                     readonly label: Schema.String;
                     readonly budgetMillis: Schema.Int;
                     readonly networkAccess: Schema.Literals<readonly ["blocked", "provider-enabled"]>;
                     readonly sandbox: Schema.Literal<"sbx">;
-                }>;
-            }, "Type">;
+                }, "Type">;
+                readonly target?: Schema.Struct.ReadonlySide<{
+                    readonly sourceJobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+                    readonly suggestionId: Schema.brand<Schema.String, "PrReviewSuggestionId">;
+                    readonly selectedRevisionId: Schema.brand<Schema.String, "PrReviewSuggestionRevisionId">;
+                    readonly history: Schema.Struct<{
+                        readonly current: typeof PrReviewSuggestionRevision;
+                        readonly revisions: Schema.$Array<typeof PrReviewSuggestionRevision>;
+                        readonly hasMore: Schema.Boolean;
+                        readonly nextBeforeSequence: Schema.NullOr<Schema.brand<Schema.Int, "PrReviewSuggestionRevisionSequence">>;
+                    }>;
+                }, "Type">;
+                readonly intent?: "suggestion-edit" | "suggestion-revalidation" | "full-review";
+            };
         }[];
         nextCursor: number & import("effect/Brand").Brand<"AgentEventCursor">;
     }, Schema.SchemaError | PersistenceOperationError | PersistedRecordError, never>;
@@ -827,34 +1277,46 @@ declare const makeAgentJobRepository: Effect.Effect<{
         readonly limit: Schema.brand<Schema.Int, "AgentThreadEventPageSize">;
     }, "Type">) => Effect.Effect<{
         events: {
-            readonly payload: unknown;
-            readonly jobId: string & import("effect/Brand").Brand<"JobId">;
             readonly workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">;
-            readonly eventSequence: number & import("effect/Brand").Brand<"AgentEventCursor">;
+            readonly jobId: string & import("effect/Brand").Brand<"JobId">;
             readonly occurredAt: DateTime.Utc;
+            readonly payload: unknown;
+            readonly eventSequence: number & import("effect/Brand").Brand<"AgentEventCursor">;
             readonly threadId: string & import("effect/Brand").Brand<"AgentThreadId">;
             readonly attemptSequence: (number & import("effect/Brand").Brand<"AgentAttemptSequence">) | null;
-            readonly eventKind: "progress" | "user-message" | "job-queued" | "job-started" | "assistant-output" | "usage" | "job-completed" | "job-failed" | "cancel-requested" | "review-report" | "review-suggestion-revised" | "review-suggestion-published";
+            readonly eventKind: "cancel-requested" | "progress" | "user-message" | "job-queued" | "job-started" | "assistant-output" | "usage" | "job-completed" | "job-failed" | "review-report" | "review-suggestion-revised" | "review-suggestion-published";
             readonly task?: Schema.Struct.ReadonlySide<{
                 readonly _tag: Schema.tag<"release-chat">;
-            }, "Type"> | Schema.Struct.ReadonlySide<{
-                readonly _tag: Schema.tag<"pr-review">;
-                pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
-                subject: Schema.Struct<{
+            }, "Type"> | {
+                readonly pluginConnectionId: string & import("effect/Brand").Brand<"PluginConnectionId">;
+                readonly _tag: "pr-review";
+                readonly subject: Schema.Struct.ReadonlySide<{
                     readonly providerId: Schema.Literal<"codecommit">;
                     readonly repository: Schema.String;
                     readonly pullRequestId: Schema.String;
                     readonly baseRevision: Schema.String;
                     readonly headRevision: Schema.String;
-                }>;
-                reviewProfile: Schema.Struct<{
+                }, "Type">;
+                readonly reviewProfile: Schema.Struct.ReadonlySide<{
                     readonly profileId: Schema.brand<Schema.String, "ReviewAgentProfileId">;
                     readonly label: Schema.String;
                     readonly budgetMillis: Schema.Int;
                     readonly networkAccess: Schema.Literals<readonly ["blocked", "provider-enabled"]>;
                     readonly sandbox: Schema.Literal<"sbx">;
-                }>;
-            }, "Type">;
+                }, "Type">;
+                readonly target?: Schema.Struct.ReadonlySide<{
+                    readonly sourceJobId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "JobId">;
+                    readonly suggestionId: Schema.brand<Schema.String, "PrReviewSuggestionId">;
+                    readonly selectedRevisionId: Schema.brand<Schema.String, "PrReviewSuggestionRevisionId">;
+                    readonly history: Schema.Struct<{
+                        readonly current: typeof PrReviewSuggestionRevision;
+                        readonly revisions: Schema.$Array<typeof PrReviewSuggestionRevision>;
+                        readonly hasMore: Schema.Boolean;
+                        readonly nextBeforeSequence: Schema.NullOr<Schema.brand<Schema.Int, "PrReviewSuggestionRevisionSequence">>;
+                    }>;
+                }, "Type">;
+                readonly intent?: "suggestion-edit" | "suggestion-revalidation" | "full-review";
+            };
         }[];
         nextCursor: number & import("effect/Brand").Brand<"AgentEventCursor">;
     }, Schema.SchemaError | RecordNotFoundError | PersistenceOperationError | PersistedRecordError, never>;