@opengeni/core 0.28.1 → 1.0.0

package/src/application/session-commands.ts

@@ -16,12 +16,11 @@ import type {
   WorkspaceInferenceControlRequest,
   WorkspaceInferenceControlResponse,
 } from "@opengeni/contracts";
+import { DraftTimelineAnnotations } from "@opengeni/contracts";
+import type { Settings } from "@opengeni/config";
+import { HTTPException } from "hono/http-exception";
 import {
-  DraftTimelineAnnotations,
-  latencyModeForMetadata,
-  reasoningEffortForMetadata,
-} from "@opengeni/contracts";
-import {
+  checkWorkspaceAllowance,
   deleteSessionQueueItemInTransaction,
   editQueuedTurnInTransaction,
   getComposerDraftInTransaction,
@@ -29,9 +28,12 @@ import {
   getSessionEvent,
   getWorkspaceControlEvent,
   getSessionQueueSnapshot,
+  frozenInitiatorForCommandActor,
+  isCodexBilledTurn,
   moveQueuedTurnInTransaction,
   mutateSessionControlInTransaction,
   mutateWorkspaceControlInTransaction,
+  setWorkspacePauseTimerInTransaction,
   projectEffectiveControlForRelatedAccess,
   runIdempotentPersistenceTransaction,
   saveComposerDraftInTransaction,
@@ -39,6 +41,7 @@ import {
   serializeEffectiveSessionControl,
   steerAgentSessionInTransaction,
   steerQueuedTurnInTransaction,
+  workspaceControlRequestLockTimeoutMs,
   withWorkspaceRls,
   withWorkspaceSessionActivityRls,
   withWorkspaceSubjectRls,
@@ -55,6 +58,9 @@ import {
 import type { SessionWorkflowClient } from "../dependencies";
 import { normalizeResources } from "../domain/resources";
 import { validateDraftTimelineAnnotations } from "../domain/timeline-annotations";
+import { initiatingHumanForAllowance } from "../domain/sessions";
+import { modelFundingForAdmission } from "../billing/limits";
+import { resolveWorkspaceCatalogSettings } from "../model-catalog";
 import {
   requireSessionAuthorization,
   type ResolvedSessionAuthorization,
@@ -150,6 +156,51 @@ function agentActor(context: AgentSessionCommandContext) {
   };
 }
 
+/**
+ * Called inside the command's exact live-attempt fence, after receipt recovery
+ * but before any fresh work or Steer interruption. Attribution comes from the
+ * caller's accepted turn, never the target creator or request subject.
+ */
+async function assertFreshAgentCommandAllowance(
+  tx: SessionActivityDatabase,
+  deps: { settings?: Settings },
+  context: AgentSessionCommandContext,
+  targetSessionId: string,
+): Promise<void> {
+  const target = await getSession(tx, context.workspaceId, targetSessionId);
+  if (!target || target.accountId !== context.accountId) {
+    throw new HTTPException(404, { message: "Target session not found" });
+  }
+  if (deps.settings) {
+    const { settings } = await resolveWorkspaceCatalogSettings(tx, deps.settings, {
+      accountId: target.accountId,
+      workspaceId: context.workspaceId,
+      retainedProductModelId: target.model,
+    });
+    const codexBilled = await isCodexBilledTurn({
+      db: tx,
+      settings,
+      workspaceId: context.workspaceId,
+      model: target.model,
+    });
+    if (modelFundingForAdmission(settings, target.model, codexBilled).fundedWithoutCredits) {
+      return;
+    }
+  }
+  const frozen = await frozenInitiatorForCommandActor(tx, context.workspaceId, agentActor(context));
+  const refusal = await checkWorkspaceAllowance(tx, {
+    accountId: target.accountId,
+    workspaceId: context.workspaceId,
+    subjectId: initiatingHumanForAllowance(frozen),
+  });
+  if (refusal) {
+    throw new HTTPException(402, {
+      message: refusal.message,
+      cause: { allowed: false, ...refusal },
+    });
+  }
+}
+
 /**
  * Retry only one operation-keyed session command transaction. Callers keep
  * event publication and Temporal wake delivery after this returns, so a
@@ -185,18 +236,68 @@ async function runSessionCommandPersistenceTransaction<T>(
   );
 }
 
-async function publishAndWakeAgentCommand(
+type SessionCommandPostCommitDeps = {
+  /** Historical name; now schedules replayable follow-up for every interactive session command. */
+  schedulePromptPostCommit?: ((task: () => Promise<void>) => void) | undefined;
+};
+
+type SessionCommandPostCommitStep = {
+  kind: "session_event_fanout" | "workspace_control_fanout" | "workflow_wake";
+  run: () => Promise<void>;
+};
+
+/**
+ * A committed interactive command must never wait for ephemeral fanout or an
+ * immediate Temporal nudge. Durable events and wake outboxes are the recovery
+ * contract; these steps only reduce propagation latency.
+ */
+function scheduleSessionCommandPostCommit(
+  deps: SessionCommandPostCommitDeps,
+  operation: string,
+  steps: SessionCommandPostCommitStep[],
+): void {
+  const task = async () => {
+    await Promise.all(
+      steps.map(async (step) => {
+        try {
+          await step.run();
+        } catch {
+          console.warn("[session-commands] replayable post-commit step failed", {
+            errorClass: "SessionCommandPostCommitError",
+            errorCode: "session_command_post_commit_failed",
+            origin: "core",
+            operation,
+            step: step.kind,
+          });
+        }
+      }),
+    );
+  };
+  try {
+    const schedule =
+      deps.schedulePromptPostCommit ??
+      ((pending: () => Promise<void>) => {
+        void pending();
+      });
+    schedule(task);
+  } catch {
+    console.warn("[session-commands] post-commit scheduling failed", {
+      errorClass: "SessionCommandPostCommitScheduleError",
+      errorCode: "session_command_post_commit_schedule_failed",
+      origin: "core",
+      operation,
+    });
+  }
+}
+
+async function wakeSessionCommand(
   deps: {
-    db: Database;
-    bus: EventBus;
     workflowClient: Pick<SessionWorkflowClient, "wakeSessionWorkflow">;
-    sessionAuthorization?: SessionAuthorizationPort | null;
   },
   input: {
     accountId: string;
     workspaceId: string;
     sessionId: string;
-    eventIds: string[];
     workflowId: string;
     wakeRevision: number | null;
     shouldSignal: boolean;
@@ -204,7 +305,6 @@ async function publishAndWakeAgentCommand(
     controlRequested?: boolean;
   },
 ): Promise<void> {
-  await publishSessionEventIds(deps, input.workspaceId, input.sessionId, input.eventIds);
   if (!input.shouldSignal || input.wakeRevision === null) return;
   try {
     await deps.workflowClient.wakeSessionWorkflow({
@@ -218,14 +318,11 @@ async function publishAndWakeAgentCommand(
         : {}),
     });
   } catch {
-    console.warn(
-      "[session-commands] immediate Agent command wake failed; durable outbox will retry",
-      {
-        errorClass: "WorkflowWakeOperationError",
-        errorCode: "agent_command_wake_failed",
-        origin: "core",
-      },
-    );
+    console.warn("[session-commands] immediate command wake failed; durable outbox will retry", {
+      errorClass: "WorkflowWakeOperationError",
+      errorCode: "session_command_wake_failed",
+      origin: "core",
+    });
   }
 }
 
@@ -290,10 +387,11 @@ async function publishWorkspaceControlEvent(
 export async function sendAgentSessionMessage(
   deps: {
     db: Database;
+    settings?: Settings;
     bus: EventBus;
     workflowClient: Pick<SessionWorkflowClient, "wakeSessionWorkflow">;
     sessionAuthorization?: SessionAuthorizationPort | null;
-  },
+  } & SessionCommandPostCommitDeps,
   context: AgentSessionCommandContext,
   input: { targetSessionId: string; text: string; idempotencyKey: string },
 ) {
@@ -312,30 +410,57 @@ export async function sendAgentSessionMessage(
           actor: agentActor(context),
           operationKey: input.idempotencyKey,
           text: input.text,
+          assertFreshAdmission: (scoped) =>
+            assertFreshAgentCommandAllowance(scoped, deps, context, input.targetSessionId),
+          controlLockTimeoutMs: workspaceControlRequestLockTimeoutMs(),
         }),
     },
   );
-  await publishAndWakeAgentCommand(deps, {
-    accountId: context.accountId,
-    workspaceId: context.workspaceId,
-    sessionId: input.targetSessionId,
-    eventIds: result.eventIds,
-    workflowId: result.workflowId,
-    wakeRevision: result.wakeRevision,
-    shouldSignal: result.shouldSignal,
-    interruptionCount: 0,
-  });
-  await publishWorkspaceControlEvent(deps, context.workspaceId, result.workspaceControlEventId);
+  scheduleSessionCommandPostCommit(deps, "agent_message", [
+    {
+      kind: "session_event_fanout",
+      run: async () =>
+        await publishSessionEventIds(
+          deps,
+          context.workspaceId,
+          input.targetSessionId,
+          result.eventIds,
+        ),
+    },
+    {
+      kind: "workspace_control_fanout",
+      run: async () =>
+        await publishWorkspaceControlEvent(
+          deps,
+          context.workspaceId,
+          result.workspaceControlEventId,
+        ),
+    },
+    {
+      kind: "workflow_wake",
+      run: async () =>
+        await wakeSessionCommand(deps, {
+          accountId: context.accountId,
+          workspaceId: context.workspaceId,
+          sessionId: input.targetSessionId,
+          workflowId: result.workflowId,
+          wakeRevision: result.wakeRevision,
+          shouldSignal: result.shouldSignal,
+          interruptionCount: 0,
+        }),
+    },
+  ]);
   return result;
 }
 
 export async function steerAgentSession(
   deps: {
     db: Database;
+    settings?: Settings;
     bus: EventBus;
     workflowClient: Pick<SessionWorkflowClient, "wakeSessionWorkflow">;
     sessionAuthorization?: SessionAuthorizationPort | null;
-  },
+  } & SessionCommandPostCommitDeps,
   context: AgentSessionCommandContext,
   input: {
     targetSessionId: string;
@@ -358,21 +483,47 @@ export async function steerAgentSession(
           actor: agentActor(context),
           operationKey: input.idempotencyKey,
           instruction: input.instruction,
+          assertFreshAdmission: (scoped) =>
+            assertFreshAgentCommandAllowance(scoped, deps, context, input.targetSessionId),
+          controlLockTimeoutMs: workspaceControlRequestLockTimeoutMs(),
         }),
     },
   );
