@opengeni/core 0.4.6 → 0.4.8

package/dist/index.js

@@ -1,3 +1,8 @@
+// src/workflow-wake-contract.ts
+var SESSION_WORKFLOW_WAKE_DISPATCHER_SCHEDULE_ID = "opengeni-session-workflow-wake-dispatcher";
+var SESSION_WORKFLOW_WAKE_DISPATCHER_WORKFLOW_TYPE = "sessionWorkflowWakeDispatcherWorkflow";
+var SESSION_WORKFLOW_WAKE_DISPATCHER_PERIOD_MS = 1e4;
+
 // src/sandbox/fleet.ts
 import {
   getEnrollment,
@@ -10,7 +15,8 @@ import {
 import {
   NatsControlRpc as NatsControlRpc2,
   selfhostedLiveness,
-  SelfhostedSession
+  SelfhostedSession,
+  swapTargetEstablishability
 } from "@opengeni/runtime/sandbox";
 import { HTTPException } from "hono/http-exception";
 
@@ -63,7 +69,12 @@ function wrapChannelABoxWithRouting(services, ids, established) {
     defaultKind: established.backendId,
     getSandbox: async (sandboxId) => {
       const sandbox = await getSandbox(db, ids.workspaceId, sandboxId);
-      return sandbox ? { id: sandbox.id, kind: sandbox.kind, name: sandbox.name, enrollmentId: sandbox.enrollmentId } : null;
+      return sandbox ? {
+        id: sandbox.id,
+        kind: sandbox.kind,
+        name: sandbox.name,
+        enrollmentId: sandbox.enrollmentId
+      } : null;
     },
     controlRpcFactory: controlRpcFactory(bus),
     relay: relayConfigFromSettings(settings)
@@ -126,7 +137,9 @@ async function probeEnrollment(services, workspaceId, enrollment) {
       exposure: enrollment.exposure,
       allowScreenControl: enrollment.allowScreenControl,
       hasDisplay: enrollment.hasDisplay,
-      lastSeenAt: enrollment.lastSeenAt
+      lastSeenAt: enrollment.lastSeenAt,
+      wentOfflineAt: enrollment.wentOfflineAt,
+      wentOfflineReason: enrollment.wentOfflineReason
     },
     probeResponded
   });
@@ -171,7 +184,11 @@ async function listFleet(services, ctx) {
       lastSeenAt: enrollment?.lastSeenAt ?? null
     });
   }
