@opengeni/core 0.21.10 → 0.24.1

package/dist/managed-session.d.ts

@@ -1,5 +1,5 @@
 import type { Context } from "hono";
-import type { ManagedAuth } from "./managed-auth-type";
+import type { ManagedAuth } from "./managed-auth-type.js";
 /**
  * Read a Better Auth session without bypassing its sliding-cookie renewal.
  *

package/dist/rigs/index.d.ts

@@ -1,5 +1,6 @@
 import type { AccessGrant, CreateRigRequest, RigDefinitionEditPayload, ProposeRigChangeRequest, Rig, RigChange, RigVersion, UpdateRigRequest } from "@opengeni/contracts";
 import { type Database } from "@opengeni/db";
+export * from "./provider-images.js";
 export declare const MAX_RIGS_PER_WORKSPACE = 50;
 export declare const MAX_CHECKS_PER_RIG = 100;
 export declare const MAX_CREDENTIAL_HOOKS_PER_RIG = 50;
@@ -54,4 +55,3 @@ export declare function createRigVersionForApi(deps: RigServices, grant: AccessG
 export declare function activateRigVersionForApi(deps: RigServices, grant: AccessGrant, rig: Rig, versionId: string): Promise<RigVersion>;
 export declare function listRigVersionsForApi(deps: RigServices, workspaceId: string, rigId: string): Promise<RigVersion[]>;
 export declare function listRigChangesForApi(deps: RigServices, workspaceId: string, rigId: string, limit?: number): Promise<RigChange[]>;
-export {};

package/dist/rigs/provider-images.d.ts

@@ -0,0 +1,31 @@
+import { type RigChangeVerification, type RigProviderImage, type RigProviderImages, type RigVersion, type SandboxBackend } from "@opengeni/contracts";
+export type RigProviderImageDefinition = Pick<RigVersion, "image" | "setupScript" | "checks" | "credentialHooks" | "defaultVariableSetIds">;
+export declare function rigProviderImageProviderBindingKeyHash(bindingKey: string): string;
+export declare function rigProviderImageSetupHash(definition: Pick<RigProviderImageDefinition, "setupScript">): string;
+/**
+ * Hash every exact rig-definition input that can affect whether a provider
+ * image may be reused. Credential values and variable-set contents are
+ * intentionally absent: verification never injects them into the build box.
+ * Their declared hook/set identities still participate so a new rig version
+ * cannot silently inherit an older build record.
+ */
+export declare function rigProviderImageContentHash(input: {
+    backend: SandboxBackend;
+    sourceImage: string | null;
+    definition: RigProviderImageDefinition;
+}): string;
+/** Modal's patched snapshot API accepts a caller-owned UUID idempotency key.
+ * v2 denotes images proven by a separate cold boot before publication. */
+export declare function rigProviderImageBuildRequestId(input: {
+    targetId: string;
+    backend: SandboxBackend;
+    contentHash: string;
+}): string;
+export declare function rigProviderImageMatchesDefinition(image: RigProviderImage, definition: RigProviderImageDefinition): boolean;
+/**
+ * Promotion copies only a finalized, structurally valid build record whose
+ * hashes match the exact version definition being inserted. A malformed or
+ * stale optimization record is discarded; the version remains correct and
+ * falls back to runtime setup.
+ */
+export declare function rigProviderImagesFromVerification(verification: RigChangeVerification | null, definition: RigProviderImageDefinition): RigProviderImages;

package/dist/sandbox/routing.d.ts

@@ -7,6 +7,7 @@ export type ChannelARoutingServices = {
     settings: Settings;
     bus?: EventBus;
     onSandboxOperation?: RoutingSandboxOperationObserver;
+    waitSignal?: AbortSignal;
 };
 /** Map the deployment relay URL to the leaf's `SelfhostedRelayConfig` shape. The
  *  relay URL (`OPENGENI_SELFHOSTED_RELAY_URL`) may carry a path (the relay's wss

package/dist/session-authorization.d.ts

@@ -1,6 +1,6 @@
 import { SessionAuthorizationActor, SessionAuthorizationListScope, type AccessGrant, type SessionAuthorizationOperation, type SessionAuthorizationSurface, type SessionAuthorizationTarget } from "@opengeni/contracts";
 import { type Database } from "@opengeni/db";
-import type { AppDependencies } from "./dependencies";
+import type { AppDependencies } from "./dependencies.js";
 export type SessionAuthorizationDependencies = Pick<AppDependencies, "db" | "sessionAuthorization">;
 /** Maximum time an omitted host hint leaves a live session stream unchecked. */
 export declare const SESSION_AUTHORIZATION_DEFAULT_REAUTHORIZE_MS = 15000;

