@opengeni/core 0.10.0 → 0.11.1

package/dist/index.js

@@ -9,6 +9,7 @@ import {
   getSandbox as getSandbox2,
   listSandboxes,
   readActiveSandbox as readActiveSandbox2,
+  readLease,
   requireSession,
   setActiveSandbox
 } from "@opengeni/db";
@@ -21,8 +22,20 @@ import {
 import { HTTPException } from "hono/http-exception";
 
 // src/sandbox/routing.ts
-import { getSandbox, readActiveSandbox } from "@opengeni/db";
 import {
+  advanceWorkspaceGenerationForDirectRequest,
+  advanceWorkspaceGenerationForRetainedProcess,
+  getSandbox,
+  markWarmLeaseInstanceLost,
+  readActiveSandbox,
+  retainWorkspaceMutationProcess,
+  settleRetainedProcess,
+  verifyDirectWorkspaceMutationSettlement,
+  verifyRetainedProcessMutationSettlement
+} from "@opengeni/db";
+import { appendAndPublishEvents } from "@opengeni/events";
+import {
+  isProviderSandboxGoneDuringRoutedOperation,
   makeActiveBackendResolver,
   NatsControlRpc,
   RoutingSandboxSession
@@ -63,6 +76,129 @@ function routingEnabled(settings) {
 }
 function wrapChannelABoxWithRouting(services, ids, established) {
   const { db, settings, bus } = services;
+  const beforeMutation = async ({
+    op,
+    backend
+  }) => {
+    if (backend.sandboxId !== null || backend.leaseEpoch === void 0 || backend.providerInstanceId === void 0) {
+      return null;
+    }
+    if (backend.activeEpoch === void 0) {
+      throw new Error("API-direct workspace mutation resolved without an active route epoch");
+    }
+    return await advanceWorkspaceGenerationForDirectRequest(db, {
+      accountId: ids.accountId,
+      workspaceId: ids.workspaceId,
+      sessionId: ids.sessionId,
+      requestId: ids.directRequest.requestId,
+      holderId: ids.directRequest.holderId,
+      sandboxGroupId: ids.homeLease.sandboxGroupId,
+      expectedEpoch: backend.leaseEpoch,
+      expectedInstanceId: backend.providerInstanceId,
+      routeTargetId: backend.sandboxId,
+      routeEpoch: backend.activeEpoch,
+      operation: op
+    });
+  };
+  const afterMutation = async ({
+    op,
+    backend,
+    admission,
+    outcome,
+    retainedProcess
+  }) => {
+    if (admission === null) return;
+    if (!admission || typeof admission !== "object" || typeof admission.id !== "string" || typeof admission.workspaceGeneration !== "number" || backend.leaseEpoch === void 0 || backend.providerInstanceId === void 0 || backend.activeEpoch === void 0) {
+      throw new Error("API-direct workspace mutation settlement lacked its exact admission");
+    }
+    const exactAdmission = admission;
+    if (outcome === "resolved" && retainedProcess) {
+      await retainWorkspaceMutationProcess(db, {
+        accountId: ids.accountId,
+        workspaceId: ids.workspaceId,
+        sessionId: ids.sessionId,
+        processId: retainedProcess.id,
+        providerSessionId: retainedProcess.providerSessionId,
+        admissionId: exactAdmission.id,
+        admittedWorkspaceGeneration: exactAdmission.workspaceGeneration,
+        operation: op,
+        owner: {
+          kind: "direct",
+          requestId: ids.directRequest.requestId,
+          holderId: ids.directRequest.holderId,
+          sandboxGroupId: ids.homeLease.sandboxGroupId,
+          expectedEpoch: backend.leaseEpoch,
+          expectedInstanceId: backend.providerInstanceId,
+          routeTargetId: exactAdmission.routeTargetId,
+          routeEpoch: exactAdmission.routeEpoch
+        }
+      });
+      return;
+    }
+    await verifyDirectWorkspaceMutationSettlement(db, {
+      accountId: ids.accountId,
+      workspaceId: ids.workspaceId,
+      sessionId: ids.sessionId,
+      requestId: ids.directRequest.requestId,
+      holderId: ids.directRequest.holderId,
+      sandboxGroupId: ids.homeLease.sandboxGroupId,
+      expectedEpoch: backend.leaseEpoch,
+      expectedInstanceId: backend.providerInstanceId,
+      routeTargetId: exactAdmission.routeTargetId,
+      routeEpoch: exactAdmission.routeEpoch,
+      admission: exactAdmission,
+      operation: op,
+      outcome
+    });
+  };
+  const beforeProcessMutation = async ({
+    op,
+    process
+  }) => await advanceWorkspaceGenerationForRetainedProcess(db, {
+    accountId: ids.accountId,
+    workspaceId: ids.workspaceId,
+    sessionId: ids.sessionId,
+    processId: process.id,
+    operation: op
+  });
+  const afterProcessMutation = async ({
+    op,
+    process,
+    admission,
+    outcome
+  }) => {
+    if (!admission || typeof admission !== "object" || typeof admission.id !== "string" || typeof admission.workspaceGeneration !== "number") {
+      throw new Error("API retained-process mutation settlement lacked its exact admission");
+    }
+    await verifyRetainedProcessMutationSettlement(db, {
+      accountId: ids.accountId,
+      workspaceId: ids.workspaceId,
+      sessionId: ids.sessionId,
+      processId: process.id,
+      admission,
+      operation: op,
+      outcome
+    });
+  };
+  const settleProcess = async ({
+    backend,
+    process,
+    proof
+  }) => {
+    if (backend.sandboxId !== null || backend.leaseEpoch === void 0 || backend.providerInstanceId === void 0) {
+      return;
+    }
+    await settleRetainedProcess(db, {
+      accountId: ids.accountId,
+      workspaceId: ids.workspaceId,
+      sessionId: ids.sessionId,
+      processId: process.id,
+      outcome: proof.outcome,
+      exitCode: proof.exitCode,
+      reason: proof.reason,
+      idleGraceMs: settings.sandboxIdleGraceMs
+    });
+  };
   const resolver = makeActiveBackendResolver({
     workspaceId: ids.workspaceId,
     defaultBackend: established.session,
@@ -77,14 +213,61 @@ function wrapChannelABoxWithRouting(services, ids, established) {
       } : null;
     },
     controlRpcFactory: controlRpcFactory(bus),
-    relay: relayConfigFromSettings(settings)
+    relay: relayConfigFromSettings(settings),
+    resolveDefaultBackend: async () => ({
+      session: established.session,
+      sandboxId: null,
+      kind: established.backendId,
+      leaseEpoch: ids.homeLease.leaseEpoch,
+      providerInstanceId: ids.homeLease.instanceId
+    })
   });
   const proxy = new RoutingSandboxSession({
+    defaultResolved: {
+      session: established.session,
+      sandboxId: null,
+      kind: established.backendId,
+      leaseEpoch: ids.homeLease.leaseEpoch,
+      providerInstanceId: ids.homeLease.instanceId
+    },
     readPointer: async () => {
+      if (!routingEnabled(settings)) {
+        return { activeSandboxId: null, activeEpoch: 0 };
+      }
       const pointer = await readActiveSandbox(db, ids.workspaceId, ids.sessionId);
       return pointer ?? { activeSandboxId: null, activeEpoch: 0 };
     },
-    resolveActiveBackend: resolver
+    resolveActiveBackend: resolver,
+    beforeMutation,
+    afterMutation,
+    beforeProcessMutation,
+    afterProcessMutation,
+    settleProcess,
+    onDefaultBackendError: async ({ error }) => {
+      if (!isProviderSandboxGoneDuringRoutedOperation(ids.homeLease.backend, error)) return null;
+      const marked = await markWarmLeaseInstanceLost(db, {
+        accountId: ids.accountId,
+        workspaceId: ids.workspaceId,
+        sandboxGroupId: ids.homeLease.sandboxGroupId,
+        expectedEpoch: ids.homeLease.leaseEpoch,
+        expectedInstanceId: ids.homeLease.instanceId,
+        diagnostic: "provider_not_found_during_routed_operation"
+      });
+      if (marked.status === "marked" && bus) {
+        await appendAndPublishEvents(db, bus, ids.workspaceId, ids.sessionId, [
+          {
+            type: "sandbox.box.lost",
+            payload: { sandboxId: ids.homeLease.instanceId }
+          }
+        ]).catch(() => void 0);
+      }
+      const lease = marked.lease;
+      const restore = lease?.recovery.restore.status;
+      return {
+        leaseEpoch: lease?.leaseEpoch ?? ids.homeLease.leaseEpoch,
+        recovery: marked.status === "stale" ? "superseded" : restore === "pending" ? "pending" : restore === "degraded" ? "degraded" : "unrecoverable"
+      };
+    }
   });
   return { ...established, session: proxy };
 }
@@ -153,15 +336,33 @@ async function listFleet(services, ctx) {
   };
   const entries = [];
   const groupActive = pointer.activeSandboxId === null;
+  const groupLease = await readLease(db, ctx.workspaceId, ctx.sessionGroupId);
+  const groupOnline = Boolean(
+    groupLease?.liveness === "warm" && groupLease.recovery.provider.status === "exists" && groupLease.recovery.workspace.status === "ready"
+  );
+  const groupRecovering = Boolean(
+    groupLease && (groupLease.liveness === "warming" || groupLease.recovery.restore.status === "pending" || groupLease.recovery.restore.status === "restoring" || groupLease.recovery.restore.status === "verifying")
+  );
   entries.push({
     id: ctx.sessionGroupId,
     kind: ctx.sessionBackend === "selfhosted" ? "selfhosted" : "modal",
     name: "session sandbox",
-    liveness: "online",
+    liveness: groupOnline ? "online" : groupRecovering ? "reconnecting" : "offline",
     active: groupActive,
     isSessionGroup: true,
     enrollmentId: null,
-    attachable: true
+    attachable: groupOnline,
+    providerStatus: groupLease?.recovery.provider.status ?? "not_created",
+    leaseLiveness: groupLease?.liveness ?? null,
+    routeStatus: groupActive ? "attached" : "detached",
+    archiveStatus: groupLease?.recovery.archive.status ?? "none",
+    restoreStatus: groupLease?.recovery.restore.status ?? "not_required",
+    workspaceStatus: groupLease?.recovery.workspace.status ?? "unknown",
+    leaseEpoch: groupLease?.leaseEpoch ?? null,
+    routeEpoch: pointer.activeEpoch,
+    workspaceGeneration: groupLease?.workspaceGeneration ?? null,
+    archiveGeneration: groupLease?.archiveGeneration ?? null,
+    archiveComplete: groupLease?.archiveComplete ?? false
   });
   const sandboxes = await listSandboxes(db, ctx.workspaceId);
   for (const sandbox of sandboxes) {
@@ -181,7 +382,18 @@ async function listFleet(services, ctx) {
       attachable: probe.liveness === "online",
       consented: probe.consented,
       hasDisplay: probe.hasDisplay,
-      lastSeenAt: enrollment?.lastSeenAt ?? null
+      lastSeenAt: enrollment?.lastSeenAt ?? null,
+      providerStatus: probe.liveness === "online" ? "exists" : probe.liveness === "reconnecting" ? "unknown" : "missing",
+      leaseLiveness: null,
+      routeStatus: pointer.activeSandboxId === sandbox.id ? "attached" : "detached",
+      archiveStatus: "none",
+      restoreStatus: "not_required",
+      workspaceStatus: probe.liveness === "online" ? "ready" : "not_ready",
+      leaseEpoch: null,
+      routeEpoch: pointer.activeEpoch,
+      workspaceGeneration: null,
+      archiveGeneration: null,
+      archiveComplete: false
     });
   }
   return {
@@ -239,57 +451,75 @@ async function resolveTarget(services, ctx, target) {
 async function swapActiveSandbox(services, ctx, target, workingDir) {
   const resolved = await resolveTarget(services, ctx, target);
   if (!resolved.ok) {
-    const pointer2 = await readActiveSandbox2(services.db, ctx.workspaceId, ctx.sessionId) ?? {
+    const pointer = await readActiveSandbox2(services.db, ctx.workspaceId, ctx.sessionId) ?? {
       activeSandboxId: null,
       activeEpoch: 0
     };
     return {
       swapped: false,
-      activeSandboxId: pointer2.activeSandboxId,
-      activeEpoch: pointer2.activeEpoch,
+      activeSandboxId: pointer.activeSandboxId,
+      activeEpoch: pointer.activeEpoch,
       reason: resolved.reason,
       code: resolved.code
     };
   }
-  for (let attempt = 0; attempt < 2; attempt += 1) {
-    const pointer2 = await readActiveSandbox2(services.db, ctx.workspaceId, ctx.sessionId) ?? {
-      activeSandboxId: null,
-      activeEpoch: 0
-    };
-    if (pointer2.activeSandboxId === resolved.targetSandboxId) {
+  let readinessHold;
+  if (resolved.targetSandboxId === null && services.ensureSessionGroupReady) {
+    try {
+      readinessHold = await services.ensureSessionGroupReady(ctx);
+    } catch (error) {
+      const lease = await readLease(services.db, ctx.workspaceId, ctx.sessionGroupId);
+      const restore = lease?.recovery.restore.status;
+      const code = restore === "degraded" ? "recovery_degraded" : restore === "unrecoverable" ? "recovery_unrecoverable" : "recovery_in_progress";
+      const pointer = await readActiveSandbox2(services.db, ctx.workspaceId, ctx.sessionId) ?? {
+        activeSandboxId: null,
+        activeEpoch: 0
+      };
       return {
-        swapped: true,
-        activeSandboxId: pointer2.activeSandboxId,
-        activeEpoch: pointer2.activeEpoch
+        swapped: false,
+        activeSandboxId: pointer.activeSandboxId,
+        activeEpoch: pointer.activeEpoch,
+        reason: error instanceof Error ? error.message : "session sandbox did not reach verified readiness",
+        code
       };
     }
-    const result = await setActiveSandbox(services.db, {
-      accountId: ctx.accountId,
-      workspaceId: ctx.workspaceId,
-      sessionId: ctx.sessionId,
-      targetSandboxId: resolved.targetSandboxId,
-      expectedEpoch: pointer2.activeEpoch,
-      ...workingDir !== void 0 ? { workingDir } : {}
-    });
-    if (result.swapped && result.pointer) {
-      return {
-        swapped: true,
-        activeSandboxId: result.pointer.activeSandboxId,
-        activeEpoch: result.pointer.activeEpoch
+  }
+  try {
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      const pointer2 = await readActiveSandbox2(services.db, ctx.workspaceId, ctx.sessionId) ?? {
+        activeSandboxId: null,
+        activeEpoch: 0
       };
+      const result = await setActiveSandbox(services.db, {
+        accountId: ctx.accountId,
+        workspaceId: ctx.workspaceId,
+        sessionId: ctx.sessionId,
+        targetSandboxId: resolved.targetSandboxId,
+        expectedEpoch: pointer2.activeEpoch,
+        ...workingDir !== void 0 ? { workingDir } : {}
+      });
+      if (result.swapped && result.pointer) {
+        return {
+          swapped: true,
+          activeSandboxId: result.pointer.activeSandboxId,
+          activeEpoch: result.pointer.activeEpoch
+        };
+      }
     }
+    const pointer = await readActiveSandbox2(services.db, ctx.workspaceId, ctx.sessionId) ?? {
+      activeSandboxId: null,
+      activeEpoch: 0
+    };
+    return {
+      swapped: false,
+      activeSandboxId: pointer.activeSandboxId,
+      activeEpoch: pointer.activeEpoch,
+      reason: "a concurrent swap won the epoch fence; re-read and retry",
+      code: "concurrent_swap"
+    };
+  } finally {
+    await readinessHold?.release().catch(() => void 0);
   }
-  const pointer = await readActiveSandbox2(services.db, ctx.workspaceId, ctx.sessionId) ?? {
-    activeSandboxId: null,
-    activeEpoch: 0
-  };
-  return {
-    swapped: false,
-    activeSandboxId: pointer.activeSandboxId,
-    activeEpoch: pointer.activeEpoch,
-    reason: "a concurrent swap won the epoch fence; re-read and retry",
-    code: "concurrent_swap"
-  };
 }
 async function runOnSandbox(services, ctx, target, op) {
   const sandbox = await getSandbox2(services.db, ctx.workspaceId, target);
@@ -3044,8 +3274,10 @@ function sessionWithEffectiveToolPolicy(session, workspaceServerIds, workspaceDe
 import {
   createScheduledTask,
   deleteScheduledTask,
+  getNestedAgentDepthDeploymentPolicy,
   getRig as getRig3,
   getScheduledTask,
+  requireWorkspace as requireWorkspace2,
   updateScheduledTask
 } from "@opengeni/db";
 import { HTTPException as HTTPException10 } from "hono/http-exception";
@@ -3061,6 +3293,7 @@ import {
 import {
   CreateSessionRequest,
   DEFAULT_FIRST_PARTY_MCP_PERMISSIONS,
+  SessionSpawnDenial,
   ServiceTurnInitiator,
   ServiceTurnInitiatorContext,
   evaluateWorkspaceModelPolicy,
@@ -3069,7 +3302,7 @@ import {
 } from "@opengeni/contracts";
 import {
   createSession,
-  createSessionWithIdempotencyKey,
+  createSessionWithIdempotencyKeyResult,
   encryptVariableSetValue as encryptVariableSetValue2,
   getAnySessionInGroup,
   getEnrollment as getEnrollment2,
@@ -3080,7 +3313,7 @@ import {
   getSandbox as getSandbox3,
   getSession as getSession2,
   SessionIdConflictError,
-  getSessionByCreateIdempotencyKey,
+  getSessionSpawnDenialByIdempotencyKey,
   getSessionEvent,
   getWorkspaceControlEvent,
   getSessionLineage,
@@ -3096,10 +3329,11 @@ import {
   withWorkspaceSubjectRls,
   QueueCommandConflictError,
   AgentCommandAuthorityError,
+  SessionSpawnDeniedDbError,
   SessionControlConflictError
 } from "@opengeni/db";
 import {
-  appendAndPublishEvents,
+  appendAndPublishEvents as appendAndPublishEvents2,
   publishDurableSessionEvents,
   publishDurableWorkspaceControlEvent
 } from "@opengeni/events";
@@ -3108,6 +3342,29 @@ var reservedSessionMcpServerIds = /* @__PURE__ */ new Set(["opengeni", "files",
 var maxSessionMcpCredentialHeaders = 16;
 var maxSessionMcpCredentialHeaderValueLength = 4096;
 var sessionMcpCredentialHeaderName = /^[A-Za-z0-9!#$%&'*+.^_`|~-]+$/;
+var SessionSpawnDeniedError = class extends Error {
+  denial;
+  constructor(denial) {
+    super(sessionSpawnDeniedMessage(denial));
+    this.name = "SessionSpawnDeniedError";
+    this.denial = denial;
+  }
+};
+function sessionSpawnDeniedMessage(denial) {
+  if (denial.code === "nested_agent_depth_override_forbidden") {
+    return `requested nested-agent depth limit ${denial.requestedMaxNestedAgentDepthOverride ?? "unknown"} exceeds inherited limit ${denial.effectiveMaxNestedAgentDepth}; workspace:admin is required to increase it`;
+  }
+  return `nested-agent depth ${denial.attemptedDepth} exceeds effective limit ${denial.effectiveMaxNestedAgentDepth} (current parent depth ${denial.currentDepth})`;
+}
+function sessionSpawnDenialEnvelope(error) {
+  return {
+    error: {
+      code: error.denial.code,
+      message: error.message,
+      details: { denial: error.denial }
+    }
+  };
+}
 function serviceInitiatorForGrant(grant) {
   if (!grant.serviceInitiator) {
     if (grant.serviceInitiatorContext) {
@@ -3377,21 +3634,7 @@ async function createAndStartSession(input) {
     reasoningEffort: input.reasoningEffort
   };
   if (input.createIdempotencyKey) {
-    const existing = await getSessionByCreateIdempotencyKey(
-      input.db,
-      input.workspaceId,
-      input.createIdempotencyKey
-    );
-    if (existing) {
-      if (input.requestedSessionId && existing.id !== input.requestedSessionId) {
-        throw new SessionIdConflictError(input.requestedSessionId);
-      }
-      return await finishStartSession(
-        existing.temporalWorkflowId ? { ...input, seedTargetSandbox: null } : input,
-        existing
-      );
-    }
-    const { session: keyed, created } = await createSessionWithIdempotencyKey(input.db, {
+    const keyedResult = await createSessionWithIdempotencyKeyResult(input.db, {
       ...input.requestedSessionId ? { requestedSessionId: input.requestedSessionId } : {},
       accountId: input.accountId,
       workspaceId: input.workspaceId,
@@ -3415,8 +3658,15 @@ async function createAndStartSession(input) {
       createIdempotencyKey: input.createIdempotencyKey,
       sandboxGroupId: input.sandboxGroupId ?? null,
       ...input.sandboxOs ? { sandboxOs: input.sandboxOs } : {},
-      mcpServers: input.mcpServers ?? []
+      mcpServers: input.mcpServers ?? [],
+      maxNestedAgentDepthOverride: input.maxNestedAgentDepthOverride ?? null,
+      allowNestedAgentDepthIncrease: input.allowNestedAgentDepthIncrease ?? false,
+      subjectId: input.subjectId ?? null
     });
+    if (keyedResult.denied) {
+      throw new SessionSpawnDeniedError(SessionSpawnDenial.parse(keyedResult.denial));
+    }
+    const { session: keyed, created } = keyedResult;
     if (!created) {
       return await finishStartSession(
         keyed.temporalWorkflowId ? { ...input, seedTargetSandbox: null } : input,
@@ -3425,31 +3675,42 @@ async function createAndStartSession(input) {
     }
     return await finishStartSession(input, keyed);
   }
-  const session = await createSession(input.db, {
-    ...input.requestedSessionId ? { requestedSessionId: input.requestedSessionId } : {},
-    accountId: input.accountId,
-    workspaceId: input.workspaceId,
-    initialMessage: input.initialMessage,
-    initialTurnInstructions: input.turnInstructions ?? null,
-    resources: input.resources,
-    tools: input.tools,
-    ...input.toolPolicy ? { toolPolicy: input.toolPolicy } : {},
-    metadata: sessionMetadata,
-    ...input.createdBy ? { createdBy: input.createdBy } : {},
-    ...input.createdByContext ? { createdByContext: input.createdByContext } : {},
-    createdByActor: input.createdByActor ?? null,
-    model: input.model,
-    sandboxBackend: input.sandboxBackend,
-    variableSetId: input.variableSet?.id ?? null,
-    rigId: input.rigId ?? null,
-    rigVersionId: input.rigVersionId ?? null,
-    firstPartyMcpPermissions: input.firstPartyMcpPermissions ?? null,
-    instructions: input.instructions ?? null,
-    parentSessionId: input.parentSessionId ?? null,
-    sandboxGroupId: input.sandboxGroupId ?? null,
-    ...input.sandboxOs ? { sandboxOs: input.sandboxOs } : {},
-    mcpServers: input.mcpServers ?? []
-  });
+  let session;
+  try {
+    session = await createSession(input.db, {
+      ...input.requestedSessionId ? { requestedSessionId: input.requestedSessionId } : {},
+      accountId: input.accountId,
+      workspaceId: input.workspaceId,
+      initialMessage: input.initialMessage,
+      initialTurnInstructions: input.turnInstructions ?? null,
+      resources: input.resources,
+      tools: input.tools,
+      ...input.toolPolicy ? { toolPolicy: input.toolPolicy } : {},
+      metadata: sessionMetadata,
+      ...input.createdBy ? { createdBy: input.createdBy } : {},
+      ...input.createdByContext ? { createdByContext: input.createdByContext } : {},
+      createdByActor: input.createdByActor ?? null,
+      model: input.model,
+      sandboxBackend: input.sandboxBackend,
+      variableSetId: input.variableSet?.id ?? null,
+      rigId: input.rigId ?? null,
+      rigVersionId: input.rigVersionId ?? null,
+      firstPartyMcpPermissions: input.firstPartyMcpPermissions ?? null,
+      instructions: input.instructions ?? null,
+      parentSessionId: input.parentSessionId ?? null,
+      sandboxGroupId: input.sandboxGroupId ?? null,
+      ...input.sandboxOs ? { sandboxOs: input.sandboxOs } : {},
+      mcpServers: input.mcpServers ?? [],
+      maxNestedAgentDepthOverride: input.maxNestedAgentDepthOverride ?? null,
+      allowNestedAgentDepthIncrease: input.allowNestedAgentDepthIncrease ?? false,
+      subjectId: input.subjectId ?? null
+    });
+  } catch (error) {
+    if (error instanceof SessionSpawnDeniedDbError) {
+      throw new SessionSpawnDeniedError(SessionSpawnDenial.parse(error.denial));
+    }
+    throw error;
+  }
   return await finishStartSession(input, session);
 }
 async function finishStartSession(input, session) {
@@ -3496,7 +3757,8 @@ async function finishStartSession(input, session) {
       text: input.goal.text,
       ...input.goal.successCriteria !== void 0 ? { successCriteria: input.goal.successCriteria } : {},
       ...input.goal.maxAutoContinuations !== void 0 ? { maxAutoContinuations: input.goal.maxAutoContinuations } : {}
-    } : null
+    } : null,
+    consumeNewSessionDraft: input.consumeNewSessionDraft ?? null
   });
   await publishDurableSessionEvents(input.bus, session.workspaceId, session.id, started.events);
   if (started.workflowWakeRevision !== null) {
@@ -3672,6 +3934,16 @@ async function postUserMessageTurn(input) {
 async function createSessionForRequest(deps, grant, workspaceId, rawPayload) {
   const { settings, db, bus, workflowClient, objectStorage } = deps;
   const payload = CreateSessionRequest.parse(rawPayload);
+  if (payload.idempotencyKey) {
+    const denial = await getSessionSpawnDenialByIdempotencyKey(
+      db,
+      workspaceId,
+      payload.idempotencyKey
+    );
+    if (denial) {
+      throw new SessionSpawnDeniedError(SessionSpawnDenial.parse(denial));
+    }
+  }
   const parentSessionId = typeof grant.metadata?.["sessionId"] === "string" ? grant.metadata["sessionId"] : null;
   if (parentSessionId) {
     await requireSessionAuthorization(deps, grant, {
@@ -3962,11 +4234,18 @@ async function createSessionForRequest(deps, grant, workspaceId, rawPayload) {
       sessionMcpServers: sessionMcpServers.metadata,
       parentSessionId,
       createIdempotencyKey: payload.idempotencyKey ?? null,
+      maxNestedAgentDepthOverride: payload.maxNestedAgentDepth ?? null,
+      allowNestedAgentDepthIncrease: hasPermission(grant.permissions, "workspace:admin"),
+      subjectId: grant.subjectId,
       // Create-time machine targeting (A-2a): when a target sandbox is named, the
       // active-sandbox pointer is seeded race-free inside createAndStartSession
       // (after the row exists, before the first turn dispatches). Validation
       // (ownership/liveness) lives in swapActiveSandbox; an invalid target 422s.
-      seedTargetSandbox: payload.targetSandboxId ? { sandboxId: payload.targetSandboxId, settings, workingDir: payload.workingDir ?? null } : null
+      seedTargetSandbox: payload.targetSandboxId ? { sandboxId: payload.targetSandboxId, settings, workingDir: payload.workingDir ?? null } : null,
+      consumeNewSessionDraft: payload.expectedNewSessionDraftRevision !== void 0 ? {
+        subjectId: grant.subjectId,
+        expectedRevision: payload.expectedNewSessionDraftRevision
+      } : null
     });
   } catch (error) {
     if (error instanceof AgentCommandAuthorityError) {
@@ -4136,7 +4415,7 @@ async function updateSessionTitle(deps, grant, sessionId, title, source) {
   const workspaceId = grant.workspaceId;
   const result = await updateSessionTitleRow(db, { workspaceId, sessionId, title, source });
   if (result.updated) {
-    await appendAndPublishEvents(db, bus, workspaceId, sessionId, [
+    await appendAndPublishEvents2(db, bus, workspaceId, sessionId, [
       {
         type: "session.title_set",
         payload: {
@@ -4333,6 +4612,7 @@ async function validatedScheduledTaskUpdate(input) {
       settings: input.settings,
       db: input.db,
       objectStorage: input.objectStorage,
+      grant: input.grant,
       workspaceId: input.existing.workspaceId,
       payload: { agentConfig: input.payload.agentConfig },
       ...input.toolsProvided !== void 0 ? { toolsProvided: input.toolsProvided } : {}
@@ -4415,6 +4695,18 @@ async function validateScheduledTaskAgentConfig(input) {
     throw new HTTPException10(503, { message: "object storage is not configured" });
   }
   await validateFileResources(input.db, input.workspaceId, resources);
+  const requestedMaxDepth = input.payload.agentConfig.maxNestedAgentDepth;
+  if (requestedMaxDepth !== void 0) {
+    const workspace = await requireWorkspace2(input.db, input.workspaceId);
+    const workspaceMaxDepth = workspace.settings.maxNestedAgentDepth;
+    const deploymentPolicy = await getNestedAgentDepthDeploymentPolicy(input.db);
+    const inheritedMaxDepth = typeof workspaceMaxDepth === "number" ? workspaceMaxDepth : deploymentPolicy.maxNestedAgentDepth;
+    if (requestedMaxDepth > inheritedMaxDepth && !hasPermission(input.grant.permissions, "workspace:admin")) {
+      throw new HTTPException10(403, {
+        message: `scheduled task maxNestedAgentDepth ${requestedMaxDepth} exceeds inherited limit ${inheritedMaxDepth}; workspace:admin is required to increase it`
+      });
+    }
+  }
   return {
     ...input.payload.agentConfig,
     ...model === void 0 || model === null ? {} : { model },
@@ -4485,6 +4777,102 @@ function assertWorkspaceDeletable(input) {
   }
 }
 
+// src/application/new-session-drafts.ts
+import {
+  NewSessionDraft,
+  SaveNewSessionDraftRequest
+} from "@opengeni/contracts";
+import {
+  getNewSessionDraftInTransaction,
+  NewSessionDraftAccessError,
+  saveNewSessionDraftInTransaction,
+  withWorkspaceSubjectRls as withWorkspaceSubjectRls2
+} from "@opengeni/db";
+import { HTTPException as HTTPException12 } from "hono/http-exception";
+function mapNewSessionDraft(row) {
+  if (!row) return null;
+  return NewSessionDraft.parse({
+    revision: row.revision,
+    text: row.text,
+    resources: row.resources,
+    tools: row.tools,
+    model: row.model,
+    reasoningEffort: row.reasoningEffort,
+    options: row.sessionOptions,
+    updatedAt: row.updatedAt.toISOString()
+  });
+}
+async function getActorNewSessionDraft(deps, grant, workspaceId) {
+  const row = await withWorkspaceSubjectRls2(
+    deps.db,
+    workspaceId,
+    grant.subjectId,
+    (scoped) => getNewSessionDraftInTransaction(scoped, {
+      workspaceId,
+      subjectId: grant.subjectId
+    })
+  );
+  return mapNewSessionDraft(row) ?? {
+    revision: 0,
+    text: "",
+    resources: [],
+    tools: [],
+    model: deps.settings.openaiModel,
+    reasoningEffort: deps.settings.openaiReasoningEffort,
+    options: {},
+    updatedAt: null
+  };
+}
+async function saveActorNewSessionDraft(deps, grant, workspaceId, rawInput) {
+  const input = SaveNewSessionDraftRequest.parse(rawInput);
+  const runtimeSettings = await settingsWithEnabledCapabilityMcpServers(
+    deps.db,
+    workspaceId,
+    deps.settings
+  );
+  const resources = normalizeResources(input.resources);
+  const tools = validateToolRefs(input.tools, runtimeSettings);
+  await validateGitHubRepositorySelection(deps.db, workspaceId, resources);
+  if (resources.some((resource) => resource.kind === "file") && !deps.objectStorage) {
+    throw new HTTPException12(503, { message: "object storage is not configured" });
+  }
+  await validateFileResources(deps.db, workspaceId, resources);
+  assertConfiguredModel(deps.settings, input.model);
+  await assertWorkspaceModelPolicyAllows(deps.db, deps.settings, workspaceId, input.model);
+  try {
+    const saved = await withWorkspaceSubjectRls2(
+      deps.db,
+      workspaceId,
+      grant.subjectId,
+      (scoped) => scoped.transaction(
+        (tx) => saveNewSessionDraftInTransaction(tx, {
+          accountId: grant.accountId,
+          workspaceId,
+          subjectId: grant.subjectId,
+          expectedRevision: input.expectedRevision,
+          text: input.text,
+          resources,
+          tools,
+          model: input.model,
+          reasoningEffort: input.reasoningEffort,
+          options: input.options,
+          // Only managed people are removed through removeWorkspaceMember().
+          // API keys and delegated service actors (for example the first-party
+          // worker MCP principal) legitimately have no workspace_memberships
+          // row, so they must not be rejected by the human-removal fence.
+          requireWorkspaceMembership: grant.subjectId.startsWith("user:")
+        })
+      )
+    );
+    return mapNewSessionDraft(saved);
+  } catch (error) {
+    if (error instanceof NewSessionDraftAccessError) {
+      throw new HTTPException12(403, { message: error.message });
+    }
+    throw error;
+  }
+}
+
 // src/application/session-commands.ts
 import { reasoningEffortForMetadata as reasoningEffortForMetadata2 } from "@opengeni/contracts";
 import {
@@ -4506,7 +4894,7 @@ import {
   steerAgentSessionInTransaction,
   steerQueuedTurnInTransaction,
   withWorkspaceRls,
-  withWorkspaceSubjectRls as withWorkspaceSubjectRls2
+  withWorkspaceSubjectRls as withWorkspaceSubjectRls3
 } from "@opengeni/db";
 import {
   publishDurableSessionEvents as publishDurableSessionEvents2,
@@ -4798,7 +5186,7 @@ async function deleteHumanQueuePrompt(deps, context, turnId, input) {
 }
 async function editHumanQueuePrompt(deps, context, turnId, input) {
   const authorization = await authorizeHumanSessionCommand(deps, context, "session.queue.control");
-  const result = await withWorkspaceSubjectRls2(
+  const result = await withWorkspaceSubjectRls3(
     deps.db,
     context.workspaceId,
     context.subjectId,
@@ -4920,7 +5308,7 @@ async function controlHumanWorkspace(deps, context, input) {
 }
 async function getHumanComposerDraft(deps, context) {
   await authorizeHumanSessionCommand(deps, context, "session.composer.read");
-  const row = await withWorkspaceSubjectRls2(
+  const row = await withWorkspaceSubjectRls3(
     deps.db,
     context.workspaceId,
     context.subjectId,
@@ -4949,7 +5337,7 @@ async function getHumanComposerDraft(deps, context) {
 }
 async function saveHumanComposerDraft(deps, context, input) {
   await authorizeHumanSessionCommand(deps, context, "session.composer.write");
-  const row = await withWorkspaceSubjectRls2(
+  const row = await withWorkspaceSubjectRls3(
     deps.db,
     context.workspaceId,
     context.subjectId,
@@ -4977,6 +5365,7 @@ export {
   SESSION_WORKFLOW_WAKE_DISPATCHER_WORKFLOW_TYPE,
   SessionAuthorizationDeniedError,
   SessionAuthorizationUnavailableError,
+  SessionSpawnDeniedError,
   acceptSessionUserMessage,
   activateRigVersionForApi,
   appendRigSetupCommand,
@@ -5012,6 +5401,7 @@ export {
   editHumanQueuePrompt,
   enableCapability,
   enabledCapabilityMcpToolRefs,
+  getActorNewSessionDraft,
   getCapabilityPack,
   getHumanComposerDraft,
   hasPermission,
@@ -5062,11 +5452,13 @@ export {
   rigActorForGrant,
   routingEnabled,
   runOnSandbox,
+  saveActorNewSessionDraft,
   saveHumanComposerDraft,
   scheduledTaskTemporalScheduleId,
   scheduledTaskToolsProvided,
   scheduledTaskTriggerToken,
   sendAgentSessionMessage,
+  sessionSpawnDenialEnvelope,
   sessionWithEffectiveToolPolicy,
   settingsWithEnabledCapabilityMcpServers,
   settingsWithMcpCapabilityServers,