@opengeni/db 3.7.4 → 4.0.0-canary.0

package/src/session-background-commands.ts

@@ -4,8 +4,8 @@ import type {
 } from "@opengeni/contracts";
 import { and, desc, eq, inArray, sql } from "drizzle-orm";
 
-import type { Database } from "./database";
-import { withRlsContext } from "./database";
+import type { Database, SessionActivityDatabase } from "./database";
+import { withRlsContext, withSessionActivityRlsContext } from "./database";
 import * as schema from "./schema";
 
 export type ConnectedMachineBackgroundCommandProof = {
@@ -15,6 +15,27 @@ export type ConnectedMachineBackgroundCommandProof = {
   observedAt: Date;
 };
 
+export const SESSION_BACKGROUND_COMMAND_REASON_MAX_BYTES = 512;
+
+export function boundedSessionBackgroundCommandReason(value: string, label: string): string {
+  const normalized = value.trim();
+  let bounded = "";
+  let bytes = 0;
+  for (const character of normalized) {
+    const characterBytes = Buffer.byteLength(character, "utf8");
+    if (bytes + characterBytes > SESSION_BACKGROUND_COMMAND_REASON_MAX_BYTES) break;
+    bounded += character;
+    bytes += characterBytes;
+  }
+  if (!bounded) throw new Error(`${label} must not be empty`);
+  return bounded;
+}
+
+export type SessionBackgroundCommandTerminalMutation = {
+  prepare: (tx: SessionActivityDatabase) => Promise<void>;
+  commit: (tx: SessionActivityDatabase, command: SessionBackgroundCommand) => Promise<void>;
+};
+
 export type ConnectedMachineBackgroundCommandClaim = {
   commandId: string;
   accountId: string;
@@ -360,8 +381,10 @@ export async function recordConnectedMachineBackgroundCommandProof(
     proof: ConnectedMachineBackgroundCommandProof;
   },
 ): Promise<void> {
-  const reason = input.proof.reason.trim().slice(0, 512);
-  if (!reason) throw new Error("Connected command proof reason must not be empty");
+  const reason = boundedSessionBackgroundCommandReason(
+    input.proof.reason,
+    "Connected command proof reason",
+  );
   if (input.proof.outcome === "exited" && input.proof.exitCode === null) {
     throw new Error("Connected command exit proof requires an exit code");
   }
@@ -444,44 +467,54 @@ export async function deferConnectedMachineBackgroundCommandReconciliation(
 }
 
 /** Settle only from the proof already checkpointed under this exact claim. */
-export async function settleClaimedConnectedMachineBackgroundCommand(
+export async function settleClaimedConnectedMachineBackgroundCommandWithMutation(
   db: Database,
   input: { claim: ConnectedMachineBackgroundCommandClaim },
+  mutateTerminal: SessionBackgroundCommandTerminalMutation,
 ): Promise<boolean> {
-  return await withRlsContext(
+  return await withSessionActivityRlsContext(
     db,
     { accountId: input.claim.accountId, workspaceId: input.claim.workspaceId },
-    async (scopedDb) => {
-      const rows = await scopedDb.execute<{ id: string }>(sql`
-        update ${schema.sessionBackgroundCommands} command set
-          state = command.reconcile_proof_outcome,
-          exit_code = case
-            when command.reconcile_proof_outcome = 'exited'
-              then command.reconcile_proof_exit_code
-            else null
-          end,
-          settlement_reason = command.reconcile_proof_reason,
-          settled_at = command.reconcile_proof_observed_at,
-          reconcile_claim_id = null,
-          reconcile_claimed_at = null,
-          last_reconcile_outcome = 'settled_' || command.reconcile_proof_outcome,
-          updated_at = clock_timestamp()
-        where command.id = ${input.claim.commandId}
-          and command.account_id = ${input.claim.accountId}
-          and command.workspace_id = ${input.claim.workspaceId}
-          and command.session_id = ${input.claim.sessionId}
-          and command.provider = 'connected_machine'
-          and command.control_workspace_id = ${input.claim.controlWorkspaceId}
-          and command.enrollment_id = ${input.claim.enrollmentId}
-          and command.connection_instance_id = ${input.claim.connectionInstanceId}
-          and command.op_id = ${input.claim.opId}
-          and command.reconcile_claim_id = ${input.claim.claimId}
-          and command.state in ('running', 'stopping')
-          and command.reconcile_proof_outcome in ('exited', 'lost')
-          and command.reconcile_proof_observed_at is not null
-        returning command.id
-      `);
-      return rows.length === 1;
+    async (tx) => {
+      await mutateTerminal.prepare(tx);
+      const rows = await tx.execute<{ id: string }>(sql`
+          update ${schema.sessionBackgroundCommands} command set
+            state = command.reconcile_proof_outcome,
+            exit_code = case
+              when command.reconcile_proof_outcome = 'exited'
+                then command.reconcile_proof_exit_code
+              else null
+            end,
+            settlement_reason = command.reconcile_proof_reason,
+            settled_at = command.reconcile_proof_observed_at,
+            reconcile_claim_id = null,
+            reconcile_claimed_at = null,
+            last_reconcile_outcome = 'settled_' || command.reconcile_proof_outcome,
+            updated_at = clock_timestamp()
+          where command.id = ${input.claim.commandId}
+            and command.account_id = ${input.claim.accountId}
+            and command.workspace_id = ${input.claim.workspaceId}
+            and command.session_id = ${input.claim.sessionId}
+            and command.provider = 'connected_machine'
+            and command.control_workspace_id = ${input.claim.controlWorkspaceId}
+            and command.enrollment_id = ${input.claim.enrollmentId}
+            and command.connection_instance_id = ${input.claim.connectionInstanceId}
+            and command.op_id = ${input.claim.opId}
+            and command.reconcile_claim_id = ${input.claim.claimId}
+            and command.state in ('running', 'stopping')
+            and command.reconcile_proof_outcome in ('exited', 'lost')
+            and command.reconcile_proof_observed_at is not null
+          returning command.id
+        `);
+      if (rows.length !== 1) return false;
+      const [row] = await tx
+        .select()
+        .from(schema.sessionBackgroundCommands)
+        .where(eq(schema.sessionBackgroundCommands.id, input.claim.commandId))
+        .limit(1);
+      if (!row) throw new Error("Settled Connected Machine command disappeared");
+      await mutateTerminal.commit(tx, mapCommand(row));
+      return true;
     },
   );
 }
@@ -652,8 +685,8 @@ export async function requestWorkspaceBackgroundCommandCancellationsInTransactio
   return Number(rows[0]?.commandCount ?? 0);
 }
 
-export async function settleSessionBackgroundCommandForRetainedProcess(
-  db: Database,
+export async function settleSessionBackgroundCommandForRetainedProcessInTransaction(
+  tx: SessionActivityDatabase,
   input: {
     accountId: string;
     workspaceId: string;
@@ -663,38 +696,76 @@ export async function settleSessionBackgroundCommandForRetainedProcess(
     exitCode: number | null;
     reason: string;
   },
+  mutateTerminal: SessionBackgroundCommandTerminalMutation,
 ): Promise<SessionBackgroundCommand | null> {
-  return await withRlsContext(
-    db,
-    { accountId: input.accountId, workspaceId: input.workspaceId },
-    async (scopedDb) => {
-      const [row] = await scopedDb
-        .update(schema.sessionBackgroundCommands)
-        .set({
-          state: input.outcome,
-          exitCode: input.outcome === "exited" ? input.exitCode : null,
-          settlementReason: input.reason.slice(0, 512),
-          settledAt: new Date(),
-          reconcileClaimId: null,
-          reconcileClaimedAt: null,
-          lastReconcileOutcome: `settled_${input.outcome}`,
-          updatedAt: new Date(),
-        })
-        .where(
-          and(
-            eq(schema.sessionBackgroundCommands.workspaceId, input.workspaceId),
-            eq(schema.sessionBackgroundCommands.sessionId, input.sessionId),
-            eq(schema.sessionBackgroundCommands.retainedProcessId, input.retainedProcessId),
-            inArray(schema.sessionBackgroundCommands.state, ["running", "stopping"]),
-          ),
-        )
-        .returning();
-      return row ? mapCommand(row) : null;
-    },
+  const reason = boundedSessionBackgroundCommandReason(
+    input.reason,
+    "Managed command settlement reason",
   );
+  await mutateTerminal.prepare(tx);
+  const [updatedRow] = await tx
+    .update(schema.sessionBackgroundCommands)
+    .set({
+      state: input.outcome,
+      exitCode: input.outcome === "exited" ? input.exitCode : null,
+      settlementReason: reason,
+      settledAt: new Date(),
+      reconcileClaimId: null,
+      reconcileClaimedAt: null,
+      lastReconcileOutcome: `settled_${input.outcome}`,
+      updatedAt: new Date(),
+    })
+    .where(
+      and(
+        eq(schema.sessionBackgroundCommands.workspaceId, input.workspaceId),
+        eq(schema.sessionBackgroundCommands.sessionId, input.sessionId),
+        eq(schema.sessionBackgroundCommands.retainedProcessId, input.retainedProcessId),
+        inArray(schema.sessionBackgroundCommands.state, ["running", "stopping"]),
+      ),
+    )
+    .returning();
+  let row = updatedRow;
+  if (!row) {
+    const [current] = await tx
+      .select()
+      .from(schema.sessionBackgroundCommands)
+      .where(
+        and(
+          eq(schema.sessionBackgroundCommands.workspaceId, input.workspaceId),
+          eq(schema.sessionBackgroundCommands.sessionId, input.sessionId),
+          eq(schema.sessionBackgroundCommands.retainedProcessId, input.retainedProcessId),
+        ),
+      )
+      .for("update")
+      .limit(1);
+    if (!current) return null;
+    if (
+      current.state !== input.outcome ||
+      current.exitCode !== (input.outcome === "exited" ? input.exitCode : null)
+    ) {
+      throw new Error("Managed background command terminal state conflicts with process proof");
+    }
+    const [existingEvent] = await tx
+      .select({ id: schema.sessionEvents.id })
+      .from(schema.sessionEvents)
+      .where(
+        and(
+          eq(schema.sessionEvents.workspaceId, input.workspaceId),
+          eq(schema.sessionEvents.sessionId, input.sessionId),
+          eq(schema.sessionEvents.type, "session.command.finished"),
+          sql`${schema.sessionEvents.payload} ->> 'commandId' = ${current.id}`,
+        ),
+      )
+      .limit(1);
+    if (existingEvent) return mapCommand(current);
+    row = current;
+  }
+  const command = mapCommand(row);
+  await mutateTerminal.commit(tx, command);
+  return command;
 }
 
-export async function settleConnectedMachineSessionBackgroundCommand(
+export async function settleConnectedMachineSessionBackgroundCommandWithMutation(
   db: Database,
   input: {
     accountId: string;
@@ -709,21 +780,25 @@ export async function settleConnectedMachineSessionBackgroundCommand(
     exitCode: number | null;
     reason: string;
   },
+  mutateTerminal: SessionBackgroundCommandTerminalMutation,
 ): Promise<SessionBackgroundCommand | null> {
-  return await withRlsContext(
+  const reason = boundedSessionBackgroundCommandReason(
+    input.reason,
+    "Connected command settlement reason",
+  );
+  if (input.outcome === "exited" && input.exitCode === null) {
+    throw new Error("Connected command exit settlement requires an exit code");
+  }
+  if (input.outcome === "lost" && input.exitCode !== null) {
+    throw new Error("Connected command loss settlement cannot carry an exit code");
+  }
+  return await withSessionActivityRlsContext(
     db,
     { accountId: input.accountId, workspaceId: input.workspaceId },
-    async (scopedDb) => {
+    async (tx) => {
+      await mutateTerminal.prepare(tx);
       const settledAt = new Date();
-      const reason = input.reason.trim().slice(0, 512);
-      if (!reason) throw new Error("Connected command settlement reason must not be empty");
-      if (input.outcome === "exited" && input.exitCode === null) {
-        throw new Error("Connected command exit settlement requires an exit code");
-      }
-      if (input.outcome === "lost" && input.exitCode !== null) {
-        throw new Error("Connected command loss settlement cannot carry an exit code");
-      }
-      const [row] = await scopedDb
+      const [row] = await tx
         .update(schema.sessionBackgroundCommands)
         .set({
           state: input.outcome,
@@ -753,6 +828,33 @@ export async function settleConnectedMachineSessionBackgroundCommand(
           ),
         )
         .returning();
+      if (!row) return null;
+      const command = mapCommand(row);
+      await mutateTerminal.commit(tx, command);
+      return command;
+    },
+  );
+}
+
+export async function getSessionBackgroundCommand(
+  db: Database,
+  input: { accountId: string; workspaceId: string; sessionId: string; commandId: string },
+): Promise<SessionBackgroundCommand | null> {
+  return await withRlsContext(
+    db,
+    { accountId: input.accountId, workspaceId: input.workspaceId },
+    async (scopedDb) => {
+      const [row] = await scopedDb
+        .select()
+        .from(schema.sessionBackgroundCommands)
+        .where(
+          and(
+            eq(schema.sessionBackgroundCommands.workspaceId, input.workspaceId),
+            eq(schema.sessionBackgroundCommands.sessionId, input.sessionId),
+            eq(schema.sessionBackgroundCommands.id, input.commandId),
+          ),
+        )
+        .limit(1);
       return row ? mapCommand(row) : null;
     },
   );

package/src/session-control.ts

@@ -244,11 +244,11 @@ export async function assertAgentCommandAuthorityInTransaction(
     workspaceId: string;
     actor: Extract<SessionCommandActor, { type: "agent_attempt" }>;
     targetSessionId: string;
-    action: "pause" | "resume" | "steer" | "message" | "goal";
+    action: "pause" | "resume" | "steer" | "message" | "goal" | "wait";
   },
 ): Promise<void> {
-  if (input.action === "goal" && input.targetSessionId !== input.actor.sessionId) {
-    throw new SessionControlInvariantError("An agent goal command must target its own session");
+  if (["goal", "wait"].includes(input.action) && input.targetSessionId !== input.actor.sessionId) {
+    throw new SessionControlInvariantError("An agent self command must target its own session");
   }
   // Every command caller establishes the control/workspace prefix first.
   // Reusing the event-write helper here keeps cross-session actor authority on
@@ -1855,13 +1855,13 @@ async function findCommandReceipt(
     targetSessionId: string | null;
     targetTurnId: string | null;
     operationKey: string;
-    identityScope: "actor" | "goal_operation";
+    identityScope: "actor" | "target_operation";
   },
 ): Promise<SessionCommandReceiptRow | null> {
   const actorSubjectId = input.actor.type === "agent_attempt" ? null : input.actor.subjectId;
   const actorAttemptId = input.actor.type === "agent_attempt" ? input.actor.attemptId : null;
   const identity =
-    input.identityScope === "goal_operation"
+    input.identityScope === "target_operation"
       ? and(
           eq(schema.sessionCommandReceipts.workspaceId, input.workspaceId),
           eq(schema.sessionCommandReceipts.actorType, "agent_attempt"),
@@ -1884,6 +1884,174 @@ async function findCommandReceipt(
   return rows[0] ?? null;
 }
 
+export type SessionPromptCommandAction = "prompt.send" | "prompt.steer";
+
+async function findPromptCommandReceipts(
+  db: Database,
+  input: {
+    workspaceId: string;
+    actor: SessionCommandActor;
+    operationKey: string;
+    lock?: "none" | "update";
+  },
+): Promise<SessionCommandReceiptRow[]> {
+  const actorSubjectId = input.actor.type === "agent_attempt" ? null : input.actor.subjectId;
+  const actorAttemptId = input.actor.type === "agent_attempt" ? input.actor.attemptId : null;
+  const query = db
+    .select()
+    .from(schema.sessionCommandReceipts)
+    .where(
+      and(
+        eq(schema.sessionCommandReceipts.workspaceId, input.workspaceId),
+        eq(schema.sessionCommandReceipts.actorType, input.actor.type),
+        sql`${schema.sessionCommandReceipts.actorSubjectId} is not distinct from ${actorSubjectId}`,
+        sql`${schema.sessionCommandReceipts.actorAttemptId} is not distinct from ${actorAttemptId}::uuid`,
+        inArray(schema.sessionCommandReceipts.action, ["prompt.send", "prompt.steer"]),
+        eq(schema.sessionCommandReceipts.operationKey, input.operationKey),
+      ),
+    );
+  const rows = input.lock === "update" ? await query.for("update") : await query;
+  return rows;
+}
+
+function fingerprintedPromptCommandReceipt(
+  receipts: readonly SessionCommandReceiptRow[],
+): SessionCommandReceiptRow | null {
+  const fingerprinted = receipts.filter(
+    (receipt) => typeof receipt.result.boundaryRequestHash === "string",
+  );
+  if (fingerprinted.length > 1) {
+    throw new SessionControlInvariantError(
+      "Prompt operation key resolved to multiple fingerprinted receipts",
+    );
+  }
+  return fingerprinted[0] ?? null;
+}
+
+function assertPromptCommandReceiptIdentity(
+  receipt: SessionCommandReceiptRow,
+  input: {
+    action: SessionPromptCommandAction;
+    targetSessionId: string;
+    boundaryRequestHash: string;
+  },
+): void {
+  if (
+    receipt.action !== input.action ||
+    receipt.targetSessionId !== input.targetSessionId ||
+    receipt.targetTurnId !== null ||
+    (typeof receipt.result.boundaryRequestHash === "string" &&
+      receipt.result.boundaryRequestHash !== input.boundaryRequestHash)
+  ) {
+    throw new SessionCommandIdempotencyError();
+  }
+}
+
+/**
+ * Prompt operation keys are actor-scoped across target sessions and across the
+ * Send/Steer action pair. The advisory lock closes the gap left by the legacy
+ * action/target-specific unique index without changing old receipt identities.
+ */
+export async function reserveSessionPromptCommandReceipt(
+  db: Database,
+  input: {
+    accountId: string;
+    workspaceId: string;
+    actor: SessionCommandActor;
+    action: SessionPromptCommandAction;
+    targetSessionId: string;
+    operationKey: string;
+    canonicalRequestHash: string;
+    boundaryRequestHash: string;
+  },
+): Promise<{ receipt: SessionCommandReceiptRow; replay: boolean }> {
+  await lockSessionPromptCommandOperation(db, input);
+  const existingReceipts = await findPromptCommandReceipts(db, {
+    workspaceId: input.workspaceId,
+    actor: input.actor,
+    operationKey: input.operationKey,
+    lock: "update",
+  });
+  const fingerprinted = fingerprintedPromptCommandReceipt(existingReceipts);
+  if (fingerprinted) {
+    assertPromptCommandReceiptIdentity(fingerprinted, input);
+    return { receipt: fingerprinted, replay: true };
+  }
+  const legacyExact = existingReceipts.find(
+    (receipt) =>
+      receipt.action === input.action &&
+      receipt.targetSessionId === input.targetSessionId &&
+      receipt.targetTurnId === null,
+  );
+  if (legacyExact) {
+    if (legacyExact.canonicalRequestHash !== input.canonicalRequestHash) {
+      throw new SessionCommandIdempotencyError();
+    }
+    return { receipt: legacyExact, replay: true };
+  }
+  return await reserveSessionCommandReceipt(db, {
+    accountId: input.accountId,
+    workspaceId: input.workspaceId,
+    actor: input.actor,
+    action: input.action,
+    targetSessionId: input.targetSessionId,
+    targetTurnId: null,
+    operationKey: input.operationKey,
+    canonicalRequestHash: input.canonicalRequestHash,
+    ...(existingReceipts.length === 0
+      ? { initialResult: { boundaryRequestHash: input.boundaryRequestHash } }
+      : {}),
+  });
+}
+
+/** Serialize one actor-scoped prompt operation before replay or reservation. */
+export async function lockSessionPromptCommandOperation(
+  db: Database,
+  input: {
+    workspaceId: string;
+    actor: SessionCommandActor;
+    operationKey: string;
+  },
+): Promise<void> {
+  const actorIdentity =
+    input.actor.type === "agent_attempt"
+      ? `attempt:${input.actor.attemptId}`
+      : `${input.actor.type}:${input.actor.subjectId}`;
+  await db.execute(
+    sql`select pg_advisory_xact_lock(hashtextextended(${`session-prompt:${input.workspaceId}:${actorIdentity}:${input.operationKey}`}, 0))`,
+  );
+}
+
+/** Return only a fully committed exact prompt receipt with the new boundary fingerprint. */
+export async function getCompletedSessionPromptCommandReceipt(
+  db: Database,
+  input: {
+    workspaceId: string;
+    actor: SessionCommandActor;
+    action: SessionPromptCommandAction;
+    targetSessionId: string;
+    operationKey: string;
+    boundaryRequestHash: string;
+  },
+): Promise<SessionCommandReceiptRow | null> {
+  const receipt = fingerprintedPromptCommandReceipt(
+    await findPromptCommandReceipts(db, {
+      workspaceId: input.workspaceId,
+      actor: input.actor,
+      operationKey: input.operationKey,
+    }),
+  );
+  if (!receipt) return null;
+  assertPromptCommandReceiptIdentity(receipt, input);
+  if (
+    typeof receipt.result.boundaryRequestHash !== "string" ||
+    receipt.appliedQueueVersion === null
+  ) {
+    return null;
+  }
+  return receipt;
+}
+
 export async function reserveSessionCommandReceipt(
   db: Database,
   input: {
@@ -1895,20 +2063,21 @@ export async function reserveSessionCommandReceipt(
     targetTurnId: string | null;
     operationKey: string;
     canonicalRequestHash: string;
-    identityScope?: "actor" | "goal_operation";
+    identityScope?: "actor" | "target_operation";
+    initialResult?: Record<string, unknown>;
   },
 ): Promise<{ receipt: SessionCommandReceiptRow; replay: boolean }> {
   if (!input.operationKey.trim()) throw new Error("operationKey must not be empty");
   const identityScope = input.identityScope ?? "actor";
   if (
-    identityScope === "goal_operation" &&
+    identityScope === "target_operation" &&
     (input.actor.type !== "agent_attempt" ||
-      !["goal.update", "goal.progress", "goal.wait"].includes(input.action) ||
+      !["goal.update", "goal.progress", "session.wait_for_input"].includes(input.action) ||
       input.targetSessionId === null ||
       input.targetTurnId !== null)
   ) {
     throw new SessionControlInvariantError(
-      "Target-scoped receipt identity is reserved for agent goal commands",
+      "Target-scoped receipt identity is reserved for agent self commands",
     );
   }
   const actorSubjectId = input.actor.type === "agent_attempt" ? null : input.actor.subjectId;
@@ -1926,6 +2095,7 @@ export async function reserveSessionCommandReceipt(
       targetTurnId: input.targetTurnId,
       operationKey: input.operationKey,
       canonicalRequestHash: input.canonicalRequestHash,
+      result: input.initialResult ?? {},
     })
     .onConflictDoNothing()
     .returning();
@@ -1990,13 +2160,12 @@ async function registerContinuableWakes(
       )
     ), upserted as (
       insert into ${schema.sessionWorkflowWakeOutbox} (
-        session_id, account_id, workspace_id, temporal_workflow_id, reason, control_revision
+        session_id, account_id, workspace_id, temporal_workflow_id, reason
       )
-      select session_id, account_id, workspace_id, temporal_workflow_id, ${input.reason}, 1
+      select session_id, account_id, workspace_id, temporal_workflow_id, ${input.reason}
       from eligible
       on conflict (session_id) do update set
         wake_revision = ${schema.sessionWorkflowWakeOutbox}.wake_revision + 1,
-        control_revision = ${schema.sessionWorkflowWakeOutbox}.wake_revision + 1,
         temporal_workflow_id = excluded.temporal_workflow_id,
         reason = excluded.reason,
         attempts = 0,

package/src/session-goal-pacing.ts

@@ -2,14 +2,10 @@ import { and, eq } from "drizzle-orm";
 import type { Database } from "./database";
 import * as schema from "./schema";
 
-/** Column reset shared by every goal head mutation that retires a `goal_wait` hold. */
-export const SESSION_GOAL_HOLD_CLEARED = {
-  continuationHoldTurnId: null,
-  continuationHoldUntil: null,
-  continuationHoldReason: null,
-  continuationHoldSetAt: null,
+/** Clear a terminal unchanged-input continuation fence after newer goal truth. */
+export const SESSION_GOAL_SUPPRESSION_CLEARED = {
+  continuationSuppressedTurnId: null,
 } as const;
-
 /** The pause reason written when a per-goal or deployment continuation ceiling is reached. */
 export const SESSION_GOAL_CAP_PAUSED_REASON = "max_auto_continuations";
 
@@ -103,7 +99,7 @@ export async function autoResumeGoalPausedByCapInTransaction(
       version: existing.version + 1,
       continuationWakeRevision: existing.continuationWakeRevision + 1,
       ...SESSION_GOAL_CONTINUATION_EPOCH_RESET,
-      ...SESSION_GOAL_HOLD_CLEARED,
+      ...SESSION_GOAL_SUPPRESSION_CLEARED,
       updatedAt: input.now,
     })
     .where(eq(schema.sessionGoals.id, existing.id))