-  await publishAndWakeAgentCommand(deps, {
-    accountId: context.accountId,
-    workspaceId: context.workspaceId,
-    sessionId: input.targetSessionId,
-    eventIds: result.eventIds,
-    workflowId: result.workflowId,
-    wakeRevision: result.wakeRevision,
-    shouldSignal: result.shouldSignal,
-    interruptionCount: result.interruptionCount,
-    controlRequested: true,
-  });
-  await publishWorkspaceControlEvent(deps, context.workspaceId, result.workspaceControlEventId);
+  scheduleSessionCommandPostCommit(deps, "agent_steer", [
+    {
+      kind: "session_event_fanout",
+      run: async () =>
+        await publishSessionEventIds(
+          deps,
+          context.workspaceId,
+          input.targetSessionId,
+          result.eventIds,
+        ),
+    },
+    {
+      kind: "workspace_control_fanout",
+      run: async () =>
+        await publishWorkspaceControlEvent(
+          deps,
+          context.workspaceId,
+          result.workspaceControlEventId,
+        ),
+    },
+    {
+      kind: "workflow_wake",
+      run: async () =>
+        await wakeSessionCommand(deps, {
+          accountId: context.accountId,
+          workspaceId: context.workspaceId,
+          sessionId: input.targetSessionId,
+          workflowId: result.workflowId,
+          wakeRevision: result.wakeRevision,
+          shouldSignal: result.shouldSignal,
+          interruptionCount: result.interruptionCount,
+          controlRequested: true,
+        }),
+    },
+  ]);
   return result;
 }
 
