@opengeni/core 2.5.3 → 2.6.4

package/dist/index.js

@@ -125,8 +125,8 @@ import {
   markManagedAuthRequestActorTransitionApplied,
   releaseManagedAuthRequestActorLease,
   validateManagedAuthRequestActorLease
-} from "./chunk-ZVZJTMSV.js";
-import "./chunk-YGOMUGYS.js";
+} from "./chunk-OF65T3PM.js";
+import "./chunk-QO5GVFFO.js";
 
 // src/workflow-wake-contract.ts
 var SESSION_WORKFLOW_WAKE_DISPATCHER_SCHEDULE_ID = "opengeni-session-workflow-wake-dispatcher";
@@ -260,6 +260,16 @@ import {
 function directRetainedProcessMatchesBackend(durable, process, backend) {
   return durable.providerSessionId === process.providerSessionId && durable.providerBackend === backend.kind && durable.providerInstanceId === backend.providerInstanceId && durable.leaseEpoch === backend.leaseEpoch && durable.routeKind === "active" && durable.routeTargetId === backend.sandboxId && durable.routeEpoch === backend.activeEpoch;
 }
+function retainedProcessBackgroundSettlement(process, fallback) {
+  if (process.state === "active") {
+    throw new Error("Retained-process settlement returned an active durable process");
+  }
+  return {
+    outcome: process.state,
+    exitCode: process.exitCode,
+    reason: process.settlementReason ?? fallback.reason
+  };
+}
 function relayConfigFromSettings(settings) {
   const raw = settings.selfhostedRelayUrl?.trim();
   if (!raw) {
@@ -460,7 +470,7 @@ function wrapChannelABoxWithRouting(services, ids, established) {
         "API retained-process settlement lost its exact durable backend identity"
       );
     }
-    await settleRetainedProcess(db, {
+    const settlement = await settleRetainedProcess(db, {
       accountId: ids.accountId,
       workspaceId: ids.workspaceId,
       sessionId: ids.sessionId,
@@ -471,14 +481,13 @@ function wrapChannelABoxWithRouting(services, ids, established) {
       reason: proof.reason,
       idleGraceMs: settings.sandboxIdleGraceMs
     });
+    const backgroundSettlement = retainedProcessBackgroundSettlement(settlement.process, proof);
     await settleSessionBackgroundCommandForRetainedProcess(db, {
       accountId: ids.accountId,
       workspaceId: ids.workspaceId,
       sessionId: ids.sessionId,
       retainedProcessId: process.id,
-      outcome: proof.outcome,
-      exitCode: proof.exitCode,
-      reason: proof.reason
+      ...backgroundSettlement
     });
   } : void 0;
   const resolver = makeActiveBackendResolver({
@@ -588,6 +597,235 @@ function wrapChannelABoxWithRouting(services, ids, established) {
   return { ...established, session: proxy };
 }
 
+// src/sandbox/runtime-settings.ts
+import {
+  CapabilityPack
+} from "@opengeni/contracts";
+import {
+  getRigVersion,
+  getWorkspacePack,
+  listPackInstallations
+} from "@opengeni/db";
+import { resolveModalCheckpointProviderBinding } from "@opengeni/runtime/sandbox";
+
+// src/rigs/provider-images.ts
+import { createHash } from "crypto";
+import {
+  RigProviderImage as RigProviderImageContract,
+  stableJson
+} from "@opengeni/contracts";
+function sha256(value) {
+  return `sha256:${createHash("sha256").update(value, "utf8").digest("hex")}`;
+}
+function rigProviderImageProviderBindingKeyHash(bindingKey) {
+  return sha256(bindingKey);
+}
+function rigProviderImageSetupHash(definition) {
+  return sha256(definition.setupScript ?? "");
+}
+function rigProviderImageContentHash(input) {
+  return sha256(
+    stableJson({
+      version: 2,
+      backend: input.backend,
+      sourceImage: input.sourceImage,
+      setupScript: input.definition.setupScript,
+      checks: input.definition.checks,
+      credentialHooks: input.definition.credentialHooks,
+      defaultVariableSetIds: input.definition.defaultVariableSetIds
+    })
+  );
+}
+function rigProviderImageBuildRequestId(input) {
+  const bytes = createHash("sha256").update("opengeni-rig-provider-image-build-v2\0", "utf8").update(input.targetId, "utf8").update("\0", "utf8").update(input.backend, "utf8").update("\0", "utf8").update(input.contentHash, "utf8").digest().subarray(0, 16);
+  bytes[6] = bytes[6] & 15 | 80;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = bytes.toString("hex");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function rigProviderImageMatchesDefinition(image, definition) {
+  return image.setupHash === rigProviderImageSetupHash(definition) && image.contentHash === rigProviderImageContentHash({
+    backend: image.backend,
+    sourceImage: image.sourceImage,
+    definition
+  });
+}
+function rigProviderImagesFromVerification(verification, definition) {
+  const parsed = RigProviderImageContract.safeParse(verification?.providerImage);
+  if (!parsed.success || parsed.data.status === "building") return {};
+  if (!rigProviderImageMatchesDefinition(parsed.data, definition)) return {};
+  return { [parsed.data.backend]: parsed.data };
+}
+
+// src/sandbox/runtime-settings.ts
+function managedSessionGroupBackend(deploymentBackend, sessionBackend) {
+  if (sessionBackend === "none") return null;
+  const backend = sessionBackend === "selfhosted" ? deploymentBackend : sessionBackend;
+  return backend === "none" || backend === "selfhosted" ? null : backend;
+}
+function managedSessionGroupOs(sessionBackend, sessionOs) {
+  return sessionBackend === "selfhosted" ? "linux" : sessionOs;
+}
+function packInstallationUsesLegacyRuntime(input) {
+  return input.manifestSnapshot === null && input.manifestDigest === null;
+}
+async function resolveWorkspaceLegacyRuntimePacks(db, workspaceId) {
+  const installations = await listPackInstallations(db, workspaceId);
+  const packs2 = [];
+  for (const installation of installations) {
+    if (installation.status !== "active" || !packInstallationUsesLegacyRuntime(installation)) {
+      continue;
+    }
+    const registration = await getWorkspacePack(db, workspaceId, installation.packId);
+    const parsed = CapabilityPack.safeParse(registration?.pack);
+    if (parsed.success) packs2.push(parsed.data);
+  }
+  return packs2;
+}
+function legacySandboxRuntimeFromPacks(packs2) {
+  const imagePacks = packs2.filter(
+    (pack) => typeof pack.sandboxImage === "string" && pack.sandboxImage.trim().length > 0
+  );
+  if (imagePacks.length > 1) {
+    const ids = imagePacks.map((pack) => pack.id).sort().join(", ");
+    throw new Error(
+      `Multiple enabled packs declare a sandbox image (${ids}). Only one enabled pack per workspace may declare sandboxImage; disable the others and retry.`
+    );
+  }
+  return {
+    sandboxImage: imagePacks[0]?.sandboxImage?.trim() ?? null,
+    sandboxProviderImages: imagePacks[0]?.sandboxProviderImages ?? null
+  };
+}
+function settingsWithPackSandboxImage(settings, sandboxImage, sandboxProviderImages = null) {
+  if (!sandboxImage) return settings;
+  return {
+    ...settings,
+    dockerImage: sandboxImage,
+    modalImageRef: sandboxImage,
+    modalImageId: sandboxProviderImages?.modal?.imageId
+  };
+}
+function settingsWithRigImage(settings, rigImage) {
+  void rigImage;
+  return settings;
+}
+function rigProviderImageSourceImage(settings, backend) {
+  if (backend === "modal") return settings.modalImageId ?? settings.modalImageRef ?? null;
+  if (backend === "docker") return settings.dockerImage ?? null;
+  return null;
+}
+function resolveRigProviderImageSelection(settings, version, backend, currentProviderBindingKeyHash) {
+  if (!version) return { settings, reason: "missing", contentHash: null, imageId: null };
+  if (backend !== "modal") {
+    return { settings, reason: "provider_unsupported", contentHash: null, imageId: null };
+  }
+  const image = version.providerImages[backend];
+  if (!image) return { settings, reason: "missing", contentHash: null, imageId: null };
+  if (image.status !== "ready" || !image.imageId) {
+    return {
+      settings,
+      reason: "not_ready",
+      contentHash: image.contentHash,
+      imageId: image.imageId
+    };
+  }
+  if (image.coldBootValidation?.version !== 1) {
+    return {
+      settings,
+      reason: "not_cold_boot_validated",
+      contentHash: image.contentHash,
+      imageId: null
+    };
+  }
+  const sourceImage = rigProviderImageSourceImage(settings, backend);
+  const expectedContentHash = rigProviderImageContentHash({
+    backend,
+    sourceImage,
+    definition: version
+  });
+  if (image.sourceImage !== sourceImage || image.contentHash !== expectedContentHash || !rigProviderImageMatchesDefinition(image, version)) {
+    return {
+      settings,
+      reason: "content_mismatch",
+      contentHash: expectedContentHash,
+      imageId: null
+    };
+  }
+  if (!image.providerBindingKeyHash || !currentProviderBindingKeyHash) {
+    return {
+      settings,
+      reason: "provider_binding_unavailable",
+      contentHash: expectedContentHash,
+      imageId: null
+    };
+  }
+  if (image.providerBindingKeyHash !== currentProviderBindingKeyHash) {
+    return {
+      settings,
+      reason: "provider_binding_mismatch",
+      contentHash: expectedContentHash,
+      imageId: null
+    };
+  }
+  return {
+    settings: { ...settings, modalImageId: image.imageId },
+    reason: "selected",
+    contentHash: expectedContentHash,
+    imageId: image.imageId
+  };
+}
+async function resolveRigProviderImageForRun(settings, version, backend, resolveBinding = resolveModalCheckpointProviderBinding) {
+  const image = backend === "modal" ? version?.providerImages.modal : null;
+  if (image?.status !== "ready" || !image.providerBindingKeyHash) {
+    return resolveRigProviderImageSelection(settings, version, backend, null);
+  }
+  const structural = resolveRigProviderImageSelection(
+    settings,
+    version,
+    backend,
+    image.providerBindingKeyHash
+  );
+  if (structural.reason !== "selected") return structural;
+  let currentProviderBindingKeyHash = null;
+  try {
+    const binding = await resolveBinding(settings);
+    currentProviderBindingKeyHash = rigProviderImageProviderBindingKeyHash(binding.key);
+  } catch {
+  }
+  return resolveRigProviderImageSelection(
+    settings,
+    version,
+    backend,
+    currentProviderBindingKeyHash
+  );
+}
+async function settingsWithRigProviderImage(settings, version, backend, resolveBinding = resolveModalCheckpointProviderBinding) {
+  return (await resolveRigProviderImageForRun(settings, version, backend, resolveBinding)).settings;
+}
+async function resolveSessionSandboxRuntime(db, settings, session) {
+  const [packs2, rigVersion] = await Promise.all([
+    resolveWorkspaceLegacyRuntimePacks(db, session.workspaceId),
+    session.rigId && session.rigVersionId ? getRigVersion(db, session.workspaceId, session.rigId, session.rigVersionId) : Promise.resolve(null)
+  ]);
+  if (session.rigVersionId && !rigVersion) {
+    throw new Error(`Frozen rig version ${session.rigVersionId} is unavailable`);
+  }
+  const legacy = legacySandboxRuntimeFromPacks(packs2);
+  const logicalSettings = rigVersion ? settings : settingsWithPackSandboxImage(settings, legacy.sandboxImage, legacy.sandboxProviderImages);
+  return {
+    settings: {
+      ...logicalSettings,
+      sandboxBackend: session.sandboxBackend
+    },
+    image: rigProviderImageSourceImage(logicalSettings, session.sandboxBackend),
+    rigVersion
+  };
+}
+async function providerSettingsForSessionSandboxRuntime(runtime, backend) {
+  return await settingsWithRigProviderImage(runtime.settings, runtime.rigVersion, backend);
+}
+
 // src/sandbox/fleet.ts
 async function buildFleetContextForSession(deps, ctx) {
   const session = await requireSession(deps.db, ctx.workspaceId, ctx.sessionId);
@@ -661,7 +899,11 @@ async function listFleet(services, ctx) {
     activeEpoch: 0
   };
   const entries = [];
-  if (ctx.sessionBackend !== "none") {
+  const groupBackend = managedSessionGroupBackend(
+    services.settings.sandboxBackend,
+    ctx.sessionBackend
+  );
+  if (groupBackend) {
     const groupActive = pointer.activeSandboxId === null;
     const groupLease = await readLease(db, ctx.workspaceId, ctx.sessionGroupId);
     const groupOnline = Boolean(
@@ -673,10 +915,10 @@ async function listFleet(services, ctx) {
     const groupRecoveryUnavailable = Boolean(
       groupLease && (groupLease.recovery.restore.status === "degraded" || groupLease.recovery.restore.status === "unrecoverable" || groupLease.recovery.workspace.status === "degraded" || groupLease.recovery.workspace.status === "unrecoverable")
     );
-    const groupOperationAvailability = groupOnline ? "ready" : groupRecoveryUnavailable ? "unavailable" : groupRecovering ? "recovering" : ctx.sessionBackend === "selfhosted" ? "unavailable" : "wakeable";
+    const groupOperationAvailability = groupOnline ? "ready" : groupRecoveryUnavailable ? "unavailable" : groupRecovering ? "recovering" : "wakeable";
     entries.push({
       id: ctx.sessionGroupId,
-      kind: ctx.sessionBackend === "selfhosted" ? "selfhosted" : ctx.sessionBackend === "opensandbox" ? "opensandbox" : "modal",
+      kind: groupBackend === "opensandbox" ? "opensandbox" : "modal",
       name: "session sandbox",
       liveness: groupOnline ? "online" : groupRecovering ? "reconnecting" : "offline",
       active: groupActive,
@@ -780,10 +1022,10 @@ async function listFleet(services, ctx) {
 }
 async function resolveTarget(services, ctx, target) {
   if (target === ctx.sessionGroupId || target === "session" || target === "default") {
-    if (ctx.sessionBackend === "none") {
+    if (!managedSessionGroupBackend(services.settings.sandboxBackend, ctx.sessionBackend)) {
       return {
         ok: false,
-        reason: "this session has no home sandbox; attach a Connected Machine",
+        reason: ctx.sessionBackend === "none" ? "this session has no home sandbox; attach a Connected Machine" : "this deployment has no managed session sandbox; select an enrolled machine",
         code: "unsupported_backend_context"
       };
     }
@@ -1149,307 +1391,86 @@ async function runOnSandbox(services, ctx, target, op, options = {}) {
       const current = sandbox.scope === "user" && ctx.subjectId && ctx.attemptAuthority ? await resolvePersonalMachineConnectionForAttempt(services.db, {
         accountId: ctx.accountId,
         workspaceId: ctx.workspaceId,
-        subjectId: ctx.subjectId,
-        sessionId: ctx.sessionId,
-        turnId: ctx.attemptAuthority.turnId,
-        attemptId: ctx.attemptAuthority.attemptId,
-        executionGeneration: ctx.attemptAuthority.executionGeneration,
-        enrollmentId: sandbox.enrollmentId,
-        requireActiveSandbox: false
-      }) : await getLiveEnrollmentConnection2(
-        services.db,
-        ctx.subjectId ? {
-          accountId: ctx.accountId,
-          workspaceId: ctx.workspaceId,
-          subjectId: ctx.subjectId
-        } : sandbox.workspaceId,
-        sandbox.enrollmentId
-      );
-      return runOnOperationAdmission(services, current);
-    } catch {
-      return null;
-    }
-  };
-  const result = await executeRunOnSelfhostedMachine(
-    {
-      workspaceId: sandbox.workspaceId,
-      agentId: sandbox.enrollmentId,
-      connectionInstanceId: enrollment.connectionInstanceId,
-      workspaceRoot: enrollment.workspaceRoot,
-      controlRpc: controlRpc(services.bus),
-      relay: relayConfigFromSettings(services.settings),
-      controlTimeoutMs: services.settings.sandboxSelfhostedControlTimeoutMs,
-      execTimeoutMs: services.settings.sandboxSelfhostedExecTimeoutMs,
-      operationResourcePolicy: enrollment.operationPolicy,
-      operationResourcePolicySupported: enrollment.agentCapabilities.operationResourcePolicy === true,
-      operationCpuQuotaSupported: enrollment.agentCapabilities.operationCpuQuota === true,
-      resolveOperationAdmission,
-      ...options.transientExecEnvironment !== void 0 ? { transientExecEnvironment: options.transientExecEnvironment } : {},
-      ...services.settings.agentOpStreamEnabled === true && enrollment.opStream === true && services.bus?.getOpStreamConnection ? {
-        opStream: {
-          transport: new NatsOpStreamTransport2(
-            async () => services.bus?.getOpStreamConnection?.() ?? null
-          )
-        }
-      } : {}
-    },
-    target,
-    op
-  );
-  return { ...result, targetName: sandbox.name };
-}
-async function provisionSandbox(services, ctx, input) {
-  if (input.kind === "selfhosted") {
-    const base = (services.settings.publicBaseUrl ?? "https://app.opengeni.ai").replace(/\/+$/, "");
-    const unixEnvironment = `OPENGENI_API_URL=${base} OPENGENI_WORKSPACE_ID=${ctx.workspaceId}`;
-    const windowsEnvironment = `$env:OPENGENI_API_URL='${base}'; $env:OPENGENI_WORKSPACE_ID='${ctx.workspaceId}';`;
-    return {
-      kind: "selfhosted",
-      instructions: "Share one of these deployment-specific commands with a human operator. It installs the OpenGeni agent and starts `opengeni-agent connect` for this exact deployment and workspace; do not run a second bare `connect`. Complete the device-flow at the verification URL (the loud whole-machine + screen-control consent), and the machine then appears here as an attachable selfhosted sandbox. Existing connections to other OpenGeni workspaces or deployments are preserved.",
-      // Install from THIS control plane's origin (not a hardcoded public CDN): the
-      // served install script is rewritten to pull the per-SHA agent baked into
-      // this exact deployment (see apps/api/src/routes/install.ts), so a deployed
-      // env is self-contained and a private/air-gapped one works with no public DNS.
-      installCommandUnix: `curl -fsSL ${base}/install.sh | ${unixEnvironment} sh`,
-      installCommandWindows: `${windowsEnvironment} irm ${base}/install.ps1 | iex`,
-      verificationUri: `${base}/device`,
-      note: "Whole-machine access requires explicit human consent in the device-flow web page; the agent cannot self-consent."
-    };
-  }
-  const { createSandbox } = await import("@opengeni/db");
-  const sandbox = await createSandbox(services.db, {
-    accountId: ctx.accountId,
-    workspaceId: ctx.workspaceId,
-    kind: "modal",
-    name: input.name?.trim() || "modal-box"
-  });
-  return {
-    kind: "modal",
-    sandbox,
-    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/sandbox/runtime-settings.ts
-import {
-  CapabilityPack
-} from "@opengeni/contracts";
-import {
-  getRigVersion,
-  getWorkspacePack,
-  listPackInstallations
-} from "@opengeni/db";
-import { resolveModalCheckpointProviderBinding } from "@opengeni/runtime/sandbox";
-
-// src/rigs/provider-images.ts
-import { createHash } from "crypto";
-import {
-  RigProviderImage as RigProviderImageContract,
-  stableJson
-} from "@opengeni/contracts";
-function sha256(value) {
-  return `sha256:${createHash("sha256").update(value, "utf8").digest("hex")}`;
-}
-function rigProviderImageProviderBindingKeyHash(bindingKey) {
-  return sha256(bindingKey);
-}
-function rigProviderImageSetupHash(definition) {
-  return sha256(definition.setupScript ?? "");
-}
-function rigProviderImageContentHash(input) {
-  return sha256(
-    stableJson({
-      version: 2,
-      backend: input.backend,
-      sourceImage: input.sourceImage,
-      setupScript: input.definition.setupScript,
-      checks: input.definition.checks,
-      credentialHooks: input.definition.credentialHooks,
-      defaultVariableSetIds: input.definition.defaultVariableSetIds
-    })
-  );
-}
-function rigProviderImageBuildRequestId(input) {
-  const bytes = createHash("sha256").update("opengeni-rig-provider-image-build-v2\0", "utf8").update(input.targetId, "utf8").update("\0", "utf8").update(input.backend, "utf8").update("\0", "utf8").update(input.contentHash, "utf8").digest().subarray(0, 16);
-  bytes[6] = bytes[6] & 15 | 80;
-  bytes[8] = bytes[8] & 63 | 128;
-  const hex = bytes.toString("hex");
-  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
-}
-function rigProviderImageMatchesDefinition(image, definition) {
-  return image.setupHash === rigProviderImageSetupHash(definition) && image.contentHash === rigProviderImageContentHash({
-    backend: image.backend,
-    sourceImage: image.sourceImage,
-    definition
-  });
-}
-function rigProviderImagesFromVerification(verification, definition) {
-  const parsed = RigProviderImageContract.safeParse(verification?.providerImage);
-  if (!parsed.success || parsed.data.status === "building") return {};
-  if (!rigProviderImageMatchesDefinition(parsed.data, definition)) return {};
-  return { [parsed.data.backend]: parsed.data };
-}
-
-// src/sandbox/runtime-settings.ts
-function packInstallationUsesLegacyRuntime(input) {
-  return input.manifestSnapshot === null && input.manifestDigest === null;
-}
-async function resolveWorkspaceLegacyRuntimePacks(db, workspaceId) {
-  const installations = await listPackInstallations(db, workspaceId);
-  const packs2 = [];
-  for (const installation of installations) {
-    if (installation.status !== "active" || !packInstallationUsesLegacyRuntime(installation)) {
-      continue;
-    }
-    const registration = await getWorkspacePack(db, workspaceId, installation.packId);
-    const parsed = CapabilityPack.safeParse(registration?.pack);
-    if (parsed.success) packs2.push(parsed.data);
-  }
-  return packs2;
-}
-function legacySandboxRuntimeFromPacks(packs2) {
-  const imagePacks = packs2.filter(
-    (pack) => typeof pack.sandboxImage === "string" && pack.sandboxImage.trim().length > 0
-  );
-  if (imagePacks.length > 1) {
-    const ids = imagePacks.map((pack) => pack.id).sort().join(", ");
-    throw new Error(
-      `Multiple enabled packs declare a sandbox image (${ids}). Only one enabled pack per workspace may declare sandboxImage; disable the others and retry.`
-    );
-  }
-  return {
-    sandboxImage: imagePacks[0]?.sandboxImage?.trim() ?? null,
-    sandboxProviderImages: imagePacks[0]?.sandboxProviderImages ?? null
-  };
-}
-function settingsWithPackSandboxImage(settings, sandboxImage, sandboxProviderImages = null) {
-  if (!sandboxImage) return settings;
-  return {
-    ...settings,
-    dockerImage: sandboxImage,
-    modalImageRef: sandboxImage,
-    modalImageId: sandboxProviderImages?.modal?.imageId
-  };
-}
-function settingsWithRigImage(settings, rigImage) {
-  void rigImage;
-  return settings;
-}
-function rigProviderImageSourceImage(settings, backend) {
-  if (backend === "modal") return settings.modalImageId ?? settings.modalImageRef ?? null;
-  if (backend === "docker") return settings.dockerImage ?? null;
-  return null;
-}
-function resolveRigProviderImageSelection(settings, version, backend, currentProviderBindingKeyHash) {
-  if (!version) return { settings, reason: "missing", contentHash: null, imageId: null };
-  if (backend !== "modal") {
-    return { settings, reason: "provider_unsupported", contentHash: null, imageId: null };
-  }
-  const image = version.providerImages[backend];
-  if (!image) return { settings, reason: "missing", contentHash: null, imageId: null };
-  if (image.status !== "ready" || !image.imageId) {
-    return {
-      settings,
-      reason: "not_ready",
-      contentHash: image.contentHash,
-      imageId: image.imageId
-    };
-  }
-  if (image.coldBootValidation?.version !== 1) {
-    return {
-      settings,
-      reason: "not_cold_boot_validated",
-      contentHash: image.contentHash,
-      imageId: null
-    };
-  }
-  const sourceImage = rigProviderImageSourceImage(settings, backend);
-  const expectedContentHash = rigProviderImageContentHash({
-    backend,
-    sourceImage,
-    definition: version
-  });
-  if (image.sourceImage !== sourceImage || image.contentHash !== expectedContentHash || !rigProviderImageMatchesDefinition(image, version)) {
-    return {
-      settings,
-      reason: "content_mismatch",
-      contentHash: expectedContentHash,
-      imageId: null
-    };
-  }
-  if (!image.providerBindingKeyHash || !currentProviderBindingKeyHash) {
-    return {
-      settings,
-      reason: "provider_binding_unavailable",
-      contentHash: expectedContentHash,
-      imageId: null
-    };
-  }
-  if (image.providerBindingKeyHash !== currentProviderBindingKeyHash) {
-    return {
-      settings,
-      reason: "provider_binding_mismatch",
-      contentHash: expectedContentHash,
-      imageId: null
-    };
-  }
-  return {
-    settings: { ...settings, modalImageId: image.imageId },
-    reason: "selected",
-    contentHash: expectedContentHash,
-    imageId: image.imageId
-  };
-}
-async function resolveRigProviderImageForRun(settings, version, backend, resolveBinding = resolveModalCheckpointProviderBinding) {
-  const image = backend === "modal" ? version?.providerImages.modal : null;
-  if (image?.status !== "ready" || !image.providerBindingKeyHash) {
-    return resolveRigProviderImageSelection(settings, version, backend, null);
-  }
-  const structural = resolveRigProviderImageSelection(
-    settings,
-    version,
-    backend,
-    image.providerBindingKeyHash
-  );
-  if (structural.reason !== "selected") return structural;
-  let currentProviderBindingKeyHash = null;
-  try {
-    const binding = await resolveBinding(settings);
-    currentProviderBindingKeyHash = rigProviderImageProviderBindingKeyHash(binding.key);
-  } catch {
-  }
-  return resolveRigProviderImageSelection(
-    settings,
-    version,
-    backend,
-    currentProviderBindingKeyHash
+        subjectId: ctx.subjectId,
+        sessionId: ctx.sessionId,
+        turnId: ctx.attemptAuthority.turnId,
+        attemptId: ctx.attemptAuthority.attemptId,
+        executionGeneration: ctx.attemptAuthority.executionGeneration,
+        enrollmentId: sandbox.enrollmentId,
+        requireActiveSandbox: false
+      }) : await getLiveEnrollmentConnection2(
+        services.db,
+        ctx.subjectId ? {
+          accountId: ctx.accountId,
+          workspaceId: ctx.workspaceId,
+          subjectId: ctx.subjectId
+        } : sandbox.workspaceId,
+        sandbox.enrollmentId
+      );
+      return runOnOperationAdmission(services, current);
+    } catch {
+      return null;
+    }
+  };
+  const result = await executeRunOnSelfhostedMachine(
+    {
+      workspaceId: sandbox.workspaceId,
+      agentId: sandbox.enrollmentId,
+      connectionInstanceId: enrollment.connectionInstanceId,
+      workspaceRoot: enrollment.workspaceRoot,
+      controlRpc: controlRpc(services.bus),
+      relay: relayConfigFromSettings(services.settings),
+      controlTimeoutMs: services.settings.sandboxSelfhostedControlTimeoutMs,
+      execTimeoutMs: services.settings.sandboxSelfhostedExecTimeoutMs,
+      operationResourcePolicy: enrollment.operationPolicy,
+      operationResourcePolicySupported: enrollment.agentCapabilities.operationResourcePolicy === true,
+      operationCpuQuotaSupported: enrollment.agentCapabilities.operationCpuQuota === true,
+      resolveOperationAdmission,
+      ...options.transientExecEnvironment !== void 0 ? { transientExecEnvironment: options.transientExecEnvironment } : {},
+      ...services.settings.agentOpStreamEnabled === true && enrollment.opStream === true && services.bus?.getOpStreamConnection ? {
+        opStream: {
+          transport: new NatsOpStreamTransport2(
+            async () => services.bus?.getOpStreamConnection?.() ?? null
+          )
+        }
+      } : {}
+    },
+    target,
+    op
   );
+  return { ...result, targetName: sandbox.name };
 }
-async function settingsWithRigProviderImage(settings, version, backend, resolveBinding = resolveModalCheckpointProviderBinding) {
-  return (await resolveRigProviderImageForRun(settings, version, backend, resolveBinding)).settings;
-}
-async function resolveSessionSandboxRuntime(db, settings, session) {
-  const [packs2, rigVersion] = await Promise.all([
-    resolveWorkspaceLegacyRuntimePacks(db, session.workspaceId),
-    session.rigId && session.rigVersionId ? getRigVersion(db, session.workspaceId, session.rigId, session.rigVersionId) : Promise.resolve(null)
-  ]);
-  if (session.rigVersionId && !rigVersion) {
-    throw new Error(`Frozen rig version ${session.rigVersionId} is unavailable`);
+async function provisionSandbox(services, ctx, input) {
+  if (input.kind === "selfhosted") {
+    const base = (services.settings.publicBaseUrl ?? "https://app.opengeni.ai").replace(/\/+$/, "");
+    const unixEnvironment = `OPENGENI_API_URL=${base} OPENGENI_WORKSPACE_ID=${ctx.workspaceId}`;
+    const windowsEnvironment = `$env:OPENGENI_API_URL='${base}'; $env:OPENGENI_WORKSPACE_ID='${ctx.workspaceId}';`;
+    return {
+      kind: "selfhosted",
+      instructions: "Share one of these deployment-specific commands with a human operator. It installs the OpenGeni agent and starts `opengeni-agent connect` for this exact deployment and workspace; do not run a second bare `connect`. Complete the device-flow at the verification URL (the loud whole-machine + screen-control consent), and the machine then appears here as an attachable selfhosted sandbox. Existing connections to other OpenGeni workspaces or deployments are preserved.",
+      // Install from THIS control plane's origin (not a hardcoded public CDN): the
+      // served install script is rewritten to pull the per-SHA agent baked into
+      // this exact deployment (see apps/api/src/routes/install.ts), so a deployed
+      // env is self-contained and a private/air-gapped one works with no public DNS.
+      installCommandUnix: `curl -fsSL ${base}/install.sh | ${unixEnvironment} sh`,
+      installCommandWindows: `${windowsEnvironment} irm ${base}/install.ps1 | iex`,
+      verificationUri: `${base}/device`,
+      note: "Whole-machine access requires explicit human consent in the device-flow web page; the agent cannot self-consent."
+    };
   }
-  const legacy = legacySandboxRuntimeFromPacks(packs2);
-  const logicalSettings = rigVersion ? settings : settingsWithPackSandboxImage(settings, legacy.sandboxImage, legacy.sandboxProviderImages);
+  const { createSandbox } = await import("@opengeni/db");
+  const sandbox = await createSandbox(services.db, {
+    accountId: ctx.accountId,
+    workspaceId: ctx.workspaceId,
+    kind: "modal",
+    name: input.name?.trim() || "modal-box"
+  });
   return {
-    settings: {
-      ...logicalSettings,
-      sandboxBackend: session.sandboxBackend
-    },
-    image: rigProviderImageSourceImage(logicalSettings, session.sandboxBackend),
-    rigVersion
+    kind: "modal",
+    sandbox,
+    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."
   };
 }
-async function providerSettingsForSessionSandboxRuntime(runtime, backend) {
-  return await settingsWithRigProviderImage(runtime.settings, runtime.rigVersion, backend);
-}
 
 // src/access/index.ts
 import { resolveFirstPartyDelegationSecret } from "@opengeni/config";
@@ -1467,7 +1488,38 @@ import { HTTPException } from "hono/http-exception";
 var bearerPrefix = "Bearer ";
 var accessContextByRequest = /* @__PURE__ */ new WeakMap();
 var canonicalManagedCookieContexts = /* @__PURE__ */ new WeakSet();
+var canonicalLocalHumanContexts = /* @__PURE__ */ new WeakSet();
 var resolvedAccessGrantAuthorizations = /* @__PURE__ */ new WeakSet();
+var accountScopedApiKeyContexts = /* @__PURE__ */ new WeakMap();
+var accountScopedApiKeyAccountPermissions = /* @__PURE__ */ new Set([
+  "account:read",
+  "account:admin",
+  "workspace:create",
+  "billing:read",
+  "billing:manage",
+  "api_keys:manage"
+]);
+var accountScopedApiKeyWorkspaceExcludedPermissions = /* @__PURE__ */ new Set([
+  "account:read",
+  "account:admin",
+  "workspace:create",
+  "billing:read",
+  "billing:manage"
+]);
+function accountScopedApiKeyWorkspaceAuthority(context) {
+  const authority = accountScopedApiKeyContexts.get(context);
+  if (!authority) return null;
+  const matchingAccountGrants = context.accountGrants.filter(
+    (grant) => grant.accountId === authority.accountId && grant.subjectId === context.subjectId
+  );
+  if (!context.subjectId.startsWith("api_key:") || matchingAccountGrants.length !== 1 || context.defaultAccountId !== authority.accountId || context.defaultWorkspaceId !== null) {
+    return null;
+  }
+  return {
+    accountId: authority.accountId,
+    permissions: [...authority.permissions]
+  };
+}
 async function requireAccessContext(c, deps) {
   let pending = accessContextByRequest.get(c.req.raw);
   if (!pending) {
@@ -1505,7 +1557,8 @@ function accessGrantAuthorizationFromContext(context, grant) {
     accountGrant: contextIntegrity ? matchingAccountGrants[0] : null,
     authenticatedSubjectId: context.subjectId,
     contextIntegrity,
-    canonicalManagedHumanSession: isCanonicalManagedHumanSession(context, grant)
+    canonicalManagedHumanSession: isCanonicalManagedHumanSession(context, grant),
+    canonicalLocalHumanSession: isCanonicalLocalHumanSession(context, grant)
   };
   resolvedAccessGrantAuthorizations.add(authorization);
   return authorization;
@@ -1522,13 +1575,31 @@ function requireAccountAdminAuthorizationStamp(authorization) {
     permission: "account:admin"
   });
 }
+async function requireCanonicalLocalAccountAdministrator(c, deps, accountId) {
+  if (c.req.header("authorization")) {
+    throw new HTTPException(401, { message: "organization administrator session required" });
+  }
+  const context = await requireAccessContext(c, deps);
+  const grant = context.workspaceGrants.find((candidate) => candidate.accountId === accountId);
+  if (!grant) {
+    throw new HTTPException(403, {
+      message: "local organization administration is not authorized"
+    });
+  }
+  const authorization = accessGrantAuthorizationFromContext(context, grant);
+  if (!authorization.canonicalLocalHumanSession) {
+    throw new HTTPException(401, { message: "organization administrator session required" });
+  }
+  requireAccountAdminAuthorizationStamp(authorization);
+  return { subjectId: context.subjectId, authorization };
+}
 async function requireAccessGrantAuthorization(c, deps, workspaceId, permission) {
   const context = await requireAccessContext(c, deps);
   return await accessGrantAuthorization(context, deps, workspaceId, permission);
 }
 async function accessGrantAuthorization(context, deps, workspaceId, permission) {
   const principalKind = hostedHumanSessionPrincipalKind(context);
-  const grant = context.workspaceGrants.find((candidate) => candidate.workspaceId === workspaceId) ?? await getWorkspaceGrant(
+  let grant = context.workspaceGrants.find((candidate) => candidate.workspaceId === workspaceId) ?? await getWorkspaceGrant(
     deps.db,
     context.subjectId,
     workspaceId,
@@ -1539,7 +1610,20 @@ async function accessGrantAuthorization(context, deps, workspaceId, permission)
     if (!workspace) {
       throw new HTTPException(404, { message: "workspace not found" });
     }
-    throw new HTTPException(403, { message: "workspace access denied" });
+    const authority = accountScopedApiKeyWorkspaceAuthority(context);
+    const requiredWorkspacePermission = permission ?? "workspace:read";
+    if (authority && workspace.accountId === authority.accountId && workspace.kind === "shared" && hasPermission(authority.permissions, requiredWorkspacePermission)) {
+      grant = {
+        workspaceId: workspace.id,
+        accountId: workspace.accountId,
+        subjectId: context.subjectId,
+        ...context.subjectLabel ? { subjectLabel: context.subjectLabel } : {},
+        permissions: authority.permissions,
+        principalKind: "api_key"
+      };
+    } else {
+      throw new HTTPException(403, { message: "workspace access denied" });
+    }
   }
   if (permission) {
     requirePermission(grant, permission);
@@ -1549,6 +1633,9 @@ async function accessGrantAuthorization(context, deps, workspaceId, permission)
 function isCanonicalManagedHumanSession(context, grant) {
   return canonicalManagedCookieContexts.has(context) && grant.subjectId === context.subjectId && grant.subjectId.startsWith("user:");
 }
+function isCanonicalLocalHumanSession(context, grant) {
+  return canonicalLocalHumanContexts.has(context) && context.mode === "local" && context.subjectId === "dev" && grant.subjectId === context.subjectId && grant.principalKind === "human_session" && grant.metadata?.delegated !== true && !grant.serviceInitiator;
+}
 function hostedHumanSessionPrincipalKind(context) {
   if (context.mode !== "managed" || context.workspaceGrants.length === 0) {
     return void 0;
@@ -1598,7 +1685,7 @@ async function resolveAccessContext(c, deps) {
     if (delegated) {
       return delegated;
     }
-    return await bootstrapWorkspace(deps.db, {
+    const context = await bootstrapWorkspace(deps.db, {
       accountExternalSource: "opengeni:local",
       accountExternalId: "default",
       accountName: "Local",
@@ -1608,6 +1695,8 @@ async function resolveAccessContext(c, deps) {
       subjectId: "dev",
       subjectLabel: "Local dev"
     });
+    canonicalLocalHumanContexts.add(context);
+    return context;
   }
   if (deps.settings.productAccessMode === "configured") {
     const delegated = await delegatedAccessContext(c, deps, "configured");
@@ -1676,8 +1765,10 @@ async function apiKeyAccessContext(c, deps, mode) {
   const subjectId = `api_key:${apiKey.id}`;
   const accountPermissions = apiKey.workspaceId ? apiKey.permissions.filter(
     (permission) => permission === "billing:read" || permission === "billing:manage"
-  ) : apiKey.permissions;
-  return {
+  ) : apiKey.permissions.filter(
+    (permission) => accountScopedApiKeyAccountPermissions.has(permission)
+  );
+  const context = {
     mode,
     subjectId,
     subjectLabel: apiKey.name,
@@ -1702,6 +1793,20 @@ async function apiKeyAccessContext(c, deps, mode) {
     defaultAccountId: apiKey.accountId,
     defaultWorkspaceId: apiKey.workspaceId
   };
+  if (apiKey.workspaceId === null && apiKey.credentialKind === "organization") {
+    accountScopedApiKeyContexts.set(
+      context,
+      Object.freeze({
+        accountId: apiKey.accountId,
+        permissions: Object.freeze(
+          apiKey.permissions.filter(
+            (permission) => !accountScopedApiKeyWorkspaceExcludedPermissions.has(permission)
+          )
+        )
+      })
+    );
+  }
+  return context;
 }
 async function delegatedAccessContext(c, deps, mode, token = bearerToken(c)) {
   const delegationSecret = resolveFirstPartyDelegationSecret(deps.settings);
@@ -1972,6 +2077,7 @@ async function resolveSessionAuthorizationActor(db, grant) {
 import { configuredStaticUsageLimits, resolveModelProvider } from "@opengeni/config";
 import {
   countActiveApiKeysForWorkspace,
+  countActiveOrganizationApiKeysForAccount,
   countScheduledTasksForWorkspace,
   countWorkspacesForAccount,
   getBillingBalance,
@@ -2050,10 +2156,10 @@ async function checkStaticCaps(deps, input, externallyBilled) {
       );
     }
     case "api_key:create": {
-      if (!limits.maxApiKeysPerWorkspace || !input.workspaceId) {
+      if (!limits.maxApiKeysPerWorkspace) {
         return { allowed: true };
       }
-      const count = await countActiveApiKeysForWorkspace(deps.db, input.workspaceId);
+      const count = input.workspaceId ? await countActiveApiKeysForWorkspace(deps.db, input.workspaceId) : await countActiveOrganizationApiKeysForAccount(deps.db, input.accountId);
       return count < limits.maxApiKeysPerWorkspace ? { allowed: true } : blocked(
         "max_api_keys_per_workspace",
         `API key limit reached (${limits.maxApiKeysPerWorkspace})`
@@ -4965,42 +5071,15 @@ function sha256Hex2(bytes) {
 
 // src/domain/environments.ts
 import { environmentsEncryptionKeyBytes as environmentsEncryptionKeyBytes2 } from "@opengeni/config";
+import {
+  variableSetVariableNameReservation
+} from "@opengeni/contracts";
 import { getVariableSet as getVariableSet2, recordAuditEvent } from "@opengeni/db";
 import { HTTPException as HTTPException6 } from "hono/http-exception";
 var MAX_ENVIRONMENTS_PER_WORKSPACE = 25;
 var MAX_VARIABLES_PER_ENVIRONMENT = 100;
-var reservedExactNames = /* @__PURE__ */ new Set([
-  "HOME",
-  "PATH",
-  "SHELL",
-  "USER",
-  "LOGNAME",
-  "TMPDIR",
-  "IFS",
-  "ENV",
-  "BASH_ENV",
-  "NODE_OPTIONS",
-  "PYTHONPATH",
-  "PYTHONSTARTUP",
-  "PERL5OPT",
-  "PERL5LIB",
-  "GH_TOKEN",
-  "GITHUB_TOKEN",
-  "GITLAB_TOKEN",
-  "AZURE_DEVOPS_EXT_PAT",
-  "GIT_ASKPASS",
-  "GIT_TERMINAL_PROMPT"
-]);
-var reservedPrefixes = [
-  "OPENGENI_",
-  "GIT_CONFIG_",
-  "GIT_AUTHOR_",
-  "GIT_COMMITTER_",
-  "LD_",
-  "DYLD_"
-];
 function assertAllowedVariableSetVariableName(name) {
-  if (reservedExactNames.has(name) || reservedPrefixes.some((prefix) => name.startsWith(prefix))) {
+  if (variableSetVariableNameReservation(name)) {
     throw new HTTPException6(422, {
       message: `reserved variable set variable name / reserved environment variable name: ${name}`
     });
@@ -6250,15 +6329,40 @@ function personalConnectionDelegationsFromParent(input) {
   const projected = [
     ...mcp,
     ...input.parentDelegations.filter(
-      (item) => childEligible(item) && (item.connectionType === "social" || item.connectionType === "atlassian" || item.serverId === GOOGLE_DRIVE_PUBLICATION_SERVER_ID)
+      (item) => childEligible(item) && (item.connectionType === "social" || item.connectionType === "atlassian" || item.connectionType === "github_personal" || item.serverId === GOOGLE_DRIVE_PUBLICATION_SERVER_ID)
     ).map((item) => ({ ...item }))
   ];
-  if (input.rejectActivatedConnections && projected.some((delegation) => delegation.userDelegation)) {
+  const requestedGitHub = personalGitHubRepositoryResources(input.personalGitHubResources ?? []);
+  const inherited = projected.flatMap((delegation) => {
+    if (delegation.connectionType !== "github_personal") return [delegation];
+    if (requestedGitHub.length === 0) return [];
+    const snapshot = delegation.personalGitHubRepositorySelection;
+    if (!snapshot) return [];
+    const repositories = requestedGitHub.map((resource) => {
+      const parent = snapshot.repositories.find(
+        (candidate) => candidate.repositoryId === resource.repositoryId && candidate.canonicalUrl === resource.uri && candidate.ref === resource.ref
+      );
+      if (!parent || resource.credentialBindingId !== snapshot.credentialBindingId || resource.access === "write" && parent.access !== "write") {
+        throw new Error("agent-created personal GitHub repository exceeds parent authority");
+      }
+      return { ...parent, access: resource.access };
+    });
+    return [
+      {
+        ...delegation,
+        personalGitHubRepositorySelection: { ...snapshot, repositories }
+      }
+    ];
+  });
+  if (requestedGitHub.length > 0 && !inherited.some((delegation) => delegation.connectionType === "github_personal")) {
+    throw new Error("agent-created personal GitHub repository authority is unavailable");
+  }
+  if (input.rejectActivatedConnections && inherited.some((delegation) => delegation.userDelegation)) {
     throw new Error(
       "scheduled connection authority is not available until task occurrence authority is activated"
     );
   }
-  return projected;
+  return inherited;
 }
 function googleDrivePublicationDelegationFromVisibleConnections(input) {
   const selection = input.authoritySelection;
@@ -6471,11 +6575,6 @@ async function freezePersonalConnectionDelegations(input) {
         "agent-created work inherits connection authority from its exact parent turn"
       );
     }
-    if (personalGitHubResources.length > 0) {
-      throw new Error(
-        "agent-created personal GitHub repository authority is not activated in this delivery phase"
-      );
-    }
     const inherited = personalConnectionDelegationsFromParent({
       servers,
       parentDelegations: await getSessionTurnPersonalConnectionDelegations(
@@ -6484,6 +6583,7 @@ async function freezePersonalConnectionDelegations(input) {
         input.source.sessionId,
         input.source.turnId
       ),
+      personalGitHubResources,
       ...input.targetSessionId ? { targetSessionId: input.targetSessionId } : {},
       ...input.rejectUnselectedActivatedConnections !== void 0 ? { rejectActivatedConnections: input.rejectUnselectedActivatedConnections } : {}
     });
@@ -6935,6 +7035,8 @@ import {
   createScheduledTask,
   deleteScheduledTask,
   getConnectionMetadata as getConnectionMetadata4,
+  getEnrollment as getEnrollment3,
+  getLiveEnrollmentConnection as getLiveEnrollmentConnection3,
   getKnowledgeSourceForSyncAuthority,
   getNestedAgentDepthDeploymentPolicy,
   getRig as getRig5,
@@ -6942,6 +7044,7 @@ import {
   getScheduledTaskIncludingDeletedForUpdate,
   getScheduledTaskPersonalConnectionDelegations,
   getScheduledTaskXaiProviderAccountAuthoritySnapshot,
+  getSandbox as getSandbox4,
   getSessionTurnXaiProviderAccountAuthoritySnapshot as getSessionTurnXaiProviderAccountAuthoritySnapshot2,
   getSession as getSession3,
   nestedPostgresSqlState as nestedPostgresSqlState2,
@@ -6966,6 +7069,7 @@ import {
   XAI_SUBSCRIPTION_MODEL_ID_PREFIX
 } from "@opengeni/config";
 import {
+  AUTOMATIC_SESSION_TITLE_FALLBACK,
   CreateSessionRequest,
   DEFAULT_FIRST_PARTY_MCP_PERMISSIONS,
   DEFAULT_FIRST_PARTY_MCP_TOOLS,
@@ -6976,6 +7080,7 @@ import {
   ServiceTurnInitiator,
   ServiceTurnInitiatorContext,
   evaluateWorkspaceModelPolicy,
+  normalizeAutomaticSessionTitle,
   resolveWorkspaceSessionToolDefaults as resolveWorkspaceSessionToolDefaults2,
   stableJson as stableJson4,
   SessionMcpApprovalPolicy
@@ -7876,6 +7981,22 @@ function validateSessionMcpCredentialUpdates(input) {
   });
   return encryptedUpdates;
 }
+var AGENT_CHILD_AUTOMATIC_TITLE_CONTEXT_KEY = "agentChildAutomaticTitle";
+function freezeAgentChildAutomaticTitleInCreatorContext(context, title) {
+  return title ? { ...context ?? {}, [AGENT_CHILD_AUTOMATIC_TITLE_CONTEXT_KEY]: title } : context;
+}
+function initialAutomaticTitleForSessionStart(session, requestedTitle) {
+  const frozenTitle = session.createdByContext[AGENT_CHILD_AUTOMATIC_TITLE_CONTEXT_KEY];
+  return typeof frozenTitle === "string" ? frozenTitle : requestedTitle ?? null;
+}
+function automaticTitleForAgentChildCreate(presentation, goal, initialMessage) {
+  for (const candidate of [presentation.automaticTitleCandidate, goal?.text, initialMessage]) {
+    if (typeof candidate !== "string") continue;
+    const normalized = normalizeAutomaticSessionTitle(candidate);
+    if (normalized && normalized !== AUTOMATIC_SESSION_TITLE_FALLBACK) return normalized;
+  }
+  return null;
+}
 async function createAndStartSessionWithOutcome(input) {
   const sessionMetadata = {
     ...input.metadata,
@@ -7883,6 +8004,10 @@ async function createAndStartSessionWithOutcome(input) {
     reasoningEffort: input.reasoningEffort,
     ...input.latencyMode !== void 0 ? { latencyMode: input.latencyMode } : {}
   };
+  const frozenCreatedByContext = freezeAgentChildAutomaticTitleInCreatorContext(
+    input.createdByContext,
+    input.initialAutomaticTitle
+  );
   if (input.createIdempotencyKey) {
     const keyedResult = await createSessionWithIdempotencyKeyResult(input.db, {
       ...input.requestedSessionId ? { requestedSessionId: input.requestedSessionId } : {},
@@ -7897,7 +8022,7 @@ async function createAndStartSessionWithOutcome(input) {
       toolPolicy: input.toolPolicy,
       metadata: sessionMetadata,
       ...input.createdBy ? { createdBy: input.createdBy } : {},
-      ...input.createdByContext ? { createdByContext: input.createdByContext } : {},
+      ...frozenCreatedByContext ? { createdByContext: frozenCreatedByContext } : {},
       createdByActor: input.createdByActor ?? null,
       model: input.model,
       reasoningEffort: input.reasoningEffort,
@@ -7966,7 +8091,7 @@ async function createAndStartSessionWithOutcome(input) {
       toolPolicy: input.toolPolicy,
       metadata: sessionMetadata,
       ...input.createdBy ? { createdBy: input.createdBy } : {},
-      ...input.createdByContext ? { createdByContext: input.createdByContext } : {},
+      ...frozenCreatedByContext ? { createdByContext: frozenCreatedByContext } : {},
       createdByActor: input.createdByActor ?? null,
       model: input.model,
       reasoningEffort: input.reasoningEffort,
@@ -8070,6 +8195,10 @@ async function finishStartSession(input, session) {
       ...input.goal.maxAutoContinuations !== void 0 ? { maxAutoContinuations: input.goal.maxAutoContinuations } : {},
       ...input.goal.mutationPolicy !== void 0 ? { mutationPolicy: input.goal.mutationPolicy } : {}
     } : null,
+    initialAutomaticTitle: initialAutomaticTitleForSessionStart(
+      session,
+      input.initialAutomaticTitle
+    ),
     consumeNewSessionDraft: input.consumeNewSessionDraft ?? null,
     rememberNewSessionSelection: input.rememberNewSessionSelection ?? null,
     deferInitialTurn: input.deferInitialTurn === true
@@ -8372,7 +8501,7 @@ function resolveSessionCreateVisibility(input) {
   }
   return input.requestedVisibility === "private" ? "user_private" : "workspace_shared";
 }
-async function createSessionForRequestWithOutcome(deps, grant, workspaceId, rawPayload, authorization) {
+async function createSessionForRequestWithOutcome(deps, grant, workspaceId, rawPayload, authorization, agentChildPresentation) {
   const { settings, db, bus, workflowClient, objectStorage } = deps;
   const payload = CreateSessionRequest.parse(rawPayload);
   const visibilityProvided = hasOwnProperty(rawPayload, "visibility");
@@ -8480,6 +8609,11 @@ async function createSessionForRequestWithOutcome(deps, grant, workspaceId, rawP
       });
     }
   }
+  const initialAutomaticTitle = parentSession && agentChildPresentation ? automaticTitleForAgentChildCreate(
+    agentChildPresentation,
+    effectiveGoal,
+    payload.initialMessage
+  ) : null;
   const personalResourceSubjectId = creationInitiator.actor ? (await requireLiveAgentAttemptAuthorization(db, grant, creationInitiator.actor.sessionId)).initiatingHumanSubjectId : grant.subjectId;
   const xaiProviderAccountAuthoritySnapshot = parentSession && creationInitiator.actor ? await getSessionTurnXaiProviderAccountAuthoritySnapshot(
     db,
@@ -8733,6 +8867,8 @@ async function createSessionForRequestWithOutcome(deps, grant, workspaceId, rawP
   const sandboxChoice = payload.sandbox ?? (payload.targetSandboxId ? "new" : parentSessionId ? "shared" : "new");
   let sandboxGroupId = null;
   let inheritedBackend;
+  let inheritedSandboxOs;
+  let inheritedActiveTarget = null;
   const requestedVariableSetIds = variableSets.map((variableSet) => variableSet.id);
   const variableSetsMatchGroup = (memberVariableSetIds) => stableJson4(memberVariableSetIds) === stableJson4(requestedVariableSetIds);
   const rigVersionMatchesGroup = (memberRigVersionId) => memberRigVersionId === frozenRigVersionId;
@@ -8768,6 +8904,11 @@ async function createSessionForRequestWithOutcome(deps, grant, workspaceId, rawP
     } else {
       sandboxGroupId = parent.sandboxGroupId;
       inheritedBackend = parent.sandboxBackend;
+      inheritedSandboxOs = parent.sandboxOs;
+      inheritedActiveTarget = parent.activeSandboxId ? {
+        sandboxId: parent.activeSandboxId,
+        workingDir: parent.workingDir
+      } : null;
     }
   } else if (typeof sandboxChoice === "object") {
     const member = await getAnySessionInGroup(db, workspaceId, sandboxChoice.groupId);
@@ -8804,12 +8945,18 @@ async function createSessionForRequestWithOutcome(deps, grant, workspaceId, rawP
     }
     sandboxGroupId = sandboxChoice.groupId;
     inheritedBackend = member.sandboxBackend;
+    inheritedSandboxOs = member.sandboxOs;
   }
   if (payload.workingDir !== void 0 && !payload.targetSandboxId) {
     throw new HTTPException11(422, {
       message: "workingDir requires targetSandboxId (it is the targeted machine's working directory)"
     });
   }
+  if (inheritedBackend === void 0 && !payload.targetSandboxId && (payload.sandboxBackend ?? settings.sandboxBackend) === "selfhosted") {
+    throw new HTTPException11(422, {
+      message: "selfhosted sessions require targetSandboxId; select an online Connected Machine"
+    });
+  }
   let machineHomeBackend;
   let machineHomeOs;
   if (payload.targetSandboxId && inheritedBackend === void 0 && settings.sandboxOwnershipEnabled && settings.sandboxSelfhostedEnabled) {
@@ -8832,6 +8979,17 @@ async function createSessionForRequestWithOutcome(deps, grant, workspaceId, rawP
       }
     }
   }
+  const effectiveSandboxBackend = inheritedBackend ?? machineHomeBackend ?? payload.sandboxBackend ?? settings.sandboxBackend;
+  const effectiveSandboxOs = inheritedSandboxOs ?? machineHomeOs;
+  const effectiveSeedTarget = payload.targetSandboxId ? {
+    sandboxId: payload.targetSandboxId,
+    workingDir: payload.workingDir ?? null
+  } : inheritedActiveTarget;
+  if (effectiveSandboxBackend === "selfhosted" && effectiveSeedTarget === null && managedSessionGroupBackend(settings.sandboxBackend, effectiveSandboxBackend) === null) {
+    throw new HTTPException11(422, {
+      message: "self-hosted execution runs on a Connected Machine, but no machine was selected or inherited; connect the parent session to a machine or provide machineTarget"
+    });
+  }
   if (payload.startMode !== "realtime") {
     await requireLimit(deps, {
       accountId: grant.accountId,
@@ -8868,10 +9026,10 @@ async function createSessionForRequestWithOutcome(deps, grant, workspaceId, rawP
       // machine-targeted create (top-level or own-box child) labels the home
       // "selfhosted" (machineHomeBackend), overriding the caller/deployment
       // default so the row matches where the session actually runs.
-      sandboxBackend: inheritedBackend ?? machineHomeBackend ?? payload.sandboxBackend ?? settings.sandboxBackend,
+      sandboxBackend: effectiveSandboxBackend,
       // Mirror the backend relabel on the OS axis: a machine-targeted own-box
-      // create carries a derived OS; shared spawns keep the parent-box behavior.
-      ...machineHomeOs ? { sandboxOs: machineHomeOs } : {},
+      // create carries a derived OS; shared spawns inherit the exact parent box.
+      ...effectiveSandboxOs ? { sandboxOs: effectiveSandboxOs } : {},
       sandboxGroupId,
       metadata: payload.metadata,
       ...creationInitiator.initiator ? { createdBy: creationInitiator.initiator } : {},
@@ -8887,6 +9045,7 @@ async function createSessionForRequestWithOutcome(deps, grant, workspaceId, rawP
       rigVersionId: frozenRigVersionId,
       channelId,
       goal: effectiveGoal ?? null,
+      initialAutomaticTitle,
       // Per-session persona instructions (already trimmed/validated by the
       // contracts schema). Persisted on the row; composed system-level at turn
       // time. Not surfaced as an event.
@@ -8908,10 +9067,10 @@ async function createSessionForRequestWithOutcome(deps, grant, workspaceId, rawP
       // active-sandbox pointer is seeded race-free inside createAndStartSession
       // (after the row exists, before the first turn dispatches). Validation
       // (ownership/liveness) lives in swapActiveSandbox; an invalid target 422s.
-      seedTargetSandbox: payload.targetSandboxId ? {
-        sandboxId: payload.targetSandboxId,
+      seedTargetSandbox: effectiveSeedTarget ? {
+        sandboxId: effectiveSeedTarget.sandboxId,
         settings,
-        workingDir: payload.workingDir ?? null,
+        workingDir: effectiveSeedTarget.workingDir,
         resourceSubjectId: personalResourceSubjectId
       } : null,
       consumeNewSessionDraft: payload.expectedNewSessionDraftRevision !== void 0 && payload.startMode !== "realtime" ? {
@@ -9513,6 +9672,15 @@ async function createValidatedScheduledTask(input) {
     rigId: input.payload.rigId,
     agentConfig
   });
+  if (!knowledgeAction) {
+    await validateScheduledTaskMachineTarget({
+      settings: input.settings,
+      db: input.db,
+      grant: input.grant,
+      runMode: input.payload.runMode,
+      agentConfig
+    });
+  }
   if (!knowledgeAction && input.payload.variableSetId) {
     await validateVariableSetAttachment(
       { settings: input.settings, db: input.db },
@@ -9695,6 +9863,59 @@ async function validateScheduledTaskTarget(input) {
   }
   return session;
 }
+async function validateScheduledTaskMachineTarget(input) {
+  const machineTarget = input.agentConfig.machineTarget;
+  if (!machineTarget) {
+    if (input.runMode !== "existing_session" && (input.agentConfig.sandboxBackend ?? input.settings.sandboxBackend) === "selfhosted") {
+      throw new HTTPException12(422, {
+        message: "self-hosted scheduled tasks require a Connected Machine; select a machine before saving"
+      });
+    }
+    return null;
+  }
+  if (input.runMode === "existing_session") {
+    throw new HTTPException12(422, {
+      message: "machineTarget cannot be used with an existing-session target"
+    });
+  }
+  if (!input.settings.sandboxOwnershipEnabled || !input.settings.sandboxSelfhostedEnabled) {
+    throw new HTTPException12(422, {
+      message: "Connected Machines are not enabled for scheduled tasks in this deployment"
+    });
+  }
+  const access = {
+    accountId: input.grant.accountId,
+    workspaceId: input.grant.workspaceId,
+    subjectId: input.grant.subjectId
+  };
+  const sandbox = await getSandbox4(input.db, access, machineTarget.targetSandboxId);
+  if (!sandbox || sandbox.kind !== "selfhosted" || !sandbox.enrollmentId) {
+    throw new HTTPException12(422, {
+      message: "the selected Connected Machine is unavailable"
+    });
+  }
+  if (sandbox.scope === "user") {
+    throw new HTTPException12(422, {
+      message: "personal Connected Machines cannot run unattended schedules; select a workspace or organization machine"
+    });
+  }
+  const enrollment = input.requireOnline ? await getLiveEnrollmentConnection3(input.db, access, sandbox.enrollmentId) : await getEnrollment3(input.db, access, sandbox.enrollmentId);
+  if (!enrollment || enrollment.status !== "active") {
+    throw new HTTPException12(422, {
+      message: input.requireOnline ? "the selected Connected Machine is offline" : "the selected Connected Machine is unavailable"
+    });
+  }
+  if (input.requireOnline && !enrollment.workspaceRoot) {
+    throw new HTTPException12(422, {
+      message: "the selected Connected Machine has not reported a workspace root; reconnect it with a current agent"
+    });
+  }
+  return {
+    sandboxId: sandbox.id,
+    enrollmentId: sandbox.enrollmentId,
+    sandboxOs: enrollment.os
+  };
+}
 function scheduledTaskForGrant(task, grant) {
   if (hasPermission(grant.permissions, "sessions:control") || task.targetSessionId === null) {
     return task;
@@ -9966,6 +10187,13 @@ async function validatedScheduledTaskUpdate(input) {
     rigId: input.payload.rigId !== void 0 ? input.payload.rigId : input.existing.rigId,
     agentConfig: update.agentConfig ?? input.existing.agentConfig
   });
+  await validateScheduledTaskMachineTarget({
+    settings: input.settings,
+    db: input.db,
+    grant: input.grant,
+    runMode: nextRunMode,
+    agentConfig: update.agentConfig ?? input.existing.agentConfig
+  });
   if (input.payload.targetSessionId !== void 0 || input.existing.runMode === "existing_session" || nextRunMode === "existing_session" || input.existing.runMode === "reusable_session" && nextRunMode !== "reusable_session") {
     update.targetSessionId = nextTargetSessionId;
   }
@@ -11008,6 +11236,7 @@ function denied(reason) {
 
 // src/domain/memory-slack-delivery.ts
 import {
+  correctWorkspaceMemory,
   enqueueMemorySlackPublication,
   getCurrentMemorySlackPublicationConfiguration,
   getWorkspaceMemorySlackPublicationSnapshot,
@@ -11021,6 +11250,25 @@ async function saveWorkspaceMemoryWithSlackPublication(db, input, publication, e
     return { ...result, slackPublication };
   });
 }
+async function correctWorkspaceMemoryWithSlackPublication(db, input, publication, embedder) {
+  return await withWorkspaceRls(db, input.workspaceId, async (scopedDb) => {
+    const result = await correctWorkspaceMemory(scopedDb, input, embedder);
+    if (!publication || result.action !== "superseded" || !result.replacement) {
+      return { ...result, slackPublication: { decision: null, enqueue: null } };
+    }
+    const replacement = await requiredSnapshot(scopedDb, input.workspaceId, result.replacement.id);
+    const slackPublication = await evaluateAndEnqueue(scopedDb, {
+      accountId: input.accountId,
+      workspaceId: input.workspaceId,
+      snapshot: replacement,
+      changeKind: "corrected",
+      relatedMemoryId: result.memory.id,
+      occurredAt: result.replacement.updatedAt,
+      publication
+    });
+    return { ...result, slackPublication };
+  });
+}
 async function publishSavedMemoryMutation(db, input, result, publication) {
   if (result.updated || result.deduped && !result.superseded) {
     return { decision: null, enqueue: null };
@@ -11405,7 +11653,13 @@ import {
   writeCompanyBrainGovernedProposal
 } from "@opengeni/db";
 import { createHash as createHash7 } from "crypto";
-var DEFAULT_AUTOMATIC_LEARNING_DESTINATIONS = ["preference"];
+var DEFAULT_AUTOMATIC_LEARNING_DESTINATIONS = ["preference", "instruction_policy"];
+function dispatchBestEffortGovernedLearningNotification(notify) {
+  try {
+    void notify().catch(() => void 0);
+  } catch {
+  }
+}
 function createCompanyBrainGovernedWriteRouter(options) {
   const authority = options.authority ?? writeCompanyBrainGovernedProposal;
   return {
@@ -11566,15 +11820,14 @@ function createCompanyBrainLearningPolicyRouter(options) {
           learningFailure: classifyLearningFailure("activation", error)
         });
       }
-      try {
-        await notifyActivation({
+      dispatchBestEffortGovernedLearningNotification(
+        () => notifyActivation({
           db: options.db,
           receipt: activation,
           sessionId: attempt.sessionId,
           attemptId: attempt.attemptId
-        });
-      } catch {
-      }
+        })
+      );
       return CompanyBrainLearningPolicyRouteReceipt.parse({
         operationId: request.operationId,
         workspaceId: attempt.workspaceId,
@@ -12020,15 +12273,14 @@ function createRememberRouter(options) {
         }
       }
       if (!activation) throw asRememberFailure(lastFailure);
-      try {
-        await notifyActivation({
+      dispatchBestEffortGovernedLearningNotification(
+        () => notifyActivation({
           db: options.db,
           receipt: activation,
           sessionId: attempt.sessionId,
           attemptId: attempt.attemptId
-        });
-      } catch {
-      }
+        })
+      );
       return RememberConfirmReceipt.parse({
         status: "activated",
         operationId: request.operationId,
@@ -12848,7 +13100,9 @@ function resolveMemberSubjectId(userId) {
 function assertWorkspaceMemberRemovable(input) {
   const { members, subjectId, callerSubjectId } = input;
   if (subjectId === callerSubjectId) {
-    throw new HTTPException13(409, { message: "you cannot remove your own membership" });
+    throw new HTTPException13(409, {
+      message: "you cannot remove your own membership"
+    });
   }
   const target = members.find((member) => member.subjectId === subjectId);
   if (!target) {
@@ -12865,9 +13119,28 @@ function assertWorkspaceMemberRemovable(input) {
     }
   }
 }
+function assertWorkspaceMemberUpdateAllowed(input) {
+  const { members, subjectId, callerSubjectId, nextPermissions } = input;
+  if (subjectId === callerSubjectId) {
+    throw new HTTPException13(409, {
+      message: "you cannot change your own workspace access"
+    });
+  }
+  const target = members.find((member) => member.subjectId === subjectId);
+  if (!target) {
+    throw new HTTPException13(404, { message: "member not found" });
+  }
+  if (memberCanAdminister(target) && !memberCanAdminister({ permissions: nextPermissions }) && !members.some((member) => member.subjectId !== subjectId && memberCanAdminister(member))) {
+    throw new HTTPException13(409, {
+      message: "the workspace must keep at least one administrator"
+    });
+  }
+}
 function assertWorkspaceDeletable(input) {
   if (input.workspaceCountForAccount <= 1) {
-    throw new HTTPException13(409, { message: "cannot delete the account's only workspace" });
+    throw new HTTPException13(409, {
+      message: "cannot delete the account's only workspace"
+    });
   }
   if (input.activeSessionCount > 0) {
     throw new HTTPException13(409, {
@@ -13125,9 +13398,9 @@ import {
 } from "@opengeni/contracts";
 import {
   getNewSessionDraftInTransaction,
-  getEnrollment as getEnrollment3,
+  getEnrollment as getEnrollment4,
   getRig as getRig6,
-  getSandbox as getSandbox4,
+  getSandbox as getSandbox5,
   getVariableSet as getVariableSet4,
   NewSessionDraftAccessError,
   newSessionDraftToolsProvided,
@@ -13220,8 +13493,8 @@ async function hydrateNewSessionDraft(deps, grant, workspaceId, row) {
     if (!rig?.activeVersion) delete options.rigId;
   }
   if (options.targetSandboxId) {
-    const sandbox = await getSandbox4(deps.db, workspaceId, options.targetSandboxId);
-    const enrollment = sandbox?.enrollmentId ? await getEnrollment3(deps.db, workspaceId, sandbox.enrollmentId) : null;
+    const sandbox = await getSandbox5(deps.db, workspaceId, options.targetSandboxId);
+    const enrollment = sandbox?.enrollmentId ? await getEnrollment4(deps.db, workspaceId, sandbox.enrollmentId) : null;
     if (!sandbox || sandbox.kind !== "selfhosted" || !enrollment || enrollment.status !== "active") {
       delete options.targetSandboxId;
       delete options.workingDir;
@@ -14118,6 +14391,7 @@ async function saveHumanComposerDraft(deps, context, input) {
 // src/application/user-resource-grants.ts
 import {
   issueSelfUserResourceGrant,
+  issueSelfLocalConnectionUseGrant,
   listSelfUserResourceAuthorities,
   revokeSelfUserResourceGrant,
   sessionTenancyProductActivated as sessionTenancyProductActivated3,
@@ -14144,7 +14418,11 @@ async function requireOwnerProductGate(deps, authorization, workspaceId, permiss
   }
 }
 function requireOwnerAuthority(authorization, workspaceId, permissions) {
-  requireCanonicalManagedHuman(authorization, workspaceId);
+  if (!authorization.canonicalLocalHumanSession) {
+    requireCanonicalManagedHuman(authorization, workspaceId);
+  } else if (!authorization.contextIntegrity || authorization.authenticatedSubjectId !== authorization.grant.subjectId || authorization.grant.workspaceId !== workspaceId) {
+    throw new SessionTenancyManagedHumanRequiredError();
+  }
   for (const permission of permissions) requirePermission(authorization.grant, permission);
 }
 async function listManagedHumanUserResourceAuthorities(deps, authorization, workspaceId, input) {
@@ -14161,6 +14439,23 @@ async function listManagedHumanUserResourceAuthorities(deps, authorization, work
 }
 async function issueManagedHumanUserResourceGrant(deps, authorization, workspaceId, authorityId, request, authorizationSurface = "core") {
   const modePermissions = request.mode === "session" ? ["sessions:control"] : ["sessions:create"];
+  if (authorization.canonicalLocalHumanSession) {
+    requireOwnerAuthority(authorization, workspaceId, [
+      ...ISSUE_PERMISSIONS[request.resourceKind],
+      "sessions:create"
+    ]);
+    if (request.resourceKind !== "connection" || request.mode !== "always") {
+      throw new SessionTenancyManagedHumanRequiredError();
+    }
+    return await issueSelfLocalConnectionUseGrant(deps.db, {
+      accountId: authorization.grant.accountId,
+      workspaceId,
+      subjectId: authorization.grant.subjectId,
+      authorityId,
+      context: request.context,
+      workspaceSharedAcknowledged: request.workspaceSharedAcknowledged
+    });
+  }
   await requireOwnerProductGate(deps, authorization, workspaceId, [
     ...ISSUE_PERMISSIONS[request.resourceKind],
     ...modePermissions
@@ -14317,6 +14612,7 @@ export {
   acceptSessionUserMessage,
   acceptSessionUserMessageWithOutcome,
   accessGrantAuthorizationFromContext,
+  accountScopedApiKeyWorkspaceAuthority,
   activateRigVersionForApi,
   apiIntegrationsMatchingDelegations,
   appendRigSetupCommand,
@@ -14344,6 +14640,7 @@ export {
   assertVideoGenerationTransition,
   assertWorkspaceDeletable,
   assertWorkspaceMemberRemovable,
+  assertWorkspaceMemberUpdateAllowed,
   assertWorkspaceModelPolicyAllows,
   authorizedAtlassianConnectionsForGrant,
   authorizedSocialConnectionsForGrant,
@@ -14374,6 +14671,7 @@ export {
   controlHumanSessionWorkstreamWithOutcome,
   controlHumanWorkspace,
   conversationDeliveryNextAction,
+  correctWorkspaceMemoryWithSlackPublication,
   createAndStartSession,
   createAndStartSessionWithOutcome,
   createCatalogItem,
@@ -14405,6 +14703,7 @@ export {
   directRetainedProcessMatchesBackend,
   disableCapability,
   discoverMcpRegistryCapabilities,
+  dispatchBestEffortGovernedLearningNotification,
   editHumanQueuePrompt,
   editableArtifactActorKey,
   editableArtifactAuthorizationRevisionPortFromPostgres,
@@ -14442,6 +14741,7 @@ export {
   fikenConnectionMetadata,
   filenameForMimeType,
   forkManagedHumanSession,
+  freezeAgentChildAutomaticTitleInCreatorContext,
   freezePersonalConnectionDelegations,
   getActorNewSessionDraft,
   getAutomationAdapter,
@@ -14465,6 +14765,7 @@ export {
   hasReservedOpenGeniSlackBotSessionMetadata,
   hashEditableArtifactCreateRequest,
   hashEditableArtifactImportRequest,
+  initialAutomaticTitleForSessionStart,
   inlinePackSkillInstall,
   insightsSessionLabel,
   inspectEditableArtifactLiveWireEnvelope,
@@ -14486,6 +14787,8 @@ export {
   listRigVersionsForApi,
   listWorkspaceCapabilityPacks,
   loadRigDefaultVariableSetEnvironment,
+  managedSessionGroupBackend,
+  managedSessionGroupOs,
   manualScheduledTaskTriggerUsageKey,
   manualScheduledTaskTriggerWorkflowId,
   markManagedAuthRequestActorTransitionApplied,
@@ -14557,6 +14860,7 @@ export {
   requireAccessGrantAuthorization,
   requireAccountAdminAuthorizationStamp,
   requireAutomationAdapter,
+  requireCanonicalLocalAccountAdministrator,
   requireCanonicalManagedHuman,
   requireEnvironmentEncryption,
   requireFreshAccessGrant,
@@ -14589,6 +14893,7 @@ export {
   resolveSkillImport,
   resolveWorkspaceLegacyRuntimePacks,
   restoreScheduledTask,
+  retainedProcessBackgroundSettlement,
   revokeManagedHumanUserResourceGrant,
   rigActorForGrant,
   rigProviderImageBuildRequestId,
@@ -14653,6 +14958,7 @@ export {
   validateManagedAuthRequestActorLease,
   validateMcpCapabilityConnection,
   validateOpenGeniSlackBotConnectionSelection,
+  validateScheduledTaskMachineTarget,
   validateScheduledTaskTarget,
   validateToolRefs,
   validateToolRefsForSessionPolicy,