package/dist/workflow-wake-contract.d.ts

@@ -2,3 +2,10 @@
 export declare const SESSION_WORKFLOW_WAKE_DISPATCHER_SCHEDULE_ID = "opengeni-session-workflow-wake-dispatcher";
 export declare const SESSION_WORKFLOW_WAKE_DISPATCHER_WORKFLOW_TYPE = "sessionWorkflowWakeDispatcherWorkflow";
 export declare const SESSION_WORKFLOW_WAKE_DISPATCHER_PERIOD_MS = 10000;
+/**
+ * Temporal delivers activity cancellation through heartbeats. Keep both the
+ * activity's local heartbeat timer and the worker's SDK throttle at this bound
+ * so the end-to-end Pause/Steer physical-cancellation contract is not already
+ * exhausted before sandbox/tool quiescence and replacement admission begin.
+ */
+export declare const TURN_ACTIVITY_CANCELLATION_HEARTBEAT_INTERVAL_MS = 500;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/core",
-  "version": "0.21.10",
+  "version": "0.24.1",
   "description": "OpenGeni framework-agnostic core: the domain, access, and billing layers (neutral access, off-HTTP V2 surface). Behavior-preserving extraction from apps/api — keeps Hono's HTTPException for error throwing (typed-errors cleanup deferred).",
   "license": "Apache-2.0",
   "repository": {
@@ -21,6 +21,14 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./editable-artifacts": {
+      "types": "./dist/editable-artifacts.d.ts",
+      "import": "./dist/editable-artifacts.js"
+    },
+    "./editable-artifact-live": {
+      "types": "./dist/editable-artifact-live.d.ts",
+      "import": "./dist/editable-artifact-live.js"
     }
   },
   "publishConfig": {
@@ -34,15 +42,15 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@opengeni/codex": "^0.2.13",
-    "@opengeni/config": "^0.12.1",
-    "@opengeni/contracts": "^0.40.0",
-    "@opengeni/db": "^0.28.9",
-    "@opengeni/documents": "^0.5.18",
-    "@opengeni/events": "^0.3.88",
-    "@opengeni/observability": "^0.5.6",
-    "@opengeni/runtime": "^0.18.24",
-    "@opengeni/storage": "^0.2.75",
+    "@opengeni/codex": "^0.2.15",
+    "@opengeni/config": "^0.13.2",
+    "@opengeni/contracts": "^0.44.1",
+    "@opengeni/db": "^0.31.1",
+    "@opengeni/documents": "^0.5.32",
+    "@opengeni/events": "^0.3.103",
+    "@opengeni/observability": "^0.6.2",
+    "@opengeni/runtime": "^0.19.2",
+    "@opengeni/storage": "^0.2.87",
     "hono": "^4.12.18"
   },
   "engines": {

package/src/application/new-session-drafts.ts

@@ -67,6 +67,7 @@ async function hydrateNewSessionDraft(
     deps.db,
     workspaceId,
     deps.settings,
+    { subjectId: grant.subjectId },
   );
   const resources = [] as NewSessionDraftValue["resources"];
   for (const resource of mapped.resources) {
@@ -200,6 +201,7 @@ export async function saveActorNewSessionDraft(
     deps.db,
     workspaceId,
     deps.settings,
+    { subjectId: grant.subjectId },
   );
   const resources = normalizeResources(input.resources);
   const tools = toolsProvided ? validateToolRefs(input.tools, runtimeSettings) : [];

package/src/application/session-commands.ts

@@ -16,7 +16,11 @@ import type {
   WorkspaceInferenceControlRequest,
   WorkspaceInferenceControlResponse,
 } from "@opengeni/contracts";
-import { latencyModeForMetadata, reasoningEffortForMetadata } from "@opengeni/contracts";
+import {
+  DraftTimelineAnnotations,
+  latencyModeForMetadata,
+  reasoningEffortForMetadata,
+} from "@opengeni/contracts";
 import {
   deleteSessionQueueItemInTransaction,
   editQueuedTurnInTransaction,
@@ -36,8 +40,11 @@ import {
   steerAgentSessionInTransaction,
   steerQueuedTurnInTransaction,
   withWorkspaceRls,
+  withWorkspaceSessionActivityRls,
   withWorkspaceSubjectRls,
+  withWorkspaceSubjectSessionActivityRls,
   type Database,
+  type SessionActivityDatabase,
   type SessionCommandReceiptRow,
 } from "@opengeni/db";
 import {
@@ -47,6 +54,7 @@ import {
 } from "@opengeni/events";
 import type { SessionWorkflowClient } from "../dependencies";
 import { normalizeResources } from "../domain/resources";
+import { validateDraftTimelineAnnotations } from "../domain/timeline-annotations";
 import {
   requireSessionAuthorization,
   type ResolvedSessionAuthorization,
@@ -143,17 +151,18 @@ function agentActor(context: AgentSessionCommandContext) {
 }
 
 /**
- * Retry only one operation-keyed Agent command transaction. The caller keeps
+ * Retry only one operation-keyed session command transaction. Callers keep
  * event publication and Temporal wake delivery after this returns, so a
- * deadlock/serialization retry can never replay an external effect.
+ * deadlock/serialization retry can never replay an external effect. Human
+ * draft ownership is applied inside every retry attempt when required.
  */
-async function runAgentCommandPersistenceTransaction<T>(
+async function runSessionCommandPersistenceTransaction<T>(
   deps: { db: Database },
-  context: AgentSessionCommandContext,
+  scope: { workspaceId: string; subjectId?: string },
   input: {
     stage: string;
     eventTypes: string[];
-    transaction: (tx: Database) => Promise<T>;
+    transaction: (tx: SessionActivityDatabase) => Promise<T>;
   },
 ): Promise<T> {
   return await runIdempotentPersistenceTransaction(
@@ -162,10 +171,17 @@ async function runAgentCommandPersistenceTransaction<T>(
       eventTypes: input.eventTypes,
       maxAttempts: 3,
     },
-    async () =>
-      await withWorkspaceRls(deps.db, context.workspaceId, async (scoped) =>
-        scoped.transaction(async (tx) => await input.transaction(tx as unknown as Database)),
-      ),
+    async () => {
+      const run = async (scoped: SessionActivityDatabase) => await input.transaction(scoped);
+      return scope.subjectId === undefined
+        ? await withWorkspaceSessionActivityRls(deps.db, scope.workspaceId, run)
+        : await withWorkspaceSubjectSessionActivityRls(
+            deps.db,
+            scope.workspaceId,
+            scope.subjectId,
+            run,
+          );
+    },
   );
 }
 
@@ -282,19 +298,23 @@ export async function sendAgentSessionMessage(
   input: { targetSessionId: string; text: string; idempotencyKey: string },
 ) {
   await authorizeAgentSessionCommand(deps, context, input.targetSessionId, "session.append");
-  const result = await runAgentCommandPersistenceTransaction(deps, context, {
-    stage: "session_commands.agent_message",
-    eventTypes: ["system.update.pending"],
-    transaction: async (tx) =>
-      await sendAgentMessageInTransaction(tx, {
-        accountId: context.accountId,
-        workspaceId: context.workspaceId,
-        targetSessionId: input.targetSessionId,
-        actor: agentActor(context),
-        operationKey: input.idempotencyKey,
-        text: input.text,
-      }),
-  });
+  const result = await runSessionCommandPersistenceTransaction(
+    deps,
+    { workspaceId: context.workspaceId },
+    {
+      stage: "session_commands.agent_message",
+      eventTypes: ["system.update.pending"],
+      transaction: async (tx) =>
+        await sendAgentMessageInTransaction(tx, {
+          accountId: context.accountId,
+          workspaceId: context.workspaceId,
+          targetSessionId: input.targetSessionId,
+          actor: agentActor(context),
+          operationKey: input.idempotencyKey,
+          text: input.text,
+        }),
+    },
+  );
   await publishAndWakeAgentCommand(deps, {
     accountId: context.accountId,
     workspaceId: context.workspaceId,
@@ -317,22 +337,30 @@ export async function steerAgentSession(
     sessionAuthorization?: SessionAuthorizationPort | null;
   },
   context: AgentSessionCommandContext,
-  input: { targetSessionId: string; instruction: string; idempotencyKey: string },
+  input: {
+    targetSessionId: string;
+    instruction: string;
+    idempotencyKey: string;
+  },
 ) {
   await authorizeAgentSessionCommand(deps, context, input.targetSessionId, "session.steer");
-  const result = await runAgentCommandPersistenceTransaction(deps, context, {
-    stage: "session_commands.agent_steer",
-    eventTypes: ["session.control.steer_requested", "system.update.pending", "turn.superseded"],
-    transaction: async (tx) =>
-      await steerAgentSessionInTransaction(tx, {
-        accountId: context.accountId,
-        workspaceId: context.workspaceId,
-        targetSessionId: input.targetSessionId,
-        actor: agentActor(context),
-        operationKey: input.idempotencyKey,
-        instruction: input.instruction,
-      }),
-  });
+  const result = await runSessionCommandPersistenceTransaction(
+    deps,
+    { workspaceId: context.workspaceId },
+    {
+      stage: "session_commands.agent_steer",
+      eventTypes: ["session.control.steer_requested", "system.update.pending", "turn.superseded"],
+      transaction: async (tx) =>
+        await steerAgentSessionInTransaction(tx, {
+          accountId: context.accountId,
+          workspaceId: context.workspaceId,
+          targetSessionId: input.targetSessionId,
+          actor: agentActor(context),
+          operationKey: input.idempotencyKey,
+          instruction: input.instruction,
+        }),
+    },
+  );
   await publishAndWakeAgentCommand(deps, {
     accountId: context.accountId,
     workspaceId: context.workspaceId,
@@ -369,18 +397,23 @@ export async function controlAgentSessionWorkstream(
     input.targetSessionId,
     "session.control",
   );
-  const result = await withWorkspaceRls(deps.db, context.workspaceId, (scoped) =>
-    scoped.transaction((tx) =>
-      mutateSessionControlInTransaction(tx as unknown as Database, {
-        accountId: context.accountId,
-        workspaceId: context.workspaceId,
-        sessionId: input.targetSessionId,
-        actor: agentActor(context),
-        operationKey: input.idempotencyKey,
-        action: input.action,
-        reason: input.reason ?? null,
-      }),
-    ),
+  const result = await runSessionCommandPersistenceTransaction(
+    deps,
+    { workspaceId: context.workspaceId },
+    {
+      stage: "session_commands.agent_control",
+      eventTypes: [input.action === "pause" ? "session.control.paused" : "session.control.resumed"],
+      transaction: async (tx) =>
+        await mutateSessionControlInTransaction(tx, {
+          accountId: context.accountId,
+          workspaceId: context.workspaceId,
+          sessionId: input.targetSessionId,
+          actor: agentActor(context),
+          operationKey: input.idempotencyKey,
+          action: input.action,
+          reason: input.reason ?? null,
+        }),
+    },
   );
   await publishSessionEventIds(deps, context.workspaceId, input.targetSessionId, [
     result.sessionControlEventId,
@@ -412,6 +445,7 @@ function composerDraft(
   return {
     revision: row.revision,
     text: row.text,
+    annotations: DraftTimelineAnnotations.parse(row.annotations),
     resources: row.resources as ComposerDraft["resources"],
     model: row.model,
     reasoningEffort: row.reasoningEffort as ComposerDraft["reasoningEffort"],
@@ -441,23 +475,32 @@ async function authoritativeQueue(
 }
 
 export async function moveHumanQueuePrompt(
-  deps: { db: Database; bus: EventBus; sessionAuthorization?: SessionAuthorizationPort | null },
+  deps: {
+    db: Database;
+    bus: EventBus;
+    sessionAuthorization?: SessionAuthorizationPort | null;
+  },
   context: HumanSessionCommandContext,
   turnId: string,
   input: MoveSessionQueueItemRequest,
 ): Promise<SessionQueueMutationResponse> {
   const authorization = await authorizeHumanSessionCommand(deps, context, "session.queue.control");
-  const result = await withWorkspaceRls(deps.db, context.workspaceId, (scoped) =>
-    scoped.transaction((tx) =>
-      moveQueuedTurnInTransaction(tx as unknown as Database, {
-        ...context,
-        turnId,
-        beforeTurnId: input.beforeTurnId,
-        expectedQueueVersion: input.expectedQueueVersion,
-        actor: { type: "human", subjectId: context.subjectId },
-        operationKey: input.clientEventId,
-      }),
-    ),
+  const result = await runSessionCommandPersistenceTransaction(
+    deps,
+    { workspaceId: context.workspaceId },
+    {
+      stage: "session_commands.human_queue_move",
+      eventTypes: ["session.queue.changed"],
+      transaction: async (tx) =>
+        await moveQueuedTurnInTransaction(tx, {
+          ...context,
+          turnId,
+          beforeTurnId: input.beforeTurnId,
+          expectedQueueVersion: input.expectedQueueVersion,
+          actor: { type: "human", subjectId: context.subjectId },
+          operationKey: input.clientEventId,
+        }),
+    },
   );
   const response = {
     receipt: receipt(result.receipt),
@@ -473,23 +516,32 @@ export async function moveHumanQueuePrompt(
 }
 
 export async function deleteHumanQueuePrompt(
-  deps: { db: Database; bus: EventBus; sessionAuthorization?: SessionAuthorizationPort | null },
+  deps: {
+    db: Database;
+    bus: EventBus;
+    sessionAuthorization?: SessionAuthorizationPort | null;
+  },
   context: HumanSessionCommandContext,
   turnId: string,
   input: DeleteSessionQueueItemRequest,
 ): Promise<SessionQueueMutationResponse> {
   const authorization = await authorizeHumanSessionCommand(deps, context, "session.queue.control");
-  const result = await withWorkspaceRls(deps.db, context.workspaceId, (scoped) =>
-    scoped.transaction((tx) =>
-      deleteSessionQueueItemInTransaction(tx as unknown as Database, {
-        ...context,
-        turnId,
-        expectedTurnVersion: input.expectedTurnVersion,
-        actor: { type: "human", subjectId: context.subjectId },
-        operationKey: input.clientEventId,
-        reason: input.reason ?? null,
-      }),
-    ),
+  const result = await runSessionCommandPersistenceTransaction(
+    deps,
+    { workspaceId: context.workspaceId },
+    {
+      stage: "session_commands.human_queue_delete",
+      eventTypes: ["session.queue.changed"],
+      transaction: async (tx) =>
+        await deleteSessionQueueItemInTransaction(tx, {
+          ...context,
+          turnId,
+          expectedTurnVersion: input.expectedTurnVersion,
+          actor: { type: "human", subjectId: context.subjectId },
+          operationKey: input.clientEventId,
+          reason: input.reason ?? null,
+        }),
+    },
   );
   const response = {
     receipt: receipt(result.receipt),
@@ -505,19 +557,24 @@ export async function deleteHumanQueuePrompt(
 }
 
 export async function editHumanQueuePrompt(
-  deps: { db: Database; bus: EventBus; sessionAuthorization?: SessionAuthorizationPort | null },
+  deps: {
+    db: Database;
+    bus: EventBus;
+    sessionAuthorization?: SessionAuthorizationPort | null;
+  },
   context: HumanSessionCommandContext,
   turnId: string,
   input: EditSessionQueueItemRequest,
 ): Promise<SessionQueueMutationResponse> {
   const authorization = await authorizeHumanSessionCommand(deps, context, "session.queue.control");
-  const result = await withWorkspaceSubjectRls(
-    deps.db,
-    context.workspaceId,
-    context.subjectId,
-    (scoped) =>
-      scoped.transaction((tx) =>
-        editQueuedTurnInTransaction(tx as unknown as Database, {
+  const result = await runSessionCommandPersistenceTransaction(
+    deps,
+    { workspaceId: context.workspaceId, subjectId: context.subjectId },
+    {
+      stage: "session_commands.human_queue_edit",
+      eventTypes: ["session.queue.changed"],
+      transaction: async (tx) =>
+        await editQueuedTurnInTransaction(tx, {
           ...context,
           turnId,
           expectedTurnVersion: input.expectedTurnVersion,
@@ -526,7 +583,7 @@ export async function editHumanQueuePrompt(
           actor: { type: "human", subjectId: context.subjectId },
           operationKey: input.clientEventId,
         }),
-      ),
+    },
   );
   const response = {
     receipt: receipt(result.receipt),
@@ -543,23 +600,32 @@ export async function editHumanQueuePrompt(
 }
 
 export async function steerHumanQueuePrompt(
-  deps: { db: Database; bus: EventBus; sessionAuthorization?: SessionAuthorizationPort | null },
+  deps: {
+    db: Database;
+    bus: EventBus;
+    sessionAuthorization?: SessionAuthorizationPort | null;
+  },
   context: HumanSessionCommandContext,
   turnId: string,
   input: SteerSessionQueueItemRequest,
 ): Promise<SessionQueueMutationResponse> {
   const authorization = await authorizeHumanSessionCommand(deps, context, "session.queue.control");
-  const result = await withWorkspaceRls(deps.db, context.workspaceId, (scoped) =>
-    scoped.transaction((tx) =>
-      steerQueuedTurnInTransaction(tx as unknown as Database, {
-        ...context,
-        turnId,
-        expectedTurnVersion: input.expectedTurnVersion,
-        controlEtag: input.controlEtag ?? null,
-        actor: { type: "human", subjectId: context.subjectId },
-        operationKey: input.clientEventId,
-      }),
-    ),
+  const result = await runSessionCommandPersistenceTransaction(
+    deps,
+    { workspaceId: context.workspaceId },
+    {
+      stage: "session_commands.human_queue_steer",
+      eventTypes: ["session.control.steer_requested", "session.queue.changed", "turn.superseded"],
+      transaction: async (tx) =>
+        await steerQueuedTurnInTransaction(tx, {
+          ...context,
+          turnId,
+          expectedTurnVersion: input.expectedTurnVersion,
+          controlEtag: input.controlEtag ?? null,
+          actor: { type: "human", subjectId: context.subjectId },
+          operationKey: input.clientEventId,
+        }),
+    },
   );
   const response = {
     receipt: receipt(result.receipt),
@@ -586,19 +652,26 @@ export async function controlHumanSessionWorkstreamWithOutcome(
   input: SessionControlRequest,
 ): Promise<{ response: SessionControlResponse; replay: boolean }> {
   const authorization = await authorizeHumanSessionCommand(deps, context, "session.control");
-  const result = await withWorkspaceRls(deps.db, context.workspaceId, (scoped) =>
-    scoped.transaction((tx) =>
-      mutateSessionControlInTransaction(tx as unknown as Database, {
-        accountId: context.accountId,
-        workspaceId: context.workspaceId,
-        sessionId: context.sessionId,
-        actor: { type: "human", subjectId: context.subjectId },
-        operationKey: input.clientEventId,
-        action: input.action,
-        reason: input.reason ?? null,
-        expectedControlEtag: input.expectedControlEtag ?? null,
-      }),
-    ),
+  const result = await runSessionCommandPersistenceTransaction(
+    deps,
+    { workspaceId: context.workspaceId },
+    {
+      stage: "session_commands.human_control",
+      eventTypes: [
+        input.action === "resume" ? "session.control.resumed" : "session.control.paused",
+      ],
+      transaction: async (tx) =>
+        await mutateSessionControlInTransaction(tx, {
+          accountId: context.accountId,
+          workspaceId: context.workspaceId,
+          sessionId: context.sessionId,
+          actor: { type: "human", subjectId: context.subjectId },
+          operationKey: input.clientEventId,
+          action: input.action,
+          reason: input.reason ?? null,
+          expectedControlEtag: input.expectedControlEtag ?? null,
+        }),
+    },
   );
   const response = {
     receipt: receipt(result.receipt),
@@ -686,6 +759,7 @@ export async function getHumanComposerDraft(
   return {
     revision: 0,
     text: "",
+    annotations: [],
     resources: [],
     model: session.model,
     reasoningEffort: reasoningEffortForMetadata(session.metadata, "medium"),
@@ -702,6 +776,12 @@ export async function saveHumanComposerDraft(
   input: SaveComposerDraftRequest,
 ): Promise<ComposerDraft> {
   await authorizeHumanSessionCommand(deps, context, "session.composer.write");
+  const annotations = await validateDraftTimelineAnnotations(
+    deps.db,
+    context.workspaceId,
+    context.sessionId,
+    input.annotations ?? [],
+  );
   const row = await withWorkspaceSubjectRls(
     deps.db,
     context.workspaceId,
@@ -711,6 +791,7 @@ export async function saveHumanComposerDraft(
         saveComposerDraftInTransaction(tx as unknown as Database, {
           ...context,
           ...input,
+          annotations,
           resources: normalizeResources(input.resources),
           subjectId: context.subjectId,
         }),