@@ -380,9 +531,12 @@ export async function controlAgentSessionWorkstream(
   deps: {
     db: Database;
     bus: EventBus;
-    workflowClient: Pick<SessionWorkflowClient, "requestSessionWorkflowWakeDispatch">;
+    workflowClient: Pick<
+      SessionWorkflowClient,
+      "requestSessionWorkflowWakeDispatch" | "wakeSessionWorkflow"
+    >;
     sessionAuthorization?: SessionAuthorizationPort | null;
-  },
+  } & SessionCommandPostCommitDeps,
   context: AgentSessionCommandContext,
   input: {
     targetSessionId: string;
@@ -412,14 +566,60 @@ export async function controlAgentSessionWorkstream(
           operationKey: input.idempotencyKey,
           action: input.action,
           reason: input.reason ?? null,
+          controlLockTimeoutMs: workspaceControlRequestLockTimeoutMs(),
         }),
     },
   );
-  await publishSessionEventIds(deps, context.workspaceId, input.targetSessionId, [
-    result.sessionControlEventId,
+  scheduleSessionCommandPostCommit(deps, "agent_control", [
+    ...(result.sessionControlEventId
+      ? [
+          {
+            kind: "session_event_fanout" as const,
+            run: async () =>
+              await publishSessionEventIds(deps, context.workspaceId, input.targetSessionId, [
+                result.sessionControlEventId!,
+              ]),
+          },
+        ]
+      : []),
+    ...(result.workspaceControlEventId
+      ? [
+          {
+            kind: "workspace_control_fanout" as const,
+            run: async () =>
+              await publishWorkspaceControlEvent(
+                deps,
+                context.workspaceId,
+                result.workspaceControlEventId!,
+              ),
+          },
+        ]
+      : []),
+    ...(result.wakeCount > 0
+      ? [
+          {
+            kind: "workflow_wake" as const,
+            run: async () => await requestControlWakeDispatch(deps, result.wakeCount),
+          },
+        ]
+      : []),
+    {
+      kind: "workflow_wake",
+      run: async () => {
+        if (!result.workflowWake) return;
+        await wakeSessionCommand(deps, {
+          accountId: result.workflowWake.accountId,
+          workspaceId: result.workflowWake.workspaceId,
+          sessionId: result.workflowWake.sessionId,
+          workflowId: result.workflowWake.temporalWorkflowId,
+          wakeRevision: result.workflowWake.wakeRevision,
+          shouldSignal: true,
+          interruptionCount: result.interruptionCount,
+          controlRequested: input.action === "pause",
+        });
+      },
+    },
   ]);
-  await publishWorkspaceControlEvent(deps, context.workspaceId, result.workspaceControlEventId);
-  await requestControlWakeDispatch(deps, result.wakeCount);
   return { ...result, authorization };
 }
 
@@ -479,7 +679,7 @@ export async function moveHumanQueuePrompt(
     db: Database;
     bus: EventBus;
     sessionAuthorization?: SessionAuthorizationPort | null;
-  },
+  } & SessionCommandPostCommitDeps,
   context: HumanSessionCommandContext,
   turnId: string,
   input: MoveSessionQueueItemRequest,