-  return { activeSandboxId: pointer.activeSandboxId, activeEpoch: pointer.activeEpoch, sandboxes: entries };
+  return {
+    activeSandboxId: pointer.activeSandboxId,
+    activeEpoch: pointer.activeEpoch,
+    sandboxes: entries
+  };
 }
 async function resolveTarget(services, ctx, target) {
   if (target === ctx.sessionGroupId || target === "session" || target === "default") {
@@ -179,19 +196,42 @@ async function resolveTarget(services, ctx, target) {
   }
   const sandbox = await getSandbox2(services.db, ctx.workspaceId, target);
   if (!sandbox) {
-    return { ok: false, reason: `sandbox ${target} not found in this workspace` };
+    return {
+      ok: false,
+      reason: `sandbox ${target} not found in this workspace`,
+      code: "stale_pointer"
+    };
+  }
+  const establishable = swapTargetEstablishability({
+    kind: sandbox.kind,
+    isSessionGroup: false
+  });
+  if (!establishable.ok) {
+    return { ok: false, reason: establishable.reason, code: establishable.code };
   }
   if (sandbox.kind === "selfhosted") {
     if (!sandbox.enrollmentId) {
-      return { ok: false, reason: `selfhosted sandbox ${target} has no enrollment` };
+      return {
+        ok: false,
+        reason: `selfhosted sandbox ${target} has no enrollment`,
+        code: "offline_enrollment"
+      };
     }
     const enrollment = await getEnrollment(services.db, ctx.workspaceId, sandbox.enrollmentId);
     if (!enrollment) {
-      return { ok: false, reason: `enrollment for sandbox ${target} not found` };
+      return {
+        ok: false,
+        reason: `enrollment for sandbox ${target} not found`,
+        code: "offline_enrollment"
+      };
     }
     const probe = await probeEnrollment(services, ctx.workspaceId, enrollment);
     if (probe.liveness !== "online") {
-      return { ok: false, reason: `sandbox ${target} is ${probe.liveness}; cannot attach to a non-online machine` };
+      return {
+        ok: false,
+        reason: `sandbox ${target} is ${probe.liveness}; cannot attach to a non-online machine`,
+        code: "offline_enrollment"
+      };
     }
   }
   return { ok: true, targetSandboxId: sandbox.id };
@@ -203,7 +243,13 @@ async function swapActiveSandbox(services, ctx, target, workingDir) {
       activeSandboxId: null,
       activeEpoch: 0
     };
-    return { swapped: false, activeSandboxId: pointer2.activeSandboxId, activeEpoch: pointer2.activeEpoch, reason: resolved.reason };
+    return {
+      swapped: false,
+      activeSandboxId: pointer2.activeSandboxId,
+      activeEpoch: pointer2.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) ?? {
@@ -211,7 +257,11 @@ async function swapActiveSandbox(services, ctx, target, workingDir) {
       activeEpoch: 0
     };
     if (pointer2.activeSandboxId === resolved.targetSandboxId) {
-      return { swapped: true, activeSandboxId: pointer2.activeSandboxId, activeEpoch: pointer2.activeEpoch };
+      return {
+        swapped: true,
+        activeSandboxId: pointer2.activeSandboxId,
+        activeEpoch: pointer2.activeEpoch
+      };
     }
     const result = await setActiveSandbox(services.db, {
       accountId: ctx.accountId,
@@ -222,7 +272,11 @@ async function swapActiveSandbox(services, ctx, target, workingDir) {
       ...workingDir !== void 0 ? { workingDir } : {}
     });
     if (result.swapped && result.pointer) {
-      return { swapped: true, activeSandboxId: result.pointer.activeSandboxId, activeEpoch: result.pointer.activeEpoch };
+      return {
+        swapped: true,
+        activeSandboxId: result.pointer.activeSandboxId,
+        activeEpoch: result.pointer.activeEpoch
+      };
     }
   }
   const pointer = await readActiveSandbox2(services.db, ctx.workspaceId, ctx.sessionId) ?? {
@@ -233,13 +287,19 @@ async function swapActiveSandbox(services, ctx, target, workingDir) {
     swapped: false,
     activeSandboxId: pointer.activeSandboxId,
     activeEpoch: pointer.activeEpoch,
-    reason: "a concurrent swap won the epoch fence; re-read and retry"
+    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);
   if (!sandbox) {
-    return { target, kind: op.kind, ok: false, reason: `sandbox ${target} not found in this workspace` };
+    return {
+      target,
+      kind: op.kind,
+      ok: false,
+      reason: `sandbox ${target} not found in this workspace`
+    };
   }
   if (sandbox.kind !== "selfhosted" || !sandbox.enrollmentId) {
     return {
@@ -261,8 +321,18 @@ async function runOnSandbox(services, ctx, target, op) {
   });
   try {
     if (op.kind === "exec") {
-      const res = await session.exec({ cmd: op.cmd, ...op.workdir ? { workdir: op.workdir } : {} });
-      return { target, kind: "exec", ok: true, stdout: res.stdout, stderr: res.stderr, exitCode: res.exitCode };
+      const res = await session.exec({
+        cmd: op.cmd,
+        ...op.workdir ? { workdir: op.workdir } : {}
+      });
+      return {
+        target,
+        kind: "exec",
+        ok: true,
+        stdout: res.stdout,
+        stderr: res.stderr,
+        exitCode: res.exitCode
+      };
     }
     if (op.kind === "read") {
       const bytes = await session.readFile({ path: op.path });
@@ -301,12 +371,14 @@ async function provisionSandbox(services, ctx, input) {
   return {
     kind: "modal",
     sandbox,
-    note: "A named Modal sandbox record was created. Its box is materialized when first swapped-to; the session's own group box remains the default until then."
+    note: "A named Modal sandbox record was created, but it is NOT yet attachable as a swap target: routing a session onto a second Modal box is not supported yet, so a sandbox_swap to this id is rejected. Use the session's own box (the default) or attach a Connected Machine instead."
   };
 }
 
 // src/access/index.ts
-import { verifyDelegatedAccessToken } from "@opengeni/contracts";
+import {
+  verifyDelegatedAccessToken
+} from "@opengeni/contracts";
 import {
   bootstrapWorkspace,
   ensureManagedAccessForUser,
@@ -340,11 +412,25 @@ async function requireAccessGrant(c, deps, workspaceId, permission) {
 }
 function requirePermission(grant, permission) {
   if (!hasPermission(grant.permissions, permission)) {
+    if (permission === "variable-sets:use") {
+      throw new HTTPException2(403, {
+        message: "missing permission: variable-sets:use (deprecated alias: environments:use)"
+      });
+    }
+    if (permission === "variable-sets:manage") {
+      throw new HTTPException2(403, {
+        message: "missing permission: variable-sets:manage (deprecated alias: environments:manage)"
+      });
+    }
     throw new HTTPException2(403, { message: `missing permission: ${permission}` });
   }
 }
 function hasPermission(permissions, permission) {
-  return permissions.includes(permission) || permissions.includes("workspace:admin");
+  const aliases = {
+    "variable-sets:use": ["environments:use"],
+    "variable-sets:manage": ["environments:manage"]
+  };
+  return permissions.includes(permission) || (aliases[permission]?.some((alias) => permissions.includes(alias)) ?? false) || permissions.includes("workspace:admin");
 }
 async function resolveAccessContext(c, deps) {
   if (deps.settings.productAccessMode === "local") {
@@ -364,6 +450,10 @@ async function resolveAccessContext(c, deps) {
     if (delegated) {
       return delegated;
     }
+    const apiKey = await apiKeyAccessContext(c, deps, "configured");
+    if (apiKey) {
+      return apiKey;
+    }
     if (deps.settings.delegationSecret) {
       return null;
     }
@@ -384,29 +474,9 @@ async function resolveAccessContext(c, deps) {
     if (delegated) {
       return delegated;
     }
-    const apiKey = await findActiveApiKeyByHash(deps.db, await sha256Hex(bearer));
+    const apiKey = await apiKeyAccessContext(c, deps, "managed");
     if (apiKey) {
-      const accountPermissions = apiKey.workspaceId ? apiKey.permissions.filter((permission) => permission === "billing:read" || permission === "billing:manage") : apiKey.permissions;
-      return {
-        mode: "managed",
-        subjectId: `api_key:${apiKey.id}`,
-        subjectLabel: apiKey.name,
-        accountGrants: [{
-          accountId: apiKey.accountId,
-          subjectId: `api_key:${apiKey.id}`,
-          subjectLabel: apiKey.name,
-          permissions: accountPermissions
-        }],
-        workspaceGrants: apiKey.workspaceId ? [{
-          workspaceId: apiKey.workspaceId,
-          accountId: apiKey.accountId,
-          subjectId: `api_key:${apiKey.id}`,
-          subjectLabel: apiKey.name,
-          permissions: apiKey.permissions
-        }] : [],
-        defaultAccountId: apiKey.accountId,
-        defaultWorkspaceId: apiKey.workspaceId
-      };
+      return apiKey;
     }
   }
   if (deps.managedAuth) {
@@ -421,6 +491,44 @@ async function resolveAccessContext(c, deps) {
   }
   return null;
 }
+async function apiKeyAccessContext(c, deps, mode) {
+  const bearer = bearerToken(c);
+  if (!bearer) {
+    return null;
+  }
+  const apiKey = await findActiveApiKeyByHash(deps.db, await sha256Hex(bearer));
+  if (!apiKey) {
+    return null;
+  }
+  const subjectId = `api_key:${apiKey.id}`;
+  const accountPermissions = apiKey.workspaceId ? apiKey.permissions.filter(
+    (permission) => permission === "billing:read" || permission === "billing:manage"
+  ) : apiKey.permissions;
+  return {
+    mode,
+    subjectId,
+    subjectLabel: apiKey.name,
+    accountGrants: [
+      {
+        accountId: apiKey.accountId,
+        subjectId,
+        subjectLabel: apiKey.name,
+        permissions: accountPermissions
+      }
+    ],
+    workspaceGrants: apiKey.workspaceId ? [
+      {
+        workspaceId: apiKey.workspaceId,
+        accountId: apiKey.accountId,
+        subjectId,
+        subjectLabel: apiKey.name,
+        permissions: apiKey.permissions
+      }
+    ] : [],
+    defaultAccountId: apiKey.accountId,
+    defaultWorkspaceId: apiKey.workspaceId
+  };
+}
 async function delegatedAccessContext(c, deps, mode, token = bearerToken(c)) {
   if (!token || !deps.settings.delegationSecret) {
     return null;
@@ -433,22 +541,34 @@ async function delegatedAccessContext(c, deps, mode, token = bearerToken(c)) {
     mode,
     subjectId: payload.subjectId,
     ...payload.subjectLabel ? { subjectLabel: payload.subjectLabel } : {},
-    accountGrants: [{
-      accountId: payload.accountId,
-      subjectId: payload.subjectId,
-      ...payload.subjectLabel ? { subjectLabel: payload.subjectLabel } : {},
-      permissions: payload.permissions
-    }],
-    workspaceGrants: [{
-      workspaceId: payload.workspaceId,
-      accountId: payload.accountId,
-      subjectId: payload.subjectId,
-      ...payload.subjectLabel ? { subjectLabel: payload.subjectLabel } : {},
-      permissions: payload.permissions,
-      // sessionId is worker-asserted (HMAC-signed token claim), not agent
-      // controlled; it scopes session-bound MCP tools such as goal management.
-      metadata: { delegated: true, ...payload.sessionId ? { sessionId: payload.sessionId } : {} }
-    }],
+    accountGrants: [
+      {
+        accountId: payload.accountId,
+        subjectId: payload.subjectId,
+        ...payload.subjectLabel ? { subjectLabel: payload.subjectLabel } : {},
+        permissions: payload.permissions
+      }
+    ],
+    workspaceGrants: [
+      {
+        workspaceId: payload.workspaceId,
+        accountId: payload.accountId,
+        subjectId: payload.subjectId,
+        ...payload.subjectLabel ? { subjectLabel: payload.subjectLabel } : {},
+        permissions: payload.permissions,
+        // sessionId is worker-asserted (HMAC-signed token claim), not agent
+        // controlled; it scopes session-bound MCP tools such as goal management.
+        metadata: {
+          delegated: true,
+          ...payload.sessionId ? { sessionId: payload.sessionId } : {},
+          // Caller identity: the turn that minted this token. Tools classify the
+          // CALLER from this instead of re-reading the live active pointer.
+          ...payload.turnId ? { turnId: payload.turnId } : {},
+          ...payload.attemptId ? { attemptId: payload.attemptId } : {},
+          ...payload.executionGeneration ? { executionGeneration: payload.executionGeneration } : {}
+        }
+      }
+    ],
     defaultAccountId: payload.accountId,
     defaultWorkspaceId: payload.workspaceId
   };
@@ -483,10 +603,17 @@ async function requireLimit(deps, input) {
   if (decision.allowed) {
     return;
   }
-  throw new HTTPException3(decision.code === "insufficient_credits" ? 402 : 429, { message: decision.message });
+  throw new HTTPException3(decision.code === "insufficient_credits" ? 402 : 429, {
+    message: decision.message
+  });
 }
 async function checkLimit(deps, input) {
-  const codexBilled = input.workspaceId ? await isCodexBilledTurn({ db: deps.db, settings: deps.settings, workspaceId: input.workspaceId, model: input.model }) : false;
+  const codexBilled = input.workspaceId ? await isCodexBilledTurn({
+    db: deps.db,
+    settings: deps.settings,
+    workspaceId: input.workspaceId,
+    model: input.model
+  }) : false;
   const creditDecision = await checkCreditBalance(deps, input, codexBilled);
   if (!creditDecision.allowed) {
     return creditDecision;
@@ -518,7 +645,10 @@ async function checkStaticCaps(deps, input, codexBilled) {
       since: startOfUtcMonth()
     });
     if (used >= limits.maxMonthlyCostMicrosPerAccount) {
-      return blocked("max_monthly_cost_micros_per_account", `monthly model cost limit reached (${limits.maxMonthlyCostMicrosPerAccount} micros)`);
+      return blocked(
+        "max_monthly_cost_micros_per_account",
+        `monthly model cost limit reached (${limits.maxMonthlyCostMicrosPerAccount} micros)`
+      );
     }
   }
   switch (input.action) {
@@ -527,27 +657,39 @@ async function checkStaticCaps(deps, input, codexBilled) {
         return { allowed: true };
       }
       const count = await countWorkspacesForAccount(deps.db, input.accountId);
-      return count < limits.maxWorkspacesPerAccount ? { allowed: true } : blocked("max_workspaces_per_account", `workspace limit reached (${limits.maxWorkspacesPerAccount})`);
+      return count < limits.maxWorkspacesPerAccount ? { allowed: true } : blocked(
+        "max_workspaces_per_account",
+        `workspace limit reached (${limits.maxWorkspacesPerAccount})`
+      );
     }
     case "api_key:create": {
       if (!limits.maxApiKeysPerWorkspace || !input.workspaceId) {
         return { allowed: true };
       }
       const count = await countActiveApiKeysForWorkspace(deps.db, input.workspaceId);
-      return count < limits.maxApiKeysPerWorkspace ? { allowed: true } : blocked("max_api_keys_per_workspace", `API key limit reached (${limits.maxApiKeysPerWorkspace})`);
+      return count < limits.maxApiKeysPerWorkspace ? { allowed: true } : blocked(
+        "max_api_keys_per_workspace",
+        `API key limit reached (${limits.maxApiKeysPerWorkspace})`
+      );
     }
     case "schedule:create": {
       if (!limits.maxSchedulesPerWorkspace || !input.workspaceId) {
         return { allowed: true };
       }
       const count = await countScheduledTasksForWorkspace(deps.db, input.workspaceId);
-      return count < limits.maxSchedulesPerWorkspace ? { allowed: true } : blocked("max_schedules_per_workspace", `scheduled task limit reached (${limits.maxSchedulesPerWorkspace})`);
+      return count < limits.maxSchedulesPerWorkspace ? { allowed: true } : blocked(
+        "max_schedules_per_workspace",
+        `scheduled task limit reached (${limits.maxSchedulesPerWorkspace})`
+      );
     }
     case "file:upload": {
       if (!limits.maxFileUploadBytes || !input.quantity) {
         return { allowed: true };
       }
-      return input.quantity <= limits.maxFileUploadBytes ? { allowed: true } : blocked("max_file_upload_bytes", `file upload exceeds static limit of ${limits.maxFileUploadBytes} bytes`);
+      return input.quantity <= limits.maxFileUploadBytes ? { allowed: true } : blocked(
+        "max_file_upload_bytes",
+        `file upload exceeds static limit of ${limits.maxFileUploadBytes} bytes`
+      );
     }
     case "agent_run:create": {
       if (!limits.maxMonthlyAgentRunsPerWorkspace || !input.workspaceId) {
@@ -559,7 +701,10 @@ async function checkStaticCaps(deps, input, codexBilled) {
         since: startOfUtcMonth()
       });
       const requested = input.quantity ?? 0;
-      return used + requested <= limits.maxMonthlyAgentRunsPerWorkspace ? { allowed: true } : blocked("max_monthly_agent_runs_per_workspace", `monthly agent run limit reached (${limits.maxMonthlyAgentRunsPerWorkspace})`);
+      return used + requested <= limits.maxMonthlyAgentRunsPerWorkspace ? { allowed: true } : blocked(
+        "max_monthly_agent_runs_per_workspace",
+        `monthly agent run limit reached (${limits.maxMonthlyAgentRunsPerWorkspace})`
+      );
     }
     case "tokens:consume": {
       if (codexBilled || !limits.maxMonthlyTokensPerWorkspace || !input.workspaceId) {
@@ -571,7 +716,10 @@ async function checkStaticCaps(deps, input, codexBilled) {
         since: startOfUtcMonth()
       });
       const requested = input.quantity ?? 0;
-      return used + requested <= limits.maxMonthlyTokensPerWorkspace ? { allowed: true } : blocked("max_monthly_tokens_per_workspace", `monthly token limit reached (${limits.maxMonthlyTokensPerWorkspace})`);
+      return used + requested <= limits.maxMonthlyTokensPerWorkspace ? { allowed: true } : blocked(
+        "max_monthly_tokens_per_workspace",
+        `monthly token limit reached (${limits.maxMonthlyTokensPerWorkspace})`
+      );
     }
     case "document:index": {
       if (!limits.maxDocumentIndexedChunksPerWorkspace || !input.workspaceId) {
@@ -583,7 +731,10 @@ async function checkStaticCaps(deps, input, codexBilled) {
         since: startOfUtcMonth()
       });
       const requested = input.quantity ?? 0;
-      return used + requested <= limits.maxDocumentIndexedChunksPerWorkspace ? { allowed: true } : blocked("max_document_indexed_chunks_per_workspace", `monthly document indexing limit reached (${limits.maxDocumentIndexedChunksPerWorkspace} chunks)`);
+      return used + requested <= limits.maxDocumentIndexedChunksPerWorkspace ? { allowed: true } : blocked(
+        "max_document_indexed_chunks_per_workspace",
+        `monthly document indexing limit reached (${limits.maxDocumentIndexedChunksPerWorkspace} chunks)`
+      );
     }
   }
 }
@@ -604,7 +755,7 @@ function usesCreditLimits(deps) {
   return deps.settings.billingMode === "stripe" || deps.settings.usageLimitsMode === "managed";
 }
 function isCostlyAction(action) {
-  return action === "agent_run:create" || action === "tokens:consume" || action === "file:upload" || action === "document:index";
+  return action === "agent_run:create" || action === "tokens:consume" || action === "document:index";
 }
 function blocked(code, message) {
   return { allowed: false, code, message };
@@ -623,18 +774,18 @@ import {
   CapabilityCatalogItem
 } from "@opengeni/contracts";
 import {
-  decryptEnvironmentValue,
+  decryptVariableSetValue,
   decryptedCapabilityHeaders,
   disableCapabilityInstallation,
   enableCapabilityInstallation,
   enablePackInstallation,
-  encryptEnvironmentValue,
+  encryptVariableSetValue,
   getCapabilityCatalogItem,
   getCapabilityInstallation,
   getConnectionMetadata,
   getPackInstallation,
   getStoredCapabilityHeaderCiphertext,
-  getWorkspaceEnvironment as getWorkspaceEnvironment2,
+  getVariableSet as getVariableSet2,
   listCapabilityCatalogItems,
   listCapabilityInstallations,
   listEnabledMcpCapabilityServers,
@@ -647,10 +798,7 @@ import { HTTPException as HTTPException6 } from "hono/http-exception";
 
 // src/domain/environments.ts
 import { environmentsEncryptionKeyBytes } from "@opengeni/config";
-import {
-  getWorkspaceEnvironment,
-  recordAuditEvent
-} from "@opengeni/db";
+import { getVariableSet, recordAuditEvent } from "@opengeni/db";
 import { HTTPException as HTTPException4 } from "hono/http-exception";
 var MAX_ENVIRONMENTS_PER_WORKSPACE = 25;
 var MAX_VARIABLES_PER_ENVIRONMENT = 100;
@@ -671,6 +819,8 @@ var reservedExactNames = /* @__PURE__ */ new Set([
   "PERL5LIB",
   "GH_TOKEN",
   "GITHUB_TOKEN",
+  "GITLAB_TOKEN",
+  "AZURE_DEVOPS_EXT_PAT",
   "GIT_ASKPASS",
   "GIT_TERMINAL_PROMPT"
 ]);
@@ -682,46 +832,52 @@ var reservedPrefixes = [
   "LD_",
   "DYLD_"
 ];
-function assertAllowedEnvironmentVariableName(name) {
+function assertAllowedVariableSetVariableName(name) {
   if (reservedExactNames.has(name) || reservedPrefixes.some((prefix) => name.startsWith(prefix))) {
-    throw new HTTPException4(422, { message: `reserved environment variable name: ${name}` });
+    throw new HTTPException4(422, {
+      message: `reserved variable set variable name / reserved environment variable name: ${name}`
+    });
   }
 }
-function requireEnvironmentEncryption(settings) {
+var assertAllowedEnvironmentVariableName = assertAllowedVariableSetVariableName;
+function requireVariableSetEncryption(settings) {
   const key = environmentsEncryptionKeyBytes(settings);
   if (!key) {
-    throw new HTTPException4(503, { message: "workspace environments require OPENGENI_ENVIRONMENTS_ENCRYPTION_KEY" });
+    throw new HTTPException4(503, {
+      message: "variable sets require OPENGENI_ENVIRONMENTS_ENCRYPTION_KEY"
+    });
   }
   return key;
 }
-async function requireEnvironmentForApi(db, workspaceId, environmentId) {
-  const environment = await getWorkspaceEnvironment(db, workspaceId, environmentId);
-  if (!environment) {
-    throw new HTTPException4(404, { message: "environment not found" });
+var requireEnvironmentEncryption = requireVariableSetEncryption;
+async function requireVariableSetForApi(db, workspaceId, variableSetId) {
+  const variableSet = await getVariableSet(db, workspaceId, variableSetId);
+  if (!variableSet) {
+    throw new HTTPException4(404, { message: "variableSet not found" });
   }
-  return environment;
+  return variableSet;
 }
-async function validateEnvironmentAttachment(deps, grant, workspaceId, environmentId, options = {}) {
-  requireEnvironmentEncryption(deps.settings);
+async function validateVariableSetAttachment(deps, grant, workspaceId, variableSetId, options = {}) {
+  requireVariableSetEncryption(deps.settings);
   if (!options.preauthorized) {
-    requirePermission(grant, "environments:use");
+    requirePermission(grant, "variable-sets:use");
   }
-  const environment = await getWorkspaceEnvironment(deps.db, workspaceId, environmentId);
-  if (!environment) {
-    throw new HTTPException4(422, { message: "unknown environmentId" });
+  const variableSet = await getVariableSet(deps.db, workspaceId, variableSetId);
+  if (!variableSet) {
+    throw new HTTPException4(422, { message: "unknown variableSetId" });
   }
-  return environment;
+  return variableSet;
 }
-async function recordEnvironmentAuditEvent(db, input) {
+async function recordVariableSetAuditEvent(db, input) {
   await recordAuditEvent(db, {
     accountId: input.grant.accountId,
     workspaceId: input.grant.workspaceId,
     subjectId: input.grant.subjectId,
     action: input.action,
-    targetType: "workspace_environment",
-    targetId: input.environmentId,
+    targetType: "workspace_variable_set",
+    targetId: input.variableSetId,
     metadata: {
-      environmentId: input.environmentId,
+      variableSetId: input.variableSetId,
       ...input.variableName ? { name: input.variableName } : {}
     }
   });
@@ -731,7 +887,11 @@ async function recordEnvironmentAuditEvent(db, input) {
 import {
   CapabilityPack
 } from "@opengeni/contracts";
-import { getWorkspacePack, listPackInstallations, listWorkspacePacks } from "@opengeni/db";
+import {
+  getWorkspacePack,
+  listPackInstallations,
+  listWorkspacePacks
+} from "@opengeni/db";
 import { HTTPException as HTTPException5 } from "hono/http-exception";
 var MARKETING_SOCIAL_PACK_ID = "marketing-social-daily-analysis";
 var marketingSocialPack = {
@@ -780,7 +940,12 @@ var marketingSocialPack = {
       category: "social-media",
       authModel: "oauth2_authorization_code",
       providers: ["instagram", "facebook"],
-      scopes: ["instagram_basic", "instagram_manage_insights", "pages_read_engagement", "pages_show_list"],
+      scopes: [
+        "instagram_basic",
+        "instagram_manage_insights",
+        "pages_read_engagement",
+        "pages_show_list"
+      ],
       required: false,
       metadata: {
         docs: "https://developers.facebook.com/docs/instagram-platform/instagram-graph-api/"
@@ -804,7 +969,10 @@ var marketingSocialPack = {
       category: "social-media",
       authModel: "oauth2_authorization_code",
       providers: ["youtube"],
-      scopes: ["https://www.googleapis.com/auth/youtube.readonly", "https://www.googleapis.com/auth/yt-analytics.readonly"],
+      scopes: [
+        "https://www.googleapis.com/auth/youtube.readonly",
+        "https://www.googleapis.com/auth/yt-analytics.readonly"
+      ],
       required: false,
       metadata: {
         docs: "https://developers.google.com/youtube/v3"
@@ -957,16 +1125,24 @@ async function buildCapabilityCatalog(input) {
     listWorkspaceCapabilityPacks(input.db, input.workspaceId),
     discoverBundledSkills()
   ]);
-  const capabilityInstallationById = new Map(capabilityInstallations.map((installation) => [installation.capabilityId, installation]));
-  const activePackIds = new Set(packInstallations.filter((installation) => installation.status === "active").map((installation) => installation.packId));
+  const capabilityInstallationById = new Map(
+    capabilityInstallations.map((installation) => [installation.capabilityId, installation])
+  );
+  const activePackIds = new Set(
+    packInstallations.filter((installation) => installation.status === "active").map((installation) => installation.packId)
+  );
   const builtInPackIds = new Set(listCapabilityPacks().map((pack) => pack.id));
   const builtIns = [
-    ...workspacePacks.map((pack) => packCatalogItem(pack, builtInPackIds.has(pack.id) ? "built_in" : "manual")),
+    ...workspacePacks.map(
+      (pack) => packCatalogItem(pack, builtInPackIds.has(pack.id) ? "built_in" : "manual")
+    ),
     ...configuredMcpCatalogItems(input.settings),
     ...platformApiCatalogItems(),
     ...bundledSkills
   ];
-  const items = dedupeCatalogItems([...builtIns, ...persistedItems]).map((item) => applyCapabilityEnablement(item, capabilityInstallationById.get(item.id), activePackIds)).sort(compareCatalogItems);
+  const items = dedupeCatalogItems([...builtIns, ...persistedItems]).map(
+    (item) => applyCapabilityEnablement(item, capabilityInstallationById.get(item.id), activePackIds)
+  ).sort(compareCatalogItems);
   return {
     items,
     installations: capabilityInstallations
@@ -975,7 +1151,9 @@ async function buildCapabilityCatalog(input) {
 async function createCatalogItem(input) {
   const id = input.payload.id?.trim() || generatedCapabilityId(input.payload);
   if (id.startsWith("pack:")) {
-    throw new HTTPException6(422, { message: "packs are managed by OpenGeni and cannot be manually created" });
+    throw new HTTPException6(422, {
+      message: "packs are managed by OpenGeni and cannot be manually created"
+    });
   }
   const source = input.payload.source === "built_in" || input.payload.source === "configured" || input.payload.source === "registry" ? "manual" : input.payload.source;
   const metadata = {
@@ -1000,9 +1178,16 @@ async function createCatalogItem(input) {
   });
 }
 async function enableCapability(input) {
-  const item = await requireCatalogItem(input.db, input.workspaceId, input.settings, input.capabilityId);
+  const item = await requireCatalogItem(
+    input.db,
+    input.workspaceId,
+    input.settings,
+    input.capabilityId
+  );
   if (item.kind === "mcp" && !item.runtime.available) {
-    throw new HTTPException6(422, { message: "MCP capabilities need a remote streamable HTTP endpoint before they can be enabled" });
+    throw new HTTPException6(422, {
+      message: "MCP capabilities need a remote streamable HTTP endpoint before they can be enabled"
+    });
   }
   let installationMetadata = input.payload.metadata;
   const installationConfig = { ...input.payload.config };
@@ -1024,7 +1209,7 @@ async function enableCapability(input) {
     if (headers) {
       const key = requireCapabilityHeaderEncryption(input.settings);
       installationConfig.headersEncrypted = Object.fromEntries(
-        Object.entries(headers).map(([name, value]) => [name, encryptEnvironmentValue(key, value)])
+        Object.entries(headers).map(([name, value]) => [name, encryptVariableSetValue(key, value)])
       );
     }
   }
@@ -1036,36 +1221,44 @@ async function enableCapability(input) {
     }
     await assertPackSandboxImageCompatible(input.db, input.workspaceId, pack);
     const existing = await getPackInstallation(input.db, input.workspaceId, packId);
-    const storedEnvironmentId = typeof existing?.metadata.environmentId === "string" ? existing.metadata.environmentId : void 0;
-    const requestedEnvironmentId = input.payload.environmentId;
-    const environmentId = requestedEnvironmentId ?? storedEnvironmentId;
-    if (pack.environment?.required && !environmentId) {
+    const storedVariableSetId = typeof existing?.metadata.variableSetId === "string" ? existing.metadata.variableSetId : typeof existing?.metadata.environmentId === "string" ? existing.metadata.environmentId : void 0;
+    const requestedVariableSetId = input.payload.variableSetId;
+    const variableSetId = requestedVariableSetId ?? storedVariableSetId;
+    if (pack.variableSet?.required && !variableSetId) {
       throw new HTTPException6(422, {
-        message: `pack ${packId} requires an environment attachment; pass environmentId`
+        message: `pack ${packId} requires an variableSet attachment; pass variableSetId`
       });
     }
-    if (environmentId) {
-      if (requestedEnvironmentId) {
-        const environment = await validateEnvironmentAttachment(
+    if (variableSetId) {
+      if (requestedVariableSetId) {
+        const variableSet = await validateVariableSetAttachment(
           { settings: input.settings, db: input.db },
           input.grant,
           input.workspaceId,
-          requestedEnvironmentId
+          requestedVariableSetId
+        );
+        const missing = (pack.variableSet?.requiredVariables ?? []).filter(
+          (name) => !variableSet.variables.some((variable) => variable.name === name)
         );
-        const missing = (pack.environment?.requiredVariables ?? []).filter((name) => !environment.variables.some((variable) => variable.name === name));
         if (missing.length > 0) {
-          throw new HTTPException6(422, { message: `environment is missing required variable(s): ${missing.join(", ")}` });
+          throw new HTTPException6(422, {
+            message: `variable set is missing required variable(s): ${missing.join(", ")}`
+          });
         }
       } else {
-        const environment = await getWorkspaceEnvironment2(input.db, input.workspaceId, environmentId);
-        if (!environment) {
+        const variableSet = await getVariableSet2(input.db, input.workspaceId, variableSetId);
+        if (!variableSet) {
           throw new HTTPException6(422, {
-            message: `the stored environment attachment for pack ${packId} no longer exists; re-enable it with environmentId`
+            message: `the stored variableSet attachment for pack ${packId} no longer exists; re-enable it with variableSetId`
           });
         }
-        const missing = (pack.environment?.requiredVariables ?? []).filter((name) => !environment.variables.some((variable) => variable.name === name));
+        const missing = (pack.variableSet?.requiredVariables ?? []).filter(
+          (name) => !variableSet.variables.some((variable) => variable.name === name)
+        );
         if (missing.length > 0) {
-          throw new HTTPException6(422, { message: `environment is missing required variable(s): ${missing.join(", ")}` });
+          throw new HTTPException6(422, {
+            message: `variable set is missing required variable(s): ${missing.join(", ")}`
+          });
         }
       }
     }
@@ -1076,7 +1269,7 @@ async function enableCapability(input) {
       metadata: {
         ...input.payload.metadata,
         packVersion: pack.version,
-        ...environmentId ? { environmentId } : {}
+        ...variableSetId ? { variableSetId } : {}
       }
     });
   }
@@ -1095,13 +1288,22 @@ async function resolveMcpCredentialHeaders(input, item) {
     requireCapabilityHeaderEncryption(input.settings);
     return provided;
   }
-  const storedCiphertext = await getStoredCapabilityHeaderCiphertext(input.db, input.workspaceId, item.id);
+  const storedCiphertext = await getStoredCapabilityHeaderCiphertext(
+    input.db,
+    input.workspaceId,
+    item.id
+  );
   if (!storedCiphertext) {
     return null;
   }
   const key = requireCapabilityHeaderEncryption(input.settings);
   try {
-    return Object.fromEntries(Object.entries(storedCiphertext).map(([name, value]) => [name, decryptEnvironmentValue(key, value)]));
+    return Object.fromEntries(
+      Object.entries(storedCiphertext).map(([name, value]) => [
+        name,
+        decryptVariableSetValue(key, value)
+      ])
+    );
   } catch {
     throw new HTTPException6(422, {
       message: `stored credential headers for "${item.name}" could not be decrypted; supply them again in the enable request "headers" field`
@@ -1114,7 +1316,9 @@ function normalizedMcpCredentialHeaders(headers) {
     return null;
   }
   if (entries.length > maxMcpCredentialHeaders) {
-    throw new HTTPException6(422, { message: `an MCP capability supports at most ${maxMcpCredentialHeaders} credential headers` });
+    throw new HTTPException6(422, {
+      message: `an MCP capability supports at most ${maxMcpCredentialHeaders} credential headers`
+    });
   }
   const seen = /* @__PURE__ */ new Set();
   for (const [name, value] of entries) {
@@ -1127,17 +1331,23 @@ function normalizedMcpCredentialHeaders(headers) {
     }
     seen.add(lower);
     if (value.length === 0 || value.length > maxMcpCredentialHeaderValueLength) {
-      throw new HTTPException6(422, { message: `credential header ${name} must be 1-${maxMcpCredentialHeaderValueLength} characters` });
+      throw new HTTPException6(422, {
+        message: `credential header ${name} must be 1-${maxMcpCredentialHeaderValueLength} characters`
+      });
     }
     if (/[\u0000-\u0008\u000A-\u001F\u007F]/.test(value)) {
-      throw new HTTPException6(422, { message: `credential header ${name} contains forbidden control characters` });
+      throw new HTTPException6(422, {
+        message: `credential header ${name} contains forbidden control characters`
+      });
     }
   }
   return Object.fromEntries(entries);
 }
 async function validateMcpCapabilityConnectionRef(input, item, ref) {
   if (ref.subjectScope === "subject") {
-    throw new HTTPException6(422, { message: "subject-owned connection refs are not supported for agent runtime use yet" });
+    throw new HTTPException6(422, {
+      message: "subject-owned connection refs are not supported for agent runtime use yet"
+    });
   }
   const normalized = {
     providerDomain: ref.providerDomain.trim(),
@@ -1151,26 +1361,43 @@ async function validateMcpCapabilityConnectionRef(input, item, ref) {
     throw new HTTPException6(422, { message: "connectionRef.providerDomain is required" });
   }
   if (!item.endpointUrl || !item.runtime.mcpServerId) {
-    throw new HTTPException6(422, { message: "MCP capabilities need a remote streamable HTTP endpoint before they can use a connectionRef" });
+    throw new HTTPException6(422, {
+      message: "MCP capabilities need a remote streamable HTTP endpoint before they can use a connectionRef"
+    });
   }
   if (!normalized.connectionId) {
     return normalized;
   }
-  const connection = await getConnectionMetadata(input.db, input.workspaceId, normalized.connectionId, input.grant.subjectId);
+  const connection = await getConnectionMetadata(
+    input.db,
+    input.workspaceId,
+    normalized.connectionId,
+    input.grant.subjectId
+  );
   if (!connection) {
-    throw new HTTPException6(422, { message: "connectionRef.connectionId does not reference a visible connection" });
+    throw new HTTPException6(422, {
+      message: "connectionRef.connectionId does not reference a visible connection"
+    });
   }
   if (connection.subjectId !== null) {
-    throw new HTTPException6(422, { message: "agent runtime connection refs must reference workspace-shared connections in I1" });
+    throw new HTTPException6(422, {
+      message: "agent runtime connection refs must reference workspace-shared connections in I1"
+    });
   }
   if (connection.status !== "active") {
-    throw new HTTPException6(422, { message: `connectionRef.connectionId is not active (${connection.status})` });
+    throw new HTTPException6(422, {
+      message: `connectionRef.connectionId is not active (${connection.status})`
+    });
   }
   if (connection.providerDomain !== normalized.providerDomain) {
-    throw new HTTPException6(422, { message: "connectionRef.providerDomain does not match the referenced connection" });
+    throw new HTTPException6(422, {
+      message: "connectionRef.providerDomain does not match the referenced connection"
+    });
   }
   if (normalized.kind && connection.kind !== normalized.kind) {
-    throw new HTTPException6(422, { message: "connectionRef.kind does not match the referenced connection" });
+    throw new HTTPException6(422, {
+      message: "connectionRef.kind does not match the referenced connection"
+    });
   }
   return normalized;
 }
@@ -1210,7 +1437,9 @@ function requiredCapabilityHeaders(metadata) {
 function requireCapabilityHeaderEncryption(settings) {
   const key = environmentsEncryptionKeyBytes2(settings);
   if (!key) {
-    throw new HTTPException6(503, { message: "MCP credential headers require OPENGENI_ENVIRONMENTS_ENCRYPTION_KEY" });
+    throw new HTTPException6(503, {
+      message: "MCP credential headers require OPENGENI_ENVIRONMENTS_ENCRYPTION_KEY"
+    });
   }
   return key;
 }
@@ -1219,7 +1448,9 @@ async function validateMcpCapabilityConnection(item, probe = probeStreamableHttp
     return {};
   }
   if (!item.endpointUrl || !item.runtime.mcpServerId) {
-    throw new HTTPException6(422, { message: "MCP capabilities need a remote streamable HTTP endpoint before they can be enabled" });
+    throw new HTTPException6(422, {
+      message: "MCP capabilities need a remote streamable HTTP endpoint before they can be enabled"
+    });
   }
   try {
     const result = await probe({
@@ -1245,7 +1476,10 @@ async function validateMcpCapabilityConnection(item, probe = probeStreamableHttp
 async function probeStreamableHttpMcpServer(input) {
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), input.timeoutMs);
-  const client = new Client({ name: "opengeni-capability-probe", version: "0.1.0" }, { capabilities: {} });
+  const client = new Client(
+    { name: "opengeni-capability-probe", version: "0.1.0" },
+    { capabilities: {} }
+  );
   try {
     const transport = new StreamableHTTPClientTransport(new URL(input.url), {
       requestInit: {
@@ -1253,8 +1487,14 @@ async function probeStreamableHttpMcpServer(input) {
         ...input.headers ? { headers: input.headers } : {}
       }
     });
-    await client.connect(transport, { timeout: input.timeoutMs, maxTotalTimeout: input.timeoutMs });
-    const tools = await client.listTools(void 0, { timeout: input.timeoutMs, maxTotalTimeout: input.timeoutMs });
+    await client.connect(transport, {
+      timeout: input.timeoutMs,
+      maxTotalTimeout: input.timeoutMs
+    });
+    const tools = await client.listTools(void 0, {
+      timeout: input.timeoutMs,
+      maxTotalTimeout: input.timeoutMs
+    });
     return { toolCount: tools.tools.length };
   } finally {
     clearTimeout(timeout);
@@ -1264,18 +1504,32 @@ async function probeStreamableHttpMcpServer(input) {
 function mcpProbeErrorMessage(error, endpointUrl) {
   const message = error instanceof Error ? error.message : String(error);
   const normalized = message.replace(/\s+/g, " ").trim();
-  if (/404|405|not found|unexpected token|not valid json|invalid json|failed to parse|streamable http error|unable to connect|fetch failed|econnrefused|enotfound|timeout|aborted/i.test(normalized)) {
+  if (/404|405|not found|unexpected token|not valid json|invalid json|failed to parse|streamable http error|unable to connect|fetch failed|econnrefused|enotfound|timeout|aborted/i.test(
+    normalized
+  )) {
     return `OpenGeni could not reach a valid Streamable HTTP MCP server at ${endpointUrl}. Check the endpoint URL or choose a different catalog entry.`;
   }
   return `OpenGeni could not initialize ${endpointUrl}: ${normalized.slice(0, 500) || "unknown error"}`;
 }
 async function disableCapability(input) {
-  const item = await requireCatalogItem(input.db, input.workspaceId, input.settings, input.capabilityId);
+  const item = await requireCatalogItem(
+    input.db,
+    input.workspaceId,
+    input.settings,
+    input.capabilityId
+  );
   if ((item.source === "built_in" || item.source === "configured") && item.kind !== "pack") {
-    throw new HTTPException6(409, { message: "built-in and configured capabilities are always available; remove them from configuration to disable them" });
+    throw new HTTPException6(409, {
+      message: "built-in and configured capabilities are always available; remove them from configuration to disable them"
+    });
   }
   if (item.kind === "pack") {
-    await updatePackInstallationStatus(input.db, input.workspaceId, packIdFromCapabilityId(item.id), "disabled").catch(() => void 0);
+    await updatePackInstallationStatus(
+      input.db,
+      input.workspaceId,
+      packIdFromCapabilityId(item.id),
+      "disabled"
+    ).catch(() => void 0);
     if (!await getCapabilityInstallation(input.db, input.workspaceId, item.id)) {
       await enableCapabilityInstallation(input.db, {
         accountId: input.accountId,
@@ -1306,16 +1560,18 @@ function settingsWithMcpCapabilityServers(settings, enabled) {
     if (headers === "unavailable" && !server.connectionRef) {
       return [];
     }
-    return [{
-      id: server.id,
-      name: server.name,
-      url: server.url,
-      ...server.allowedTools ? { allowedTools: server.allowedTools } : {},
-      ...server.timeoutMs ? { timeoutMs: server.timeoutMs } : {},
-      cacheToolsList: server.cacheToolsList ?? false,
-      ...headers && headers !== "unavailable" ? { headers } : {},
-      ...server.connectionRef ? { connectionRef: server.connectionRef } : {}
-    }];
+    return [
+      {
+        id: server.id,
+        name: server.name,
+        url: server.url,
+        ...server.allowedTools ? { allowedTools: server.allowedTools } : {},
+        ...server.timeoutMs ? { timeoutMs: server.timeoutMs } : {},
+        cacheToolsList: server.cacheToolsList ?? false,
+        ...headers && headers !== "unavailable" ? { headers } : {},
+        ...server.connectionRef ? { connectionRef: server.connectionRef } : {}
+      }
+    ];
   });
   return dynamicServers.length ? { ...settings, mcpServers: [...settings.mcpServers, ...dynamicServers] } : settings;
 }
@@ -1369,7 +1625,10 @@ async function discoverMcpRegistryCapabilities(input) {
 async function fetchMcpRegistryPage(url, options = {}) {
   const fetchImpl = options.fetchImpl ?? fetch;
   const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), options.timeoutMs ?? mcpRegistryFetchTimeoutMs);
+  const timeout = setTimeout(
+    () => controller.abort(),
+    options.timeoutMs ?? mcpRegistryFetchTimeoutMs
+  );
   try {
     const response = await fetchImpl(url, { signal: controller.signal });
     if (!response.ok) {
@@ -1426,28 +1685,30 @@ function packCatalogItem(pack, source) {
   });
 }
 function configuredMcpCatalogItems(settings) {
-  return settings.mcpServers.map((server) => CapabilityCatalogItem.parse({
-    id: `mcp:${server.id}`,
-    kind: "mcp",
-    source: firstPartyMcpServerIds.has(server.id) ? "built_in" : "configured",
-    name: server.name ?? server.id,
-    description: firstPartyMcpDescription(server.id),
-    category: firstPartyMcpServerIds.has(server.id) ? "platform" : "configured",
-    tags: ["mcp", ...server.allowedTools?.length ? ["limited-tools"] : []],
-    endpointUrl: server.url,
-    tools: [{ kind: "mcp", id: server.id }],
-    runtime: {
-      available: true,
-      mcpServerId: server.id,
-      transport: "streamable-http",
-      notes: firstPartyMcpServerIds.has(server.id) ? "Available from OpenGeni runtime configuration." : "Configured through OPENGENI_MCP_SERVERS."
-    },
-    metadata: {
-      mcpServerId: server.id,
-      allowedTools: server.allowedTools ?? [],
-      cacheToolsList: server.cacheToolsList
-    }
-  }));
+  return settings.mcpServers.map(
+    (server) => CapabilityCatalogItem.parse({
+      id: `mcp:${server.id}`,
+      kind: "mcp",
+      source: firstPartyMcpServerIds.has(server.id) ? "built_in" : "configured",
+      name: server.name ?? server.id,
+      description: firstPartyMcpDescription(server.id),
+      category: firstPartyMcpServerIds.has(server.id) ? "platform" : "configured",
+      tags: ["mcp", ...server.allowedTools?.length ? ["limited-tools"] : []],
+      endpointUrl: server.url,
+      tools: [{ kind: "mcp", id: server.id }],
+      runtime: {
+        available: true,
+        mcpServerId: server.id,
+        transport: "streamable-http",
+        notes: firstPartyMcpServerIds.has(server.id) ? "Available from OpenGeni runtime configuration." : "Configured through OPENGENI_MCP_SERVERS."
+      },
+      metadata: {
+        mcpServerId: server.id,
+        allowedTools: server.allowedTools ?? [],
+        cacheToolsList: server.cacheToolsList
+      }
+    })
+  );
 }
 function platformApiCatalogItems() {
   return [
@@ -1483,46 +1744,56 @@ function platformApiCatalogItems() {
       tags: ["api", "schedules", "agents"],
       endpointPath: "/v1/workspaces/{workspaceId}/scheduled-tasks"
     }
-  ].map((item) => CapabilityCatalogItem.parse({
-    id: item.id,
-    name: item.name,
-    description: item.description,
-    category: item.category,
-    tags: item.tags,
-    kind: "api",
-    source: "built_in",
-    runtime: {
-      available: true,
-      notes: "Available through the OpenGeni API."
-    },
-    metadata: {
-      endpointPath: item.endpointPath
-    }
-  }));
+  ].map(
+    (item) => CapabilityCatalogItem.parse({
+      id: item.id,
+      name: item.name,
+      description: item.description,
+      category: item.category,
+      tags: item.tags,
+      kind: "api",
+      source: "built_in",
+      runtime: {
+        available: true,
+        notes: "Available through the OpenGeni API."
+      },
+      metadata: {
+        endpointPath: item.endpointPath
+      }
+    })
+  );
 }
 async function discoverBundledSkills() {
-  const skillsDir = new URL("../../../../packages/runtime/src/bundled_hashicorp_terraform_skills/", import.meta.url);
+  const skillsDir = new URL(
+    "../../../../packages/runtime/src/bundled_hashicorp_terraform_skills/",
+    import.meta.url
+  );
   try {
     const entries = await readdir(skillsDir, { withFileTypes: true });
-    const skills = await Promise.all(entries.filter((entry) => entry.isDirectory()).map(async (entry) => {
-      const skill = await readSkillMetadata(new URL(`${entry.name}/SKILL.md`, skillsDir), entry.name);
-      return CapabilityCatalogItem.parse({
-        id: `skill:${entry.name}`,
-        kind: "skill",
-        source: "built_in",
-        name: skill.name,
-        description: skill.description,
-        category: skill.category,
-        tags: ["skill", skill.category],
-        runtime: {
-          available: true,
-          notes: "Bundled into the sandbox skill library."
-        },
-        metadata: {
-          path: `packages/runtime/src/bundled_hashicorp_terraform_skills/${entry.name}/SKILL.md`
-        }
-      });
-    }));
+    const skills = await Promise.all(
+      entries.filter((entry) => entry.isDirectory()).map(async (entry) => {
+        const skill = await readSkillMetadata(
+          new URL(`${entry.name}/SKILL.md`, skillsDir),
+          entry.name
+        );
+        return CapabilityCatalogItem.parse({
+          id: `skill:${entry.name}`,
+          kind: "skill",
+          source: "built_in",
+          name: skill.name,
+          description: skill.description,
+          category: skill.category,
+          tags: ["skill", skill.category],
+          runtime: {
+            available: true,
+            notes: "Bundled into the sandbox skill library."
+          },
+          metadata: {
+            path: `packages/runtime/src/bundled_hashicorp_terraform_skills/${entry.name}/SKILL.md`
+          }
+        });
+      })
+    );
     return skills;
   } catch {
     return [];
@@ -1599,7 +1870,11 @@ function firstPartyMcpDescription(id) {
   return null;
 }
 function generatedCapabilityId(payload) {
-  const source = [payload.kind, payload.name, payload.endpointUrl ?? payload.installUrl ?? payload.homepageUrl ?? ""].join(":");
+  const source = [
+    payload.kind,
+    payload.name,
+    payload.endpointUrl ?? payload.installUrl ?? payload.homepageUrl ?? ""
+  ].join(":");
   return `${payload.kind}:${slugify(payload.name)}-${shortHash(source)}`;
 }
 function publicRegistryCapabilityId(name, version, endpointUrl) {
@@ -1637,7 +1912,9 @@ function mcpRegistryEntryToCatalogItem(entry) {
   if (official?.isLatest === false) {
     return null;
   }
-  const remote = server.remotes?.find((candidate) => candidate.type === "streamable-http" && candidate.url);
+  const remote = server.remotes?.find(
+    (candidate) => candidate.type === "streamable-http" && candidate.url
+  );
   const endpointUrl = validUrl(remote?.url);
   if (!remote || !endpointUrl) {
     return null;
@@ -1654,7 +1931,12 @@ function mcpRegistryEntryToCatalogItem(entry) {
     name: server.title || server.name,
     description: server.description ?? null,
     category: "public-mcp",
-    tags: ["mcp", "public", "registry", ...requiredHeaders.length ? ["requires-credentials"] : []],
+    tags: [
+      "mcp",
+      "public",
+      "registry",
+      ...requiredHeaders.length ? ["requires-credentials"] : []
+    ],
     homepageUrl,
     endpointUrl,
     installUrl: homepageUrl,
@@ -1732,6 +2014,367 @@ function storedConnectionRef(config) {
   return !!ref && typeof ref === "object" && !Array.isArray(ref) && typeof ref.providerDomain === "string";
 }
 
+// src/rigs/index.ts
+import {
+  activateRigVersion,
+  countRigs,
+  createRig,
+  createRigChange,
+  createRigVersion,
+  createRigVersionForChangePromotion,
+  deleteRigIfNoActiveSessions,
+  getRig,
+  getRigByName,
+  getRigChange,
+  getRigVersion,
+  getVariableSet as getVariableSet3,
+  listRigChanges,
+  listRigVersions,
+  recordAuditEvent as recordAuditEvent2,
+  RigActiveVersionChangedError,
+  RigChangeTransitionError,
+  updateRig
+} from "@opengeni/db";
+import { HTTPException as HTTPException7 } from "hono/http-exception";
+var MAX_RIGS_PER_WORKSPACE = 50;
+var MAX_CHECKS_PER_RIG = 100;
+var MAX_CREDENTIAL_HOOKS_PER_RIG = 50;
+var MAX_DEFAULT_VARIABLE_SETS_PER_RIG = 25;
+async function recordRigAuditEvent(db, input) {
+  await recordAuditEvent2(db, {
+    accountId: input.grant.accountId,
+    workspaceId: input.grant.workspaceId,
+    subjectId: input.grant.subjectId,
+    action: input.action,
+    targetType: "rig",
+    targetId: input.rigId,
+    metadata: { rigId: input.rigId, ...input.metadata ?? {} }
+  });
+}
+function rigActorForGrant(grant) {
+  return `user:${grant.subjectId}`;
+}
+async function requireRigForApi(db, workspaceId, rigId) {
+  const rig = await getRig(db, workspaceId, rigId);
+  if (!rig) {
+    throw new HTTPException7(404, { message: "rig not found" });
+  }
+  return rig;
+}
+async function requireRigChangeForApi(db, workspaceId, rigId, changeId) {
+  const change = await getRigChange(db, workspaceId, changeId);
+  if (!change || change.rigId !== rigId) {
+    throw new HTTPException7(404, { message: "rig change not found" });
+  }
+  return change;
+}
+function trimmedRigName(name) {
+  const trimmed = name.trim();
+  if (!trimmed) {
+    throw new HTTPException7(422, { message: "rig name is required" });
+  }
+  return trimmed;
+}
+function assertUniqueCheckNames(checks) {
+  if (!checks) {
+    return;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const check of checks) {
+    if (seen.has(check.name)) {
+      throw new HTTPException7(422, { message: `duplicate rig check name: ${check.name}` });
+    }
+    seen.add(check.name);
+  }
+}
+async function assertVariableSetsExist(db, workspaceId, ids) {
+  if (!ids || ids.length === 0) {
+    return;
+  }
+  const unique = [...new Set(ids)];
+  for (const id of unique) {
+    const variableSet = await getVariableSet3(db, workspaceId, id);
+    if (!variableSet) {
+      throw new HTTPException7(422, { message: `unknown defaultVariableSetId: ${id}` });
+    }
+  }
+}
+async function createRigForApi(deps, grant, payload) {
+  const workspaceId = grant.workspaceId;
+  const name = trimmedRigName(payload.name);
+  assertUniqueCheckNames(payload.checks);
+  await assertVariableSetsExist(deps.db, workspaceId, payload.defaultVariableSetIds);
+  if (await countRigs(deps.db, workspaceId) >= MAX_RIGS_PER_WORKSPACE) {
+    throw new HTTPException7(422, {
+      message: `a workspace supports at most ${MAX_RIGS_PER_WORKSPACE} rigs`
+    });
+  }
+  if (await getRigByName(deps.db, workspaceId, name)) {
+    throw new HTTPException7(409, { message: `rig name is already in use: ${name}` });
+  }
+  const createdBy = rigActorForGrant(grant);
+  const rig = await createRig(deps.db, {
+    accountId: grant.accountId,
+    workspaceId,
+    name,
+    description: payload.description ?? null,
+    createdBy,
+    initialVersion: {
+      image: payload.image ?? null,
+      setupScript: payload.setupScript ?? null,
+      checks: payload.checks,
+      credentialHooks: payload.credentialHooks,
+      defaultVariableSetIds: payload.defaultVariableSetIds,
+      changelog: "Initial version",
+      createdBy
+    }
+  });
+  await recordRigAuditEvent(deps.db, { grant, action: "rig.created", rigId: rig.id });
+  return rig;
+}
+async function updateRigForApi(deps, grant, rig, payload) {
+  const workspaceId = grant.workspaceId;
+  const name = payload.name !== void 0 ? trimmedRigName(payload.name) : void 0;
+  if (name !== void 0 && name !== rig.name) {
+    const existing = await getRigByName(deps.db, workspaceId, name);
+    if (existing && existing.id !== rig.id) {
+      throw new HTTPException7(409, { message: `rig name is already in use: ${name}` });
+    }
+  }
+  const updated = await updateRig(deps.db, workspaceId, rig.id, {
+    ...name !== void 0 ? { name } : {},
+    ...payload.description !== void 0 ? { description: payload.description } : {}
+  });
+  await recordRigAuditEvent(deps.db, { grant, action: "rig.updated", rigId: rig.id });
+  return updated;
+}
+async function deleteRigForApi(deps, grant, rig) {
+  const workspaceId = grant.workspaceId;
+  const deleted = await deleteRigIfNoActiveSessions(deps.db, workspaceId, rig.id);
+  if (deleted.activeSessionCount > 0) {
+    throw new HTTPException7(409, {
+      message: `rig is referenced by ${deleted.activeSessionCount} active session(s); it cannot be deleted`
+    });
+  }
+  if (!deleted.deleted) {
+    throw new HTTPException7(404, { message: "rig not found" });
+  }
+  await recordRigAuditEvent(deps.db, { grant, action: "rig.deleted", rigId: rig.id });
+}
+async function proposeRigChangeForApi(deps, grant, rig, request, options = {}) {
+  const workspaceId = grant.workspaceId;
+  if (!rig.activeVersion) {
+    throw new HTTPException7(422, { message: "rig has no active version to base a change on" });
+  }
+  if (request.kind === "definition_edit") {
+    assertUniqueCheckNames(request.payload.checks);
+    await assertVariableSetsExist(
+      deps.db,
+      workspaceId,
+      request.payload.defaultVariableSetIds ?? void 0
+    );
+  }
+  const change = await createRigChange(deps.db, {
+    accountId: grant.accountId,
+    workspaceId,
+    rigId: rig.id,
+    baseVersionId: rig.activeVersion.id,
+    kind: request.kind,
+    payload: request.payload,
+    proposedBy: options.proposedBy ?? rigActorForGrant(grant)
+  });
+  await recordRigAuditEvent(deps.db, {
+    grant,
+    action: "rig.change.proposed",
+    rigId: rig.id,
+    metadata: { changeId: change.id, kind: change.kind }
+  });
+  return change;
+}
+function classifyRigVerificationOutcome(input) {
+  if (input.infraError) {
+    return { status: "failed", action: "retryable_failure" };
+  }
+  if (!input.passed) {
+    return { status: "rejected", action: "reject" };
+  }
+  if (input.kind === "setup_append") {
+    return { status: "merged", action: "auto_promote" };
+  }
+  return { status: "proposed", action: "await_manage_promote" };
+}
+function appendRigSetupCommand(baseSetupScript, command) {
+  const base = (baseSetupScript ?? "").trimEnd();
+  return base ? `${base}
+${command}` : command;
+}
+async function promoteChangeWithActiveCas(deps, workspaceId, rigId, changeId, input) {
+  try {
+    return await createRigVersionForChangePromotion(deps.db, workspaceId, rigId, changeId, input);
+  } catch (error) {
+    if (error instanceof RigActiveVersionChangedError) {
+      throw new HTTPException7(409, {
+        message: `rig moved since this change was verified (base ${error.expectedVersionId}, now ${error.actualVersionId ?? "none"}); re-verify before promoting`
+      });
+    }
+    if (error instanceof RigChangeTransitionError) {
+      throw new HTTPException7(409, { message: error.message });
+    }
+    throw error;
+  }
+}
+async function promoteSetupAppendChange(deps, grant, rig, change) {
+  if (change.kind !== "setup_append") {
+    throw new HTTPException7(422, {
+      message: "only setup_append changes auto-promote through this path"
+    });
+  }
+  if (change.status !== "proposed" && change.status !== "verifying") {
+    throw new HTTPException7(409, { message: `rig change is ${change.status}; cannot promote` });
+  }
+  if (!change.baseVersionId) {
+    throw new HTTPException7(422, { message: "rig change has no base version" });
+  }
+  const base = await getRigVersion(deps.db, grant.workspaceId, rig.id, change.baseVersionId);
+  if (!base) {
+    throw new HTTPException7(404, { message: "base rig version not found" });
+  }
+  const payload = change.payload;
+  if (typeof payload.command !== "string" || !payload.command.trim()) {
+    throw new HTTPException7(422, { message: "setup_append change is missing command" });
+  }
+  const { version, change: updated } = await promoteChangeWithActiveCas(
+    deps,
+    grant.workspaceId,
+    rig.id,
+    change.id,
+    {
+      expectedActiveVersionId: change.baseVersionId,
+      image: base.image,
+      setupScript: appendRigSetupCommand(base.setupScript, payload.command),
+      checks: base.checks,
+      credentialHooks: base.credentialHooks,
+      defaultVariableSetIds: base.defaultVariableSetIds,
+      changelog: typeof payload.note === "string" && payload.note.trim() ? payload.note : "Verified setup append",
+      createdBy: change.proposedBy ?? rigActorForGrant(grant)
+    }
+  );
+  await recordRigAuditEvent(deps.db, {
+    grant,
+    action: "rig.change.merged",
+    rigId: rig.id,
+    metadata: { changeId: change.id, versionId: version.id, version: version.version }
+  });
+  await recordRigAuditEvent(deps.db, {
+    grant,
+    action: "rig.version.promoted",
+    rigId: rig.id,
+    metadata: { changeId: change.id, versionId: version.id, version: version.version }
+  });
+  return { change: updated, version };
+}
+async function promoteVerifiedDefinitionEditChangeForApi(deps, grant, rig, change) {
+  if (change.kind !== "definition_edit") {
+    throw new HTTPException7(422, { message: "only definition_edit changes use explicit promote" });
+  }
+  if (change.status !== "proposed") {
+    throw new HTTPException7(409, { message: `rig change is ${change.status}; cannot promote` });
+  }
+  if (change.verification?.passed !== true) {
+    throw new HTTPException7(422, {
+      message: "definition_edit change must pass verification before promote"
+    });
+  }
+  if (!change.baseVersionId) {
+    throw new HTTPException7(422, { message: "rig change has no base version" });
+  }
+  const base = await getRigVersion(deps.db, grant.workspaceId, rig.id, change.baseVersionId);
+  if (!base) {
+    throw new HTTPException7(404, { message: "base rig version not found" });
+  }
+  const payload = change.payload;
+  const { version, change: updated } = await promoteChangeWithActiveCas(
+    deps,
+    grant.workspaceId,
+    rig.id,
+    change.id,
+    {
+      expectedActiveVersionId: change.baseVersionId,
+      image: payload.image === void 0 ? base.image : payload.image,
+      setupScript: payload.setupScript === void 0 ? base.setupScript : payload.setupScript,
+      checks: Array.isArray(payload.checks) ? payload.checks : base.checks,
+      credentialHooks: Array.isArray(payload.credentialHooks) ? payload.credentialHooks : base.credentialHooks,
+      defaultVariableSetIds: Array.isArray(payload.defaultVariableSetIds) ? payload.defaultVariableSetIds : base.defaultVariableSetIds,
+      changelog: typeof payload.changelog === "string" && payload.changelog.trim() ? payload.changelog : "Verified definition edit",
+      createdBy: rigActorForGrant(grant)
+    }
+  );
+  await recordRigAuditEvent(deps.db, {
+    grant,
+    action: "rig.change.merged",
+    rigId: rig.id,
+    metadata: { changeId: change.id, versionId: version.id, version: version.version }
+  });
+  await recordRigAuditEvent(deps.db, {
+    grant,
+    action: "rig.version.promoted",
+    rigId: rig.id,
+    metadata: { changeId: change.id, versionId: version.id, version: version.version }
+  });
+  return { change: updated, version };
+}
+async function createRigVersionForApi(deps, grant, rig, payload) {
+  if (!rig.activeVersion) {
+    throw new HTTPException7(422, { message: "rig has no active version" });
+  }
+  assertUniqueCheckNames(payload.checks);
+  await assertVariableSetsExist(
+    deps.db,
+    grant.workspaceId,
+    payload.defaultVariableSetIds ?? void 0
+  );
+  const base = rig.activeVersion;
+  const version = await createRigVersion(
+    deps.db,
+    grant.workspaceId,
+    rig.id,
+    {
+      image: payload.image === void 0 ? base.image : payload.image,
+      setupScript: payload.setupScript === void 0 ? base.setupScript : payload.setupScript,
+      checks: payload.checks ?? base.checks,
+      credentialHooks: payload.credentialHooks ?? base.credentialHooks,
+      defaultVariableSetIds: payload.defaultVariableSetIds ?? base.defaultVariableSetIds,
+      changelog: payload.changelog ?? "Manager-created version",
+      createdBy: rigActorForGrant(grant)
+    },
+    { activate: true }
+  );
+  await recordRigAuditEvent(deps.db, {
+    grant,
+    action: "rig.version.promoted",
+    rigId: rig.id,
+    metadata: { versionId: version.id, version: version.version, direct: true }
+  });
+  return version;
+}
+async function activateRigVersionForApi(deps, grant, rig, versionId) {
+  const workspaceId = grant.workspaceId;
+  const version = await activateRigVersion(deps.db, workspaceId, rig.id, versionId);
+  await recordRigAuditEvent(deps.db, {
+    grant,
+    action: "rig.version.activated",
+    rigId: rig.id,
+    metadata: { versionId: version.id, version: version.version }
+  });
+  return version;
+}
+async function listRigVersionsForApi(deps, workspaceId, rigId) {
+  return await listRigVersions(deps.db, workspaceId, rigId);
+}
+async function listRigChangesForApi(deps, workspaceId, rigId, limit) {
+  return await listRigChanges(deps.db, workspaceId, rigId, limit);
+}
+
 // src/domain/resources.ts
 import {
   mergeResourceRefs as mergeContractResourceRefs,
@@ -1740,26 +2383,27 @@ import {
   ResourceRefConflictError,
   stableJson
 } from "@opengeni/contracts";
-import {
-  listGitHubInstallationIdsForWorkspace,
-  requireFile
-} from "@opengeni/db";
-import { HTTPException as HTTPException7 } from "hono/http-exception";
+import { listGitHubInstallationIdsForWorkspace, requireFile } from "@opengeni/db";
+import { HTTPException as HTTPException8 } from "hono/http-exception";
 function validateToolRefs(tools, settings) {
   const mcpServerIds = new Set(settings.mcpServers.map((server) => server.id));
   const out = [];
   for (const tool of tools) {
     if (tool.kind !== "mcp") {
-      throw new HTTPException7(422, { message: `unsupported tool kind: ${tool.kind}` });
+      throw new HTTPException8(422, {
+        message: `unsupported tool kind: ${tool.kind}`
+      });
     }
     const optional = tool.optional === true;
     if (!mcpServerIds.has(tool.id)) {
       if (optional) {
         continue;
       }
-      throw new HTTPException7(422, { message: `unknown MCP server id: ${tool.id}` });
+      throw new HTTPException8(422, { message: `unknown MCP server id: ${tool.id}` });
     }
-    out.push(optional ? { kind: "mcp", id: tool.id, optional: true } : { kind: "mcp", id: tool.id });
+    out.push(
+      optional ? { kind: "mcp", id: tool.id, optional: true } : { kind: "mcp", id: tool.id }
+    );
   }
   return mergeToolRefs([], out);
 }
@@ -1787,12 +2431,12 @@ function normalizeResources(resources) {
     } else {
       const url = parseResourceUrl(resource.uri);
       if (url.protocol !== "https:" || !url.hostname) {
-        throw new HTTPException7(422, { message: "repository resources must use HTTPS Git URLs" });
+        throw new HTTPException8(422, { message: "repository resources must use HTTPS Git URLs" });
       }
       const path = url.pathname.replace(/^\/+|\/+$/g, "").replace(/\.git$/, "");
       const parts = path.split("/").filter(Boolean);
       if (parts.length < 2) {
-        throw new HTTPException7(422, { message: "repository URL must include owner and repo" });
+        throw new HTTPException8(422, { message: "repository URL must include owner and repo" });
       }
       const repo = parts.join("/");
       const mountPath = normalizeMountPath(resource.mountPath ?? `repos/${repo}`);
@@ -1802,6 +2446,11 @@ function normalizeResources(resources) {
         ref: resource.ref.trim(),
         mountPath,
         ...resource.subpath ? { subpath: normalizeMountPath(resource.subpath) } : {},
+        ...resource.provider ? { provider: resource.provider } : {},
+        ...resource.repositoryId !== void 0 ? { repositoryId: resource.repositoryId } : {},
+        ...resource.installationId !== void 0 ? { installationId: resource.installationId } : {},
+        ...resource.projectId !== void 0 ? { projectId: resource.projectId } : {},
+        ...resource.connectionId ? { connectionId: resource.connectionId } : {},
         ...resource.githubInstallationId ? { githubInstallationId: resource.githubInstallationId } : {},
         ...resource.githubRepositoryId ? { githubRepositoryId: resource.githubRepositoryId } : {}
       };
@@ -1809,7 +2458,9 @@ function normalizeResources(resources) {
     const key = stableJson(normalized);
     const mounted = normalized.mountPath ? mountPaths.get(normalized.mountPath) : void 0;
     if (mounted && mounted !== key) {
-      throw new HTTPException7(422, { message: `duplicate resource mount path: ${normalized.mountPath}` });
+      throw new HTTPException8(422, {
+        message: `duplicate resource mount path: ${normalized.mountPath}`
+      });
     }
     if (normalized.mountPath) {
       mountPaths.set(normalized.mountPath, key);
@@ -1817,7 +2468,9 @@ function normalizeResources(resources) {
     const identity = resourceIdentityKey(normalized);
     const seenIdentity = identities.get(identity);
     if (seenIdentity && seenIdentity !== key) {
-      throw new HTTPException7(422, { message: `duplicate resource with different settings: ${identity}` });
+      throw new HTTPException8(422, {
+        message: `duplicate resource with different settings: ${identity}`
+      });
     }
     identities.set(identity, key);
     if (!seenResources.has(key)) {
@@ -1832,7 +2485,7 @@ function mergeResourceRefs(existing, additions) {
     return mergeContractResourceRefs(existing, additions, { rejectConflicts: true });
   } catch (error) {
     if (error instanceof ResourceRefConflictError) {
-      throw new HTTPException7(422, { message: error.message });
+      throw new HTTPException8(422, { message: error.message });
     }
     throw error;
   }
@@ -1842,8 +2495,8 @@ function validateGitHubRepositorySelectionShape(resources) {
     if (resource.kind !== "repository") {
       return [];
     }
-    const installationRaw = resource.githubInstallationId;
-    const repositoryRaw = resource.githubRepositoryId;
+    const installationRaw = resource.githubInstallationId ?? (resource.provider === "github" ? resource.installationId : void 0);
+    const repositoryRaw = resource.githubRepositoryId ?? (resource.provider === "github" ? resource.repositoryId : void 0);
     if (installationRaw === null && repositoryRaw === null) {
       return [];
     }
@@ -1853,7 +2506,7 @@ function validateGitHubRepositorySelectionShape(resources) {
     const installationId2 = positiveInteger(installationRaw);
     const repositoryId = positiveInteger(repositoryRaw);
     if (!installationId2 || !repositoryId) {
-      throw new HTTPException7(422, {
+      throw new HTTPException8(422, {
         message: "GitHub App repository resources require positive github_installation_id and github_repository_id"
       });
     }
@@ -1864,7 +2517,7 @@ function validateGitHubRepositorySelectionShape(resources) {
   }
   const installationId = selected[0].installationId;
   if (selected.some((item) => item.installationId !== installationId)) {
-    throw new HTTPException7(422, {
+    throw new HTTPException8(422, {
       message: "GitHub App repository resources must belong to one installation"
     });
   }
@@ -1875,9 +2528,11 @@ async function validateGitHubRepositorySelection(db, workspaceId, resources) {
   if (installationId === null) {
     return;
   }
-  const linkedInstallationIds = new Set(await listGitHubInstallationIdsForWorkspace(db, workspaceId));
+  const linkedInstallationIds = new Set(
+    await listGitHubInstallationIdsForWorkspace(db, workspaceId)
+  );
   if (!linkedInstallationIds.has(installationId)) {
-    throw new HTTPException7(422, {
+    throw new HTTPException8(422, {
       message: "GitHub App repository resources must belong to a GitHub App installation linked to this workspace"
     });
   }
@@ -1889,22 +2544,24 @@ async function validateFileResources(db, workspaceId, resources) {
       continue;
     }
     if (fileIds.has(resource.fileId)) {
-      throw new HTTPException7(422, { message: `duplicate file resource: ${resource.fileId}` });
+      throw new HTTPException8(422, { message: `duplicate file resource: ${resource.fileId}` });
     }
     fileIds.add(resource.fileId);
     const file = await requireFile(db, workspaceId, resource.fileId).catch(() => null);
     if (!file) {
-      throw new HTTPException7(422, { message: `unknown file resource: ${resource.fileId}` });
+      throw new HTTPException8(422, { message: `unknown file resource: ${resource.fileId}` });
     }
     if (file.status !== "ready") {
-      throw new HTTPException7(422, { message: `file resource ${resource.fileId} is ${file.status}` });
+      throw new HTTPException8(422, {
+        message: `file resource ${resource.fileId} is ${file.status}`
+      });
     }
   }
 }
 function normalizeMountPath(path) {
   const normalized = path.trim().replace(/^\/+|\/+$/g, "");
   if (!normalized || normalized.includes("..")) {
-    throw new HTTPException7(422, { message: `invalid resource mount path: ${path}` });
+    throw new HTTPException8(422, { message: `invalid resource mount path: ${path}` });
   }
   return normalized;
 }
@@ -1912,7 +2569,7 @@ function parseResourceUrl(uri) {
   try {
     return new URL(uri);
   } catch {
-    throw new HTTPException7(422, { message: "repository resources must use valid URLs" });
+    throw new HTTPException8(422, { message: "repository resources must use valid URLs" });
   }
 }
 function positiveInteger(value) {
@@ -1929,38 +2586,52 @@ function positiveInteger(value) {
 import {
   createScheduledTask,
   deleteScheduledTask,
+  getRig as getRig3,
   getScheduledTask,
   updateScheduledTask
 } from "@opengeni/db";
-import { HTTPException as HTTPException9 } from "hono/http-exception";
+import { HTTPException as HTTPException10 } from "hono/http-exception";
 
 // src/domain/sessions.ts
 import { CODEX_MODEL_ID_PREFIX } from "@opengeni/codex";
-import { configuredAllowedModels } from "@opengeni/config";
+import { configuredAllowedModels, policyProviderIdForModel } from "@opengeni/config";
 import {
   CreateSessionRequest,
+  evaluateWorkspaceModelPolicy,
   reasoningEffortForMetadata
 } from "@opengeni/contracts";
 import {
-  appendSessionEventsWithLockedSessionUpdate,
   createSession,
-  createSessionGoal,
   createSessionWithIdempotencyKey,
-  enqueueSessionTurn,
-  encryptEnvironmentValue as encryptEnvironmentValue2,
+  encryptVariableSetValue as encryptVariableSetValue2,
   getAnySessionInGroup,
   getEnrollment as getEnrollment2,
-  listDistinctEnvironmentIdsInGroup,
+  getRig as getRig2,
+  getWorkspaceDefaultRigId,
+  listDistinctVariableSetIdsInGroup,
+  listDistinctRigVersionIdsInGroup,
   getSandbox as getSandbox3,
   getSession,
   getSessionByCreateIdempotencyKey,
+  getSessionEvent,
+  getWorkspaceControlEvent,
+  getSessionLineage,
   getSessionTurn,
+  getWorkspaceModelPolicy,
+  initializeSessionStartAtomically,
   requireSession as requireSession2,
-  setTemporalWorkflowId,
-  updateSessionTitle as updateSessionTitleRow
+  submitHumanPromptInTransaction,
+  updateSessionTitle as updateSessionTitleRow,
+  withWorkspaceSubjectRls,
+  QueueCommandConflictError,
+  SessionControlConflictError
 } from "@opengeni/db";
-import { appendAndPublishEvents } from "@opengeni/events";
-import { HTTPException as HTTPException8 } from "hono/http-exception";
+import {
+  appendAndPublishEvents,
+  publishDurableSessionEvents,
+  publishDurableWorkspaceControlEvent
+} from "@opengeni/events";
+import { HTTPException as HTTPException9 } from "hono/http-exception";
 var reservedSessionMcpServerIds = /* @__PURE__ */ new Set(["opengeni", "files", "docs", "codex_apps"]);
 var maxSessionMcpCredentialHeaders = 16;
 var maxSessionMcpCredentialHeaderValueLength = 4096;
@@ -1971,23 +2642,29 @@ function normalizedSessionMcpCredentialHeaders(headers) {
   }
   const entries = Object.entries(headers).map(([name, value]) => [name.trim(), value]).filter(([name]) => name.length > 0);
   if (entries.length > maxSessionMcpCredentialHeaders) {
-    throw new HTTPException8(422, { message: `a session MCP server supports at most ${maxSessionMcpCredentialHeaders} credential headers` });
+    throw new HTTPException9(422, {
+      message: `a session MCP server supports at most ${maxSessionMcpCredentialHeaders} credential headers`
+    });
   }
   const seen = /* @__PURE__ */ new Set();
   for (const [name, value] of entries) {
     if (!sessionMcpCredentialHeaderName.test(name)) {
-      throw new HTTPException8(422, { message: `invalid credential header name: ${name}` });
+      throw new HTTPException9(422, { message: `invalid credential header name: ${name}` });
     }
     const lower = name.toLowerCase();
     if (seen.has(lower)) {
-      throw new HTTPException8(422, { message: `duplicate credential header name: ${name}` });
+      throw new HTTPException9(422, { message: `duplicate credential header name: ${name}` });
     }
     seen.add(lower);
     if (value.length === 0 || value.length > maxSessionMcpCredentialHeaderValueLength) {
-      throw new HTTPException8(422, { message: `credential header ${name} must be 1-${maxSessionMcpCredentialHeaderValueLength} characters` });
+      throw new HTTPException9(422, {
+        message: `credential header ${name} must be 1-${maxSessionMcpCredentialHeaderValueLength} characters`
+      });
     }
     if (/[\u0000-\u0008\u000A-\u001F\u007F]/.test(value)) {
-      throw new HTTPException8(422, { message: `credential header ${name} contains forbidden control characters` });
+      throw new HTTPException9(422, {
+        message: `credential header ${name} contains forbidden control characters`
+      });
     }
   }
   return Object.fromEntries(entries);
@@ -2018,10 +2695,7 @@ function settingsWithSessionMcpServerConfigs(settings, servers) {
   const sessionIds = new Set(servers.map((server) => server.id));
   return {
     ...settings,
-    mcpServers: [
-      ...settings.mcpServers.filter((server) => !sessionIds.has(server.id)),
-      ...servers
-    ]
+    mcpServers: [...settings.mcpServers.filter((server) => !sessionIds.has(server.id)), ...servers]
   };
 }
 function settingsWithSessionMcpServerMetadata(settings, servers) {
@@ -2032,7 +2706,7 @@ function validateSessionMcpServersForCreate(settings, grant, servers) {
     return { runtimeServers: [], dbServers: [], metadata: [] };
   }
   requirePermission(grant, "mcp_servers:attach");
-  const encryptionKey = requireEnvironmentEncryption(settings);
+  const encryptionKey = requireVariableSetEncryption(settings);
   const existingIds = new Set(settings.mcpServers.map((server) => server.id));
   const seenIds = /* @__PURE__ */ new Set();
   const runtimeServers = [];
@@ -2040,15 +2714,18 @@ function validateSessionMcpServersForCreate(settings, grant, servers) {
   const metadata = [];
   for (const server of servers) {
     if (seenIds.has(server.id)) {
-      throw new HTTPException8(422, { message: `duplicate session MCP server id: ${server.id}` });
+      throw new HTTPException9(422, { message: `duplicate session MCP server id: ${server.id}` });
     }
     seenIds.add(server.id);
     if (reservedSessionMcpServerIds.has(server.id) || existingIds.has(server.id)) {
-      throw new HTTPException8(422, { message: `MCP server id already exists: ${server.id}` });
+      throw new HTTPException9(422, { message: `MCP server id already exists: ${server.id}` });
     }
     const headers = normalizedSessionMcpCredentialHeaders(server.headers);
     const headersEncrypted = Object.fromEntries(
-      Object.entries(headers).map(([name, value]) => [name, encryptEnvironmentValue2(encryptionKey, value)])
+      Object.entries(headers).map(([name, value]) => [
+        name,
+        encryptVariableSetValue2(encryptionKey, value)
+      ])
     );
     runtimeServers.push(mcpServerConfigFromInput(server));
     dbServers.push({
@@ -2076,22 +2753,27 @@ function validateSessionMcpCredentialUpdates(input) {
     return [];
   }
   requirePermission(input.grant, "mcp_servers:attach");
-  const encryptionKey = requireEnvironmentEncryption(input.settings);
+  const encryptionKey = requireVariableSetEncryption(input.settings);
   const knownIds = new Set(input.session.mcpServers.map((server) => server.id));
   const seenIds = /* @__PURE__ */ new Set();
   const encryptedUpdates = input.updates.map((update) => {
     if (seenIds.has(update.id)) {
-      throw new HTTPException8(422, { message: `duplicate session MCP credential update id: ${update.id}` });
+      throw new HTTPException9(422, {
+        message: `duplicate session MCP credential update id: ${update.id}`
+      });
     }
     seenIds.add(update.id);
     if (!knownIds.has(update.id)) {
-      throw new HTTPException8(422, { message: `unknown session MCP server id: ${update.id}` });
+      throw new HTTPException9(422, { message: `unknown session MCP server id: ${update.id}` });
     }
     const headers = normalizedSessionMcpCredentialHeaders(update.headers);
     return {
       id: update.id,
       headersEncrypted: Object.fromEntries(
-        Object.entries(headers).map(([name, value]) => [name, encryptEnvironmentValue2(encryptionKey, value)])
+        Object.entries(headers).map(([name, value]) => [
+          name,
+          encryptVariableSetValue2(encryptionKey, value)
+        ])
       )
     };
   });
@@ -2104,9 +2786,16 @@ async function createAndStartSession(input) {
     reasoningEffort: input.reasoningEffort
   };
   if (input.createIdempotencyKey) {
-    const existing = await getSessionByCreateIdempotencyKey(input.db, input.workspaceId, input.createIdempotencyKey);
+    const existing = await getSessionByCreateIdempotencyKey(
+      input.db,
+      input.workspaceId,
+      input.createIdempotencyKey
+    );
     if (existing) {
-      return existing;
+      return await finishStartSession(
+        existing.temporalWorkflowId ? { ...input, seedTargetSandbox: null } : input,
+        existing
+      );
     }
     const { session: keyed, created } = await createSessionWithIdempotencyKey(input.db, {
       accountId: input.accountId,
@@ -2117,7 +2806,9 @@ async function createAndStartSession(input) {
       metadata: sessionMetadata,
       model: input.model,
       sandboxBackend: input.sandboxBackend,
-      environmentId: input.environment?.id ?? null,
+      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,
@@ -2127,7 +2818,10 @@ async function createAndStartSession(input) {
       mcpServers: input.mcpServers ?? []
     });
     if (!created) {
-      return keyed;
+      return await finishStartSession(
+        keyed.temporalWorkflowId ? { ...input, seedTargetSandbox: null } : input,
+        keyed
+      );
     }
     return await finishStartSession(input, keyed);
   }
@@ -2140,7 +2834,9 @@ async function createAndStartSession(input) {
     metadata: sessionMetadata,
     model: input.model,
     sandboxBackend: input.sandboxBackend,
-    environmentId: input.environment?.id ?? null,
+    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,
@@ -2151,54 +2847,9 @@ async function createAndStartSession(input) {
   return await finishStartSession(input, session);
 }
 async function finishStartSession(input, session) {
-  const goal = input.goal ? await createSessionGoal(input.db, {
-    accountId: session.accountId,
-    workspaceId: session.workspaceId,
-    sessionId: session.id,
-    text: input.goal.text,
-    successCriteria: input.goal.successCriteria ?? null,
-    maxAutoContinuations: input.goal.maxAutoContinuations ?? null,
-    createdBy: "api"
-  }) : null;
-  const initialPayload = {
-    text: input.initialMessage,
-    ...input.resources.length ? { resources: input.resources } : {},
-    ...input.tools.length ? { tools: input.tools } : {}
-  };
-  const events = await appendAndPublishEvents(input.db, input.bus, session.workspaceId, session.id, [
-    {
-      type: "session.created",
-      payload: {
-        status: "queued",
-        ...input.environment ? { environmentId: input.environment.id, environmentName: input.environment.name } : {},
-        ...input.sessionMcpServers?.length ? { mcpServers: input.sessionMcpServers } : {}
-      }
-    },
-    ...goal ? [{
-      type: "goal.set",
-      payload: {
-        goalId: goal.id,
-        text: goal.text,
-        ...goal.successCriteria ? { successCriteria: goal.successCriteria } : {},
-        version: goal.version,
-        actor: "api",
-        replaced: false
-      }
-    }] : [],
-    {
-      type: "user.message",
-      payload: initialPayload,
-      ...input.clientEventId ? { clientEventId: input.clientEventId } : {}
-    },
-    { type: "session.status.changed", payload: { status: "queued" } }
-  ]);
-  const userEvent = events.find((event) => event.type === "user.message");
-  if (!userEvent) {
-    throw new HTTPException8(500, { message: "failed to append initial user event" });
-  }
   if (input.seedTargetSandbox) {
     if (session.sandboxBackend === "none") {
-      throw new HTTPException8(422, {
+      throw new HTTPException9(422, {
         message: "cannot target a machine for a session with no sandbox (backend: none)"
       });
     }
@@ -2218,34 +2869,37 @@ async function finishStartSession(input, session) {
       input.seedTargetSandbox.workingDir ?? null
     );
     if (!seeded.swapped) {
-      throw new HTTPException8(422, {
+      throw new HTTPException9(422, {
         message: `cannot target sandbox ${input.seedTargetSandbox.sandboxId}: ${seeded.reason ?? "target is not attachable"}`
       });
     }
   }
-  const workflowId = workflowIdForSession(session.id);
-  await setTemporalWorkflowId(input.db, session.workspaceId, session.id, workflowId);
-  const turn = await enqueueSessionTurn(input.db, {
+  const started = await initializeSessionStartAtomically(input.db, {
     accountId: session.accountId,
     workspaceId: session.workspaceId,
     sessionId: session.id,
-    triggerEventId: userEvent.id,
-    temporalWorkflowId: workflowId,
-    source: "user",
-    prompt: input.initialMessage,
-    resources: input.resources,
-    tools: input.tools,
-    model: input.model,
-    reasoningEffort: input.reasoningEffort,
-    sandboxBackend: input.sandboxBackend,
-    metadata: {}
+    ...input.clientEventId ? { clientEventId: input.clientEventId } : {},
+    reasoningEffortFallback: input.reasoningEffort,
+    createdEventPayload: {
+      ...input.variableSet ? { variableSetId: input.variableSet.id, variableSetName: input.variableSet.name } : {},
+      ...input.sessionMcpServers?.length ? { mcpServers: input.sessionMcpServers } : {}
+    },
+    goal: input.goal ? {
+      text: input.goal.text,
+      ...input.goal.successCriteria !== void 0 ? { successCriteria: input.goal.successCriteria } : {},
+      ...input.goal.maxAutoContinuations !== void 0 ? { maxAutoContinuations: input.goal.maxAutoContinuations } : {}
+    } : null
   });
-  await appendAndPublishEvents(input.db, input.bus, session.workspaceId, session.id, [{
-    type: "turn.queued",
-    turnId: turn.id,
-    payload: { turnId: turn.id, triggerEventId: userEvent.id, source: turn.source }
-  }]);
-  await input.workflowClient.wakeSessionWorkflow({ accountId: session.accountId, workspaceId: session.workspaceId, sessionId: session.id, workflowId });
+  await publishDurableSessionEvents(input.bus, session.workspaceId, session.id, started.events);
+  if (started.workflowWakeRevision !== null) {
+    await input.workflowClient.wakeSessionWorkflow({
+      accountId: session.accountId,
+      workspaceId: session.workspaceId,
+      sessionId: session.id,
+      workflowId: started.temporalWorkflowId,
+      wakeRevision: started.workflowWakeRevision
+    });
+  }
   return await requireSession2(input.db, session.workspaceId, session.id);
 }
 function workflowIdForSession(sessionId) {
@@ -2261,15 +2915,33 @@ function assertConfiguredModel(settings, model) {
   if (settings.codexSubscriptionEnabled && model.startsWith(CODEX_MODEL_ID_PREFIX)) {
     return;
   }
-  throw new HTTPException8(422, { message: `model is not available: ${model}` });
+  throw new HTTPException9(422, { message: `model is not available: ${model}` });
+}
+async function assertWorkspaceModelPolicyAllows(db, settings, workspaceId, model) {
+  if (model === null || model === void 0) {
+    return;
+  }
+  const policy = await getWorkspaceModelPolicy(db, workspaceId);
+  if (!policy) {
+    return;
+  }
+  const providerId = policyProviderIdForModel(settings, model);
+  const verdict = evaluateWorkspaceModelPolicy(policy, { providerId, modelId: model });
+  if (!verdict.allowed) {
+    throw new HTTPException9(422, {
+      message: verdict.reason === "provider" ? `model "${model}" is not allowed by this workspace's model policy: provider "${providerId}" is not in the allowed providers` : `model "${model}" is not allowed by this workspace's model policy`
+    });
+  }
 }
 async function requireQueuedTurnForApi(db, workspaceId, sessionId, turnId) {
   const turn = await getSessionTurn(db, workspaceId, turnId);
   if (!turn || turn.sessionId !== sessionId) {
-    throw new HTTPException8(404, { message: "session turn not found" });
+    throw new HTTPException9(404, { message: "session turn not found" });
   }
   if (turn.status !== "queued") {
-    throw new HTTPException8(409, { message: `turn is ${turn.status}; only queued turns can be changed` });
+    throw new HTTPException9(409, {
+      message: `turn is ${turn.status}; only queued turns can be changed`
+    });
   }
   return turn;
 }
@@ -2281,98 +2953,162 @@ async function postUserMessageTurn(input) {
   const requestedModel = input.model ?? null;
   const requestedReasoningEffort = input.reasoningEffort ?? null;
   assertConfiguredModel(settings, requestedModel);
-  const appended = await appendSessionEventsWithLockedSessionUpdate(db, workspaceId, sessionId, async (lockedSession, lockedUpdate) => {
-    if (lockedSession.status === "cancelled") {
-      throw new HTTPException8(409, { message: `session is ${lockedSession.status}; cannot accept a new user message` });
+  await assertWorkspaceModelPolicyAllows(db, settings, workspaceId, requestedModel);
+  const operationKey = input.clientEventId ?? crypto.randomUUID();
+  let result;
+  try {
+    result = await withWorkspaceSubjectRls(
+      db,
+      workspaceId,
+      input.actor ?? accountId,
+      (scoped) => scoped.transaction(
+        (tx) => submitHumanPromptInTransaction(tx, {
+          accountId,
+          workspaceId,
+          sessionId,
+          subjectId: input.actor ?? accountId,
+          actor: { type: "human", subjectId: input.actor ?? accountId },
+          operationKey,
+          delivery: input.delivery ?? "send",
+          controlEtag: input.controlEtag ?? null,
+          expectedDraftRevision: input.expectedDraftRevision ?? null,
+          text: input.text,
+          resources: input.resources,
+          tools: input.tools,
+          model: requestedModel,
+          reasoningEffort: requestedReasoningEffort,
+          reasoningEffortFallback: settings.openaiReasoningEffort,
+          source: input.origin === "operator" ? "api" : "user",
+          mcpCredentialUpdates: input.mcpCredentialUpdates ?? []
+        })
+      )
+    );
+  } catch (error) {
+    if (error instanceof QueueCommandConflictError || error instanceof SessionControlConflictError) {
+      throw new HTTPException9(409, { message: error.message });
     }
-    const mcpCredentialUpdates = input.mcpCredentialUpdates?.length ? await lockedUpdate.updateSessionMcpServerCredentials(input.mcpCredentialUpdates) : { servers: [], missingIds: [] };
-    if (mcpCredentialUpdates.missingIds.length > 0) {
-      throw new HTTPException8(422, { message: `unknown session MCP server id: ${mcpCredentialUpdates.missingIds[0]}` });
+    if (error instanceof Error && error.message.includes("cancelled")) {
+      throw new HTTPException9(409, { message: error.message });
     }
-    const nextResources = mergeResourceRefs(lockedSession.resources, input.resources);
-    const nextTools = mergeToolRefs(lockedSession.tools, input.tools);
-    const shouldQueueSession = lockedSession.status === "idle" || lockedSession.status === "failed";
-    return {
-      events: [
-        {
-          type: "user.message",
-          payload: {
-            text: input.text,
-            ...input.resources.length ? { resources: input.resources } : {},
-            ...input.tools.length ? { tools: input.tools } : {},
-            ...requestedModel ? { model: requestedModel } : {},
-            ...requestedReasoningEffort ? { reasoningEffort: requestedReasoningEffort } : {},
-            ...mcpCredentialUpdates.servers.length ? { mcpCredentialUpdates: mcpCredentialUpdates.servers } : {}
-          },
-          ...input.clientEventId ? { clientEventId: input.clientEventId } : {}
-        },
-        ...shouldQueueSession ? [{ type: "session.status.changed", payload: { status: "queued" } }] : []
-      ],
-      update: {
-        resources: nextResources,
-        tools: nextTools,
-        ...shouldQueueSession ? { status: "queued", activeTurnId: null } : {}
-      }
-    };
-  }).then(async (events) => {
-    await bus.publish(workspaceId, sessionId, events);
-    return events;
-  });
-  const accepted = appended[0];
-  if (!accepted) {
-    throw new HTTPException8(500, { message: "failed to append client event" });
-  }
-  const workflowId = workflowIdForSession(sessionId);
-  const session = await requireSession2(db, workspaceId, sessionId);
-  const turn = await enqueueSessionTurn(db, {
-    accountId,
+    if (error instanceof Error && error.message.startsWith("Unknown session MCP server")) {
+      throw new HTTPException9(422, { message: error.message });
+    }
+    throw error;
+  }
+  const events = await Promise.all(
+    result.eventIds.map((eventId) => getSessionEvent(db, workspaceId, eventId))
+  );
+  if (events.some((event) => event === null)) {
+    throw new Error("Committed prompt events could not be reloaded");
+  }
+  const turn = await getSessionTurn(db, workspaceId, result.turnId);
+  if (!turn) throw new Error("Committed prompt turn could not be reloaded");
+  const accepted = events.find((event) => event?.id === result.acceptedEventId);
+  if (!accepted) throw new Error("Committed user.message event could not be reloaded");
+  await publishDurableSessionEvents(
+    bus,
     workspaceId,
     sessionId,
-    triggerEventId: accepted.id,
-    temporalWorkflowId: workflowId,
-    source: "user",
-    prompt: input.text,
-    resources: input.resources,
-    tools: input.tools,
-    model: requestedModel ?? session.model,
-    reasoningEffort: requestedReasoningEffort ?? reasoningEffortForSession(session.metadata, settings.openaiReasoningEffort),
-    sandboxBackend: session.sandboxBackend,
-    metadata: {}
-  });
-  await appendAndPublishEvents(db, bus, workspaceId, sessionId, [{
-    type: "turn.queued",
-    turnId: turn.id,
-    payload: { turnId: turn.id, triggerEventId: accepted.id, source: turn.source }
-  }]);
-  await workflowClient.wakeSessionWorkflow({ accountId, workspaceId, sessionId, workflowId });
+    events.filter((event) => event !== null)
+  );
+  if (result.workspaceControlEventId) {
+    const controlEvent = await getWorkspaceControlEvent(
+      db,
+      workspaceId,
+      result.workspaceControlEventId
+    );
+    if (!controlEvent) {
+      throw new Error(
+        `Committed workspace control event disappeared: ${result.workspaceControlEventId}`
+      );
+    }
+    await publishDurableWorkspaceControlEvent(bus, workspaceId, controlEvent);
+  }
+  try {
+    await workflowClient.wakeSessionWorkflow({
+      accountId,
+      workspaceId,
+      sessionId,
+      workflowId: turn.temporalWorkflowId,
+      wakeRevision: result.wakeRevision,
+      ...result.interruptionCount > 0 ? { interruptionRequested: true } : {}
+    });
+  } catch (error) {
+    console.warn(
+      `[sessions] workflow wake failed for committed prompt ${workspaceId}/${sessionId}; durable outbox will retry`,
+      error
+    );
+  }
   return { accepted, turn };
 }
 async function createSessionForRequest(deps, grant, workspaceId, rawPayload) {
   const { settings, db, bus, workflowClient, objectStorage } = deps;
   const payload = CreateSessionRequest.parse(rawPayload);
-  const capabilityRuntimeSettings = await settingsWithEnabledCapabilityMcpServers(db, workspaceId, settings);
-  const sessionMcpServers = validateSessionMcpServersForCreate(capabilityRuntimeSettings, grant, payload.mcpServers);
-  const runtimeSettings = settingsWithSessionMcpServerConfigs(capabilityRuntimeSettings, sessionMcpServers.runtimeServers);
+  const capabilityRuntimeSettings = await settingsWithEnabledCapabilityMcpServers(
+    db,
+    workspaceId,
+    settings
+  );
+  const sessionMcpServers = validateSessionMcpServersForCreate(
+    capabilityRuntimeSettings,
+    grant,
+    payload.mcpServers
+  );
+  const runtimeSettings = settingsWithSessionMcpServerConfigs(
+    capabilityRuntimeSettings,
+    sessionMcpServers.runtimeServers
+  );
   const resources = normalizeResources(payload.resources);
   const requestedTools = validateToolRefs(payload.tools, runtimeSettings);
   const defaultedTools = hasOwnProperty(rawPayload, "tools") ? requestedTools : withDefaultEnabledCapabilityMcpTools(requestedTools, settings, capabilityRuntimeSettings);
   const tools = withFirstPartyTools(defaultedTools, runtimeSettings);
   await validateGitHubRepositorySelection(db, workspaceId, resources);
   if (resources.some((resource) => resource.kind === "file") && !objectStorage) {
-    throw new HTTPException8(503, { message: "object storage is not configured" });
+    throw new HTTPException9(503, { message: "object storage is not configured" });
   }
   await validateFileResources(db, workspaceId, resources);
-  const environment = payload.environmentId ? await validateEnvironmentAttachment({ settings, db }, grant, workspaceId, payload.environmentId) : null;
+  const variableSet = payload.variableSetId ? await validateVariableSetAttachment(
+    { settings, db },
+    grant,
+    workspaceId,
+    payload.variableSetId
+  ) : null;
+  const requestedRigId = payload.rigId ?? await getWorkspaceDefaultRigId(db, workspaceId);
+  let frozenRigId = null;
+  let frozenRigVersionId = null;
+  if (requestedRigId) {
+    const rig = await getRig2(db, workspaceId, requestedRigId);
+    if (!rig || !rig.activeVersion) {
+      if (payload.rigId) {
+        throw new HTTPException9(422, {
+          message: rig ? `rig ${payload.rigId} has no active version to bind` : `unknown rigId: ${payload.rigId}`
+        });
+      }
+    } else {
+      frozenRigId = rig.id;
+      frozenRigVersionId = rig.activeVersion.id;
+    }
+  }
   assertConfiguredModel(settings, payload.model);
+  await assertWorkspaceModelPolicyAllows(
+    db,
+    settings,
+    workspaceId,
+    payload.model ?? settings.openaiModel
+  );
   const model = payload.model ?? settings.openaiModel;
   const reasoningEffort = payload.reasoningEffort ?? settings.openaiReasoningEffort;
   let firstPartyMcpPermissions = payload.firstPartyMcpPermissions ?? null;
   if (firstPartyMcpPermissions && firstPartyMcpPermissions.length === 0) {
-    throw new HTTPException8(422, { message: "firstPartyMcpPermissions must not be empty; omit it for the default worker permission set" });
+    throw new HTTPException9(422, {
+      message: "firstPartyMcpPermissions must not be empty; omit it for the default worker permission set"
+    });
   }
   for (const permission of firstPartyMcpPermissions ?? []) {
     if (!hasPermission(grant.permissions, permission)) {
-      throw new HTTPException8(403, { message: `cannot grant first-party MCP permission beyond the creating grant: ${permission}` });
+      throw new HTTPException9(403, {
+        message: `cannot grant first-party MCP permission beyond the creating grant: ${permission}`
+      });
     }
   }
   if (payload.goal && firstPartyMcpPermissions && !firstPartyMcpPermissions.includes("goals:manage")) {
@@ -2382,19 +3118,39 @@ async function createSessionForRequest(deps, grant, workspaceId, rawPayload) {
   const sandboxChoice = payload.sandbox ?? (parentSessionId ? "shared" : "new");
   let sandboxGroupId = null;
   let inheritedBackend;
-  const requestedEnvironmentId = payload.environmentId ?? null;
-  const environmentMatchesGroup = (memberEnvironmentId) => memberEnvironmentId === requestedEnvironmentId;
+  const requestedVariableSetId = payload.variableSetId ?? null;
+  const variableSetMatchesGroup = (memberVariableSetId) => memberVariableSetId === requestedVariableSetId;
+  const rigVersionMatchesGroup = (memberRigVersionId) => memberRigVersionId === frozenRigVersionId;
   if (sandboxChoice === "shared") {
     if (!parentSessionId) {
-      throw new HTTPException8(422, { message: "sandbox:'shared' requires a parent session (spawn from inside a session); use 'new' for a top-level create." });
+      throw new HTTPException9(422, {
+        message: "sandbox:'shared' requires a parent session (spawn from inside a session); use 'new' for a top-level create."
+      });
     }
     const parent = await getSession(db, workspaceId, parentSessionId);
     if (!parent) {
-      throw new HTTPException8(404, { message: `parent session not found in workspace: ${parentSessionId}` });
+      throw new HTTPException9(404, {
+        message: `parent session not found in workspace: ${parentSessionId}`
+      });
     }
-    if (parent.sandboxBackend !== "none" && !environmentMatchesGroup(parent.environmentId ?? null)) {
+    const parentBoxed = parent.sandboxBackend !== "none";
+    const variableSetMismatch = parentBoxed && !variableSetMatchesGroup(parent.variableSetId ?? null);
+    let rigMismatch = parentBoxed && !rigVersionMatchesGroup(parent.rigVersionId ?? null);
+    if (parentBoxed && !rigMismatch) {
+      const memberRigVersionIds = await listDistinctRigVersionIdsInGroup(
+        db,
+        workspaceId,
+        parent.sandboxGroupId
+      );
+      rigMismatch = !memberRigVersionIds.every(
+        (memberRigVersionId) => rigVersionMatchesGroup(memberRigVersionId)
+      );
+    }
+    if (variableSetMismatch || rigMismatch) {
       if (payload.sandbox === "shared") {
-        throw new HTTPException8(422, { message: "sandbox:'shared' requires the same environment as the creator's box (the box environment is fixed at creation); omit sandbox or pass 'new' when attaching a different environment." });
+        throw new HTTPException9(422, {
+          message: variableSetMismatch ? "sandbox:'shared' requires the same variableSet / same environment as the creator's box (the box variable set/environment is fixed at creation); omit sandbox or pass 'new' when attaching a different variableSet/environment." : "sandbox:'shared' requires the same rig as the creator's box (the box's rig setup is fixed at creation); omit sandbox or pass 'new' when binding a different rig."
+        });
       }
     } else {
       sandboxGroupId = parent.sandboxGroupId;
@@ -2403,19 +3159,43 @@ async function createSessionForRequest(deps, grant, workspaceId, rawPayload) {
   } else if (typeof sandboxChoice === "object") {
     const member = await getAnySessionInGroup(db, workspaceId, sandboxChoice.groupId);
     if (!member) {
-      throw new HTTPException8(404, { message: `sandbox group not found in workspace: ${sandboxChoice.groupId}` });
+      throw new HTTPException9(404, {
+        message: `sandbox group not found in workspace: ${sandboxChoice.groupId}`
+      });
     }
     if (member.sandboxBackend !== "none") {
-      const memberEnvironmentIds = await listDistinctEnvironmentIdsInGroup(db, workspaceId, sandboxChoice.groupId);
-      if (!memberEnvironmentIds.every((memberEnvironmentId) => environmentMatchesGroup(memberEnvironmentId))) {
-        throw new HTTPException8(422, { message: `sandbox group ${sandboxChoice.groupId} runs a different environment (the box environment is fixed at creation); create with the group's environment or omit sandbox for an own box.` });
+      const memberVariableSetIds = await listDistinctVariableSetIdsInGroup(
+        db,
+        workspaceId,
+        sandboxChoice.groupId
+      );
+      if (!memberVariableSetIds.every(
+        (memberVariableSetId) => variableSetMatchesGroup(memberVariableSetId)
+      )) {
+        throw new HTTPException9(422, {
+          message: `sandbox group ${sandboxChoice.groupId} runs a different variableSet / different environment (the box variable set/environment is fixed at creation); create with the group's variableSet/environment or omit sandbox for an own box.`
+        });
+      }
+      const memberRigVersionIds = await listDistinctRigVersionIdsInGroup(
+        db,
+        workspaceId,
+        sandboxChoice.groupId
+      );
+      if (!memberRigVersionIds.every(
+        (memberRigVersionId) => rigVersionMatchesGroup(memberRigVersionId)
+      )) {
+        throw new HTTPException9(422, {
+          message: `sandbox group ${sandboxChoice.groupId} runs a different rig (the box's rig setup is fixed at creation); create with the group's rig or omit sandbox for an own box.`
+        });
       }
     }
     sandboxGroupId = sandboxChoice.groupId;
     inheritedBackend = member.sandboxBackend;
   }
   if (payload.workingDir !== void 0 && !payload.targetSandboxId) {
-    throw new HTTPException8(422, { message: "workingDir requires targetSandboxId (it is the targeted machine's working directory)" });
+    throw new HTTPException9(422, {
+      message: "workingDir requires targetSandboxId (it is the targeted machine's working directory)"
+    });
   }
   let machineHomeBackend;
   let machineHomeOs;
@@ -2431,7 +3211,13 @@ async function createSessionForRequest(deps, grant, workspaceId, rawPayload) {
       }
     }
   }
-  await requireLimit(deps, { accountId: grant.accountId, workspaceId, action: "agent_run:create", quantity: 1, model });
+  await requireLimit(deps, {
+    accountId: grant.accountId,
+    workspaceId,
+    action: "agent_run:create",
+    quantity: 1,
+    model
+  });
   const session = await createAndStartSession({
     db,
     bus,
@@ -2456,7 +3242,10 @@ async function createSessionForRequest(deps, grant, workspaceId, rawPayload) {
     ...machineHomeOs ? { sandboxOs: machineHomeOs } : {},
     sandboxGroupId,
     metadata: payload.metadata,
-    environment: environment ? { id: environment.id, name: environment.name } : null,
+    variableSet: variableSet ? { id: variableSet.id, name: variableSet.name } : null,
+    // Frozen rig binding (M3): both null for a rig-less session (today's path).
+    rigId: frozenRigId,
+    rigVersionId: frozenRigVersionId,
     goal: payload.goal ?? null,
     // Per-session persona instructions (already trimmed/validated by the
     // contracts schema). Persisted on the row; composed system-level at turn
@@ -2488,9 +3277,16 @@ async function createSessionForRequest(deps, grant, workspaceId, rawPayload) {
 }
 async function acceptSessionUserMessage(deps, grant, workspaceId, sessionId, input) {
   const { settings, db, bus, workflowClient, objectStorage } = deps;
-  const capabilityRuntimeSettings = await settingsWithEnabledCapabilityMcpServers(db, workspaceId, settings);
+  const capabilityRuntimeSettings = await settingsWithEnabledCapabilityMcpServers(
+    db,
+    workspaceId,
+    settings
+  );
   const existingSession = await requireSession2(db, workspaceId, sessionId);
-  const runtimeSettings = settingsWithSessionMcpServerMetadata(capabilityRuntimeSettings, existingSession.mcpServers);
+  const runtimeSettings = settingsWithSessionMcpServerMetadata(
+    capabilityRuntimeSettings,
+    existingSession.mcpServers
+  );
   const requestedResources = normalizeResources(input.resources ?? []);
   const validatedTools = validateToolRefs(input.tools ?? [], runtimeSettings);
   const requestedTools = input.toolsProvided ? validatedTools : withDefaultEnabledCapabilityMcpTools(validatedTools, settings, capabilityRuntimeSettings);
@@ -2502,10 +3298,13 @@ async function acceptSessionUserMessage(deps, grant, workspaceId, sessionId, inp
     model: input.model ?? existingSession.model
   });
   if (requestedResources.some((resource) => resource.kind === "file") && !objectStorage) {
-    throw new HTTPException8(503, { message: "object storage is not configured" });
+    throw new HTTPException9(503, { message: "object storage is not configured" });
   }
   await validateFileResources(db, workspaceId, requestedResources);
-  await validateGitHubRepositorySelection(db, workspaceId, [...existingSession.resources, ...requestedResources]);
+  await validateGitHubRepositorySelection(db, workspaceId, [
+    ...existingSession.resources,
+    ...requestedResources
+  ]);
   const mcpCredentialUpdates = validateSessionMcpCredentialUpdates({
     settings,
     grant,
@@ -2526,6 +3325,11 @@ async function acceptSessionUserMessage(deps, grant, workspaceId, sessionId, inp
     model: input.model ?? null,
     reasoningEffort: input.reasoningEffort ?? null,
     mcpCredentialUpdates,
+    delivery: input.delivery ?? "send",
+    origin: input.origin ?? "human",
+    actor: grant.subjectId,
+    ...input.controlEtag !== void 0 ? { controlEtag: input.controlEtag } : {},
+    ...input.expectedDraftRevision !== void 0 ? { expectedDraftRevision: input.expectedDraftRevision } : {},
     ...input.clientEventId ? { clientEventId: input.clientEventId } : {}
   });
   await recordWorkspaceUsage(deps, {
@@ -2545,16 +3349,25 @@ async function updateSessionTitle(deps, workspaceId, sessionId, title, source) {
   const { db, bus } = deps;
   const result = await updateSessionTitleRow(db, { workspaceId, sessionId, title, source });
   if (result.updated) {
-    await appendAndPublishEvents(db, bus, workspaceId, sessionId, [{
-      type: "session.title_set",
-      payload: {
-        title: result.title ?? title,
-        source
+    await appendAndPublishEvents(db, bus, workspaceId, sessionId, [
+      {
+        type: "session.title_set",
+        payload: {
+          title: result.title ?? title,
+          source
+        }
       }
-    }]);
+    ]);
   }
   return result;
 }
+async function readSessionLineage(db, workspaceId, sessionId) {
+  const lineage = await getSessionLineage(db, workspaceId, sessionId);
+  if (!lineage) {
+    throw new HTTPException9(404, { message: "session not found" });
+  }
+  return lineage;
+}
 function withFirstPartyTools(tools, runtimeSettings) {
   if (!runtimeSettings.mcpServers.some((server) => server.id === "opengeni")) {
     return tools;
@@ -2562,7 +3375,9 @@ function withFirstPartyTools(tools, runtimeSettings) {
   return mergeToolRefs(tools, [{ kind: "mcp", id: "opengeni" }]);
 }
 function hasOwnProperty(value, key) {
-  return Boolean(value && typeof value === "object" && Object.prototype.hasOwnProperty.call(value, key));
+  return Boolean(
+    value && typeof value === "object" && Object.prototype.hasOwnProperty.call(value, key)
+  );
 }
 
 // src/domain/scheduled-tasks.ts
@@ -2576,18 +3391,24 @@ function scheduledTaskToolsProvided(rawPayload) {
   );
 }
 async function createValidatedScheduledTask(input) {
-  const agentConfig = await validateScheduledTaskAgentConfig({ ...input, workspaceId: input.grant.workspaceId });
+  const agentConfig = await validateScheduledTaskAgentConfig({
+    ...input,
+    workspaceId: input.grant.workspaceId
+  });
   const id = crypto.randomUUID();
   validateScheduledTaskSchedule(input.payload.schedule);
-  if (input.payload.environmentId) {
-    await validateEnvironmentAttachment(
+  if (input.payload.variableSetId) {
+    await validateVariableSetAttachment(
       { settings: input.settings, db: input.db },
       input.grant,
       input.grant.workspaceId,
-      input.payload.environmentId,
-      { preauthorized: input.environmentPreauthorized ?? false }
+      input.payload.variableSetId,
+      { preauthorized: input.variableSetPreauthorized ?? false }
     );
   }
+  if (input.payload.rigId) {
+    await requireScheduledTaskRig(input.db, input.grant.workspaceId, input.payload.rigId);
+  }
   return await createScheduledTask(input.db, {
     id,
     accountId: input.grant.accountId,
@@ -2599,10 +3420,17 @@ async function createValidatedScheduledTask(input) {
     runMode: input.payload.runMode,
     overlapPolicy: input.payload.overlapPolicy,
     agentConfig,
-    environmentId: input.payload.environmentId ?? null,
+    variableSetId: input.payload.variableSetId ?? null,
+    rigId: input.payload.rigId ?? null,
     metadata: input.payload.metadata
   });
 }
+async function requireScheduledTaskRig(db, workspaceId, rigId) {
+  const rig = await getRig3(db, workspaceId, rigId);
+  if (!rig) {
+    throw new HTTPException10(422, { message: `unknown rigId: ${rigId}` });
+  }
+}
 async function validatedScheduledTaskUpdate(input) {
   const update = {};
   if (input.payload.name !== void 0) {
@@ -2624,30 +3452,38 @@ async function validatedScheduledTaskUpdate(input) {
   if (input.payload.metadata !== void 0) {
     update.metadata = input.payload.metadata;
   }
-  if (input.payload.environmentId !== void 0) {
-    const nextEnvironmentId = input.payload.environmentId;
-    if ((input.existing.environmentId ?? null) !== (nextEnvironmentId ?? null) && input.existing.runMode === "reusable_session" && input.existing.reusableSessionId) {
-      throw new HTTPException9(409, { message: "cannot change environment of a task with a live reusable session; recreate the task" });
+  if (input.payload.variableSetId !== void 0) {
+    const nextVariableSetId = input.payload.variableSetId;
+    if ((input.existing.variableSetId ?? null) !== (nextVariableSetId ?? null) && input.existing.runMode === "reusable_session" && input.existing.reusableSessionId) {
+      throw new HTTPException10(409, {
+        message: "cannot change variableSet of a task with a live reusable session; recreate the task"
+      });
     }
-    if (nextEnvironmentId === null) {
-      if (input.existing.environmentId !== null) {
-        requirePermission(input.grant, "environments:use");
+    if (nextVariableSetId === null) {
+      if (input.existing.variableSetId !== null) {
+        requirePermission(input.grant, "variable-sets:use");
       }
-      update.environmentId = null;
+      update.variableSetId = null;
     } else {
-      await validateEnvironmentAttachment(
+      await validateVariableSetAttachment(
         { settings: input.settings, db: input.db },
         input.grant,
         input.existing.workspaceId,
-        nextEnvironmentId
+        nextVariableSetId
       );
-      update.environmentId = nextEnvironmentId;
+      update.variableSetId = nextVariableSetId;
     }
   }
+  if (input.payload.rigId !== void 0) {
+    if (input.payload.rigId !== null) {
+      await requireScheduledTaskRig(input.db, input.existing.workspaceId, input.payload.rigId);
+    }
+    update.rigId = input.payload.rigId;
+  }
   if (input.payload.agentConfig !== void 0) {
-    const willHaveEnvironment = input.payload.environmentId !== void 0 ? input.payload.environmentId !== null : Boolean(input.existing.environmentId);
-    if (willHaveEnvironment) {
-      requirePermission(input.grant, "environments:use");
+    const willHaveVariableSet = input.payload.variableSetId !== void 0 ? input.payload.variableSetId !== null : Boolean(input.existing.variableSetId);
+    if (willHaveVariableSet) {
+      requirePermission(input.grant, "variable-sets:use");
     }
     update.agentConfig = await validateScheduledTaskAgentConfig({
       settings: input.settings,
@@ -2663,7 +3499,7 @@ async function validatedScheduledTaskUpdate(input) {
 async function requireScheduledTaskForApi(db, workspaceId, taskId) {
   const task = await getScheduledTask(db, workspaceId, taskId);
   if (!task) {
-    throw new HTTPException9(404, { message: "scheduled task not found" });
+    throw new HTTPException10(404, { message: "scheduled task not found" });
   }
   return task;
 }
@@ -2676,7 +3512,7 @@ async function restoreScheduledTask(db, task) {
     overlapPolicy: task.overlapPolicy,
     agentConfig: task.agentConfig,
     reusableSessionId: task.reusableSessionId,
-    environmentId: task.environmentId,
+    variableSetId: task.variableSetId,
     metadata: task.metadata
   });
 }
@@ -2684,7 +3520,9 @@ async function syncCreatedScheduledTask(input) {
   try {
     await input.workflowClient.syncScheduledTask({ task: input.task });
   } catch (error) {
-    await deleteScheduledTask(input.db, input.task.workspaceId, input.task.id).catch(() => void 0);
+    await deleteScheduledTask(input.db, input.task.workspaceId, input.task.id).catch(
+      () => void 0
+    );
     throw error;
   }
 }
@@ -2715,17 +3553,27 @@ function manualScheduledTaskTriggerUsageKey(workspaceId, taskId, triggerToken) {
 }
 async function validateScheduledTaskAgentConfig(input) {
   assertConfiguredModel(input.settings, input.payload.agentConfig.model);
+  await assertWorkspaceModelPolicyAllows(
+    input.db,
+    input.settings,
+    input.workspaceId,
+    input.payload.agentConfig.model
+  );
   const resources = normalizeResources(input.payload.agentConfig.resources ?? []);
-  const runtimeSettings = await settingsWithEnabledCapabilityMcpServers(input.db, input.workspaceId, input.settings);
+  const runtimeSettings = await settingsWithEnabledCapabilityMcpServers(
+    input.db,
+    input.workspaceId,
+    input.settings
+  );
   const requestedTools = validateToolRefs(input.payload.agentConfig.tools ?? [], runtimeSettings);
   const tools = input.toolsProvided ?? true ? requestedTools : withDefaultEnabledCapabilityMcpTools(requestedTools, input.settings, runtimeSettings);
   const prompt = input.payload.agentConfig.prompt.trim();
   if (!prompt) {
-    throw new HTTPException9(422, { message: "scheduled task prompt is required" });
+    throw new HTTPException10(422, { message: "scheduled task prompt is required" });
   }
   await validateGitHubRepositorySelection(input.db, input.workspaceId, resources);
   if (resources.some((resource) => resource.kind === "file") && !input.objectStorage) {
-    throw new HTTPException9(503, { message: "object storage is not configured" });
+    throw new HTTPException10(503, { message: "object storage is not configured" });
   }
   await validateFileResources(input.db, input.workspaceId, resources);
   return {
@@ -2740,19 +3588,19 @@ function validateScheduledTaskSchedule(schedule) {
     return;
   }
   if (new Date(schedule.startAt).getTime() >= new Date(schedule.endAt).getTime()) {
-    throw new HTTPException9(422, { message: "interval schedule endAt must be after startAt" });
+    throw new HTTPException10(422, { message: "interval schedule endAt must be after startAt" });
   }
 }
 function trimmedScheduledTaskName(name) {
   const trimmed = name.trim();
   if (!trimmed) {
-    throw new HTTPException9(422, { message: "scheduled task name is required" });
+    throw new HTTPException10(422, { message: "scheduled task name is required" });
   }
   return trimmed;
 }
 
 // src/domain/workspace-members.ts
-import { HTTPException as HTTPException10 } from "hono/http-exception";
+import { HTTPException as HTTPException11 } from "hono/http-exception";
 var MEMBER_ADMIN_PERMISSIONS = ["workspace:admin", "members:manage"];
 function memberCanAdminister(member) {
   return member.permissions.some((permission) => MEMBER_ADMIN_PERMISSIONS.includes(permission));
@@ -2762,110 +3610,540 @@ function isUserMember(member) {
 }
 function resolveMemberSubjectId(userId) {
   if (!userId) {
-    throw new HTTPException10(404, { message: "user is not registered" });
+    throw new HTTPException11(404, { message: "user is not registered" });
   }
   return `user:${userId}`;
 }
 function assertWorkspaceMemberRemovable(input) {
   const { members, subjectId, callerSubjectId } = input;
   if (subjectId === callerSubjectId) {
-    throw new HTTPException10(409, { message: "you cannot remove your own membership" });
+    throw new HTTPException11(409, { message: "you cannot remove your own membership" });
   }
   const target = members.find((member) => member.subjectId === subjectId);
   if (!target) {
-    throw new HTTPException10(404, { message: "member not found" });
+    throw new HTTPException11(404, { message: "member not found" });
   }
   if (memberCanAdminister(target)) {
-    const remainingAdmins = members.filter((member) => member.subjectId !== subjectId && memberCanAdminister(member));
+    const remainingAdmins = members.filter(
+      (member) => member.subjectId !== subjectId && memberCanAdminister(member)
+    );
     if (remainingAdmins.length === 0) {
-      throw new HTTPException10(409, { message: "cannot remove the last member who can manage this workspace" });
+      throw new HTTPException11(409, {
+        message: "cannot remove the last member who can manage this workspace"
+      });
     }
   }
 }
 function assertWorkspaceDeletable(input) {
   if (input.workspaceCountForAccount <= 1) {
-    throw new HTTPException10(409, { message: "cannot delete the account's only workspace" });
+    throw new HTTPException11(409, { message: "cannot delete the account's only workspace" });
   }
   if (input.activeSessionCount > 0) {
-    throw new HTTPException10(409, {
+    throw new HTTPException11(409, {
       message: "stop the workspace's running sessions before deleting it"
     });
   }
 }
+
+// src/application/session-commands.ts
+import { reasoningEffortForMetadata as reasoningEffortForMetadata2 } from "@opengeni/contracts";
+import {
+  deleteSessionQueueItemInTransaction,
+  editQueuedTurnInTransaction,
+  getComposerDraftInTransaction,
+  getSession as getSession2,
+  getSessionEvent as getSessionEvent2,
+  getWorkspaceControlEvent as getWorkspaceControlEvent2,
+  getSessionQueueSnapshot,
+  moveQueuedTurnInTransaction,
+  mutateSessionControlInTransaction,
+  mutateWorkspaceControlInTransaction,
+  saveComposerDraftInTransaction,
+  sendAgentMessageInTransaction,
+  serializeEffectiveSessionControl,
+  steerAgentSessionInTransaction,
+  steerQueuedTurnInTransaction,
+  withWorkspaceRls,
+  withWorkspaceSubjectRls as withWorkspaceSubjectRls2
+} from "@opengeni/db";
+import {
+  publishDurableSessionEvents as publishDurableSessionEvents2,
+  publishDurableWorkspaceControlEvent as publishDurableWorkspaceControlEvent2
+} from "@opengeni/events";
+function agentActor(context) {
+  return {
+    type: "agent_attempt",
+    sessionId: context.callerSessionId,
+    turnId: context.callerTurnId,
+    attemptId: context.callerAttemptId,
+    executionGeneration: context.callerExecutionGeneration
+  };
+}
+async function publishAndWakeAgentCommand(deps, input) {
+  await publishSessionEventIds(deps, input.workspaceId, input.sessionId, input.eventIds);
+  if (!input.shouldSignal || input.wakeRevision === null) return;
+  try {
+    await deps.workflowClient.wakeSessionWorkflow({
+      accountId: input.accountId,
+      workspaceId: input.workspaceId,
+      sessionId: input.sessionId,
+      workflowId: input.workflowId,
+      wakeRevision: input.wakeRevision,
+      ...input.interruptionCount > 0 ? { interruptionRequested: true } : {}
+    });
+  } catch (error) {
+    console.warn(
+      `[session-commands] immediate Agent command wake failed for ${input.workspaceId}/${input.sessionId}; durable outbox will retry`,
+      error
+    );
+  }
+}
+async function requestControlWakeDispatch(deps, wakeCount) {
+  if (wakeCount === 0) return;
+  try {
+    await deps.workflowClient.requestSessionWorkflowWakeDispatch();
+  } catch (error) {
+    console.warn(
+      `[session-commands] immediate control wake dispatch failed for ${wakeCount} committed revisions; durable outbox will retry`,
+      error
+    );
+  }
+}
+async function publishSessionEventIds(deps, workspaceId, sessionId, eventIds) {
+  if (eventIds.length === 0) return;
+  const events = await Promise.all(
+    eventIds.map((eventId) => getSessionEvent2(deps.db, workspaceId, eventId))
+  );
+  await publishDurableSessionEvents2(
+    deps.bus,
+    workspaceId,
+    sessionId,
+    events.filter((event) => event !== null)
+  );
+}
+async function publishWorkspaceControlEvent(deps, workspaceId, eventId) {
+  if (!eventId) return;
+  const event = await getWorkspaceControlEvent2(deps.db, workspaceId, eventId);
+  if (!event) {
+    throw new Error(`Committed workspace control event disappeared: ${eventId}`);
+  }
+  await publishDurableWorkspaceControlEvent2(deps.bus, workspaceId, event);
+}
+async function sendAgentSessionMessage(deps, context, input) {
+  const result = await withWorkspaceRls(
+    deps.db,
+    context.workspaceId,
+    (scoped) => scoped.transaction(
+      (tx) => 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,
+    sessionId: input.targetSessionId,
+    eventIds: result.eventIds,
+    workflowId: result.workflowId,
+    wakeRevision: result.wakeRevision,
+    shouldSignal: result.shouldSignal,
+    interruptionCount: 0
+  });
+  await publishWorkspaceControlEvent(deps, context.workspaceId, result.workspaceControlEventId);
+  return result;
+}
+async function steerAgentSession(deps, context, input) {
+  const result = await withWorkspaceRls(
+    deps.db,
+    context.workspaceId,
+    (scoped) => scoped.transaction(
+      (tx) => 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,
+    sessionId: input.targetSessionId,
+    eventIds: result.eventIds,
+    workflowId: result.workflowId,
+    wakeRevision: result.wakeRevision,
+    shouldSignal: result.shouldSignal,
+    interruptionCount: result.interruptionCount
+  });
+  await publishWorkspaceControlEvent(deps, context.workspaceId, result.workspaceControlEventId);
+  return result;
+}
+async function controlAgentSessionWorkstream(deps, context, input) {
+  const result = await withWorkspaceRls(
+    deps.db,
+    context.workspaceId,
+    (scoped) => scoped.transaction(
+      (tx) => 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
+  ]);
+  await publishWorkspaceControlEvent(deps, context.workspaceId, result.workspaceControlEventId);
+  await requestControlWakeDispatch(deps, result.wakeCount);
+  return result;
+}
+function receipt(row) {
+  return {
+    id: row.id,
+    action: row.action,
+    operationKey: row.operationKey,
+    targetSessionId: row.targetSessionId,
+    targetTurnId: row.targetTurnId,
+    appliedControlRevision: row.appliedControlRevision,
+    appliedQueueVersion: row.appliedQueueVersion,
+    appliedTurnVersion: row.appliedTurnVersion,
+    appliedDraftRevision: row.appliedDraftRevision,
+    createdAt: row.createdAt.toISOString()
+  };
+}
+function composerDraft(row) {
+  if (!row) return null;
+  return {
+    revision: row.revision,
+    text: row.text,
+    resources: row.resources,
+    tools: row.tools,
+    model: row.model,
+    reasoningEffort: row.reasoningEffort,
+    sourceTurnId: row.sourceTurnId,
+    sourceTurnVersion: row.sourceTurnVersion,
+    updatedAt: row.updatedAt.toISOString()
+  };
+}
+async function authoritativeQueue(db, workspaceId, sessionId) {
+  const snapshot = await getSessionQueueSnapshot(db, workspaceId, sessionId);
+  if (!snapshot) throw new Error(`Session not found: ${sessionId}`);
+  return snapshot;
+}
+async function moveHumanQueuePrompt(deps, context, turnId, input) {
+  const result = await withWorkspaceRls(
+    deps.db,
+    context.workspaceId,
+    (scoped) => scoped.transaction(
+      (tx) => 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),
+    snapshot: await authoritativeQueue(deps.db, context.workspaceId, context.sessionId)
+  };
+  await publishSessionEventIds(deps, context.workspaceId, context.sessionId, result.eventIds);
+  return response;
+}
+async function deleteHumanQueuePrompt(deps, context, turnId, input) {
+  const result = await withWorkspaceRls(
+    deps.db,
+    context.workspaceId,
+    (scoped) => scoped.transaction(
+      (tx) => 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),
+    snapshot: await authoritativeQueue(deps.db, context.workspaceId, context.sessionId)
+  };
+  await publishSessionEventIds(deps, context.workspaceId, context.sessionId, result.eventIds);
+  return response;
+}
+async function editHumanQueuePrompt(deps, context, turnId, input) {
+  const result = await withWorkspaceSubjectRls2(
+    deps.db,
+    context.workspaceId,
+    context.subjectId,
+    (scoped) => scoped.transaction(
+      (tx) => editQueuedTurnInTransaction(tx, {
+        ...context,
+        turnId,
+        expectedTurnVersion: input.expectedTurnVersion,
+        expectedDraftRevision: input.expectedDraftRevision,
+        replaceDraft: input.replaceDraft,
+        actor: { type: "human", subjectId: context.subjectId },
+        operationKey: input.clientEventId
+      })
+    )
+  );
+  const response = {
+    receipt: receipt(result.receipt),
+    snapshot: await authoritativeQueue(deps.db, context.workspaceId, context.sessionId),
+    draft: composerDraft(result.draft)
+  };
+  await publishSessionEventIds(deps, context.workspaceId, context.sessionId, result.eventIds);
+  return response;
+}
+async function steerHumanQueuePrompt(deps, context, turnId, input) {
+  const result = await withWorkspaceRls(
+    deps.db,
+    context.workspaceId,
+    (scoped) => scoped.transaction(
+      (tx) => 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),
+    snapshot: await authoritativeQueue(deps.db, context.workspaceId, context.sessionId)
+  };
+  await publishSessionEventIds(deps, context.workspaceId, context.sessionId, result.eventIds);
+  await publishWorkspaceControlEvent(deps, context.workspaceId, result.workspaceControlEventId);
+  return response;
+}
+async function controlHumanSessionWorkstream(deps, context, input) {
+  const result = await withWorkspaceRls(
+    deps.db,
+    context.workspaceId,
+    (scoped) => scoped.transaction(
+      (tx) => 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),
+    effectiveControl: serializeEffectiveSessionControl(result.control),
+    interruptionCount: result.interruptionCount,
+    wakeCount: result.wakeCount
+  };
+  await publishSessionEventIds(deps, context.workspaceId, context.sessionId, [
+    result.sessionControlEventId
+  ]);
+  await publishWorkspaceControlEvent(deps, context.workspaceId, result.workspaceControlEventId);
+  await requestControlWakeDispatch(deps, result.wakeCount);
+  return response;
+}
+async function controlHumanWorkspace(deps, context, input) {
+  const result = await withWorkspaceRls(
+    deps.db,
+    context.workspaceId,
+    (scoped) => scoped.transaction(
+      (tx) => mutateWorkspaceControlInTransaction(tx, {
+        accountId: context.accountId,
+        workspaceId: context.workspaceId,
+        actor: { type: "human", subjectId: context.subjectId },
+        operationKey: input.clientEventId,
+        action: input.action,
+        reason: input.reason ?? null,
+        expectedRevision: input.expectedRevision ?? null
+      })
+    )
+  );
+  const response = {
+    receipt: receipt(result.receipt),
+    state: result.workspaceState,
+    revision: result.revision,
+    interruptionCount: result.interruptionCount,
+    wakeCount: result.wakeCount
+  };
+  await publishWorkspaceControlEvent(deps, context.workspaceId, result.workspaceControlEventId);
+  await requestControlWakeDispatch(deps, result.wakeCount);
+  return response;
+}
+async function getHumanComposerDraft(db, context) {
+  const row = await withWorkspaceSubjectRls2(
+    db,
+    context.workspaceId,
+    context.subjectId,
+    (scoped) => getComposerDraftInTransaction(scoped, {
+      workspaceId: context.workspaceId,
+      sessionId: context.sessionId,
+      subjectId: context.subjectId
+    })
+  );
+  const mapped = composerDraft(row);
+  if (mapped) return mapped;
+  const session = await getSession2(db, context.workspaceId, context.sessionId);
+  if (!session) throw new Error(`Session not found: ${context.sessionId}`);
+  return {
+    revision: 0,
+    text: "",
+    resources: [],
+    tools: [],
+    model: session.model,
+    reasoningEffort: reasoningEffortForMetadata2(session.metadata, "medium"),
+    sourceTurnId: null,
+    sourceTurnVersion: null,
+    updatedAt: null
+  };
+}
+async function saveHumanComposerDraft(db, context, input) {
+  const row = await withWorkspaceSubjectRls2(
+    db,
+    context.workspaceId,
+    context.subjectId,
+    (scoped) => scoped.transaction(
+      (tx) => saveComposerDraftInTransaction(tx, {
+        ...context,
+        ...input,
+        subjectId: context.subjectId
+      })
+    )
+  );
+  return composerDraft(row);
+}
 export {
   MARKETING_SOCIAL_PACK_ID,
+  MAX_CHECKS_PER_RIG,
+  MAX_CREDENTIAL_HOOKS_PER_RIG,
+  MAX_DEFAULT_VARIABLE_SETS_PER_RIG,
   MAX_ENVIRONMENTS_PER_WORKSPACE,
+  MAX_RIGS_PER_WORKSPACE,
   MAX_VARIABLES_PER_ENVIRONMENT,
+  SESSION_WORKFLOW_WAKE_DISPATCHER_PERIOD_MS,
+  SESSION_WORKFLOW_WAKE_DISPATCHER_SCHEDULE_ID,
+  SESSION_WORKFLOW_WAKE_DISPATCHER_WORKFLOW_TYPE,
   acceptSessionUserMessage,
+  activateRigVersionForApi,
+  appendRigSetupCommand,
   applyCapabilityEnablement,
   assertAllowedEnvironmentVariableName,
+  assertAllowedVariableSetVariableName,
   assertConfiguredModel,
   assertPackSandboxImageCompatible,
   assertWorkspaceDeletable,
   assertWorkspaceMemberRemovable,
+  assertWorkspaceModelPolicyAllows,
   buildCapabilityCatalog,
   buildFleetContextForSession,
   buildMarketingDailyAnalysisAgentConfig,
   checkLimit,
+  classifyRigVerificationOutcome,
+  controlAgentSessionWorkstream,
+  controlHumanSessionWorkstream,
+  controlHumanWorkspace,
   createAndStartSession,
   createCatalogItem,
+  createRigForApi,
+  createRigVersionForApi,
   createSessionForRequest,
   createValidatedScheduledTask,
+  deleteHumanQueuePrompt,
+  deleteRigForApi,
   disableCapability,
   discoverMcpRegistryCapabilities,
+  editHumanQueuePrompt,
   enableCapability,
   enabledCapabilityMcpToolRefs,
   getCapabilityPack,
+  getHumanComposerDraft,
   hasPermission,
   isBuiltInCapabilityPack,
   isUserMember,
   listCapabilityPacks,
   listFleet,
+  listRigChangesForApi,
+  listRigVersionsForApi,
   listWorkspaceCapabilityPacks,
   manualScheduledTaskTriggerUsageKey,
   manualScheduledTaskTriggerWorkflowId,
   memberCanAdminister,
   mergeResourceRefs,
   mergeToolRefs,
+  moveHumanQueuePrompt,
   normalizeResources,
   officialMcpRegistryUrl,
   postUserMessageTurn,
+  promoteSetupAppendChange,
+  promoteVerifiedDefinitionEditChangeForApi,
+  proposeRigChangeForApi,
   provisionSandbox,
+  readSessionLineage,
   reasoningEffortForSession,
-  recordEnvironmentAuditEvent,
+  recordRigAuditEvent,
+  recordVariableSetAuditEvent,
   recordWorkspaceUsage,
   relayConfigFromSettings,
   relayDialBaseFromSettings,
   requireAccessContext,
   requireAccessGrant,
   requireEnvironmentEncryption,
-  requireEnvironmentForApi,
   requireLimit,
   requirePermission,
   requireQueuedTurnForApi,
+  requireRigChangeForApi,
+  requireRigForApi,
   requireScheduledTaskForApi,
+  requireVariableSetEncryption,
+  requireVariableSetForApi,
   resolveCapabilityPack,
   resolveMemberSubjectId,
   restoreScheduledTask,
+  rigActorForGrant,
   routingEnabled,
   runOnSandbox,
+  saveHumanComposerDraft,
   scheduledTaskTemporalScheduleId,
   scheduledTaskToolsProvided,
   scheduledTaskTriggerToken,
+  sendAgentSessionMessage,
   settingsWithEnabledCapabilityMcpServers,
   settingsWithMcpCapabilityServers,
   settingsWithSessionMcpServerMetadata,
   stableJson,
+  steerAgentSession,
+  steerHumanQueuePrompt,
   swapActiveSandbox,
   syncCreatedScheduledTask,
   syncUpdatedScheduledTask,
+  updateRigForApi,
   updateSessionTitle,
-  validateEnvironmentAttachment,
   validateFileResources,
   validateGitHubRepositorySelection,
   validateGitHubRepositorySelectionShape,
   validateMcpCapabilityConnection,
   validateToolRefs,
+  validateVariableSetAttachment,
   validatedScheduledTaskUpdate,
   withDefaultEnabledCapabilityMcpTools,
   workflowIdForSession,