@opengeni/core 0.21.2 → 0.21.10

package/dist/index.js

@@ -3,6 +3,26 @@ var SESSION_WORKFLOW_WAKE_DISPATCHER_SCHEDULE_ID = "opengeni-session-workflow-wa
 var SESSION_WORKFLOW_WAKE_DISPATCHER_WORKFLOW_TYPE = "sessionWorkflowWakeDispatcherWorkflow";
 var SESSION_WORKFLOW_WAKE_DISPATCHER_PERIOD_MS = 1e4;
 
+// src/managed-session.ts
+async function getManagedSession(c, auth) {
+  const result = await auth.api.getSession({
+    headers: c.req.raw.headers,
+    returnHeaders: true
+  });
+  for (const cookie of setCookieHeaders(result.headers)) {
+    c.header("set-cookie", cookie, { append: true });
+  }
+  return result.response;
+}
+function setCookieHeaders(headers) {
+  const getSetCookie = headers.getSetCookie;
+  if (getSetCookie) {
+    return getSetCookie.call(headers);
+  }
+  const cookie = headers.get("set-cookie");
+  return cookie ? [cookie] : [];
+}
+
 // src/transcription.ts
 var TRANSCRIPTION_PROVIDER_REQUEST_TIMEOUT_MILLISECONDS = 10 * 60 * 1e3;
 var TranscriptionServiceError = class extends Error {
@@ -79,7 +99,7 @@ function filenameForMimeType(mimeType) {
 
 // src/sandbox/fleet.ts
 import {
-  getEnrollment,
+  getEnrollment as getEnrollment2,
   getSandbox as getSandbox2,
   listSandboxes,
   readActiveSandbox as readActiveSandbox2,
@@ -89,6 +109,7 @@ import {
 } from "@opengeni/db";
 import {
   NatsControlRpc as NatsControlRpc2,
+  NatsOpStreamTransport as NatsOpStreamTransport2,
   selfhostedLiveness,
   SelfhostedSession,
   swapTargetEstablishability
@@ -100,6 +121,7 @@ import { sandboxArchiveCaptureTimeoutMs } from "@opengeni/config";
 import {
   advanceWorkspaceGenerationForDirectRequest,
   advanceWorkspaceGenerationForRetainedProcess,
+  getEnrollment,
   getRetainedProcess,
   getSandbox,
   markWarmLeaseInstanceLost,
@@ -115,6 +137,7 @@ import {
   isProviderSandboxGoneDuringRoutedOperation,
   makeActiveBackendResolver,
   NatsControlRpc,
+  NatsOpStreamTransport,
   RoutingSandboxSession,
   resolveModalCheckpointProviderBindingForSession
 } from "@opengeni/runtime/sandbox";
@@ -154,6 +177,18 @@ function controlRpcFactory(bus) {
     return bus.getRequestConnection();
   });
 }
+async function resolveSelfhostedOpStream(services, workspaceId, sandbox) {
+  if (services.settings.agentOpStreamEnabled !== true || !services.bus?.getOpStreamConnection || !sandbox.enrollmentId) {
+    return void 0;
+  }
+  const enrollment = await getEnrollment(services.db, workspaceId, sandbox.enrollmentId);
+  if (enrollment?.opStream !== true) return void 0;
+  return {
+    transport: new NatsOpStreamTransport(
+      async () => services.bus?.getOpStreamConnection?.() ?? null
+    )
+  };
+}
 function routingEnabled(settings) {
   return settings.sandboxSelfhostedEnabled === true;
 }
@@ -317,6 +352,7 @@ function wrapChannelABoxWithRouting(services, ids, established) {
       } : null;
     },
     controlRpcFactory: controlRpcFactory(bus),
+    resolveSelfhostedOpStream: (sandbox) => resolveSelfhostedOpStream(services, ids.workspaceId, sandbox),
     relay: relayConfigFromSettings(settings),
     selfhostedTimeoutMs: settings.sandboxSelfhostedControlTimeoutMs,
     selfhostedExecTimeoutMs: settings.sandboxSelfhostedExecTimeoutMs,
@@ -463,6 +499,10 @@ async function listFleet(services, ctx) {
   const groupRecovering = Boolean(
     groupLease && (groupLease.liveness === "warming" || groupLease.recovery.restore.status === "pending" || groupLease.recovery.restore.status === "restoring" || groupLease.recovery.restore.status === "verifying")
   );
+  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";
   entries.push({
     id: ctx.sessionGroupId,
     kind: ctx.sessionBackend === "selfhosted" ? "selfhosted" : "modal",
@@ -472,6 +512,7 @@ async function listFleet(services, ctx) {
     isSessionGroup: true,
     enrollmentId: null,
     attachable: groupOnline,
+    operationAvailability: groupOperationAvailability,
     providerStatus: groupLease?.recovery.provider.status ?? "not_created",
     leaseLiveness: groupLease?.liveness ?? null,
     routeStatus: groupActive ? "attached" : "detached",
@@ -489,7 +530,10 @@ async function listFleet(services, ctx) {
     if (sandbox.kind !== "selfhosted" || !sandbox.enrollmentId) {
       continue;
     }
-    const enrollment = await getEnrollment(db, ctx.workspaceId, sandbox.enrollmentId);
+    const enrollment = await getEnrollment2(db, ctx.workspaceId, sandbox.enrollmentId);
+    if (!enrollment || enrollment.status !== "active") {
+      continue;
+    }
     const probe = enrollment ? await probeEnrollment(services, ctx.workspaceId, enrollment) : { liveness: "offline", consented: false, hasDisplay: false };
     entries.push({
       id: sandbox.id,
@@ -500,6 +544,7 @@ async function listFleet(services, ctx) {
       isSessionGroup: false,
       enrollmentId: sandbox.enrollmentId,
       attachable: probe.liveness === "online",
+      operationAvailability: probe.liveness === "online" ? "ready" : probe.liveness === "reconnecting" ? "recovering" : "unavailable",
       consented: probe.consented,
       hasDisplay: probe.hasDisplay,
       lastSeenAt: enrollment?.lastSeenAt ?? null,
@@ -549,7 +594,7 @@ async function resolveTarget(services, ctx, target) {
         code: "offline_enrollment"
       };
     }
-    const enrollment = await getEnrollment(services.db, ctx.workspaceId, sandbox.enrollmentId);
+    const enrollment = await getEnrollment2(services.db, ctx.workspaceId, sandbox.enrollmentId);
     if (!enrollment) {
       return {
         ok: false,
@@ -648,7 +693,8 @@ async function executeRunOnSelfhostedMachine(machine, target, op) {
     controlRpc: machine.controlRpc,
     relay: machine.relay,
     timeoutMs: machine.controlTimeoutMs,
-    execTimeoutMs: machine.execTimeoutMs
+    execTimeoutMs: machine.execTimeoutMs,
+    ...machine.opStream !== void 0 ? { opStream: machine.opStream } : {}
   });
   try {
     if (op.kind === "exec") {
@@ -691,6 +737,8 @@ async function executeRunOnSelfhostedMachine(machine, target, op) {
       // so leave `timedOut` absent while still reporting the enforced deadline.
       ...op.kind === "exec" ? { deadlineMs: session.effectiveExecDeadlineMs } : {}
     };
+  } finally {
+    await session.finalizeOpStreamOps().catch(() => void 0);
   }
 }
 async function runOnSandbox(services, ctx, target, op) {
@@ -712,7 +760,7 @@ async function runOnSandbox(services, ctx, target, op) {
       reason: `run_on routes one-off ops to enrolled selfhosted machines; ${sandbox.kind} targets are reached via the active sandbox (swap to it first)`
     };
   }
-  const enrollment = await getEnrollment(services.db, ctx.workspaceId, sandbox.enrollmentId);
+  const enrollment = await getEnrollment2(services.db, ctx.workspaceId, sandbox.enrollmentId);
   if (!enrollment || enrollment.status !== "active") {
     return {
       target,
@@ -729,7 +777,14 @@ async function runOnSandbox(services, ctx, target, op) {
       controlRpc: controlRpc(services.bus),
       relay: relayConfigFromSettings(services.settings),
       controlTimeoutMs: services.settings.sandboxSelfhostedControlTimeoutMs,
-      execTimeoutMs: services.settings.sandboxSelfhostedExecTimeoutMs
+      execTimeoutMs: services.settings.sandboxSelfhostedExecTimeoutMs,
+      ...services.settings.agentOpStreamEnabled === true && enrollment.opStream === true && services.bus?.getOpStreamConnection ? {
+        opStream: {
+          transport: new NatsOpStreamTransport2(
+            async () => services.bus?.getOpStreamConnection?.() ?? null
+          )
+        }
+      } : {}
     },
     target,
     op
@@ -741,7 +796,7 @@ async function provisionSandbox(services, ctx, input) {
     const base = (services.settings.publicBaseUrl ?? "https://get.opengeni.ai").replace(/\/+$/, "");
     return {
       kind: "selfhosted",
-      instructions: "Share these instructions with a human operator. They install the OpenGeni agent on the machine, run `opengeni-agent enroll`, 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.",
+      instructions: "Share these instructions with a human operator. They install the OpenGeni agent on the machine, run `opengeni-agent 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
@@ -853,10 +908,43 @@ function requirePermission(grant, permission) {
     });
   }
 }
+function requireLiteralPermission(grant, permission) {
+  if (!hasLiteralPermission(grant.permissions, permission)) {
+    throw new HTTPException2(403, {
+      message: `missing literal permission: ${permission}`
+    });
+  }
+}
+function hasLiteralPermission(permissions, permission) {
+  return permissions.includes(permission);
+}
 function hasPermission(permissions, permission) {
+  if (permission === "secrets:read") {
+    return permissions.includes("secrets:read");
+  }
   const aliases = {
     "variable-sets:use": ["environments:use"],
-    "variable-sets:manage": ["environments:manage"]
+    "variable-sets:manage": ["environments:manage"],
+    "variable-sets:list": [
+      "variable-sets:use",
+      "variable-sets:manage",
+      "environments:use",
+      "environments:manage"
+    ],
+    "variable-sets:read": [
+      "variable-sets:use",
+      "variable-sets:manage",
+      "environments:use",
+      "environments:manage"
+    ],
+    "variable-sets:write": ["variable-sets:manage", "environments:manage"],
+    "secrets:list": [
+      "variable-sets:use",
+      "variable-sets:manage",
+      "environments:use",
+      "environments:manage"
+    ],
+    "secrets:write": ["variable-sets:manage", "environments:manage"]
   };
   return permissions.includes(permission) || (aliases[permission]?.some((alias) => permissions.includes(alias)) ?? false) || permissions.includes("workspace:admin");
 }
@@ -912,9 +1000,7 @@ async function resolveAccessContext(c, deps) {
     }
   }
   if (deps.managedAuth) {
-    const session = await deps.managedAuth.api.getSession({
-      headers: c.req.raw.headers
-    });
+    const session = await getManagedSession(c, deps.managedAuth);
     if (session?.user) {
       return await ensureManagedAccessForUser(deps.db, {
         userId: session.user.id,
@@ -1054,6 +1140,13 @@ var SessionAuthorizationUnavailableError = class extends Error {
     this.name = "SessionAuthorizationUnavailableError";
   }
 };
+async function requireLiveAgentAttemptAuthorization(db, grant, callerSessionId) {
+  const actor = await resolveSessionAuthorizationActor(db, grant);
+  if (actor.kind !== "agent_attempt" || actor.callerSessionId !== callerSessionId) {
+    throw new SessionAuthorizationDeniedError("caller_stale");
+  }
+  return actor;
+}
 async function requireSessionAuthorization(deps, grant, input) {
   const port = deps.sessionAuthorization;
   const slackAccess = await getSlackInteractionSessionAccessForSession(deps.db, {
@@ -1749,7 +1842,8 @@ async function buildCapabilityCatalog(input) {
     workspacePacks,
     socialConnections,
     bundledSkills,
-    curatedLibrarySkills
+    curatedLibrarySkills,
+    codexAppsCredentialId
   ] = await Promise.all([
     listCapabilityCatalogItems(input.db, input.workspaceId),
     listCapabilityInstallations(input.db, input.workspaceId),
@@ -1757,7 +1851,8 @@ async function buildCapabilityCatalog(input) {
     listWorkspaceCapabilityPacks(input.db, input.workspaceId),
     listSocialConnections(input.db, input.workspaceId, 500, input.subjectId),
     discoverBundledSkills(),
-    discoverCuratedSkillLibraryItems()
+    discoverCuratedSkillLibraryItems(),
+    input.settings.codexConnectedAppsEnabled ? resolveCodexAppsCredentialIdForRun(input.db, input.workspaceId) : Promise.resolve(null)
   ]);
   const capabilityInstallationById = new Map(
     capabilityInstallations.map((installation) => [installation.capabilityId, installation])
@@ -1775,7 +1870,14 @@ async function buildCapabilityCatalog(input) {
     ...bundledSkills,
     ...curatedLibrarySkills
   ];
-  const items = dedupeCatalogItems([...builtIns, ...persistedItems]).map(
+  const codexApps = input.settings.codexConnectedAppsEnabled ? codexAppsCatalogItem(codexAppsCredentialId !== null) : null;
+  const items = dedupeCatalogItems([
+    ...builtIns,
+    ...persistedItems.filter((item) => !isReservedCodexAppsCatalogItem(item)),
+    // Keep the reserved, server-derived item authoritative over any stale
+    // legacy catalog row with the same id.
+    ...codexApps ? [codexApps] : []
+  ]).map(
     (item) => applyCapabilityEnablement(item, capabilityInstallationById.get(item.id), activePackIds)
   ).sort(compareCatalogItems);
   return {
@@ -1795,7 +1897,7 @@ async function createCatalogItem(input) {
       message: "skill ids are managed by the OpenGeni skill library or runtime adapters"
     });
   }
-  if (input.payload.kind === "mcp" && typeof input.payload.metadata.mcpServerId === "string" && input.payload.metadata.mcpServerId.trim() === CODEX_APPS_MCP_SERVER_ID) {
+  if (input.payload.kind === "mcp" && (id === `mcp:${CODEX_APPS_MCP_SERVER_ID}` || typeof input.payload.metadata.mcpServerId === "string" && input.payload.metadata.mcpServerId.trim() === CODEX_APPS_MCP_SERVER_ID)) {
     throw new HTTPException6(422, {
       message: `${CODEX_APPS_MCP_SERVER_ID} is reserved for the canonical Codex Apps service`
     });
@@ -2435,7 +2537,7 @@ function packCatalogItem(pack, source) {
   });
 }
 function configuredMcpCatalogItems(settings) {
-  return settings.mcpServers.map(
+  return settings.mcpServers.filter((server) => server.id !== CODEX_APPS_MCP_SERVER_ID).map(
     (server) => CapabilityCatalogItem.parse({
       id: `mcp:${server.id}`,
       kind: "mcp",
@@ -2460,6 +2562,38 @@ function configuredMcpCatalogItems(settings) {
     })
   );
 }
+function isReservedCodexAppsCatalogItem(item) {
+  return item.id === `mcp:${CODEX_APPS_MCP_SERVER_ID}` || item.kind === "mcp" && (item.runtime.mcpServerId === CODEX_APPS_MCP_SERVER_ID || item.metadata.mcpServerId === CODEX_APPS_MCP_SERVER_ID);
+}
+function codexAppsCatalogItem(available) {
+  return CapabilityCatalogItem.parse({
+    id: `mcp:${CODEX_APPS_MCP_SERVER_ID}`,
+    kind: "mcp",
+    source: "built_in",
+    name: "Codex Apps",
+    description: "Use the ChatGPT Apps designated for this workspace. Sessions include this surface by default when it is authorized; explicit policies can opt out.",
+    category: "productivity",
+    tags: ["mcp", "codex", "connected-apps"],
+    providerDomain: "chatgpt.com",
+    surfaceType: "codex_apps",
+    transport: "streamable-http",
+    mcpUrl: CODEX_APPS_MCP_URL,
+    authKind: "none",
+    tools: [{ kind: "mcp", id: CODEX_APPS_MCP_SERVER_ID }],
+    runtime: {
+      available,
+      ...available ? { mcpServerId: CODEX_APPS_MCP_SERVER_ID } : {},
+      transport: "streamable-http",
+      notes: available ? "Available through the active workspace Apps designation." : "Unavailable until an active Codex Apps credential is designated for this workspace."
+    },
+    enabled: available,
+    enabledReason: available ? "designated Apps credential" : "no active Apps designation",
+    metadata: {
+      mcpServerId: CODEX_APPS_MCP_SERVER_ID,
+      authorization: "workspace_designation"
+    }
+  });
+}
 function platformApiCatalogItems(socialConnections) {
   const xConnection = preferredSocialConnection(socialConnections, "x");
   const xEnabled = xConnection?.status === "connected" || xConnection?.status === "needs_reauth";
@@ -2656,6 +2790,9 @@ function applyCapabilityEnablement(item, installation, activePackIds) {
   if (item.surfaceType === "first_party_social") {
     return { ...item, connectionRef: null };
   }
+  if (item.surfaceType === "codex_apps") {
+    return { ...item, connectionRef: null };
+  }
   if (item.source === "built_in" || item.source === "configured") {
     return {
       ...item,
@@ -3487,6 +3624,7 @@ import {
   mergeResourceRefs as mergeContractResourceRefs,
   mergeToolRefs,
   normalizeRepositorySubpath,
+  normalizeRepositoryTransportUri,
   normalizeResourceMountPath,
   resourceIdentityKey,
   resourceMountPath,
@@ -3558,21 +3696,18 @@ function normalizeResources(resources) {
         mountPath
       };
     } else {
-      const url = parseResourceUrl(resource.uri);
-      if (url.protocol !== "https:" || !url.hostname) {
-        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 HTTPException8(422, { message: "repository URL must include owner and repo" });
+      const credentialProvider = gitCredentialProviderForRepository(resource);
+      let normalizedUri;
+      try {
+        normalizedUri = normalizeRepositoryTransportUri(resource.uri);
+      } catch (error) {
+        throw new HTTPException8(422, {
+          message: error instanceof Error ? error.message : "invalid repository URI"
+        });
       }
-      const repo = parts.join("/");
-      const normalizedUri = `https://${url.host.toLowerCase()}/${repo}.git`;
       const mountPath = normalizeMountPath(
-        resource.mountPath ?? defaultRepositoryMountPath(normalizedUri)
+        resource.mountPath ?? defaultRepositoryMountPath(normalizedUri, credentialProvider)
       );
-      const credentialProvider = gitCredentialProviderForRepository(resource);
       const credentialBindingId = gitCredentialBindingIdForRepository(resource, credentialProvider);
       if ((resource.credentialBindingId || resource.connectionId || resource.access) && !credentialProvider) {
         throw new HTTPException8(422, {
@@ -3732,13 +3867,6 @@ function normalizeMountPath(path) {
     throw new HTTPException8(422, { message: `invalid resource mount path: ${path}` });
   }
 }
-function parseResourceUrl(uri) {
-  try {
-    return new URL(uri);
-  } catch {
-    throw new HTTPException8(422, { message: "repository resources must use valid URLs" });
-  }
-}
 function positiveInteger(value) {
   if (typeof value === "number" && Number.isInteger(value) && value > 0) {
     return value;
@@ -3882,6 +4010,7 @@ import {
   getRig as getRig3,
   getScheduledTask,
   getScheduledTaskPersonalConnectionDelegations,
+  getSession as getSession3,
   requireWorkspace as requireWorkspace2,
   updateScheduledTask
 } from "@opengeni/db";
@@ -3916,7 +4045,7 @@ import {
   createSessionWithIdempotencyKeyResult,
   encryptVariableSetValue as encryptVariableSetValue2,
   getAnySessionInGroup,
-  getEnrollment as getEnrollment2,
+  getEnrollment as getEnrollment3,
   getRig as getRig2,
   getWorkspaceDefaultRigId,
   listDistinctVariableSetIdsInGroup,
@@ -4305,7 +4434,7 @@ function validateSessionMcpCredentialUpdates(input) {
   });
   return encryptedUpdates;
 }
-async function createAndStartSession(input) {
+async function createAndStartSessionWithOutcome(input) {
   const sessionMetadata = {
     ...input.metadata,
     model: input.model,
@@ -4351,12 +4480,24 @@ async function createAndStartSession(input) {
     }
     const { session: keyed, created } = keyedResult;
     if (!created) {
-      return await finishStartSession(
+      const finished3 = await finishStartSession(
         keyed.temporalWorkflowId ? { ...input, seedTargetSandbox: null } : input,
         keyed
       );
+      return {
+        session: finished3.session,
+        outcome: finished3.changed ? "repaired" : "replayed",
+        replay: !finished3.changed,
+        changed: finished3.changed
+      };
     }
-    return await finishStartSession(input, keyed);
+    const finished2 = await finishStartSession(input, keyed);
+    return {
+      session: finished2.session,
+      outcome: "created",
+      replay: false,
+      changed: true
+    };
   }
   let session;
   try {
@@ -4398,7 +4539,16 @@ async function createAndStartSession(input) {
     }
     throw error;
   }
-  return await finishStartSession(input, session);
+  const finished = await finishStartSession(input, session);
+  return {
+    session: finished.session,
+    outcome: "created",
+    replay: false,
+    changed: true
+  };
+}
+async function createAndStartSession(input) {
+  return (await createAndStartSessionWithOutcome(input)).session;
 }
 async function finishStartSession(input, session) {
   if (input.seedTargetSandbox) {
@@ -4460,7 +4610,10 @@ async function finishStartSession(input, session) {
   }
   const persisted = await requireSession2(input.db, session.workspaceId, session.id);
   const initialTurnId = started.turn?.id ?? (await listSessionTurns(input.db, session.workspaceId, session.id, 1))[0]?.id ?? null;
-  return { ...persisted, initialTurnId };
+  return {
+    session: { ...persisted, initialTurnId },
+    changed: started.changed
+  };
 }
 function workflowIdForSession(sessionId) {
   return `session-${sessionId}`;
@@ -4645,15 +4798,16 @@ async function postUserMessageTurn(input) {
       wakeRevision: result.wakeRevision,
       ...(input.delivery ?? "send") === "steer" || result.interruptionCount > 0 ? { interruptionRequested: true } : {}
     });
-  } catch (error) {
-    console.warn(
-      `[sessions] workflow wake failed for committed prompt ${workspaceId}/${sessionId}; durable outbox will retry`,
-      error
-    );
+  } catch {
+    console.warn("[sessions] workflow wake failed; durable outbox will retry", {
+      errorClass: "WorkflowWakeOperationError",
+      errorCode: "session_workflow_wake_failed",
+      origin: "core"
+    });
   }
-  return { accepted, turn };
+  return { accepted, turn, replay: result.replay };
 }
-async function createSessionForRequest(deps, grant, workspaceId, rawPayload) {
+async function createSessionForRequestWithOutcome(deps, grant, workspaceId, rawPayload) {
   const { settings, db, bus, workflowClient, objectStorage } = deps;
   const payload = CreateSessionRequest.parse(rawPayload);
   if (hasReservedOpenGeniSlackBotSessionMetadata(payload.metadata)) {
@@ -4924,7 +5078,7 @@ async function createSessionForRequest(deps, grant, workspaceId, rawPayload) {
     if (targetSandbox?.kind === "selfhosted") {
       machineHomeBackend = "selfhosted";
       if (targetSandbox.enrollmentId) {
-        const enrollment = await getEnrollment2(db, workspaceId, targetSandbox.enrollmentId);
+        const enrollment = await getEnrollment3(db, workspaceId, targetSandbox.enrollmentId);
         if (enrollment && (enrollment.os === "macos" || enrollment.os === "windows" || enrollment.os === "linux")) {
           machineHomeOs = enrollment.os;
         }
@@ -4941,9 +5095,9 @@ async function createSessionForRequest(deps, grant, workspaceId, rawPayload) {
     });
   }
   const creationInitiator = creationInitiatorForGrant(grant);
-  let session;
+  let createOutcome;
   try {
-    session = await createAndStartSession({
+    createOutcome = await createAndStartSessionWithOutcome({
       ...payload.requestedSessionId ? { requestedSessionId: payload.requestedSessionId } : {},
       db,
       bus,
@@ -5018,26 +5172,45 @@ async function createSessionForRequest(deps, grant, workspaceId, rawPayload) {
     }
     throw error;
   }
+  let usageRecording = "recorded";
   if (payload.startMode !== "realtime") {
-    await recordWorkspaceUsage(deps, {
-      accountId: grant.accountId,
-      workspaceId,
-      subjectId: grant.subjectId,
-      eventType: "agent_run.created",
-      quantity: 1,
-      unit: "run",
-      sourceResourceType: "session",
-      sourceResourceId: session.id,
-      sessionId: session.id,
-      initiator: session.createdBy,
-      initiatorContext: session.createdByContext,
-      origin: creationInitiator.actor ? "system" : "user",
-      idempotencyKey: `agent_run.created:${workspaceId}:${session.id}`
-    });
+    try {
+      await recordWorkspaceUsage(deps, {
+        accountId: grant.accountId,
+        workspaceId,
+        subjectId: grant.subjectId,
+        eventType: "agent_run.created",
+        quantity: 1,
+        unit: "run",
+        sourceResourceType: "session",
+        sourceResourceId: createOutcome.session.id,
+        sessionId: createOutcome.session.id,
+        initiator: createOutcome.session.createdBy,
+        initiatorContext: createOutcome.session.createdByContext,
+        origin: creationInitiator.actor ? "system" : "user",
+        idempotencyKey: `agent_run.created:${workspaceId}:${createOutcome.session.id}`
+      });
+    } catch (error) {
+      usageRecording = "failed";
+      reportSessionUsageRecordingFailure(error);
+    }
   }
-  return session;
+  return { ...createOutcome, usageRecording };
 }
-async function acceptSessionUserMessage(deps, grant, workspaceId, sessionId, input) {
+function reportSessionUsageRecordingFailure(_error) {
+  console.warn(
+    "[sessions] usage recording failed after committed session create; returning committed outcome",
+    {
+      errorClass: "UsageRecordingError",
+      errorCode: "session_create_usage_recording_failed",
+      origin: "core"
+    }
+  );
+}
+async function createSessionForRequest(deps, grant, workspaceId, rawPayload) {
+  return (await createSessionForRequestWithOutcome(deps, grant, workspaceId, rawPayload)).session;
+}
+async function acceptSessionUserMessageWithOutcome(deps, grant, workspaceId, sessionId, input) {
   const { settings, db, bus, workflowClient, objectStorage } = deps;
   await requireSessionAuthorization(deps, grant, {
     sessionId,
@@ -5105,7 +5278,7 @@ async function acceptSessionUserMessage(deps, grant, workspaceId, sessionId, inp
     source: personalConnectionDelegationSourceForGrant(grant)
   });
   const delegatedServiceInitiator = serviceInitiatorForGrant(grant);
-  const { accepted, turn } = await postUserMessageTurn({
+  const { accepted, turn, replay } = await postUserMessageTurn({
     db,
     bus,
     workflowClient,
@@ -5155,6 +5328,16 @@ async function acceptSessionUserMessage(deps, grant, workspaceId, sessionId, inp
     origin: turn.source,
     idempotencyKey: `agent_run.created:${workspaceId}:${turn.id}`
   });
+  return { accepted, turn, replay };
+}
+async function acceptSessionUserMessage(deps, grant, workspaceId, sessionId, input) {
+  const { accepted, turn } = await acceptSessionUserMessageWithOutcome(
+    deps,
+    grant,
+    workspaceId,
+    sessionId,
+    input
+  );
   return { accepted, turn };
 }
 async function updateSessionTitle(deps, grant, sessionId, title, source) {
@@ -5452,6 +5635,17 @@ async function createValidatedScheduledTask(input) {
   });
   const id = crypto.randomUUID();
   validateScheduledTaskSchedule(input.payload.schedule);
+  const target = await validateScheduledTaskTarget({
+    db: input.db,
+    sessionAuthorization: input.sessionAuthorization,
+    authorizationSurface: input.authorizationSurface,
+    grant: input.grant,
+    targetSessionId: input.payload.targetSessionId,
+    runMode: input.payload.runMode,
+    variableSetId: input.payload.variableSetId,
+    rigId: input.payload.rigId,
+    agentConfig
+  });
   if (input.payload.variableSetId) {
     await validateVariableSetAttachment(
       { settings: input.settings, db: input.db },
@@ -5492,11 +5686,97 @@ async function createValidatedScheduledTask(input) {
     ...creationInitiator.context ? { createdByContext: creationInitiator.context } : {},
     createdByActor: creationInitiator.actor ?? null,
     personalConnectionDelegations,
+    targetSessionId: target?.id ?? null,
     variableSetId: input.payload.variableSetId ?? null,
     rigId: input.payload.rigId ?? null,
     metadata: input.payload.metadata
   });
 }
+async function validateScheduledTaskTarget(input) {
+  if (input.runMode !== "existing_session") {
+    if (input.targetSessionId) {
+      throw new HTTPException11(422, {
+        message: "targetSessionId requires runMode=existing_session"
+      });
+    }
+    return null;
+  }
+  if (!input.targetSessionId) {
+    throw new HTTPException11(input.missingTargetStatus ?? 422, {
+      message: input.missingTargetStatus === 404 ? "target session not found" : "targetSessionId is required when runMode=existing_session"
+    });
+  }
+  requirePermission(input.grant, "sessions:control");
+  if (input.agentConfig.goal) {
+    throw new HTTPException11(422, {
+      message: "agentConfig.goal cannot be used with an existing-session target"
+    });
+  }
+  try {
+    await requireSessionAuthorization(
+      {
+        db: input.db,
+        ...input.sessionAuthorization !== void 0 ? { sessionAuthorization: input.sessionAuthorization } : {}
+      },
+      input.grant,
+      {
+        sessionId: input.targetSessionId,
+        operation: "session.control",
+        surface: input.authorizationSurface ?? "http"
+      }
+    );
+  } catch (error) {
+    if (error instanceof SessionAuthorizationDeniedError) {
+      throw new HTTPException11(404, { message: "target session not found" });
+    }
+    if (error instanceof SessionAuthorizationUnavailableError) {
+      throw new HTTPException11(503, { message: "session authorization is unavailable" });
+    }
+    throw error;
+  }
+  const session = await getSession3(input.db, input.grant.workspaceId, input.targetSessionId);
+  if (!session || session.accountId !== input.grant.accountId) {
+    throw new HTTPException11(404, { message: "target session not found" });
+  }
+  if (session.status === "cancelled") {
+    throw new HTTPException11(409, {
+      message: "target session is cancelled; choose a revivable session"
+    });
+  }
+  if ((session.variableSetId ?? null) !== (input.variableSetId ?? null)) {
+    throw new HTTPException11(422, {
+      message: "target session variableSet attachment does not match the scheduled task"
+    });
+  }
+  if (input.rigId && input.rigId !== session.rigId) {
+    throw new HTTPException11(422, {
+      message: "target session rig does not match the scheduled task"
+    });
+  }
+  if (input.agentConfig.sandboxBackend !== void 0 && input.agentConfig.sandboxBackend !== session.sandboxBackend) {
+    throw new HTTPException11(422, {
+      message: "target session sandbox backend does not match the scheduled task"
+    });
+  }
+  if (scheduledSlackBotConnectionId(session.metadata) !== (input.agentConfig.slackBotConnectionId ?? null)) {
+    throw new HTTPException11(422, {
+      message: "target session OpenGeni Slack bot binding does not match the scheduled task"
+    });
+  }
+  return session;
+}
+function scheduledTaskForGrant(task, grant) {
+  if (hasPermission(grant.permissions, "sessions:control") || task.targetSessionId === null) {
+    return task;
+  }
+  return { ...task, targetSessionId: null };
+}
+function scheduledTaskRunForGrant(run, grant) {
+  if (hasPermission(grant.permissions, "sessions:control") || run.sessionId === null) {
+    return run;
+  }
+  return { ...run, sessionId: null };
+}
 async function requireScheduledTaskRig(db, workspaceId, rigId) {
   const rig = await getRig3(db, workspaceId, rigId);
   if (!rig) {
@@ -5505,6 +5785,14 @@ async function requireScheduledTaskRig(db, workspaceId, rigId) {
 }
 async function validatedScheduledTaskUpdate(input) {
   const update = {};
+  const existingTarget = input.existing.targetSessionId;
+  const nextRunMode = input.payload.runMode ?? input.existing.runMode;
+  const nextTargetSessionId = input.payload.targetSessionId !== void 0 ? input.payload.targetSessionId : nextRunMode === "existing_session" ? existingTarget : null;
+  if (input.existing.runMode === "reusable_session" && input.existing.reusableSessionId && nextRunMode === "existing_session") {
+    throw new HTTPException11(409, {
+      message: "cannot target an existing session after this task created its reusable session; create a new task"
+    });
+  }
   if (input.payload.name !== void 0) {
     update.name = trimmedScheduledTaskName(input.payload.name);
   }
@@ -5598,6 +5886,33 @@ async function validatedScheduledTaskUpdate(input) {
     }
     update.personalConnectionDelegations = personalConnectionDelegations;
   }
+  if (existingTarget && (nextRunMode !== "existing_session" || nextTargetSessionId !== existingTarget)) {
+    await validateScheduledTaskTarget({
+      db: input.db,
+      sessionAuthorization: input.sessionAuthorization,
+      authorizationSurface: input.authorizationSurface,
+      grant: input.grant,
+      targetSessionId: existingTarget,
+      runMode: "existing_session",
+      variableSetId: input.existing.variableSetId,
+      rigId: input.existing.rigId,
+      agentConfig: input.existing.agentConfig
+    });
+  }
+  await validateScheduledTaskTarget({
+    db: input.db,
+    sessionAuthorization: input.sessionAuthorization,
+    authorizationSurface: input.authorizationSurface,
+    grant: input.grant,
+    targetSessionId: nextTargetSessionId,
+    runMode: nextRunMode,
+    variableSetId: input.payload.variableSetId !== void 0 ? input.payload.variableSetId : input.existing.variableSetId,
+    rigId: input.payload.rigId !== void 0 ? input.payload.rigId : input.existing.rigId,
+    agentConfig: update.agentConfig ?? input.existing.agentConfig
+  });
+  if (input.payload.targetSessionId !== void 0 || input.existing.runMode === "existing_session" || nextRunMode === "existing_session") {
+    update.targetSessionId = nextTargetSessionId;
+  }
   return update;
 }
 async function requireScheduledTaskForApi(db, workspaceId, taskId) {
@@ -5627,28 +5942,44 @@ async function restoreScheduledTask(db, previous) {
     overlapPolicy: task.overlapPolicy,
     agentConfig: task.agentConfig,
     personalConnectionDelegations: previous.personalConnectionDelegations,
-    reusableSessionId: task.reusableSessionId,
+    ...task.runMode === "existing_session" ? { targetSessionId: task.targetSessionId } : { reusableSessionId: task.reusableSessionId },
     variableSetId: task.variableSetId,
     rigId: task.rigId,
     metadata: task.metadata
   });
 }
+var ScheduledTaskSyncError = class extends Error {
+  persistenceRestored;
+  constructor(cause, persistenceRestored) {
+    super(cause instanceof Error ? cause.message : String(cause), { cause });
+    this.name = "ScheduledTaskSyncError";
+    this.persistenceRestored = persistenceRestored;
+  }
+};
 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
-    );
-    throw error;
+    let persistenceRestored = true;
+    try {
+      await deleteScheduledTask(input.db, input.task.workspaceId, input.task.id);
+    } catch {
+      persistenceRestored = false;
+    }
+    throw new ScheduledTaskSyncError(error, persistenceRestored);
   }
 }
 async function syncUpdatedScheduledTask(input) {
   try {
     await input.workflowClient.syncScheduledTask({ task: input.task });
   } catch (error) {
-    await restoreScheduledTask(input.db, input.previous).catch(() => void 0);
-    throw error;
+    let persistenceRestored = true;
+    try {
+      await restoreScheduledTask(input.db, input.previous);
+    } catch {
+      persistenceRestored = false;
+    }
+    throw new ScheduledTaskSyncError(error, persistenceRestored);
   }
 }
 function scheduledTaskTemporalScheduleId(taskId) {
@@ -6158,7 +6489,6 @@ async function getWorkspaceInsights(db, settings, input) {
 // src/domain/memory-slack-publication.ts
 import { createHash } from "crypto";
 import {
-  redactSensitiveText,
   stableJson as stableJson3
 } from "@opengeni/contracts";
 var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
@@ -6227,9 +6557,8 @@ function evaluateMemorySlackPublication(input) {
   const deliveryMode = effectiveDeliveryMode(policy, input.distribution);
   if (!deliveryMode) return denied("below_noise_policy");
   const collapsedSummary = collapseText(input.distribution.shareSummary);
-  const redactedSummary = redactSensitiveText(collapsedSummary);
-  if (!redactedSummary) return denied("missing_summary");
-  const summary = truncateUtf8(redactedSummary, MEMORY_SLACK_SUMMARY_MAX_UTF8_BYTES);
+  if (!collapsedSummary) return denied("missing_summary");
+  const summary = truncateUtf8(collapsedSummary, MEMORY_SLACK_SUMMARY_MAX_UTF8_BYTES);
   const namespace = normalizeNamespace(input.memory.namespace);
   const labels = normalizeLabels(input.memory.labels);
   if (!namespace || !labels) return denied("invalid_input");
@@ -6245,13 +6574,11 @@ function evaluateMemorySlackPublication(input) {
     importance: input.distribution.importance,
     deliveryMode,
     summary: summary.value,
-    summaryRedacted: redactedSummary !== collapsedSummary,
     summaryTruncated: summary.truncated,
     namespace,
     labels: labels.values,
     labelsTruncated: labels.truncated,
     ownerLabel: owner.value,
-    ownerLabelRedacted: owner.redacted,
     ownerLabelTruncated: owner.truncated,
     authoritativeRecord: {
       workspaceId: input.context.workspaceId,
@@ -6325,10 +6652,8 @@ function effectiveDeliveryMode(policy, distribution) {
 }
 function normalizeNamespace(value) {
   const trimmed = value.trim();
-  if (redactSensitiveText(trimmed) !== trimmed) return null;
   const namespace = trimmed.toLowerCase();
   if (!namespace || utf8Bytes(namespace) > MEMORY_SLACK_NAMESPACE_MAX_UTF8_BYTES) return null;
-  if (redactSensitiveText(namespace) !== namespace) return null;
   const segments = namespace.split("/");
   if (segments.some((segment) => !SELECTOR_SEGMENT_PATTERN.test(segment))) return null;
   return segments.join("/");
@@ -6339,9 +6664,8 @@ function normalizeLabels(values) {
   for (const value of values) {
     if (typeof value !== "string") return null;
     const trimmed = value.trim();
-    if (redactSensitiveText(trimmed) !== trimmed) return null;
     const label = trimmed.toLowerCase();
-    if (redactSensitiveText(label) !== label || !SELECTOR_SEGMENT_PATTERN.test(label) || utf8Bytes(label) > MEMORY_SLACK_LABEL_MAX_UTF8_BYTES) {
+    if (!SELECTOR_SEGMENT_PATTERN.test(label) || utf8Bytes(label) > MEMORY_SLACK_LABEL_MAX_UTF8_BYTES) {
       return null;
     }
     labels.add(label);
@@ -6354,12 +6678,10 @@ function normalizeLabels(values) {
 }
 function boundedOptionalText(value, maxBytes) {
   const collapsed = collapseText(value ?? "");
-  if (!collapsed) return { value: null, redacted: false, truncated: false };
-  const redacted = redactSensitiveText(collapsed);
-  const bounded = truncateUtf8(redacted, maxBytes);
+  if (!collapsed) return { value: null, truncated: false };
+  const bounded = truncateUtf8(collapsed, maxBytes);
   return {
     value: bounded.value || null,
-    redacted: redacted !== collapsed,
     truncated: bounded.truncated
   };
 }
@@ -6438,7 +6760,7 @@ import {
 } from "@opengeni/contracts";
 import {
   getNewSessionDraftInTransaction,
-  getEnrollment as getEnrollment3,
+  getEnrollment as getEnrollment4,
   getRig as getRig4,
   getSandbox as getSandbox4,
   getVariableSet as getVariableSet4,
@@ -6509,7 +6831,7 @@ async function hydrateNewSessionDraft(deps, grant, workspaceId, row) {
   }
   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 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;
@@ -6620,7 +6942,7 @@ import {
   deleteSessionQueueItemInTransaction,
   editQueuedTurnInTransaction,
   getComposerDraftInTransaction,
-  getSession as getSession3,
+  getSession as getSession4,
   getSessionEvent as getSessionEvent2,
   getWorkspaceControlEvent as getWorkspaceControlEvent2,
   getSessionQueueSnapshot,
@@ -6712,10 +7034,14 @@ async function publishAndWakeAgentCommand(deps, input) {
       wakeRevision: input.wakeRevision,
       ...input.controlRequested || input.interruptionCount > 0 ? { interruptionRequested: true } : {}
     });
-  } catch (error) {
+  } catch {
     console.warn(
-      `[session-commands] immediate Agent command wake failed for ${input.workspaceId}/${input.sessionId}; durable outbox will retry`,
-      error
+      "[session-commands] immediate Agent command wake failed; durable outbox will retry",
+      {
+        errorClass: "WorkflowWakeOperationError",
+        errorCode: "agent_command_wake_failed",
+        origin: "core"
+      }
     );
   }
 }
@@ -6723,10 +7049,15 @@ async function requestControlWakeDispatch(deps, wakeCount) {
   if (wakeCount === 0) return;
   try {
     await deps.workflowClient.requestSessionWorkflowWakeDispatch();
-  } catch (error) {
+  } catch {
     console.warn(
-      `[session-commands] immediate control wake dispatch failed for ${wakeCount} committed revisions; durable outbox will retry`,
-      error
+      "[session-commands] immediate control wake dispatch failed; durable outbox will retry",
+      {
+        errorClass: "WorkflowWakeOperationError",
+        errorCode: "control_wake_dispatch_failed",
+        origin: "core",
+        wakeCount
+      }
     );
   }
 }
@@ -6990,7 +7321,7 @@ async function steerHumanQueuePrompt(deps, context, turnId, input) {
   await publishWorkspaceControlEvent(deps, context.workspaceId, result.workspaceControlEventId);
   return response;
 }
-async function controlHumanSessionWorkstream(deps, context, input) {
+async function controlHumanSessionWorkstreamWithOutcome(deps, context, input) {
   const authorization = await authorizeHumanSessionCommand(deps, context, "session.control");
   const result = await withWorkspaceRls(
     deps.db,
@@ -7025,7 +7356,10 @@ async function controlHumanSessionWorkstream(deps, context, input) {
   }
   await publishWorkspaceControlEvent(deps, context.workspaceId, result.workspaceControlEventId);
   await requestControlWakeDispatch(deps, result.wakeCount);
-  return response;
+  return { response, replay: result.replay };
+}
+async function controlHumanSessionWorkstream(deps, context, input) {
+  return (await controlHumanSessionWorkstreamWithOutcome(deps, context, input)).response;
 }
 async function controlHumanWorkspace(deps, context, input) {
   const result = await withWorkspaceRls(
@@ -7068,7 +7402,7 @@ async function getHumanComposerDraft(deps, context) {
   );
   const mapped = composerDraft(row);
   if (mapped) return mapped;
-  const session = await getSession3(deps.db, context.workspaceId, context.sessionId);
+  const session = await getSession4(deps.db, context.workspaceId, context.sessionId);
   if (!session) throw new Error(`Session not found: ${context.sessionId}`);
   return {
     revision: 0,
@@ -7092,6 +7426,7 @@ async function saveHumanComposerDraft(deps, context, input) {
       (tx) => saveComposerDraftInTransaction(tx, {
         ...context,
         ...input,
+        resources: normalizeResources(input.resources),
         subjectId: context.subjectId
       })
     )
@@ -7120,12 +7455,14 @@ export {
   SESSION_WORKFLOW_WAKE_DISPATCHER_PERIOD_MS,
   SESSION_WORKFLOW_WAKE_DISPATCHER_SCHEDULE_ID,
   SESSION_WORKFLOW_WAKE_DISPATCHER_WORKFLOW_TYPE,
+  ScheduledTaskSyncError,
   SessionAuthorizationDeniedError,
   SessionAuthorizationUnavailableError,
   SessionSpawnDeniedError,
   TRANSCRIPTION_PROVIDER_REQUEST_TIMEOUT_MILLISECONDS,
   TranscriptionServiceError,
   acceptSessionUserMessage,
+  acceptSessionUserMessageWithOutcome,
   accessGrantAuthorizationFromContext,
   activateRigVersionForApi,
   appendRigSetupCommand,
@@ -7148,14 +7485,18 @@ export {
   captureScheduledTaskRestoreState,
   checkLimit,
   classifyRigVerificationOutcome,
+  codexAppsCatalogItem,
   controlAgentSessionWorkstream,
   controlHumanSessionWorkstream,
+  controlHumanSessionWorkstreamWithOutcome,
   controlHumanWorkspace,
   createAndStartSession,
+  createAndStartSessionWithOutcome,
   createCatalogItem,
   createRigForApi,
   createRigVersionForApi,
   createSessionForRequest,
+  createSessionForRequestWithOutcome,
   createValidatedScheduledTask,
   creationInitiatorForGrant,
   defaultSessionMcpServerIds,
@@ -7174,7 +7515,9 @@ export {
   getActorNewSessionDraft,
   getCapabilityPack,
   getHumanComposerDraft,
+  getManagedSession,
   getWorkspaceInsights,
+  hasLiteralPermission,
   hasPermission,
   hasReservedOpenGeniSlackBotMetadata,
   hasReservedOpenGeniSlackBotSessionMetadata,
@@ -7217,11 +7560,14 @@ export {
   recordWorkspaceUsage,
   relayConfigFromSettings,
   relayDialBaseFromSettings,
+  reportSessionUsageRecordingFailure,
   requireAccessContext,
   requireAccessGrant,
   requireAccessGrantAuthorization,
   requireEnvironmentEncryption,
   requireLimit,
+  requireLiteralPermission,
+  requireLiveAgentAttemptAuthorization,
   requireOpenGeniSlackBotConnection,
   requirePermission,
   requireQueuedTurnForApi,
@@ -7244,6 +7590,8 @@ export {
   saveActorNewSessionDraft,
   saveHumanComposerDraft,
   scheduledSlackBotConnectionId,
+  scheduledTaskForGrant,
+  scheduledTaskRunForGrant,
   scheduledTaskTemporalScheduleId,
   scheduledTaskToolsProvided,
   scheduledTaskTriggerToken,
@@ -7272,6 +7620,7 @@ export {
   validateGitHubRepositorySelectionShapes,
   validateMcpCapabilityConnection,
   validateOpenGeniSlackBotConnectionSelection,
+  validateScheduledTaskTarget,
   validateToolRefs,
   validateToolRefsForSessionPolicy,
   validateVariableSetAttachment,