@@ -499,6 +699,7 @@ export async function moveHumanQueuePrompt(
           expectedQueueVersion: input.expectedQueueVersion,
           actor: { type: "human", subjectId: context.subjectId },
           operationKey: input.clientEventId,
+          controlLockTimeoutMs: workspaceControlRequestLockTimeoutMs(),
         }),
     },
   );
@@ -511,7 +712,13 @@ export async function moveHumanQueuePrompt(
       authorization?.relatedSessionAccess ?? "root",
     ),
   };
-  await publishSessionEventIds(deps, context.workspaceId, context.sessionId, result.eventIds);
+  scheduleSessionCommandPostCommit(deps, "human_queue_move", [
+    {
+      kind: "session_event_fanout",
+      run: async () =>
+        await publishSessionEventIds(deps, context.workspaceId, context.sessionId, result.eventIds),
+    },
+  ]);
   return response;
 }
 
@@ -520,7 +727,7 @@ export async function deleteHumanQueuePrompt(
     db: Database;
     bus: EventBus;
     sessionAuthorization?: SessionAuthorizationPort | null;
-  },
+  } & SessionCommandPostCommitDeps,
   context: HumanSessionCommandContext,
   turnId: string,
   input: DeleteSessionQueueItemRequest,
@@ -540,6 +747,7 @@ export async function deleteHumanQueuePrompt(
           actor: { type: "human", subjectId: context.subjectId },
           operationKey: input.clientEventId,
           reason: input.reason ?? null,
+          controlLockTimeoutMs: workspaceControlRequestLockTimeoutMs(),
         }),
     },
   );
