@opengeni/core 0.2.0

package/dist/index.js

@@ -0,0 +1,2627 @@
+// src/sandbox/fleet.ts
+import {
+  getEnrollment,
+  getSandbox as getSandbox2,
+  listSandboxes,
+  readActiveSandbox as readActiveSandbox2,
+  requireSession,
+  setActiveSandbox
+} from "@opengeni/db";
+import {
+  NatsControlRpc as NatsControlRpc2,
+  selfhostedLiveness,
+  SelfhostedSession
+} from "@opengeni/runtime/sandbox";
+import { HTTPException } from "hono/http-exception";
+
+// src/sandbox/routing.ts
+import { getSandbox, readActiveSandbox } from "@opengeni/db";
+import {
+  makeActiveBackendResolver,
+  NatsControlRpc,
+  RoutingSandboxSession
+} from "@opengeni/runtime/sandbox";
+function relayConfigFromSettings(settings) {
+  const raw = settings.selfhostedRelayUrl?.trim();
+  if (!raw) {
+    return { host: "relay.opengeni.local", port: 443, tls: true, path: "/stream" };
+  }
+  try {
+    const url = new URL(raw.includes("://") ? raw : `wss://${raw}`);
+    const tls = url.protocol === "wss:" || url.protocol === "https:";
+    const port = url.port ? Number(url.port) : tls ? 443 : 80;
+    const path = url.pathname && url.pathname !== "/" ? url.pathname : "/stream";
+    return { host: url.hostname, port, tls, path };
+  } catch {
+    return { host: raw, port: 443, tls: true, path: "/stream" };
+  }
+}
+function relayDialBaseFromSettings(settings) {
+  if (!settings.selfhostedRelayUrl?.trim()) return "";
+  const { host, port, tls, path } = relayConfigFromSettings(settings);
+  const scheme = tls ? "wss" : "ws";
+  const defaultPort = tls ? 443 : 80;
+  const authority = port === defaultPort ? host : `${host}:${port}`;
+  return `${scheme}://${authority}${path}`;
+}
+function controlRpcFactory(bus) {
+  return () => new NatsControlRpc(async () => {
+    if (!bus) {
+      return null;
+    }
+    return bus.getRequestConnection();
+  });
+}
+function routingEnabled(settings) {
+  return settings.sandboxSelfhostedEnabled === true;
+}
+function wrapChannelABoxWithRouting(services, ids, established) {
+  const { db, settings, bus } = services;
+  const resolver = makeActiveBackendResolver({
+    workspaceId: ids.workspaceId,
+    defaultBackend: established.session,
+    defaultKind: established.backendId,
+    getSandbox: async (sandboxId) => {
+      const sandbox = await getSandbox(db, ids.workspaceId, sandboxId);
+      return sandbox ? { id: sandbox.id, kind: sandbox.kind, name: sandbox.name, enrollmentId: sandbox.enrollmentId } : null;
+    },
+    controlRpcFactory: controlRpcFactory(bus),
+    relay: relayConfigFromSettings(settings)
+  });
+  const proxy = new RoutingSandboxSession({
+    readPointer: async () => {
+      const pointer = await readActiveSandbox(db, ids.workspaceId, ids.sessionId);
+      return pointer ?? { activeSandboxId: null, activeEpoch: 0 };
+    },
+    resolveActiveBackend: resolver
+  });
+  return { ...established, session: proxy };
+}
+
+// src/sandbox/fleet.ts
+async function buildFleetContextForSession(deps, ctx) {
+  const session = await requireSession(deps.db, ctx.workspaceId, ctx.sessionId);
+  if (session.sandboxBackend === "none") {
+    throw new HTTPException(422, {
+      message: "this session has no sandbox (backend: none); the fleet is unavailable"
+    });
+  }
+  return {
+    accountId: ctx.accountId,
+    workspaceId: ctx.workspaceId,
+    sessionId: ctx.sessionId,
+    sessionBackend: session.sandboxBackend,
+    sessionGroupId: session.sandboxGroupId
+  };
+}
+var PROBE_TIMEOUT_MS = 5e3;
+function controlRpc(bus) {
+  return new NatsControlRpc2(async () => {
+    if (!bus) {
+      return null;
+    }
+    return bus.getRequestConnection();
+  });
+}
+async function probeEnrollment(services, workspaceId, enrollment) {
+  const { settings, bus } = services;
+  let probeResponded = false;
+  if (enrollment.status === "active") {
+    const session = new SelfhostedSession({
+      workspaceId,
+      agentId: enrollment.id,
+      controlRpc: controlRpc(bus),
+      relay: relayConfigFromSettings(settings),
+      timeoutMs: PROBE_TIMEOUT_MS
+    });
+    try {
+      probeResponded = await session.ping();
+    } catch {
+      probeResponded = false;
+    }
+  }
+  const state = selfhostedLiveness({
+    enrollment: {
+      status: enrollment.status,
+      exposure: enrollment.exposure,
+      allowScreenControl: enrollment.allowScreenControl,
+      hasDisplay: enrollment.hasDisplay,
+      lastSeenAt: enrollment.lastSeenAt
+    },
+    probeResponded
+  });
+  return { liveness: state.state, consented: state.consented, hasDisplay: state.hasDisplay };
+}
+async function listFleet(services, ctx) {
+  const { db } = services;
+  const pointer = await readActiveSandbox2(db, ctx.workspaceId, ctx.sessionId) ?? {
+    activeSandboxId: null,
+    activeEpoch: 0
+  };
+  const entries = [];
+  const groupActive = pointer.activeSandboxId === null;
+  entries.push({
+    id: ctx.sessionGroupId,
+    kind: ctx.sessionBackend === "selfhosted" ? "selfhosted" : "modal",
+    name: "session sandbox",
+    liveness: "online",
+    active: groupActive,
+    isSessionGroup: true,
+    enrollmentId: null,
+    attachable: true
+  });
+  const sandboxes = await listSandboxes(db, ctx.workspaceId);
+  for (const sandbox of sandboxes) {
+    if (sandbox.kind !== "selfhosted" || !sandbox.enrollmentId) {
+      continue;
+    }
+    const enrollment = await getEnrollment(db, ctx.workspaceId, sandbox.enrollmentId);
+    const probe = enrollment ? await probeEnrollment(services, ctx.workspaceId, enrollment) : { liveness: "offline", consented: false, hasDisplay: false };
+    entries.push({
+      id: sandbox.id,
+      kind: "selfhosted",
+      name: sandbox.name,
+      liveness: probe.liveness,
+      active: pointer.activeSandboxId === sandbox.id,
+      isSessionGroup: false,
+      enrollmentId: sandbox.enrollmentId,
+      attachable: probe.liveness === "online",
+      consented: probe.consented,
+      hasDisplay: probe.hasDisplay,
+      lastSeenAt: enrollment?.lastSeenAt ?? null
+    });
+  }
+  return { activeSandboxId: pointer.activeSandboxId, activeEpoch: pointer.activeEpoch, sandboxes: entries };
+}
+async function resolveTarget(services, ctx, target) {
+  if (target === ctx.sessionGroupId || target === "session" || target === "default") {
+    return { ok: true, targetSandboxId: null };
+  }
+  const sandbox = await getSandbox2(services.db, ctx.workspaceId, target);
+  if (!sandbox) {
+    return { ok: false, reason: `sandbox ${target} not found in this workspace` };
+  }
+  if (sandbox.kind === "selfhosted") {
+    if (!sandbox.enrollmentId) {
+      return { ok: false, reason: `selfhosted sandbox ${target} has no enrollment` };
+    }
+    const enrollment = await getEnrollment(services.db, ctx.workspaceId, sandbox.enrollmentId);
+    if (!enrollment) {
+      return { ok: false, reason: `enrollment for sandbox ${target} not found` };
+    }
+    const probe = await probeEnrollment(services, ctx.workspaceId, enrollment);
+    if (probe.liveness !== "online") {
+      return { ok: false, reason: `sandbox ${target} is ${probe.liveness}; cannot attach to a non-online machine` };
+    }
+  }
+  return { ok: true, targetSandboxId: sandbox.id };
+}
+async function swapActiveSandbox(services, ctx, target, workingDir) {
+  const resolved = await resolveTarget(services, ctx, target);
+  if (!resolved.ok) {
+    const pointer2 = await readActiveSandbox2(services.db, ctx.workspaceId, ctx.sessionId) ?? {
+      activeSandboxId: null,
+      activeEpoch: 0
+    };
+    return { swapped: false, activeSandboxId: pointer2.activeSandboxId, activeEpoch: pointer2.activeEpoch, reason: resolved.reason };
+  }
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    const pointer2 = await readActiveSandbox2(services.db, ctx.workspaceId, ctx.sessionId) ?? {
+      activeSandboxId: null,
+      activeEpoch: 0
+    };
+    if (pointer2.activeSandboxId === resolved.targetSandboxId) {
+      return { swapped: true, activeSandboxId: pointer2.activeSandboxId, activeEpoch: pointer2.activeEpoch };
+    }
+    const result = await setActiveSandbox(services.db, {
+      accountId: ctx.accountId,
+      workspaceId: ctx.workspaceId,
+      sessionId: ctx.sessionId,
+      targetSandboxId: resolved.targetSandboxId,
+      expectedEpoch: pointer2.activeEpoch,
+      ...workingDir !== void 0 ? { workingDir } : {}
+    });
+    if (result.swapped && result.pointer) {
+      return { swapped: true, activeSandboxId: result.pointer.activeSandboxId, activeEpoch: result.pointer.activeEpoch };
+    }
+  }
+  const pointer = await readActiveSandbox2(services.db, ctx.workspaceId, ctx.sessionId) ?? {
+    activeSandboxId: null,
+    activeEpoch: 0
+  };
+  return {
+    swapped: false,
+    activeSandboxId: pointer.activeSandboxId,
+    activeEpoch: pointer.activeEpoch,
+    reason: "a concurrent swap won the epoch fence; re-read and retry"
+  };
+}
+async function runOnSandbox(services, ctx, target, op) {
+  const sandbox = await getSandbox2(services.db, ctx.workspaceId, target);
+  if (!sandbox) {
+    return { target, kind: op.kind, ok: false, reason: `sandbox ${target} not found in this workspace` };
+  }
+  if (sandbox.kind !== "selfhosted" || !sandbox.enrollmentId) {
+    return {
+      target,
+      kind: op.kind,
+      ok: false,
+      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);
+  if (!enrollment || enrollment.status !== "active") {
+    return { target, kind: op.kind, ok: false, reason: `sandbox ${target} is not enrolled/active` };
+  }
+  const session = new SelfhostedSession({
+    workspaceId: ctx.workspaceId,
+    agentId: sandbox.enrollmentId,
+    controlRpc: controlRpc(services.bus),
+    relay: relayConfigFromSettings(services.settings)
+  });
+  try {
+    if (op.kind === "exec") {
+      const res = await session.exec({ cmd: op.cmd, ...op.workdir ? { workdir: op.workdir } : {} });
+      return { target, kind: "exec", ok: true, stdout: res.stdout, stderr: res.stderr, exitCode: res.exitCode };
+    }
+    if (op.kind === "read") {
+      const bytes = await session.readFile({ path: op.path });
+      return { target, kind: "read", ok: true, content: new TextDecoder().decode(bytes) };
+    }
+    const bytesWritten = await session.writeFile({ path: op.path, content: op.content });
+    return { target, kind: "write", ok: true, bytesWritten };
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    return { target, kind: op.kind, ok: false, reason };
+  }
+}
+async function provisionSandbox(services, ctx, input) {
+  if (input.kind === "selfhosted") {
+    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.",
+      // 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 | sh`,
+      installCommandWindows: `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. Its box is materialized when first swapped-to; the session's own group box remains the default until then."
+  };
+}
+
+// src/access/index.ts
+import { verifyDelegatedAccessToken } from "@opengeni/contracts";
+import {
+  bootstrapWorkspace,
+  ensureManagedAccessForUser,
+  findActiveApiKeyByHash,
+  getWorkspaceGrant,
+  requireWorkspace
+} from "@opengeni/db";
+import { HTTPException as HTTPException2 } from "hono/http-exception";
+var bearerPrefix = "Bearer ";
+async function requireAccessContext(c, deps) {
+  const context = await resolveAccessContext(c, deps);
+  if (!context) {
+    throw new HTTPException2(401, { message: "authentication required" });
+  }
+  return context;
+}
+async function requireAccessGrant(c, deps, workspaceId, permission) {
+  const context = await requireAccessContext(c, deps);
+  const grant = context.workspaceGrants.find((candidate) => candidate.workspaceId === workspaceId) ?? await getWorkspaceGrant(deps.db, context.subjectId, workspaceId);
+  if (!grant) {
+    const workspace = await requireWorkspace(deps.db, workspaceId).catch(() => null);
+    if (!workspace) {
+      throw new HTTPException2(404, { message: "workspace not found" });
+    }
+    throw new HTTPException2(403, { message: "workspace access denied" });
+  }
+  if (permission) {
+    requirePermission(grant, permission);
+  }
+  return grant;
+}
+function requirePermission(grant, permission) {
+  if (!hasPermission(grant.permissions, permission)) {
+    throw new HTTPException2(403, { message: `missing permission: ${permission}` });
+  }
+}
+function hasPermission(permissions, permission) {
+  return permissions.includes(permission) || permissions.includes("workspace:admin");
+}
+async function resolveAccessContext(c, deps) {
+  if (deps.settings.productAccessMode === "local") {
+    return await bootstrapWorkspace(deps.db, {
+      accountExternalSource: "opengeni:local",
+      accountExternalId: "default",
+      accountName: "Local",
+      workspaceExternalSource: "opengeni:local",
+      workspaceExternalId: "default",
+      workspaceName: "Local",
+      subjectId: "dev",
+      subjectLabel: "Local dev"
+    });
+  }
+  if (deps.settings.productAccessMode === "configured") {
+    const delegated = await delegatedAccessContext(c, deps, "configured");
+    if (delegated) {
+      return delegated;
+    }
+    if (deps.settings.delegationSecret) {
+      return null;
+    }
+    return await bootstrapWorkspace(deps.db, {
+      accountExternalSource: "opengeni:configured",
+      accountExternalId: "default",
+      accountName: "Configured",
+      workspaceExternalSource: "opengeni:configured",
+      workspaceExternalId: "default",
+      workspaceName: "Configured",
+      subjectId: configuredSubject(c),
+      subjectLabel: "Configured key"
+    });
+  }
+  const bearer = bearerToken(c);
+  if (bearer) {
+    const delegated = await delegatedAccessContext(c, deps, "managed", bearer);
+    if (delegated) {
+      return delegated;
+    }
+    const apiKey = await findActiveApiKeyByHash(deps.db, await sha256Hex(bearer));
+    if (apiKey) {
+      const accountPermissions = apiKey.workspaceId ? apiKey.permissions.filter((permission) => permission === "billing:read" || permission === "billing:manage") : apiKey.permissions;
+      return {
+        mode: "managed",
+        subjectId: `api_key:${apiKey.id}`,
+        subjectLabel: apiKey.name,
+        accountGrants: [{
+          accountId: apiKey.accountId,
+          subjectId: `api_key:${apiKey.id}`,
+          subjectLabel: apiKey.name,
+          permissions: accountPermissions
+        }],
+        workspaceGrants: apiKey.workspaceId ? [{
+          workspaceId: apiKey.workspaceId,
+          accountId: apiKey.accountId,
+          subjectId: `api_key:${apiKey.id}`,
+          subjectLabel: apiKey.name,
+          permissions: apiKey.permissions
+        }] : [],
+        defaultAccountId: apiKey.accountId,
+        defaultWorkspaceId: apiKey.workspaceId
+      };
+    }
+  }
+  if (deps.managedAuth) {
+    const session = await deps.managedAuth.api.getSession({ headers: c.req.raw.headers });
+    if (session?.user) {
+      return await ensureManagedAccessForUser(deps.db, {
+        userId: session.user.id,
+        email: session.user.email,
+        name: session.user.name
+      });
+    }
+  }
+  return null;
+}
+async function delegatedAccessContext(c, deps, mode, token = bearerToken(c)) {
+  if (!token || !deps.settings.delegationSecret) {
+    return null;
+  }
+  const payload = await verifyDelegatedAccessToken(deps.settings.delegationSecret, token);
+  if (!payload) {
+    return null;
+  }
+  return {
+    mode,
+    subjectId: payload.subjectId,
+    ...payload.subjectLabel ? { subjectLabel: payload.subjectLabel } : {},
+    accountGrants: [{
+      accountId: payload.accountId,
+      subjectId: payload.subjectId,
+      ...payload.subjectLabel ? { subjectLabel: payload.subjectLabel } : {},
+      permissions: payload.permissions
+    }],
+    workspaceGrants: [{
+      workspaceId: payload.workspaceId,
+      accountId: payload.accountId,
+      subjectId: payload.subjectId,
+      ...payload.subjectLabel ? { subjectLabel: payload.subjectLabel } : {},
+      permissions: payload.permissions,
+      // sessionId is worker-asserted (HMAC-signed token claim), not agent
+      // controlled; it scopes session-bound MCP tools such as goal management.
+      metadata: { delegated: true, ...payload.sessionId ? { sessionId: payload.sessionId } : {} }
+    }],
+    defaultAccountId: payload.accountId,
+    defaultWorkspaceId: payload.workspaceId
+  };
+}
+function configuredSubject(c) {
+  const header = c.req.header("x-opengeni-subject");
+  return header && header.trim().length > 0 ? `configured:${header.trim()}` : "configured:key";
+}
+function bearerToken(c) {
+  const authorization = c.req.header("authorization");
+  return authorization?.startsWith(bearerPrefix) ? authorization.slice(bearerPrefix.length) : null;
+}
+async function sha256Hex(value) {
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(value));
+  return Array.from(new Uint8Array(digest)).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+
+// src/billing/limits.ts
+import { configuredStaticUsageLimits } from "@opengeni/config";
+import {
+  countActiveApiKeysForWorkspace,
+  countScheduledTasksForWorkspace,
+  countWorkspacesForAccount,
+  getBillingBalance,
+  isCodexBilledTurn,
+  recordUsageEvent,
+  sumUsageQuantity
+} from "@opengeni/db";
+import { HTTPException as HTTPException3 } from "hono/http-exception";
+async function requireLimit(deps, input) {
+  const decision = await checkLimit(deps, input);
+  if (decision.allowed) {
+    return;
+  }
+  throw new HTTPException3(decision.code === "insufficient_credits" ? 402 : 429, { message: decision.message });
+}
+async function checkLimit(deps, input) {
+  const codexBilled = input.workspaceId ? await isCodexBilledTurn({ db: deps.db, settings: deps.settings, workspaceId: input.workspaceId, model: input.model }) : false;
+  const creditDecision = await checkCreditBalance(deps, input, codexBilled);
+  if (!creditDecision.allowed) {
+    return creditDecision;
+  }
+  if (deps.settings.usageLimitsMode !== "static" && deps.settings.usageLimitsMode !== "managed") {
+    return { allowed: true };
+  }
+  return await checkStaticCaps(deps, input, codexBilled);
+}
+async function checkCreditBalance(deps, input, codexBilled) {
+  if (codexBilled) {
+    return { allowed: true };
+  }
+  if (!usesCreditLimits(deps) || !isCostlyAction(input.action)) {
+    return { allowed: true };
+  }
+  const balance = await getBillingBalance(deps.db, input.accountId);
+  if (balance.balanceMicros > 0) {
+    return { allowed: true };
+  }
+  return { allowed: false, code: "insufficient_credits", message: "insufficient OpenGeni credits" };
+}
+async function checkStaticCaps(deps, input, codexBilled) {
+  const limits = configuredStaticUsageLimits(deps.settings);
+  if (limits.maxMonthlyCostMicrosPerAccount && isCostlyAction(input.action) && !codexBilled) {
+    const used = await sumUsageQuantity(deps.db, {
+      accountId: input.accountId,
+      eventType: "model.cost",
+      since: startOfUtcMonth()
+    });
+    if (used >= limits.maxMonthlyCostMicrosPerAccount) {
+      return blocked("max_monthly_cost_micros_per_account", `monthly model cost limit reached (${limits.maxMonthlyCostMicrosPerAccount} micros)`);
+    }
+  }
+  switch (input.action) {
+    case "workspace:create": {
+      if (!limits.maxWorkspacesPerAccount) {
+        return { allowed: true };
+      }
+      const count = await countWorkspacesForAccount(deps.db, input.accountId);
+      return count < limits.maxWorkspacesPerAccount ? { allowed: true } : blocked("max_workspaces_per_account", `workspace limit reached (${limits.maxWorkspacesPerAccount})`);
+    }
+    case "api_key:create": {
+      if (!limits.maxApiKeysPerWorkspace || !input.workspaceId) {
+        return { allowed: true };
+      }
+      const count = await countActiveApiKeysForWorkspace(deps.db, input.workspaceId);
+      return count < limits.maxApiKeysPerWorkspace ? { allowed: true } : blocked("max_api_keys_per_workspace", `API key limit reached (${limits.maxApiKeysPerWorkspace})`);
+    }
+    case "schedule:create": {
+      if (!limits.maxSchedulesPerWorkspace || !input.workspaceId) {
+        return { allowed: true };
+      }
+      const count = await countScheduledTasksForWorkspace(deps.db, input.workspaceId);
+      return count < limits.maxSchedulesPerWorkspace ? { allowed: true } : blocked("max_schedules_per_workspace", `scheduled task limit reached (${limits.maxSchedulesPerWorkspace})`);
+    }
+    case "file:upload": {
+      if (!limits.maxFileUploadBytes || !input.quantity) {
+        return { allowed: true };
+      }
+      return input.quantity <= limits.maxFileUploadBytes ? { allowed: true } : blocked("max_file_upload_bytes", `file upload exceeds static limit of ${limits.maxFileUploadBytes} bytes`);
+    }
+    case "agent_run:create": {
+      if (!limits.maxMonthlyAgentRunsPerWorkspace || !input.workspaceId) {
+        return { allowed: true };
+      }
+      const used = await sumUsageQuantity(deps.db, {
+        workspaceId: input.workspaceId,
+        eventType: "agent_run.created",
+        since: startOfUtcMonth()
+      });
+      const requested = input.quantity ?? 0;
+      return used + requested <= limits.maxMonthlyAgentRunsPerWorkspace ? { allowed: true } : blocked("max_monthly_agent_runs_per_workspace", `monthly agent run limit reached (${limits.maxMonthlyAgentRunsPerWorkspace})`);
+    }
+    case "tokens:consume": {
+      if (codexBilled || !limits.maxMonthlyTokensPerWorkspace || !input.workspaceId) {
+        return { allowed: true };
+      }
+      const used = await sumUsageQuantity(deps.db, {
+        workspaceId: input.workspaceId,
+        eventType: "model.tokens",
+        since: startOfUtcMonth()
+      });
+      const requested = input.quantity ?? 0;
+      return used + requested <= limits.maxMonthlyTokensPerWorkspace ? { allowed: true } : blocked("max_monthly_tokens_per_workspace", `monthly token limit reached (${limits.maxMonthlyTokensPerWorkspace})`);
+    }
+    case "document:index": {
+      if (!limits.maxDocumentIndexedChunksPerWorkspace || !input.workspaceId) {
+        return { allowed: true };
+      }
+      const used = await sumUsageQuantity(deps.db, {
+        workspaceId: input.workspaceId,
+        eventType: "document.indexed",
+        since: startOfUtcMonth()
+      });
+      const requested = input.quantity ?? 0;
+      return used + requested <= limits.maxDocumentIndexedChunksPerWorkspace ? { allowed: true } : blocked("max_document_indexed_chunks_per_workspace", `monthly document indexing limit reached (${limits.maxDocumentIndexedChunksPerWorkspace} chunks)`);
+    }
+  }
+}
+async function recordWorkspaceUsage(deps, input) {
+  await recordUsageEvent(deps.db, {
+    accountId: input.accountId,
+    workspaceId: input.workspaceId,
+    subjectId: input.subjectId ?? null,
+    eventType: input.eventType,
+    quantity: input.quantity,
+    unit: input.unit,
+    sourceResourceType: input.sourceResourceType,
+    sourceResourceId: input.sourceResourceId,
+    idempotencyKey: input.idempotencyKey
+  });
+}
+function usesCreditLimits(deps) {
+  return deps.settings.billingMode === "stripe" || deps.settings.usageLimitsMode === "managed";
+}
+function isCostlyAction(action) {
+  return action === "agent_run:create" || action === "tokens:consume" || action === "file:upload" || action === "document:index";
+}
+function blocked(code, message) {
+  return { allowed: false, code, message };
+}
+function startOfUtcMonth() {
+  const now = /* @__PURE__ */ new Date();
+  return new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1));
+}
+
+// src/domain/capabilities.ts
+import { readdir, readFile } from "fs/promises";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { environmentsEncryptionKeyBytes as environmentsEncryptionKeyBytes2 } from "@opengeni/config";
+import {
+  CapabilityCatalogItem
+} from "@opengeni/contracts";
+import {
+  decryptEnvironmentValue,
+  decryptedCapabilityHeaders,
+  disableCapabilityInstallation,
+  enableCapabilityInstallation,
+  enablePackInstallation,
+  encryptEnvironmentValue,
+  getCapabilityCatalogItem,
+  getCapabilityInstallation,
+  getPackInstallation,
+  getStoredCapabilityHeaderCiphertext,
+  getWorkspaceEnvironment as getWorkspaceEnvironment2,
+  listCapabilityCatalogItems,
+  listCapabilityInstallations,
+  listEnabledMcpCapabilityServers,
+  listPackInstallations as listPackInstallations2,
+  mcpServerIdForCapability,
+  updatePackInstallationStatus,
+  upsertCapabilityCatalogItem
+} from "@opengeni/db";
+import { HTTPException as HTTPException6 } from "hono/http-exception";
+
+// src/domain/environments.ts
+import { environmentsEncryptionKeyBytes } from "@opengeni/config";
+import {
+  getWorkspaceEnvironment,
+  recordAuditEvent
+} from "@opengeni/db";
+import { HTTPException as HTTPException4 } 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",
+  "GIT_ASKPASS",
+  "GIT_TERMINAL_PROMPT"
+]);
+var reservedPrefixes = [
+  "OPENGENI_",
+  "GIT_CONFIG_",
+  "GIT_AUTHOR_",
+  "GIT_COMMITTER_",
+  "LD_",
+  "DYLD_"
+];
+function assertAllowedEnvironmentVariableName(name) {
+  if (reservedExactNames.has(name) || reservedPrefixes.some((prefix) => name.startsWith(prefix))) {
+    throw new HTTPException4(422, { message: `reserved environment variable name: ${name}` });
+  }
+}
+function requireEnvironmentEncryption(settings) {
+  const key = environmentsEncryptionKeyBytes(settings);
+  if (!key) {
+    throw new HTTPException4(503, { message: "workspace environments require OPENGENI_ENVIRONMENTS_ENCRYPTION_KEY" });
+  }
+  return key;
+}
+async function requireEnvironmentForApi(db, workspaceId, environmentId) {
+  const environment = await getWorkspaceEnvironment(db, workspaceId, environmentId);
+  if (!environment) {
+    throw new HTTPException4(404, { message: "environment not found" });
+  }
+  return environment;
+}
+async function validateEnvironmentAttachment(deps, grant, workspaceId, environmentId, options = {}) {
+  requireEnvironmentEncryption(deps.settings);
+  if (!options.preauthorized) {
+    requirePermission(grant, "environments:use");
+  }
+  const environment = await getWorkspaceEnvironment(deps.db, workspaceId, environmentId);
+  if (!environment) {
+    throw new HTTPException4(422, { message: "unknown environmentId" });
+  }
+  return environment;
+}
+async function recordEnvironmentAuditEvent(db, input) {
+  await recordAuditEvent(db, {
+    accountId: input.grant.accountId,
+    workspaceId: input.grant.workspaceId,
+    subjectId: input.grant.subjectId,
+    action: input.action,
+    targetType: "workspace_environment",
+    targetId: input.environmentId,
+    metadata: {
+      environmentId: input.environmentId,
+      ...input.variableName ? { name: input.variableName } : {}
+    }
+  });
+}
+
+// src/domain/packs.ts
+import {
+  CapabilityPack
+} from "@opengeni/contracts";
+import { getWorkspacePack, listPackInstallations, listWorkspacePacks } from "@opengeni/db";
+import { HTTPException as HTTPException5 } from "hono/http-exception";
+var MARKETING_SOCIAL_PACK_ID = "marketing-social-daily-analysis";
+var marketingSocialPack = {
+  id: MARKETING_SOCIAL_PACK_ID,
+  name: "Marketing social daily analysis",
+  description: "Connect social accounts, attach marketing knowledge, and schedule agents to produce daily media performance analysis.",
+  role: "marketing",
+  category: "social-media",
+  version: "0.1.0",
+  // Built-in packs deliberately declare no sandboxImage and no skills: the
+  // worker's pack-runtime resolution only reads manifest-registered packs
+  // (see apps/worker/src/activities/packs.ts), and a test enforces this.
+  skills: [],
+  tools: [
+    { kind: "mcp", id: "opengeni" },
+    { kind: "mcp", id: "docs" }
+  ],
+  connectors: [
+    {
+      id: "x",
+      name: "X",
+      category: "social-media",
+      authModel: "oauth2_authorization_code_pkce",
+      providers: ["x"],
+      scopes: ["tweet.read", "users.read", "offline.access"],
+      required: false,
+      metadata: {
+        docs: "https://docs.x.com/fundamentals/authentication/oauth-2-0/authorization-code"
+      }
+    },
+    {
+      id: "linkedin",
+      name: "LinkedIn",
+      category: "social-media",
+      authModel: "oauth2_authorization_code",
+      providers: ["linkedin"],
+      scopes: ["r_organization_social", "rw_organization_admin"],
+      required: false,
+      metadata: {
+        docs: "https://learn.microsoft.com/en-us/linkedin/marketing/community-management/community-management-overview"
+      }
+    },
+    {
+      id: "instagram",
+      name: "Instagram",
+      category: "social-media",
+      authModel: "oauth2_authorization_code",
+      providers: ["instagram", "facebook"],
+      scopes: ["instagram_basic", "instagram_manage_insights", "pages_read_engagement", "pages_show_list"],
+      required: false,
+      metadata: {
+        docs: "https://developers.facebook.com/docs/instagram-platform/instagram-graph-api/"
+      }
+    },
+    {
+      id: "tiktok",
+      name: "TikTok",
+      category: "social-media",
+      authModel: "oauth2_authorization_code",
+      providers: ["tiktok"],
+      scopes: ["user.info.basic", "video.list"],
+      required: false,
+      metadata: {
+        docs: "https://developers.tiktok.com/doc/tiktok-api-v2-introduction/"
+      }
+    },
+    {
+      id: "youtube",
+      name: "YouTube",
+      category: "social-media",
+      authModel: "oauth2_authorization_code",
+      providers: ["youtube"],
+      scopes: ["https://www.googleapis.com/auth/youtube.readonly", "https://www.googleapis.com/auth/yt-analytics.readonly"],
+      required: false,
+      metadata: {
+        docs: "https://developers.google.com/youtube/v3"
+      }
+    }
+  ],
+  knowledge: [
+    {
+      type: "document_base",
+      id: "marketing-playbook",
+      name: "Marketing playbook",
+      description: "Optional workspace document base with brand voice, campaign calendars, audience research, and reporting rules.",
+      required: false
+    }
+  ],
+  scheduledTaskTemplates: [
+    {
+      id: "daily-social-analysis",
+      name: "Daily social analysis",
+      description: "Review the latest social posts and account signals every day.",
+      defaultSchedule: {
+        type: "calendar",
+        timeZone: "UTC",
+        hour: 9,
+        minute: 0
+      },
+      defaultRunMode: "new_session_per_run",
+      defaultOverlapPolicy: "skip"
+    }
+  ],
+  metadata: {
+    skill: "social-media-marketing",
+    firstPartyMcpTools: [
+      "social_connections_list",
+      "social_posts_recent",
+      "social_daily_analysis_context"
+    ]
+  }
+};
+var packs = [marketingSocialPack];
+function listCapabilityPacks() {
+  return packs;
+}
+function getCapabilityPack(packId) {
+  return packs.find((pack) => pack.id === packId) ?? null;
+}
+function isBuiltInCapabilityPack(packId) {
+  return getCapabilityPack(packId) !== null;
+}
+async function listWorkspaceCapabilityPacks(db, workspaceId) {
+  const registered = await listWorkspacePacks(db, workspaceId);
+  const builtInIds = new Set(packs.map((pack) => pack.id));
+  const registeredPacks = registered.filter((registration) => !builtInIds.has(registration.pack.id)).flatMap((registration) => {
+    const parsed = CapabilityPack.safeParse(registration.pack);
+    return parsed.success ? [parsed.data] : [];
+  });
+  return [...packs, ...registeredPacks];
+}
+async function resolveCapabilityPack(db, workspaceId, packId) {
+  const builtIn = getCapabilityPack(packId);
+  if (builtIn) {
+    return builtIn;
+  }
+  const registration = await getWorkspacePack(db, workspaceId, packId);
+  if (!registration) {
+    return null;
+  }
+  const parsed = CapabilityPack.safeParse(registration.pack);
+  return parsed.success ? parsed.data : null;
+}
+async function assertPackSandboxImageCompatible(db, workspaceId, pack) {
+  if (!pack.sandboxImage) {
+    return;
+  }
+  const installations = await listPackInstallations(db, workspaceId);
+  for (const installation of installations) {
+    if (installation.status !== "active" || installation.packId === pack.id) {
+      continue;
+    }
+    const other = await resolveCapabilityPack(db, workspaceId, installation.packId);
+    if (other?.sandboxImage) {
+      throw new HTTPException5(409, {
+        message: `pack ${pack.id} declares a sandbox image, but enabled pack ${other.id} already declares one; only one enabled pack per workspace may declare sandboxImage \u2014 disable ${other.id} first`
+      });
+    }
+  }
+}
+function buildMarketingDailyAnalysisAgentConfig(input) {
+  const connectionIds = input.connections.map((connection) => connection.id);
+  return {
+    prompt: marketingDailyAnalysisPrompt({
+      connections: input.connections,
+      documentBaseIds: input.documentBaseIds,
+      ...input.promptInstructions ? { promptInstructions: input.promptInstructions } : {}
+    }),
+    resources: [],
+    tools: marketingSocialPack.tools,
+    metadata: {
+      packId: MARKETING_SOCIAL_PACK_ID,
+      packTemplateId: "daily-social-analysis",
+      socialConnectionIds: connectionIds,
+      documentBaseIds: input.documentBaseIds,
+      analysisWindowHours: 24
+    }
+  };
+}
+function marketingDailyAnalysisPrompt(input) {
+  const connectionLines = input.connections.map((connection) => {
+    return `- ${connection.provider}: ${connection.accountHandle} (${connection.id})`;
+  }).join("\n");
+  const knowledgeLine = input.documentBaseIds.length > 0 ? `Use these document base IDs for brand/campaign knowledge through the docs MCP: ${input.documentBaseIds.join(", ")}.` : "No document base IDs were selected; rely only on social context returned by tools.";
+  const extra = input.promptInstructions ? `
+Additional operator instructions:
+${input.promptInstructions.trim()}
+` : "";
+  return [
+    "Run the daily social media analysis for the selected accounts.",
+    "",
+    "First call the OpenGeni MCP tool social_daily_analysis_context with the selected connection IDs and a 24 hour analysis window. Use social_posts_recent only if you need a narrower follow-up query.",
+    knowledgeLine,
+    "",
+    "Selected accounts:",
+    connectionLines,
+    extra,
+    "Produce a concise report with these sections: executive summary, notable account changes, winning posts, underperforming posts, audience and content signals, recommended actions for the next 24 hours, and data gaps.",
+    "Use only metrics and posts returned by tools or document search. Do not invent metrics, posts, or account capabilities."
+  ].filter(Boolean).join("\n");
+}
+
+// src/domain/capabilities.ts
+var officialMcpRegistryUrl = "https://registry.modelcontextprotocol.io";
+var firstPartyMcpServerIds = /* @__PURE__ */ new Set(["opengeni", "files", "docs"]);
+var mcpRegistryFetchTimeoutMs = 15e3;
+var mcpRegistryMaxPages = 3;
+var mcpCapabilityProbeTimeoutMs = 15e3;
+var maxMcpCredentialHeaders = 16;
+var maxMcpCredentialHeaderValueLength = 4096;
+var mcpCredentialHeaderName = /^[A-Za-z0-9!#$%&'*+.^_`|~-]+$/;
+async function buildCapabilityCatalog(input) {
+  const [
+    persistedItems,
+    capabilityInstallations,
+    packInstallations,
+    workspacePacks,
+    bundledSkills
+  ] = await Promise.all([
+    listCapabilityCatalogItems(input.db, input.workspaceId),
+    listCapabilityInstallations(input.db, input.workspaceId),
+    listPackInstallations2(input.db, input.workspaceId),
+    listWorkspaceCapabilityPacks(input.db, input.workspaceId),
+    discoverBundledSkills()
+  ]);
+  const capabilityInstallationById = new Map(capabilityInstallations.map((installation) => [installation.capabilityId, installation]));
+  const activePackIds = new Set(packInstallations.filter((installation) => installation.status === "active").map((installation) => installation.packId));
+  const builtInPackIds = new Set(listCapabilityPacks().map((pack) => pack.id));
+  const builtIns = [
+    ...workspacePacks.map((pack) => packCatalogItem(pack, builtInPackIds.has(pack.id) ? "built_in" : "manual")),
+    ...configuredMcpCatalogItems(input.settings),
+    ...platformApiCatalogItems(),
+    ...bundledSkills
+  ];
+  const items = dedupeCatalogItems([...builtIns, ...persistedItems]).map((item) => applyCapabilityEnablement(item, capabilityInstallationById.get(item.id), activePackIds)).sort(compareCatalogItems);
+  return {
+    items,
+    installations: capabilityInstallations
+  };
+}
+async function createCatalogItem(input) {
+  const id = input.payload.id?.trim() || generatedCapabilityId(input.payload);
+  if (id.startsWith("pack:")) {
+    throw new HTTPException6(422, { message: "packs are managed by OpenGeni and cannot be manually created" });
+  }
+  const source = input.payload.source === "built_in" || input.payload.source === "configured" ? "manual" : input.payload.source;
+  const metadata = {
+    ...input.payload.metadata,
+    ...input.payload.kind === "mcp" && input.payload.endpointUrl && !input.payload.metadata.mcpServerId ? { mcpServerId: mcpServerIdForCapability(id, input.payload.metadata) } : {}
+  };
+  return await upsertCapabilityCatalogItem(input.db, {
+    accountId: input.accountId,
+    workspaceId: input.workspaceId,
+    id,
+    kind: input.payload.kind,
+    source,
+    name: input.payload.name.trim(),
+    description: input.payload.description?.trim() || null,
+    category: input.payload.category.trim() || "custom",
+    tags: uniqueTags(input.payload.tags),
+    homepageUrl: input.payload.homepageUrl ?? null,
+    endpointUrl: input.payload.endpointUrl ?? null,
+    installUrl: input.payload.installUrl ?? null,
+    authModel: input.payload.authModel?.trim() || null,
+    metadata
+  });
+}
+async function enableCapability(input) {
+  const item = await requireCatalogItem(input.db, input.workspaceId, input.settings, input.capabilityId);
+  if (item.kind === "mcp" && !item.runtime.available) {
+    throw new HTTPException6(422, { message: "MCP capabilities need a remote streamable HTTP endpoint before they can be enabled" });
+  }
+  let installationMetadata = input.payload.metadata;
+  const installationConfig = { ...input.payload.config };
+  delete installationConfig.headers;
+  delete installationConfig.headersEncrypted;
+  delete installationConfig.headerNames;
+  if (item.kind === "mcp") {
+    const headers = await resolveMcpCredentialHeaders(input, item);
+    assertRequiredMcpCredentialHeaders(item, headers);
+    installationMetadata = {
+      ...installationMetadata,
+      ...await validateMcpCapabilityConnection(item, input.probeMcpServer, headers ?? void 0)
+    };
+    if (headers) {
+      const key = requireCapabilityHeaderEncryption(input.settings);
+      installationConfig.headersEncrypted = Object.fromEntries(
+        Object.entries(headers).map(([name, value]) => [name, encryptEnvironmentValue(key, value)])
+      );
+    }
+  }
+  if (item.kind === "pack") {
+    const packId = packIdFromCapabilityId(item.id);
+    const pack = await resolveCapabilityPack(input.db, input.workspaceId, packId);
+    if (!pack) {
+      throw new HTTPException6(404, { message: "pack not found" });
+    }
+    await assertPackSandboxImageCompatible(input.db, input.workspaceId, pack);
+    const existing = await getPackInstallation(input.db, input.workspaceId, packId);
+    const storedEnvironmentId = typeof existing?.metadata.environmentId === "string" ? existing.metadata.environmentId : void 0;
+    const requestedEnvironmentId = input.payload.environmentId;
+    const environmentId = requestedEnvironmentId ?? storedEnvironmentId;
+    if (pack.environment?.required && !environmentId) {
+      throw new HTTPException6(422, {
+        message: `pack ${packId} requires an environment attachment; pass environmentId`
+      });
+    }
+    if (environmentId) {
+      if (requestedEnvironmentId) {
+        const environment = await validateEnvironmentAttachment(
+          { settings: input.settings, db: input.db },
+          input.grant,
+          input.workspaceId,
+          requestedEnvironmentId
+        );
+        const missing = (pack.environment?.requiredVariables ?? []).filter((name) => !environment.variables.some((variable) => variable.name === name));
+        if (missing.length > 0) {
+          throw new HTTPException6(422, { message: `environment is missing required variable(s): ${missing.join(", ")}` });
+        }
+      } else {
+        const environment = await getWorkspaceEnvironment2(input.db, input.workspaceId, environmentId);
+        if (!environment) {
+          throw new HTTPException6(422, {
+            message: `the stored environment attachment for pack ${packId} no longer exists; re-enable it with environmentId`
+          });
+        }
+        const missing = (pack.environment?.requiredVariables ?? []).filter((name) => !environment.variables.some((variable) => variable.name === name));
+        if (missing.length > 0) {
+          throw new HTTPException6(422, { message: `environment is missing required variable(s): ${missing.join(", ")}` });
+        }
+      }
+    }
+    await enablePackInstallation(input.db, {
+      accountId: input.accountId,
+      workspaceId: input.workspaceId,
+      packId,
+      metadata: {
+        ...input.payload.metadata,
+        packVersion: pack.version,
+        ...environmentId ? { environmentId } : {}
+      }
+    });
+  }
+  return await enableCapabilityInstallation(input.db, {
+    accountId: input.accountId,
+    workspaceId: input.workspaceId,
+    capabilityId: item.id,
+    kind: item.kind,
+    config: installationConfig,
+    metadata: installationMetadata
+  });
+}
+async function resolveMcpCredentialHeaders(input, item) {
+  const provided = normalizedMcpCredentialHeaders(input.payload.headers);
+  if (provided) {
+    requireCapabilityHeaderEncryption(input.settings);
+    return provided;
+  }
+  const storedCiphertext = await getStoredCapabilityHeaderCiphertext(input.db, input.workspaceId, item.id);
+  if (!storedCiphertext) {
+    return null;
+  }
+  const key = requireCapabilityHeaderEncryption(input.settings);
+  try {
+    return Object.fromEntries(Object.entries(storedCiphertext).map(([name, value]) => [name, decryptEnvironmentValue(key, value)]));
+  } catch {
+    throw new HTTPException6(422, {
+      message: `stored credential headers for "${item.name}" could not be decrypted; supply them again in the enable request "headers" field`
+    });
+  }
+}
+function normalizedMcpCredentialHeaders(headers) {
+  const entries = Object.entries(headers).map(([name, value]) => [name.trim(), value]).filter(([name]) => name.length > 0);
+  if (entries.length === 0) {
+    return null;
+  }
+  if (entries.length > maxMcpCredentialHeaders) {
+    throw new HTTPException6(422, { message: `an MCP capability supports at most ${maxMcpCredentialHeaders} credential headers` });
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const [name, value] of entries) {
+    if (!mcpCredentialHeaderName.test(name)) {
+      throw new HTTPException6(422, { message: `invalid credential header name: ${name}` });
+    }
+    const lower = name.toLowerCase();
+    if (seen.has(lower)) {
+      throw new HTTPException6(422, { message: `duplicate credential header name: ${name}` });
+    }
+    seen.add(lower);
+    if (value.length === 0 || value.length > maxMcpCredentialHeaderValueLength) {
+      throw new HTTPException6(422, { message: `credential header ${name} must be 1-${maxMcpCredentialHeaderValueLength} characters` });
+    }
+    if (/[\u0000-\u0008\u000A-\u001F\u007F]/.test(value)) {
+      throw new HTTPException6(422, { message: `credential header ${name} contains forbidden control characters` });
+    }
+  }
+  return Object.fromEntries(entries);
+}
+function assertRequiredMcpCredentialHeaders(item, headers) {
+  const required = requiredCapabilityHeaders(item.metadata);
+  const names = new Set(Object.keys(headers ?? {}).map((name) => name.toLowerCase()));
+  const missing = required.filter((name) => !names.has(name.toLowerCase()));
+  if (missing.length > 0) {
+    throw new HTTPException6(422, {
+      message: `MCP capability "${item.name}" requires credential header(s) ${missing.join(", ")}; pass them in the enable request "headers" field`
+    });
+  }
+  if (item.authModel && names.size === 0) {
+    throw new HTTPException6(422, {
+      message: `MCP capability "${item.name}" requires credentials; pass them in the enable request "headers" field`
+    });
+  }
+}
+function requiredCapabilityHeaders(metadata) {
+  const value = metadata.requiredHeaders;
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter((name) => typeof name === "string" && name.trim().length > 0).map((name) => name.trim());
+}
+function requireCapabilityHeaderEncryption(settings) {
+  const key = environmentsEncryptionKeyBytes2(settings);
+  if (!key) {
+    throw new HTTPException6(503, { message: "MCP credential headers require OPENGENI_ENVIRONMENTS_ENCRYPTION_KEY" });
+  }
+  return key;
+}
+async function validateMcpCapabilityConnection(item, probe = probeStreamableHttpMcpServer, headers) {
+  if (item.kind !== "mcp") {
+    return {};
+  }
+  if (!item.endpointUrl || !item.runtime.mcpServerId) {
+    throw new HTTPException6(422, { message: "MCP capabilities need a remote streamable HTTP endpoint before they can be enabled" });
+  }
+  try {
+    const result = await probe({
+      id: item.runtime.mcpServerId,
+      name: item.name,
+      url: item.endpointUrl,
+      timeoutMs: mcpCapabilityProbeTimeoutMs,
+      ...headers ? { headers } : {}
+    });
+    return {
+      mcpConnectivity: {
+        status: "ok",
+        checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        toolCount: result.toolCount
+      }
+    };
+  } catch (error) {
+    throw new HTTPException6(422, {
+      message: `MCP capability "${item.name}" could not be enabled because OpenGeni could not initialize ${item.endpointUrl}: ${mcpProbeErrorMessage(error)}`
+    });
+  }
+}
+async function probeStreamableHttpMcpServer(input) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), input.timeoutMs);
+  const client = new Client({ name: "opengeni-capability-probe", version: "0.1.0" }, { capabilities: {} });
+  try {
+    const transport = new StreamableHTTPClientTransport(new URL(input.url), {
+      requestInit: {
+        signal: controller.signal,
+        ...input.headers ? { headers: input.headers } : {}
+      }
+    });
+    await client.connect(transport, { timeout: input.timeoutMs, maxTotalTimeout: input.timeoutMs });
+    const tools = await client.listTools(void 0, { timeout: input.timeoutMs, maxTotalTimeout: input.timeoutMs });
+    return { toolCount: tools.tools.length };
+  } finally {
+    clearTimeout(timeout);
+    await client.close().catch(() => void 0);
+  }
+}
+function mcpProbeErrorMessage(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.replace(/\s+/g, " ").trim().slice(0, 500) || "unknown error";
+}
+async function disableCapability(input) {
+  const item = await requireCatalogItem(input.db, input.workspaceId, input.settings, input.capabilityId);
+  if ((item.source === "built_in" || item.source === "configured") && item.kind !== "pack") {
+    throw new HTTPException6(409, { message: "built-in and configured capabilities are always available; remove them from configuration to disable them" });
+  }
+  if (item.kind === "pack") {
+    await updatePackInstallationStatus(input.db, input.workspaceId, packIdFromCapabilityId(item.id), "disabled").catch(() => void 0);
+    if (!await getCapabilityInstallation(input.db, input.workspaceId, item.id)) {
+      await enableCapabilityInstallation(input.db, {
+        accountId: input.accountId,
+        workspaceId: input.workspaceId,
+        capabilityId: item.id,
+        kind: "pack",
+        metadata: {},
+        config: {}
+      });
+    }
+  } else if (!await getCapabilityInstallation(input.db, input.workspaceId, item.id)) {
+    throw new HTTPException6(409, { message: "capability is not currently enabled" });
+  }
+  return await disableCapabilityInstallation(input.db, input.workspaceId, item.id);
+}
+async function settingsWithEnabledCapabilityMcpServers(db, workspaceId, settings) {
+  const enabled = await listEnabledMcpCapabilityServers(db, workspaceId);
+  return settingsWithMcpCapabilityServers(settings, enabled);
+}
+function settingsWithMcpCapabilityServers(settings, enabled) {
+  if (enabled.length === 0) {
+    return settings;
+  }
+  const encryptionKey = environmentsEncryptionKeyBytes2(settings);
+  const existingIds = new Set(settings.mcpServers.map((server) => server.id));
+  const dynamicServers = enabled.filter((server) => !existingIds.has(server.id)).flatMap((server) => {
+    const headers = decryptedCapabilityHeaders(server, encryptionKey);
+    if (headers === "unavailable") {
+      return [];
+    }
+    return [{
+      id: server.id,
+      name: server.name,
+      url: server.url,
+      ...server.allowedTools ? { allowedTools: server.allowedTools } : {},
+      ...server.timeoutMs ? { timeoutMs: server.timeoutMs } : {},
+      cacheToolsList: server.cacheToolsList ?? false,
+      ...headers ? { headers } : {}
+    }];
+  });
+  return dynamicServers.length ? { ...settings, mcpServers: [...settings.mcpServers, ...dynamicServers] } : settings;
+}
+async function discoverMcpRegistryCapabilities(input) {
+  const query = (input.query ?? "").trim().toLowerCase();
+  const limit = Math.min(100, Math.max(1, Math.floor(input.limit ?? 50)));
+  const items = [];
+  const seen = /* @__PURE__ */ new Set();
+  const fetchOptions = {};
+  if (input.fetchImpl) {
+    fetchOptions.fetchImpl = input.fetchImpl;
+  }
+  if (input.timeoutMs !== void 0) {
+    fetchOptions.timeoutMs = input.timeoutMs;
+  }
+  let cursor;
+  let pages = 0;
+  while (items.length < limit && pages < mcpRegistryMaxPages) {
+    pages += 1;
+    const url = new URL("/v0.1/servers", officialMcpRegistryUrl);
+    url.searchParams.set("limit", String(limit));
+    url.searchParams.set("version", "latest");
+    if (query) {
+      url.searchParams.set("search", query);
+    }
+    if (cursor) {
+      url.searchParams.set("cursor", cursor);
+    }
+    const page = await fetchMcpRegistryPage(url, fetchOptions);
+    for (const entry of page.servers ?? []) {
+      const item = mcpRegistryEntryToCatalogItem(entry);
+      if (!item || seen.has(item.id)) {
+        continue;
+      }
+      if (query && !catalogSearchText(item).includes(query)) {
+        continue;
+      }
+      seen.add(item.id);
+      items.push(item);
+      if (items.length >= limit) {
+        break;
+      }
+    }
+    cursor = typeof page.metadata?.nextCursor === "string" ? page.metadata.nextCursor : void 0;
+    if (!cursor) {
+      break;
+    }
+  }
+  return items;
+}
+async function fetchMcpRegistryPage(url, options = {}) {
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), options.timeoutMs ?? mcpRegistryFetchTimeoutMs);
+  try {
+    const response = await fetchImpl(url, { signal: controller.signal });
+    if (!response.ok) {
+      throw new HTTPException6(502, { message: `MCP registry returned ${response.status}` });
+    }
+    return await response.json();
+  } catch (error) {
+    if (error instanceof HTTPException6) {
+      throw error;
+    }
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new HTTPException6(504, { message: "MCP registry request timed out" });
+    }
+    throw new HTTPException6(502, {
+      message: `MCP registry request failed: ${error instanceof Error ? error.message : String(error)}`
+    });
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function requireCatalogItem(db, workspaceId, settings, capabilityId) {
+  const catalog = await buildCapabilityCatalog({ db, workspaceId, settings });
+  const item = catalog.items.find((candidate) => candidate.id === capabilityId) ?? await getCapabilityCatalogItem(db, workspaceId, capabilityId);
+  if (!item) {
+    throw new HTTPException6(404, { message: "capability not found" });
+  }
+  return item;
+}
+function packCatalogItem(pack, source) {
+  return CapabilityCatalogItem.parse({
+    id: `pack:${pack.id}`,
+    kind: "pack",
+    source,
+    name: pack.name,
+    description: pack.description,
+    category: pack.category,
+    tags: [pack.role, pack.category, "pack"],
+    tools: pack.tools,
+    runtime: {
+      available: true,
+      notes: "Enables role-scoped tools, connectors, knowledge, and scheduled-task templates."
+    },
+    metadata: {
+      packId: pack.id,
+      version: pack.version,
+      connectors: pack.connectors,
+      knowledge: pack.knowledge,
+      scheduledTaskTemplates: pack.scheduledTaskTemplates,
+      // Runtime composition surface only: skill names, never file content.
+      ...pack.sandboxImage ? { sandboxImage: pack.sandboxImage } : {},
+      ...pack.skills.length > 0 ? { skills: pack.skills.map((skill) => skill.name) } : {},
+      ...pack.metadata
+    }
+  });
+}
+function configuredMcpCatalogItems(settings) {
+  return settings.mcpServers.map((server) => CapabilityCatalogItem.parse({
+    id: `mcp:${server.id}`,
+    kind: "mcp",
+    source: firstPartyMcpServerIds.has(server.id) ? "built_in" : "configured",
+    name: server.name ?? server.id,
+    description: firstPartyMcpDescription(server.id),
+    category: firstPartyMcpServerIds.has(server.id) ? "platform" : "configured",
+    tags: ["mcp", ...server.allowedTools?.length ? ["limited-tools"] : []],
+    endpointUrl: server.url,
+    tools: [{ kind: "mcp", id: server.id }],
+    runtime: {
+      available: true,
+      mcpServerId: server.id,
+      transport: "streamable-http",
+      notes: firstPartyMcpServerIds.has(server.id) ? "Available from OpenGeni runtime configuration." : "Configured through OPENGENI_MCP_SERVERS."
+    },
+    metadata: {
+      mcpServerId: server.id,
+      allowedTools: server.allowedTools ?? [],
+      cacheToolsList: server.cacheToolsList
+    }
+  }));
+}
+function platformApiCatalogItems() {
+  return [
+    {
+      id: "api:github-app",
+      name: "GitHub App",
+      description: "Repository discovery, scoped clone tokens, pushes, and pull requests.",
+      category: "source-control",
+      tags: ["api", "github", "repositories"],
+      endpointPath: "/v1/workspaces/{workspaceId}/github/app"
+    },
+    {
+      id: "api:documents",
+      name: "Document Knowledge Base",
+      description: "Upload, index, search, and attach knowledge bases to agents.",
+      category: "knowledge",
+      tags: ["api", "documents", "knowledge"],
+      endpointPath: "/v1/workspaces/{workspaceId}/document-bases"
+    },
+    {
+      id: "api:social",
+      name: "Social Accounts",
+      description: "Connect social accounts and ingest posts for marketing agents.",
+      category: "marketing",
+      tags: ["api", "social", "marketing"],
+      endpointPath: "/v1/workspaces/{workspaceId}/social/connections"
+    },
+    {
+      id: "api:scheduled-tasks",
+      name: "Scheduled Tasks",
+      description: "Run agents once, on intervals, or on calendar schedules.",
+      category: "automation",
+      tags: ["api", "schedules", "agents"],
+      endpointPath: "/v1/workspaces/{workspaceId}/scheduled-tasks"
+    }
+  ].map((item) => CapabilityCatalogItem.parse({
+    id: item.id,
+    name: item.name,
+    description: item.description,
+    category: item.category,
+    tags: item.tags,
+    kind: "api",
+    source: "built_in",
+    runtime: {
+      available: true,
+      notes: "Available through the OpenGeni API."
+    },
+    metadata: {
+      endpointPath: item.endpointPath
+    }
+  }));
+}
+async function discoverBundledSkills() {
+  const skillsDir = new URL("../../../../packages/runtime/src/bundled_hashicorp_terraform_skills/", import.meta.url);
+  try {
+    const entries = await readdir(skillsDir, { withFileTypes: true });
+    const skills = await Promise.all(entries.filter((entry) => entry.isDirectory()).map(async (entry) => {
+      const skill = await readSkillMetadata(new URL(`${entry.name}/SKILL.md`, skillsDir), entry.name);
+      return CapabilityCatalogItem.parse({
+        id: `skill:${entry.name}`,
+        kind: "skill",
+        source: "built_in",
+        name: skill.name,
+        description: skill.description,
+        category: skill.category,
+        tags: ["skill", skill.category],
+        runtime: {
+          available: true,
+          notes: "Bundled into the sandbox skill library."
+        },
+        metadata: {
+          path: `packages/runtime/src/bundled_hashicorp_terraform_skills/${entry.name}/SKILL.md`
+        }
+      });
+    }));
+    return skills;
+  } catch {
+    return [];
+  }
+}
+async function readSkillMetadata(url, fallbackName) {
+  const content = await readFile(url, "utf8");
+  const frontMatter = content.match(/^---\n([\s\S]*?)\n---/);
+  const frontMatterBody = frontMatter?.[1] ?? "";
+  const name = frontMatterBody.match(/^name:\s*(.+)$/m)?.[1]?.trim() || fallbackName;
+  const blockDescription = frontMatterBody.match(/^description:\s*>-\s*\n([\s\S]*?)(?:\n[a-zA-Z_-]+:|\n?$)/m)?.[1]?.split("\n").map((line) => line.trim()).filter(Boolean).join(" ");
+  const inlineDescription = frontMatterBody.match(/^description:\s*(?!>-\s*$)(.+)$/m)?.[1]?.trim();
+  const description = blockDescription || inlineDescription || content.match(/^#\s+(.+)$/m)?.[1]?.trim() || null;
+  const lower = `${fallbackName} ${name} ${description ?? ""}`.toLowerCase();
+  const category = lower.includes("social") || lower.includes("marketing") ? "marketing" : lower.includes("checkov") || lower.includes("terraform") || lower.includes("azure") ? "infrastructure" : "general";
+  return { name, description, category };
+}
+function applyCapabilityEnablement(item, installation, activePackIds) {
+  if (item.kind === "pack") {
+    const enabled2 = activePackIds.has(packIdFromCapabilityId(item.id)) || installation?.status === "active";
+    return {
+      ...item,
+      enabled: enabled2,
+      enabledReason: enabled2 ? "enabled" : null
+    };
+  }
+  if (item.source === "built_in" || item.source === "configured") {
+    return {
+      ...item,
+      enabled: true,
+      enabledReason: item.source === "configured" ? "configured" : "built in"
+    };
+  }
+  const activeInstallation = installation?.status === "active";
+  const enabled = !!activeInstallation && capabilityInstallationRuntimeReady(item, installation);
+  return {
+    ...item,
+    enabled,
+    enabledReason: enabled ? "enabled" : null
+  };
+}
+function dedupeCatalogItems(items) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    byId.set(item.id, item);
+  }
+  return [...byId.values()];
+}
+function compareCatalogItems(a, b) {
+  return `${a.kind}:${a.category}:${a.name}`.localeCompare(`${b.kind}:${b.category}:${b.name}`);
+}
+function firstPartyMcpDescription(id) {
+  if (id === "opengeni") {
+    return "First-party OpenGeni MCP tools for files, documents, schedules, and social analysis.";
+  }
+  if (id === "docs") {
+    return "Document-base search tools for indexed knowledge.";
+  }
+  if (id === "files") {
+    return "File download URL tools for sandbox-mounted file resources.";
+  }
+  return null;
+}
+function generatedCapabilityId(payload) {
+  const source = [payload.kind, payload.name, payload.endpointUrl ?? payload.installUrl ?? payload.homepageUrl ?? ""].join(":");
+  return `${payload.kind}:${slugify(payload.name)}-${shortHash(source)}`;
+}
+function publicRegistryCapabilityId(name, version, endpointUrl) {
+  return `mcp-registry:${slugify(name)}-${shortHash(`${name}:${version}:${endpointUrl}`)}`;
+}
+function packIdFromCapabilityId(capabilityId) {
+  return capabilityId.replace(/^pack:/, "");
+}
+function uniqueTags(tags) {
+  return [...new Set(tags.map((tag) => tag.trim()).filter(Boolean))];
+}
+function slugify(value) {
+  return value.toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60) || "capability";
+}
+function shortHash(value) {
+  let hash = 2166136261;
+  for (let index = 0; index < value.length; index += 1) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(36).padStart(7, "0").slice(0, 7);
+}
+function mcpRegistryEntryToCatalogItem(entry) {
+  const server = entry.server;
+  if (!server?.name) {
+    return null;
+  }
+  const official = entry._meta?.["io.modelcontextprotocol.registry/official"];
+  if (official?.status && official.status !== "active") {
+    return null;
+  }
+  if (official?.isLatest === false) {
+    return null;
+  }
+  const remote = server.remotes?.find((candidate) => candidate.type === "streamable-http" && candidate.url);
+  const endpointUrl = validUrl(remote?.url);
+  if (!remote || !endpointUrl) {
+    return null;
+  }
+  const version = server.version ?? "latest";
+  const id = publicRegistryCapabilityId(server.name, version, endpointUrl);
+  const homepageUrl = validUrl(server.websiteUrl) ?? validUrl(server.repository?.url);
+  const requiredHeaders = requiredRemoteHeaders(remote);
+  const mcpServerId = mcpServerIdForCapability(id, {});
+  return CapabilityCatalogItem.parse({
+    id,
+    kind: "mcp",
+    source: "public_registry",
+    name: server.title || server.name,
+    description: server.description ?? null,
+    category: "public-mcp",
+    tags: ["mcp", "public", "registry", ...requiredHeaders.length ? ["requires-credentials"] : []],
+    homepageUrl,
+    endpointUrl,
+    installUrl: homepageUrl,
+    authModel: requiredHeaders.length ? "credential_ref" : null,
+    tools: [{ kind: "mcp", id: mcpServerId }],
+    runtime: {
+      available: true,
+      mcpServerId,
+      transport: "streamable-http",
+      notes: requiredHeaders.length === 0 ? "Remote MCP server from the official MCP Registry." : `This MCP requires credential header(s) ${requiredHeaders.join(", ")} supplied in the enable request.`
+    },
+    metadata: {
+      registry: "official_mcp_registry",
+      registryName: server.name,
+      version,
+      updatedAt: official?.updatedAt,
+      packages: server.packages ?? [],
+      requiredHeaders
+    }
+  });
+}
+function requiredRemoteHeaders(remote) {
+  return (remote.headers ?? []).filter((header) => header.name && header.isRequired !== false).map((header) => header.name.trim()).filter(Boolean);
+}
+function validUrl(value) {
+  if (!value) {
+    return null;
+  }
+  try {
+    return new URL(value).toString();
+  } catch {
+    return null;
+  }
+}
+function catalogSearchText(item) {
+  return [
+    item.name,
+    item.description,
+    item.category,
+    ...item.tags,
+    item.endpointUrl,
+    item.homepageUrl,
+    item.installUrl,
+    JSON.stringify(item.metadata)
+  ].filter(Boolean).join(" ").toLowerCase();
+}
+function capabilityInstallationRuntimeReady(item, installation) {
+  if (!installation || item.kind !== "mcp") {
+    return !!installation;
+  }
+  if (!item.runtime.available) {
+    return false;
+  }
+  if (!storedCredentialHeadersSatisfy(item, installation)) {
+    return false;
+  }
+  const connectivity = installation.metadata.mcpConnectivity;
+  return !!connectivity && typeof connectivity === "object" && "status" in connectivity && connectivity.status === "ok";
+}
+function storedCredentialHeadersSatisfy(item, installation) {
+  const storedNames = new Set(
+    (Array.isArray(installation.config.headerNames) ? installation.config.headerNames : []).filter((name) => typeof name === "string").map((name) => name.toLowerCase())
+  );
+  const required = requiredCapabilityHeaders(item.metadata);
+  if (required.some((name) => !storedNames.has(name.toLowerCase()))) {
+    return false;
+  }
+  return !item.authModel || storedNames.size > 0;
+}
+
+// src/domain/resources.ts
+import {
+  mergeResourceRefs as mergeContractResourceRefs,
+  mergeToolRefs,
+  resourceIdentityKey,
+  ResourceRefConflictError,
+  stableJson
+} from "@opengeni/contracts";
+import {
+  listGitHubInstallationIdsForWorkspace,
+  requireFile
+} from "@opengeni/db";
+import { HTTPException as HTTPException7 } from "hono/http-exception";
+function validateToolRefs(tools, settings) {
+  const mcpServerIds = new Set(settings.mcpServers.map((server) => server.id));
+  const selected = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const tool of tools) {
+    if (tool.kind !== "mcp") {
+      throw new HTTPException7(422, { message: `unsupported tool kind: ${tool.kind}` });
+    }
+    if (!mcpServerIds.has(tool.id)) {
+      throw new HTTPException7(422, { message: `unknown MCP server id: ${tool.id}` });
+    }
+    if (selected.has(tool.id)) {
+      continue;
+    }
+    selected.add(tool.id);
+    out.push({ kind: "mcp", id: tool.id });
+  }
+  return out;
+}
+function enabledCapabilityMcpToolRefs(settings, runtimeSettings) {
+  const configuredIds = new Set(settings.mcpServers.map((server) => server.id));
+  return runtimeSettings.mcpServers.filter((server) => !configuredIds.has(server.id)).map((server) => ({ kind: "mcp", id: server.id, optional: true }));
+}
+function withDefaultEnabledCapabilityMcpTools(tools, settings, runtimeSettings) {
+  return mergeToolRefs(tools, enabledCapabilityMcpToolRefs(settings, runtimeSettings));
+}
+function normalizeResources(resources) {
+  const mountPaths = /* @__PURE__ */ new Map();
+  const identities = /* @__PURE__ */ new Map();
+  const seenResources = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const resource of resources) {
+    let normalized;
+    if (resource.kind === "file") {
+      const mountPath = normalizeMountPath(resource.mountPath ?? `files/${resource.fileId}`);
+      normalized = {
+        kind: "file",
+        fileId: resource.fileId,
+        mountPath
+      };
+    } else {
+      const url = parseResourceUrl(resource.uri);
+      if (url.protocol !== "https:" || !url.hostname) {
+        throw new HTTPException7(422, { message: "repository resources must use HTTPS Git URLs" });
+      }
+      const path = url.pathname.replace(/^\/+|\/+$/g, "").replace(/\.git$/, "");
+      const parts = path.split("/").filter(Boolean);
+      if (parts.length < 2) {
+        throw new HTTPException7(422, { message: "repository URL must include owner and repo" });
+      }
+      const repo = parts.join("/");
+      const mountPath = normalizeMountPath(resource.mountPath ?? `repos/${repo}`);
+      normalized = {
+        kind: "repository",
+        uri: `https://${url.hostname.toLowerCase()}/${repo}.git`,
+        ref: resource.ref.trim(),
+        mountPath,
+        ...resource.subpath ? { subpath: normalizeMountPath(resource.subpath) } : {},
+        ...resource.githubInstallationId ? { githubInstallationId: resource.githubInstallationId } : {},
+        ...resource.githubRepositoryId ? { githubRepositoryId: resource.githubRepositoryId } : {}
+      };
+    }
+    const key = stableJson(normalized);
+    const mounted = normalized.mountPath ? mountPaths.get(normalized.mountPath) : void 0;
+    if (mounted && mounted !== key) {
+      throw new HTTPException7(422, { message: `duplicate resource mount path: ${normalized.mountPath}` });
+    }
+    if (normalized.mountPath) {
+      mountPaths.set(normalized.mountPath, key);
+    }
+    const identity = resourceIdentityKey(normalized);
+    const seenIdentity = identities.get(identity);
+    if (seenIdentity && seenIdentity !== key) {
+      throw new HTTPException7(422, { message: `duplicate resource with different settings: ${identity}` });
+    }
+    identities.set(identity, key);
+    if (!seenResources.has(key)) {
+      seenResources.add(key);
+      out.push(normalized);
+    }
+  }
+  return out;
+}
+function mergeResourceRefs(existing, additions) {
+  try {
+    return mergeContractResourceRefs(existing, additions, { rejectConflicts: true });
+  } catch (error) {
+    if (error instanceof ResourceRefConflictError) {
+      throw new HTTPException7(422, { message: error.message });
+    }
+    throw error;
+  }
+}
+function validateGitHubRepositorySelectionShape(resources) {
+  const selected = resources.flatMap((resource) => {
+    if (resource.kind !== "repository") {
+      return [];
+    }
+    const installationRaw = resource.githubInstallationId;
+    const repositoryRaw = resource.githubRepositoryId;
+    if (installationRaw === null && repositoryRaw === null) {
+      return [];
+    }
+    if (installationRaw === void 0 && repositoryRaw === void 0) {
+      return [];
+    }
+    const installationId2 = positiveInteger(installationRaw);
+    const repositoryId = positiveInteger(repositoryRaw);
+    if (!installationId2 || !repositoryId) {
+      throw new HTTPException7(422, {
+        message: "GitHub App repository resources require positive github_installation_id and github_repository_id"
+      });
+    }
+    return [{ installationId: installationId2, repositoryId }];
+  });
+  if (selected.length === 0) {
+    return null;
+  }
+  const installationId = selected[0].installationId;
+  if (selected.some((item) => item.installationId !== installationId)) {
+    throw new HTTPException7(422, {
+      message: "GitHub App repository resources must belong to one installation"
+    });
+  }
+  return installationId;
+}
+async function validateGitHubRepositorySelection(db, workspaceId, resources) {
+  const installationId = validateGitHubRepositorySelectionShape(resources);
+  if (installationId === null) {
+    return;
+  }
+  const linkedInstallationIds = new Set(await listGitHubInstallationIdsForWorkspace(db, workspaceId));
+  if (!linkedInstallationIds.has(installationId)) {
+    throw new HTTPException7(422, {
+      message: "GitHub App repository resources must belong to a GitHub App installation linked to this workspace"
+    });
+  }
+}
+async function validateFileResources(db, workspaceId, resources) {
+  const fileIds = /* @__PURE__ */ new Set();
+  for (const resource of resources) {
+    if (resource.kind !== "file") {
+      continue;
+    }
+    if (fileIds.has(resource.fileId)) {
+      throw new HTTPException7(422, { message: `duplicate file resource: ${resource.fileId}` });
+    }
+    fileIds.add(resource.fileId);
+    const file = await requireFile(db, workspaceId, resource.fileId).catch(() => null);
+    if (!file) {
+      throw new HTTPException7(422, { message: `unknown file resource: ${resource.fileId}` });
+    }
+    if (file.status !== "ready") {
+      throw new HTTPException7(422, { message: `file resource ${resource.fileId} is ${file.status}` });
+    }
+  }
+}
+function normalizeMountPath(path) {
+  const normalized = path.trim().replace(/^\/+|\/+$/g, "");
+  if (!normalized || normalized.includes("..")) {
+    throw new HTTPException7(422, { message: `invalid resource mount path: ${path}` });
+  }
+  return normalized;
+}
+function parseResourceUrl(uri) {
+  try {
+    return new URL(uri);
+  } catch {
+    throw new HTTPException7(422, { message: "repository resources must use valid URLs" });
+  }
+}
+function positiveInteger(value) {
+  if (typeof value === "number" && Number.isInteger(value) && value > 0) {
+    return value;
+  }
+  if (typeof value === "string" && /^\d+$/.test(value) && Number(value) > 0) {
+    return Number(value);
+  }
+  return null;
+}
+
+// src/domain/scheduled-tasks.ts
+import {
+  createScheduledTask,
+  deleteScheduledTask,
+  getScheduledTask,
+  updateScheduledTask
+} from "@opengeni/db";
+import { HTTPException as HTTPException9 } from "hono/http-exception";
+
+// src/domain/sessions.ts
+import { CODEX_MODEL_ID_PREFIX } from "@opengeni/codex";
+import { configuredAllowedModels } from "@opengeni/config";
+import {
+  CreateSessionRequest,
+  reasoningEffortForMetadata
+} from "@opengeni/contracts";
+import {
+  appendSessionEventsWithLockedSessionUpdate,
+  createSession,
+  createSessionGoal,
+  createSessionWithIdempotencyKey,
+  enqueueSessionTurn,
+  getAnySessionInGroup,
+  getEnrollment as getEnrollment2,
+  listDistinctEnvironmentIdsInGroup,
+  getSandbox as getSandbox3,
+  getSession,
+  getSessionByCreateIdempotencyKey,
+  getSessionTurn,
+  requireSession as requireSession2,
+  setTemporalWorkflowId,
+  updateSessionTitle as updateSessionTitleRow
+} from "@opengeni/db";
+import { appendAndPublishEvents } from "@opengeni/events";
+import { HTTPException as HTTPException8 } from "hono/http-exception";
+async function createAndStartSession(input) {
+  const sessionMetadata = {
+    ...input.metadata,
+    model: input.model,
+    reasoningEffort: input.reasoningEffort
+  };
+  if (input.createIdempotencyKey) {
+    const existing = await getSessionByCreateIdempotencyKey(input.db, input.workspaceId, input.createIdempotencyKey);
+    if (existing) {
+      return existing;
+    }
+    const { session: keyed, created } = await createSessionWithIdempotencyKey(input.db, {
+      accountId: input.accountId,
+      workspaceId: input.workspaceId,
+      initialMessage: input.initialMessage,
+      resources: input.resources,
+      tools: input.tools,
+      metadata: sessionMetadata,
+      model: input.model,
+      sandboxBackend: input.sandboxBackend,
+      environmentId: input.environment?.id ?? null,
+      firstPartyMcpPermissions: input.firstPartyMcpPermissions ?? null,
+      parentSessionId: input.parentSessionId ?? null,
+      createIdempotencyKey: input.createIdempotencyKey,
+      sandboxGroupId: input.sandboxGroupId ?? null,
+      ...input.sandboxOs ? { sandboxOs: input.sandboxOs } : {}
+    });
+    if (!created) {
+      return keyed;
+    }
+    return await finishStartSession(input, keyed);
+  }
+  const session = await createSession(input.db, {
+    accountId: input.accountId,
+    workspaceId: input.workspaceId,
+    initialMessage: input.initialMessage,
+    resources: input.resources,
+    tools: input.tools,
+    metadata: sessionMetadata,
+    model: input.model,
+    sandboxBackend: input.sandboxBackend,
+    environmentId: input.environment?.id ?? null,
+    firstPartyMcpPermissions: input.firstPartyMcpPermissions ?? null,
+    parentSessionId: input.parentSessionId ?? null,
+    sandboxGroupId: input.sandboxGroupId ?? null,
+    ...input.sandboxOs ? { sandboxOs: input.sandboxOs } : {}
+  });
+  return await finishStartSession(input, session);
+}
+async function finishStartSession(input, session) {
+  const goal = input.goal ? await createSessionGoal(input.db, {
+    accountId: session.accountId,
+    workspaceId: session.workspaceId,
+    sessionId: session.id,
+    text: input.goal.text,
+    successCriteria: input.goal.successCriteria ?? null,
+    maxAutoContinuations: input.goal.maxAutoContinuations ?? null,
+    createdBy: "api"
+  }) : null;
+  const initialPayload = {
+    text: input.initialMessage,
+    ...input.resources.length ? { resources: input.resources } : {},
+    ...input.tools.length ? { tools: input.tools } : {}
+  };
+  const events = await appendAndPublishEvents(input.db, input.bus, session.workspaceId, session.id, [
+    {
+      type: "session.created",
+      payload: {
+        status: "queued",
+        ...input.environment ? { environmentId: input.environment.id, environmentName: input.environment.name } : {}
+      }
+    },
+    ...goal ? [{
+      type: "goal.set",
+      payload: {
+        goalId: goal.id,
+        text: goal.text,
+        ...goal.successCriteria ? { successCriteria: goal.successCriteria } : {},
+        version: goal.version,
+        actor: "api",
+        replaced: false
+      }
+    }] : [],
+    {
+      type: "user.message",
+      payload: initialPayload,
+      ...input.clientEventId ? { clientEventId: input.clientEventId } : {}
+    },
+    { type: "session.status.changed", payload: { status: "queued" } }
+  ]);
+  const userEvent = events.find((event) => event.type === "user.message");
+  if (!userEvent) {
+    throw new HTTPException8(500, { message: "failed to append initial user event" });
+  }
+  if (input.seedTargetSandbox) {
+    if (session.sandboxBackend === "none") {
+      throw new HTTPException8(422, {
+        message: "cannot target a machine for a session with no sandbox (backend: none)"
+      });
+    }
+    const ctx = {
+      accountId: session.accountId,
+      workspaceId: session.workspaceId,
+      sessionId: session.id,
+      sessionBackend: session.sandboxBackend,
+      sessionGroupId: session.sandboxGroupId
+    };
+    const seeded = await swapActiveSandbox(
+      { db: input.db, settings: input.seedTargetSandbox.settings, bus: input.bus },
+      ctx,
+      input.seedTargetSandbox.sandboxId,
+      // The working dir is committed in the SAME epoch-fenced CAS that seeds the
+      // pointer, so the first turn routes to the machine AND lands in working_dir.
+      input.seedTargetSandbox.workingDir ?? null
+    );
+    if (!seeded.swapped) {
+      throw new HTTPException8(422, {
+        message: `cannot target sandbox ${input.seedTargetSandbox.sandboxId}: ${seeded.reason ?? "target is not attachable"}`
+      });
+    }
+  }
+  const workflowId = workflowIdForSession(session.id);
+  await setTemporalWorkflowId(input.db, session.workspaceId, session.id, workflowId);
+  const turn = await enqueueSessionTurn(input.db, {
+    accountId: session.accountId,
+    workspaceId: session.workspaceId,
+    sessionId: session.id,
+    triggerEventId: userEvent.id,
+    temporalWorkflowId: workflowId,
+    source: "user",
+    prompt: input.initialMessage,
+    resources: input.resources,
+    tools: input.tools,
+    model: input.model,
+    reasoningEffort: input.reasoningEffort,
+    sandboxBackend: input.sandboxBackend,
+    metadata: {}
+  });
+  await appendAndPublishEvents(input.db, input.bus, session.workspaceId, session.id, [{
+    type: "turn.queued",
+    turnId: turn.id,
+    payload: { turnId: turn.id, triggerEventId: userEvent.id, source: turn.source }
+  }]);
+  await input.workflowClient.wakeSessionWorkflow({ accountId: session.accountId, workspaceId: session.workspaceId, sessionId: session.id, workflowId });
+  return await requireSession2(input.db, session.workspaceId, session.id);
+}
+function workflowIdForSession(sessionId) {
+  return `session-${sessionId}`;
+}
+function assertConfiguredModel(settings, model) {
+  if (model === null || model === void 0) {
+    return;
+  }
+  if (configuredAllowedModels(settings).includes(model)) {
+    return;
+  }
+  if (settings.codexSubscriptionEnabled && model.startsWith(CODEX_MODEL_ID_PREFIX)) {
+    return;
+  }
+  throw new HTTPException8(422, { message: `model is not available: ${model}` });
+}
+async function requireQueuedTurnForApi(db, workspaceId, sessionId, turnId) {
+  const turn = await getSessionTurn(db, workspaceId, turnId);
+  if (!turn || turn.sessionId !== sessionId) {
+    throw new HTTPException8(404, { message: "session turn not found" });
+  }
+  if (turn.status !== "queued") {
+    throw new HTTPException8(409, { message: `turn is ${turn.status}; only queued turns can be changed` });
+  }
+  return turn;
+}
+function reasoningEffortForSession(metadata, fallback) {
+  return reasoningEffortForMetadata(metadata, fallback);
+}
+async function postUserMessageTurn(input) {
+  const { db, bus, workflowClient, settings, accountId, workspaceId, sessionId } = input;
+  const requestedModel = input.model ?? null;
+  const requestedReasoningEffort = input.reasoningEffort ?? null;
+  assertConfiguredModel(settings, requestedModel);
+  const appended = await appendSessionEventsWithLockedSessionUpdate(db, workspaceId, sessionId, (lockedSession) => {
+    if (lockedSession.status === "cancelled") {
+      throw new HTTPException8(409, { message: `session is ${lockedSession.status}; cannot accept a new user message` });
+    }
+    const nextResources = mergeResourceRefs(lockedSession.resources, input.resources);
+    const nextTools = mergeToolRefs(lockedSession.tools, input.tools);
+    const shouldQueueSession = lockedSession.status === "idle" || lockedSession.status === "failed";
+    return {
+      events: [
+        {
+          type: "user.message",
+          payload: {
+            text: input.text,
+            ...input.resources.length ? { resources: input.resources } : {},
+            ...input.tools.length ? { tools: input.tools } : {},
+            ...requestedModel ? { model: requestedModel } : {},
+            ...requestedReasoningEffort ? { reasoningEffort: requestedReasoningEffort } : {}
+          },
+          ...input.clientEventId ? { clientEventId: input.clientEventId } : {}
+        },
+        ...shouldQueueSession ? [{ type: "session.status.changed", payload: { status: "queued" } }] : []
+      ],
+      update: {
+        resources: nextResources,
+        tools: nextTools,
+        ...shouldQueueSession ? { status: "queued", activeTurnId: null } : {}
+      }
+    };
+  }).then(async (events) => {
+    await bus.publish(workspaceId, sessionId, events);
+    return events;
+  });
+  const accepted = appended[0];
+  if (!accepted) {
+    throw new HTTPException8(500, { message: "failed to append client event" });
+  }
+  const workflowId = workflowIdForSession(sessionId);
+  const session = await requireSession2(db, workspaceId, sessionId);
+  const turn = await enqueueSessionTurn(db, {
+    accountId,
+    workspaceId,
+    sessionId,
+    triggerEventId: accepted.id,
+    temporalWorkflowId: workflowId,
+    source: "user",
+    prompt: input.text,
+    resources: input.resources,
+    tools: input.tools,
+    model: requestedModel ?? session.model,
+    reasoningEffort: requestedReasoningEffort ?? reasoningEffortForSession(session.metadata, settings.openaiReasoningEffort),
+    sandboxBackend: session.sandboxBackend,
+    metadata: {}
+  });
+  await appendAndPublishEvents(db, bus, workspaceId, sessionId, [{
+    type: "turn.queued",
+    turnId: turn.id,
+    payload: { turnId: turn.id, triggerEventId: accepted.id, source: turn.source }
+  }]);
+  await workflowClient.wakeSessionWorkflow({ accountId, workspaceId, sessionId, workflowId });
+  return { accepted, turn };
+}
+async function createSessionForRequest(deps, grant, workspaceId, rawPayload) {
+  const { settings, db, bus, workflowClient, objectStorage } = deps;
+  const payload = CreateSessionRequest.parse(rawPayload);
+  const runtimeSettings = await settingsWithEnabledCapabilityMcpServers(db, workspaceId, settings);
+  const resources = normalizeResources(payload.resources);
+  const requestedTools = validateToolRefs(payload.tools, runtimeSettings);
+  const defaultedTools = hasOwnProperty(rawPayload, "tools") ? requestedTools : withDefaultEnabledCapabilityMcpTools(requestedTools, settings, runtimeSettings);
+  const tools = withFirstPartyTools(defaultedTools, runtimeSettings);
+  await validateGitHubRepositorySelection(db, workspaceId, resources);
+  if (resources.some((resource) => resource.kind === "file") && !objectStorage) {
+    throw new HTTPException8(503, { message: "object storage is not configured" });
+  }
+  await validateFileResources(db, workspaceId, resources);
+  const environment = payload.environmentId ? await validateEnvironmentAttachment({ settings, db }, grant, workspaceId, payload.environmentId) : null;
+  assertConfiguredModel(settings, payload.model);
+  const model = payload.model ?? settings.openaiModel;
+  const reasoningEffort = payload.reasoningEffort ?? settings.openaiReasoningEffort;
+  let firstPartyMcpPermissions = payload.firstPartyMcpPermissions ?? null;
+  if (firstPartyMcpPermissions && firstPartyMcpPermissions.length === 0) {
+    throw new HTTPException8(422, { message: "firstPartyMcpPermissions must not be empty; omit it for the default worker permission set" });
+  }
+  for (const permission of firstPartyMcpPermissions ?? []) {
+    if (!hasPermission(grant.permissions, permission)) {
+      throw new HTTPException8(403, { message: `cannot grant first-party MCP permission beyond the creating grant: ${permission}` });
+    }
+  }
+  if (payload.goal && firstPartyMcpPermissions && !firstPartyMcpPermissions.includes("goals:manage")) {
+    firstPartyMcpPermissions = [...firstPartyMcpPermissions, "goals:manage"];
+  }
+  const parentSessionId = typeof grant.metadata?.["sessionId"] === "string" ? grant.metadata["sessionId"] : null;
+  const sandboxChoice = payload.sandbox ?? (parentSessionId ? "shared" : "new");
+  let sandboxGroupId = null;
+  let inheritedBackend;
+  const requestedEnvironmentId = payload.environmentId ?? null;
+  const environmentMatchesGroup = (memberEnvironmentId) => memberEnvironmentId === requestedEnvironmentId;
+  if (sandboxChoice === "shared") {
+    if (!parentSessionId) {
+      throw new HTTPException8(422, { message: "sandbox:'shared' requires a parent session (spawn from inside a session); use 'new' for a top-level create." });
+    }
+    const parent = await getSession(db, workspaceId, parentSessionId);
+    if (!parent) {
+      throw new HTTPException8(404, { message: `parent session not found in workspace: ${parentSessionId}` });
+    }
+    if (parent.sandboxBackend !== "none" && !environmentMatchesGroup(parent.environmentId ?? null)) {
+      if (payload.sandbox === "shared") {
+        throw new HTTPException8(422, { message: "sandbox:'shared' requires the same environment as the creator's box (the box environment is fixed at creation); omit sandbox or pass 'new' when attaching a different environment." });
+      }
+    } else {
+      sandboxGroupId = parent.sandboxGroupId;
+      inheritedBackend = parent.sandboxBackend;
+    }
+  } else if (typeof sandboxChoice === "object") {
+    const member = await getAnySessionInGroup(db, workspaceId, sandboxChoice.groupId);
+    if (!member) {
+      throw new HTTPException8(404, { message: `sandbox group not found in workspace: ${sandboxChoice.groupId}` });
+    }
+    if (member.sandboxBackend !== "none") {
+      const memberEnvironmentIds = await listDistinctEnvironmentIdsInGroup(db, workspaceId, sandboxChoice.groupId);
+      if (!memberEnvironmentIds.every((memberEnvironmentId) => environmentMatchesGroup(memberEnvironmentId))) {
+        throw new HTTPException8(422, { message: `sandbox group ${sandboxChoice.groupId} runs a different environment (the box environment is fixed at creation); create with the group's environment or omit sandbox for an own box.` });
+      }
+    }
+    sandboxGroupId = sandboxChoice.groupId;
+    inheritedBackend = member.sandboxBackend;
+  }
+  if (payload.workingDir !== void 0 && !payload.targetSandboxId) {
+    throw new HTTPException8(422, { message: "workingDir requires targetSandboxId (it is the targeted machine's working directory)" });
+  }
+  let machineHomeBackend;
+  let machineHomeOs;
+  if (payload.targetSandboxId && inheritedBackend === void 0 && settings.sandboxOwnershipEnabled && settings.sandboxSelfhostedEnabled) {
+    const targetSandbox = await getSandbox3(db, workspaceId, payload.targetSandboxId);
+    if (targetSandbox?.kind === "selfhosted") {
+      machineHomeBackend = "selfhosted";
+      if (targetSandbox.enrollmentId) {
+        const enrollment = await getEnrollment2(db, workspaceId, targetSandbox.enrollmentId);
+        if (enrollment && (enrollment.os === "macos" || enrollment.os === "windows" || enrollment.os === "linux")) {
+          machineHomeOs = enrollment.os;
+        }
+      }
+    }
+  }
+  await requireLimit(deps, { accountId: grant.accountId, workspaceId, action: "agent_run:create", quantity: 1, model });
+  const session = await createAndStartSession({
+    db,
+    bus,
+    workflowClient,
+    accountId: grant.accountId,
+    workspaceId,
+    initialMessage: payload.initialMessage,
+    resources,
+    tools,
+    ...payload.clientEventId ? { clientEventId: payload.clientEventId } : {},
+    model,
+    reasoningEffort,
+    // A shared spawn inherits the box's backend; a caller-supplied
+    // sandboxBackend on a shared spawn is ignored (it is the same box). A
+    // machine-targeted top-level create 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,
+    // Mirror the backend relabel on the OS axis: only a machine-targeted
+    // top-level create carries a derived OS; everything else is omitted and the
+    // "linux" default holds (shared spawns keep the parent-box behavior).
+    ...machineHomeOs ? { sandboxOs: machineHomeOs } : {},
+    sandboxGroupId,
+    metadata: payload.metadata,
+    environment: environment ? { id: environment.id, name: environment.name } : null,
+    goal: payload.goal ?? null,
+    firstPartyMcpPermissions,
+    parentSessionId,
+    createIdempotencyKey: payload.idempotencyKey ?? null,
+    // Create-time machine targeting (A-2a): when a target sandbox is named, the
+    // active-sandbox pointer is seeded race-free inside createAndStartSession
+    // (after the row exists, before the first turn dispatches). Validation
+    // (ownership/liveness) lives in swapActiveSandbox; an invalid target 422s.
+    seedTargetSandbox: payload.targetSandboxId ? { sandboxId: payload.targetSandboxId, settings, workingDir: payload.workingDir ?? null } : null
+  });
+  await recordWorkspaceUsage(deps, {
+    accountId: grant.accountId,
+    workspaceId,
+    subjectId: grant.subjectId,
+    eventType: "agent_run.created",
+    quantity: 1,
+    unit: "run",
+    sourceResourceType: "session",
+    sourceResourceId: session.id,
+    idempotencyKey: `agent_run.created:${workspaceId}:${session.id}`
+  });
+  return session;
+}
+async function acceptSessionUserMessage(deps, grant, workspaceId, sessionId, input) {
+  const { settings, db, bus, workflowClient, objectStorage } = deps;
+  const runtimeSettings = await settingsWithEnabledCapabilityMcpServers(db, workspaceId, settings);
+  const requestedResources = normalizeResources(input.resources ?? []);
+  const validatedTools = validateToolRefs(input.tools ?? [], runtimeSettings);
+  const requestedTools = input.toolsProvided ? validatedTools : withDefaultEnabledCapabilityMcpTools(validatedTools, settings, runtimeSettings);
+  const existingSession = await requireSession2(db, workspaceId, sessionId);
+  await requireLimit(deps, {
+    accountId: grant.accountId,
+    workspaceId,
+    action: "agent_run:create",
+    quantity: 1,
+    model: input.model ?? existingSession.model
+  });
+  if (requestedResources.some((resource) => resource.kind === "file") && !objectStorage) {
+    throw new HTTPException8(503, { message: "object storage is not configured" });
+  }
+  await validateFileResources(db, workspaceId, requestedResources);
+  await validateGitHubRepositorySelection(db, workspaceId, [...existingSession.resources, ...requestedResources]);
+  const { accepted, turn } = await postUserMessageTurn({
+    db,
+    bus,
+    workflowClient,
+    settings,
+    accountId: grant.accountId,
+    workspaceId,
+    sessionId,
+    text: input.text,
+    resources: requestedResources,
+    tools: requestedTools,
+    model: input.model ?? null,
+    reasoningEffort: input.reasoningEffort ?? null,
+    ...input.clientEventId ? { clientEventId: input.clientEventId } : {}
+  });
+  await recordWorkspaceUsage(deps, {
+    accountId: grant.accountId,
+    workspaceId,
+    subjectId: grant.subjectId,
+    eventType: "agent_run.created",
+    quantity: 1,
+    unit: "run",
+    sourceResourceType: "session_turn",
+    sourceResourceId: turn.id,
+    idempotencyKey: `agent_run.created:${workspaceId}:${turn.id}`
+  });
+  return { accepted, turn };
+}
+async function updateSessionTitle(deps, workspaceId, sessionId, title, source) {
+  const { db, bus } = deps;
+  const result = await updateSessionTitleRow(db, { workspaceId, sessionId, title, source });
+  if (result.updated) {
+    await appendAndPublishEvents(db, bus, workspaceId, sessionId, [{
+      type: "session.title_set",
+      payload: {
+        title: result.title ?? title,
+        source
+      }
+    }]);
+  }
+  return result;
+}
+function withFirstPartyTools(tools, runtimeSettings) {
+  if (!runtimeSettings.mcpServers.some((server) => server.id === "opengeni")) {
+    return tools;
+  }
+  return mergeToolRefs(tools, [{ kind: "mcp", id: "opengeni" }]);
+}
+function hasOwnProperty(value, key) {
+  return Boolean(value && typeof value === "object" && Object.prototype.hasOwnProperty.call(value, key));
+}
+
+// src/domain/scheduled-tasks.ts
+function scheduledTaskToolsProvided(rawPayload) {
+  if (!rawPayload || typeof rawPayload !== "object") {
+    return false;
+  }
+  const agentConfig = rawPayload.agentConfig;
+  return Boolean(
+    agentConfig && typeof agentConfig === "object" && Object.prototype.hasOwnProperty.call(agentConfig, "tools")
+  );
+}
+async function createValidatedScheduledTask(input) {
+  const agentConfig = await validateScheduledTaskAgentConfig({ ...input, workspaceId: input.grant.workspaceId });
+  const id = crypto.randomUUID();
+  validateScheduledTaskSchedule(input.payload.schedule);
+  if (input.payload.environmentId) {
+    await validateEnvironmentAttachment(
+      { settings: input.settings, db: input.db },
+      input.grant,
+      input.grant.workspaceId,
+      input.payload.environmentId,
+      { preauthorized: input.environmentPreauthorized ?? false }
+    );
+  }
+  return await createScheduledTask(input.db, {
+    id,
+    accountId: input.grant.accountId,
+    workspaceId: input.grant.workspaceId,
+    name: trimmedScheduledTaskName(input.payload.name),
+    status: input.payload.status,
+    schedule: input.payload.schedule,
+    temporalScheduleId: scheduledTaskTemporalScheduleId(id),
+    runMode: input.payload.runMode,
+    overlapPolicy: input.payload.overlapPolicy,
+    agentConfig,
+    environmentId: input.payload.environmentId ?? null,
+    metadata: input.payload.metadata
+  });
+}
+async function validatedScheduledTaskUpdate(input) {
+  const update = {};
+  if (input.payload.name !== void 0) {
+    update.name = trimmedScheduledTaskName(input.payload.name);
+  }
+  if (input.payload.status !== void 0) {
+    update.status = input.payload.status;
+  }
+  if (input.payload.schedule !== void 0) {
+    validateScheduledTaskSchedule(input.payload.schedule);
+    update.schedule = input.payload.schedule;
+  }
+  if (input.payload.runMode !== void 0) {
+    update.runMode = input.payload.runMode;
+  }
+  if (input.payload.overlapPolicy !== void 0) {
+    update.overlapPolicy = input.payload.overlapPolicy;
+  }
+  if (input.payload.metadata !== void 0) {
+    update.metadata = input.payload.metadata;
+  }
+  if (input.payload.environmentId !== void 0) {
+    const nextEnvironmentId = input.payload.environmentId;
+    if ((input.existing.environmentId ?? null) !== (nextEnvironmentId ?? null) && input.existing.runMode === "reusable_session" && input.existing.reusableSessionId) {
+      throw new HTTPException9(409, { message: "cannot change environment of a task with a live reusable session; recreate the task" });
+    }
+    if (nextEnvironmentId === null) {
+      if (input.existing.environmentId !== null) {
+        requirePermission(input.grant, "environments:use");
+      }
+      update.environmentId = null;
+    } else {
+      await validateEnvironmentAttachment(
+        { settings: input.settings, db: input.db },
+        input.grant,
+        input.existing.workspaceId,
+        nextEnvironmentId
+      );
+      update.environmentId = nextEnvironmentId;
+    }
+  }
+  if (input.payload.agentConfig !== void 0) {
+    const willHaveEnvironment = input.payload.environmentId !== void 0 ? input.payload.environmentId !== null : Boolean(input.existing.environmentId);
+    if (willHaveEnvironment) {
+      requirePermission(input.grant, "environments:use");
+    }
+    update.agentConfig = await validateScheduledTaskAgentConfig({
+      settings: input.settings,
+      db: input.db,
+      objectStorage: input.objectStorage,
+      workspaceId: input.existing.workspaceId,
+      payload: { agentConfig: input.payload.agentConfig },
+      ...input.toolsProvided !== void 0 ? { toolsProvided: input.toolsProvided } : {}
+    });
+  }
+  return update;
+}
+async function requireScheduledTaskForApi(db, workspaceId, taskId) {
+  const task = await getScheduledTask(db, workspaceId, taskId);
+  if (!task) {
+    throw new HTTPException9(404, { message: "scheduled task not found" });
+  }
+  return task;
+}
+async function restoreScheduledTask(db, task) {
+  return await updateScheduledTask(db, task.workspaceId, task.id, {
+    name: task.name,
+    status: task.status,
+    schedule: task.schedule,
+    runMode: task.runMode,
+    overlapPolicy: task.overlapPolicy,
+    agentConfig: task.agentConfig,
+    reusableSessionId: task.reusableSessionId,
+    environmentId: task.environmentId,
+    metadata: task.metadata
+  });
+}
+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;
+  }
+}
+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;
+  }
+}
+function scheduledTaskTemporalScheduleId(taskId) {
+  return `scheduled-task-${taskId}`;
+}
+function scheduledTaskTriggerToken(clientTriggerId) {
+  const trimmed = (clientTriggerId ?? "").trim();
+  if (!trimmed) {
+    return crypto.randomUUID();
+  }
+  const safe = trimmed.replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 128);
+  return safe.length > 0 ? safe : crypto.randomUUID();
+}
+function manualScheduledTaskTriggerWorkflowId(taskId, triggerToken) {
+  return `scheduled-task-${taskId}-manual-${triggerToken}`;
+}
+function manualScheduledTaskTriggerUsageKey(workspaceId, taskId, triggerToken) {
+  return `agent_run.created:scheduled-trigger:${workspaceId}:${taskId}:${triggerToken}`;
+}
+async function validateScheduledTaskAgentConfig(input) {
+  assertConfiguredModel(input.settings, input.payload.agentConfig.model);
+  const resources = normalizeResources(input.payload.agentConfig.resources ?? []);
+  const runtimeSettings = await settingsWithEnabledCapabilityMcpServers(input.db, input.workspaceId, input.settings);
+  const requestedTools = validateToolRefs(input.payload.agentConfig.tools ?? [], runtimeSettings);
+  const tools = input.toolsProvided ?? true ? requestedTools : withDefaultEnabledCapabilityMcpTools(requestedTools, input.settings, runtimeSettings);
+  const prompt = input.payload.agentConfig.prompt.trim();
+  if (!prompt) {
+    throw new HTTPException9(422, { message: "scheduled task prompt is required" });
+  }
+  await validateGitHubRepositorySelection(input.db, input.workspaceId, resources);
+  if (resources.some((resource) => resource.kind === "file") && !input.objectStorage) {
+    throw new HTTPException9(503, { message: "object storage is not configured" });
+  }
+  await validateFileResources(input.db, input.workspaceId, resources);
+  return {
+    ...input.payload.agentConfig,
+    prompt,
+    resources,
+    tools
+  };
+}
+function validateScheduledTaskSchedule(schedule) {
+  if (schedule.type !== "interval" || !schedule.startAt || !schedule.endAt) {
+    return;
+  }
+  if (new Date(schedule.startAt).getTime() >= new Date(schedule.endAt).getTime()) {
+    throw new HTTPException9(422, { message: "interval schedule endAt must be after startAt" });
+  }
+}
+function trimmedScheduledTaskName(name) {
+  const trimmed = name.trim();
+  if (!trimmed) {
+    throw new HTTPException9(422, { message: "scheduled task name is required" });
+  }
+  return trimmed;
+}
+
+// src/domain/workspace-members.ts
+import { HTTPException as HTTPException10 } from "hono/http-exception";
+var MEMBER_ADMIN_PERMISSIONS = ["workspace:admin", "members:manage"];
+function memberCanAdminister(member) {
+  return member.permissions.some((permission) => MEMBER_ADMIN_PERMISSIONS.includes(permission));
+}
+function isUserMember(member) {
+  return member.subjectId.startsWith("user:");
+}
+function resolveMemberSubjectId(userId) {
+  if (!userId) {
+    throw new HTTPException10(404, { message: "user is not registered" });
+  }
+  return `user:${userId}`;
+}
+function assertWorkspaceMemberRemovable(input) {
+  const { members, subjectId, callerSubjectId } = input;
+  if (subjectId === callerSubjectId) {
+    throw new HTTPException10(409, { message: "you cannot remove your own membership" });
+  }
+  const target = members.find((member) => member.subjectId === subjectId);
+  if (!target) {
+    throw new HTTPException10(404, { message: "member not found" });
+  }
+  if (memberCanAdminister(target)) {
+    const remainingAdmins = members.filter((member) => member.subjectId !== subjectId && memberCanAdminister(member));
+    if (remainingAdmins.length === 0) {
+      throw new HTTPException10(409, { message: "cannot remove the last member who can manage this workspace" });
+    }
+  }
+}
+function assertWorkspaceDeletable(input) {
+  if (input.workspaceCountForAccount <= 1) {
+    throw new HTTPException10(409, { message: "cannot delete the account's only workspace" });
+  }
+  if (input.activeSessionCount > 0) {
+    throw new HTTPException10(409, {
+      message: "stop the workspace's running sessions before deleting it"
+    });
+  }
+}
+export {
+  MARKETING_SOCIAL_PACK_ID,
+  MAX_ENVIRONMENTS_PER_WORKSPACE,
+  MAX_VARIABLES_PER_ENVIRONMENT,
+  acceptSessionUserMessage,
+  assertAllowedEnvironmentVariableName,
+  assertConfiguredModel,
+  assertPackSandboxImageCompatible,
+  assertWorkspaceDeletable,
+  assertWorkspaceMemberRemovable,
+  buildCapabilityCatalog,
+  buildFleetContextForSession,
+  buildMarketingDailyAnalysisAgentConfig,
+  checkLimit,
+  createAndStartSession,
+  createCatalogItem,
+  createSessionForRequest,
+  createValidatedScheduledTask,
+  disableCapability,
+  discoverMcpRegistryCapabilities,
+  enableCapability,
+  enabledCapabilityMcpToolRefs,
+  getCapabilityPack,
+  hasPermission,
+  isBuiltInCapabilityPack,
+  isUserMember,
+  listCapabilityPacks,
+  listFleet,
+  listWorkspaceCapabilityPacks,
+  manualScheduledTaskTriggerUsageKey,
+  manualScheduledTaskTriggerWorkflowId,
+  memberCanAdminister,
+  mergeResourceRefs,
+  mergeToolRefs,
+  normalizeResources,
+  officialMcpRegistryUrl,
+  postUserMessageTurn,
+  provisionSandbox,
+  reasoningEffortForSession,
+  recordEnvironmentAuditEvent,
+  recordWorkspaceUsage,
+  relayConfigFromSettings,
+  relayDialBaseFromSettings,
+  requireAccessContext,
+  requireAccessGrant,
+  requireEnvironmentEncryption,
+  requireEnvironmentForApi,
+  requireLimit,
+  requirePermission,
+  requireQueuedTurnForApi,
+  requireScheduledTaskForApi,
+  resolveCapabilityPack,
+  resolveMemberSubjectId,
+  restoreScheduledTask,
+  routingEnabled,
+  runOnSandbox,
+  scheduledTaskTemporalScheduleId,
+  scheduledTaskToolsProvided,
+  scheduledTaskTriggerToken,
+  settingsWithEnabledCapabilityMcpServers,
+  settingsWithMcpCapabilityServers,
+  stableJson,
+  swapActiveSandbox,
+  syncCreatedScheduledTask,
+  syncUpdatedScheduledTask,
+  updateSessionTitle,
+  validateEnvironmentAttachment,
+  validateFileResources,
+  validateGitHubRepositorySelection,
+  validateGitHubRepositorySelectionShape,
+  validateMcpCapabilityConnection,
+  validateToolRefs,
+  validatedScheduledTaskUpdate,
+  withDefaultEnabledCapabilityMcpTools,
+  workflowIdForSession,
+  wrapChannelABoxWithRouting
+};
+//# sourceMappingURL=index.js.map