@@ -552,7 +760,13 @@ export async function deleteHumanQueuePrompt(
       authorization?.relatedSessionAccess ?? "root",
     ),
   };
-  await publishSessionEventIds(deps, context.workspaceId, context.sessionId, result.eventIds);
+  scheduleSessionCommandPostCommit(deps, "human_queue_delete", [
+    {
+      kind: "session_event_fanout",
+      run: async () =>
+        await publishSessionEventIds(deps, context.workspaceId, context.sessionId, result.eventIds),
+    },
+  ]);
   return response;
 }
 
@@ -561,7 +775,7 @@ export async function editHumanQueuePrompt(
     db: Database;
     bus: EventBus;
     sessionAuthorization?: SessionAuthorizationPort | null;
-  },
+  } & SessionCommandPostCommitDeps,
   context: HumanSessionCommandContext,
   turnId: string,
   input: EditSessionQueueItemRequest,
@@ -582,6 +796,7 @@ export async function editHumanQueuePrompt(
           replaceDraft: input.replaceDraft,
           actor: { type: "human", subjectId: context.subjectId },
           operationKey: input.clientEventId,
+          controlLockTimeoutMs: workspaceControlRequestLockTimeoutMs(),
         }),
     },
   );
@@ -595,7 +810,13 @@ export async function editHumanQueuePrompt(
     ),
     draft: composerDraft(result.draft)!,
   };
-  await publishSessionEventIds(deps, context.workspaceId, context.sessionId, result.eventIds);
+  scheduleSessionCommandPostCommit(deps, "human_queue_edit", [
+    {
+      kind: "session_event_fanout",
+      run: async () =>
+        await publishSessionEventIds(deps, context.workspaceId, context.sessionId, result.eventIds),
+    },
+  ]);
   return response;
 }
 
@@ -603,8 +824,9 @@ export async function steerHumanQueuePrompt(
   deps: {
     db: Database;
     bus: EventBus;
+    workflowClient: Pick<SessionWorkflowClient, "wakeSessionWorkflow">;
     sessionAuthorization?: SessionAuthorizationPort | null;
-  },
+  } & SessionCommandPostCommitDeps,
   context: HumanSessionCommandContext,
   turnId: string,
   input: SteerSessionQueueItemRequest,
@@ -624,6 +846,7 @@ export async function steerHumanQueuePrompt(
           controlEtag: input.controlEtag ?? null,
           actor: { type: "human", subjectId: context.subjectId },
           operationKey: input.clientEventId,
+          controlLockTimeoutMs: workspaceControlRequestLockTimeoutMs(),
         }),
     },
   );
@@ -636,8 +859,36 @@ export async function steerHumanQueuePrompt(
       authorization?.relatedSessionAccess ?? "root",
     ),
   };
-  await publishSessionEventIds(deps, context.workspaceId, context.sessionId, result.eventIds);
-  await publishWorkspaceControlEvent(deps, context.workspaceId, result.workspaceControlEventId);
+  scheduleSessionCommandPostCommit(deps, "human_queue_steer", [
+    {
+      kind: "session_event_fanout",
+      run: async () =>
+        await publishSessionEventIds(deps, context.workspaceId, context.sessionId, result.eventIds),
+    },
+    {
+      kind: "workspace_control_fanout",
+      run: async () =>
+        await publishWorkspaceControlEvent(
+          deps,
+          context.workspaceId,
+          result.workspaceControlEventId,
+        ),
+    },
+    {
+      kind: "workflow_wake",
+      run: async () =>
+        await wakeSessionCommand(deps, {
+          accountId: context.accountId,
+          workspaceId: context.workspaceId,
+          sessionId: context.sessionId,
+          workflowId: result.workflowId,
+          wakeRevision: result.wakeRevision,
+          shouldSignal: true,
+          interruptionCount: result.interruptionCount,
+          controlRequested: true,
+        }),
+    },
+  ]);
   return response;
 }
 
@@ -645,12 +896,19 @@ export async function controlHumanSessionWorkstreamWithOutcome(
   deps: {
     db: Database;
     bus: EventBus;
-    workflowClient: Pick<SessionWorkflowClient, "requestSessionWorkflowWakeDispatch">;
+    workflowClient: Pick<
+      SessionWorkflowClient,
+      "requestSessionWorkflowWakeDispatch" | "wakeSessionWorkflow"
+    >;
     sessionAuthorization?: SessionAuthorizationPort | null;
-  },
+  } & SessionCommandPostCommitDeps,
   context: HumanSessionCommandContext,
   input: SessionControlRequest,
-): Promise<{ response: SessionControlResponse; replay: boolean }> {
+): Promise<{
+  response: SessionControlResponse;
+  outcome: "changed" | "unchanged" | "replayed";
+  replay: boolean;
+}> {
   const authorization = await authorizeHumanSessionCommand(deps, context, "session.control");
   const result = await runSessionCommandPersistenceTransaction(
     deps,
@@ -670,6 +928,7 @@ export async function controlHumanSessionWorkstreamWithOutcome(
           action: input.action,
           reason: input.reason ?? null,
           expectedControlEtag: input.expectedControlEtag ?? null,
+          controlLockTimeoutMs: workspaceControlRequestLockTimeoutMs(),
         }),
     },
   );
@@ -685,12 +944,56 @@ export async function controlHumanSessionWorkstreamWithOutcome(
     cancelledSessionCount: result.cancelledSessionCount,
     cancelledTurnCount: result.cancelledTurnCount,
   };
-  for (const affected of result.affectedSessionEvents) {
-    await publishSessionEventIds(deps, context.workspaceId, affected.sessionId, affected.eventIds);
-  }
-  await publishWorkspaceControlEvent(deps, context.workspaceId, result.workspaceControlEventId);
-  await requestControlWakeDispatch(deps, result.wakeCount);
-  return { response, replay: result.replay };
+  scheduleSessionCommandPostCommit(deps, "human_control", [
+    ...result.affectedSessionEvents.map((affected) => ({
+      kind: "session_event_fanout" as const,
+      run: async () =>
+        await publishSessionEventIds(
+          deps,
+          context.workspaceId,
+          affected.sessionId,
+          affected.eventIds,
+        ),
+    })),
+    ...(result.workspaceControlEventId
+      ? [
+          {
+            kind: "workspace_control_fanout" as const,
+            run: async () =>
+              await publishWorkspaceControlEvent(
+                deps,
+                context.workspaceId,
+                result.workspaceControlEventId!,
+              ),
+          },
+        ]
+      : []),
+    ...(result.wakeCount > 0
+      ? [
+          {
+            kind: "workflow_wake" as const,
+            run: async () => await requestControlWakeDispatch(deps, result.wakeCount),
+          },
+        ]
+      : []),
+    {
+      kind: "workflow_wake",
+      run: async () => {
+        if (!result.workflowWake) return;
+        await wakeSessionCommand(deps, {
+          accountId: result.workflowWake.accountId,
+          workspaceId: result.workflowWake.workspaceId,
+          sessionId: result.workflowWake.sessionId,
+          workflowId: result.workflowWake.temporalWorkflowId,
+          wakeRevision: result.workflowWake.wakeRevision,
+          shouldSignal: true,
+          interruptionCount: result.interruptionCount,
+          controlRequested: input.action === "pause",
+        });
+      },
+    },
+  ]);
+  return { response, outcome: result.outcome, replay: result.replay };
 }
 
 /** Backward-compatible response path used by the REST control route. */
@@ -707,7 +1010,7 @@ export async function controlHumanWorkspace(
     db: Database;
     bus: EventBus;
     workflowClient: Pick<SessionWorkflowClient, "requestSessionWorkflowWakeDispatch">;
-  },
+  } & SessionCommandPostCommitDeps,
   context: Omit<HumanSessionCommandContext, "sessionId">,
   input: WorkspaceInferenceControlRequest,
 ): Promise<WorkspaceInferenceControlResponse> {
@@ -721,6 +1024,7 @@ export async function controlHumanWorkspace(
         action: input.action,
         reason: input.reason ?? null,
         expectedRevision: input.expectedRevision ?? null,
+        controlLockTimeoutMs: workspaceControlRequestLockTimeoutMs(),
       }),
     ),
   );
@@ -731,8 +1035,29 @@ export async function controlHumanWorkspace(
     interruptionCount: result.interruptionCount,
     wakeCount: result.wakeCount,
   };
-  await publishWorkspaceControlEvent(deps, context.workspaceId, result.workspaceControlEventId);
-  await requestControlWakeDispatch(deps, result.wakeCount);
+  scheduleSessionCommandPostCommit(deps, "human_workspace_control", [
+    ...(result.workspaceControlEventId
+      ? [
+          {
+            kind: "workspace_control_fanout" as const,
+            run: async () =>
+              await publishWorkspaceControlEvent(
+                deps,
+                context.workspaceId,
+                result.workspaceControlEventId!,
+              ),
+          },
+        ]
+      : []),
+    ...(result.wakeCount > 0
+      ? [
+          {
+            kind: "workflow_wake" as const,
+            run: async () => await requestControlWakeDispatch(deps, result.wakeCount),
+          },
+        ]
+      : []),
+  ]);
   return response;
 }
 
@@ -762,8 +1087,8 @@ export async function getHumanComposerDraft(
     annotations: [],
     resources: [],
     model: session.model,
-    reasoningEffort: reasoningEffortForMetadata(session.metadata, "medium"),
-    latencyMode: latencyModeForMetadata(session.metadata, "standard"),
+    reasoningEffort: session.reasoningEffort,
+    latencyMode: session.latencyMode,
     sourceTurnId: null,
     sourceTurnVersion: null,
     updatedAt: null,
@@ -794,8 +1119,40 @@ export async function saveHumanComposerDraft(
           annotations,
           resources: normalizeResources(input.resources),
           subjectId: context.subjectId,
+          controlLockTimeoutMs: workspaceControlRequestLockTimeoutMs(),
         }),
       ),
   );
   return composerDraft(row)!;
 }
+
+export async function controlHumanWorkspaceTimer(
+  deps: Parameters<typeof controlHumanWorkspace>[0],
+  context: Parameters<typeof controlHumanWorkspace>[1],
+  input: import("@opengeni/contracts").WorkspacePauseTimerRequest,
+): Promise<void> {
+  const result = await withWorkspaceRls(deps.db, context.workspaceId, (scoped) =>
+    scoped.transaction((tx) =>
+      setWorkspacePauseTimerInTransaction(tx as unknown as Database, {
+        ...input,
+        ...context,
+      }),
+    ),
+  );
+  scheduleSessionCommandPostCommit(deps, "human_workspace_timer", [
+    ...(result.workspaceControlEventId
+      ? [
+          {
+            kind: "workspace_control_fanout" as const,
+            run: async () =>
+              await publishWorkspaceControlEvent(
+                deps,
+                context.workspaceId,
+                result.workspaceControlEventId!,
+              ),
+          },
+        ]
+      : []),
+    { kind: "workflow_wake" as const, run: async () => await requestControlWakeDispatch(deps, 1) },
+  ]);
+}