@cat-factory/worker 0.99.0 → 0.99.2

package/dist/infrastructure/container.js

@@ -1,4 +1,4 @@
-import { CompositeNotificationChannel, DEFAULT_MODEL_PRESET_ID, composeTraceSinks, NoopWorkRunner, } from '@cat-factory/kernel';
+import { CompositeNotificationChannel, composeTraceSinks, NoopWorkRunner, } from '@cat-factory/kernel';
 import { AiAgentExecutor, inlineWebSearchOptionsFromEnv, resolveAgentConfig, isProxyableProvider, vendorConcurrencyLimiterFromEnv, } from '@cat-factory/agents';
 import { cloudflareBindingRegistry } from '@cat-factory/provider-cloudflare';
 import { ConfluenceProvider, FigmaProvider, ZeplinProvider, GitHubDocsProvider, GitHubIssuesProvider, JiraProvider, LinearDocumentProvider, LinearTaskProvider, NotionProvider, EMAIL_CIPHER_INFO, PersonalSubscriptionService, ProviderSubscriptionService, RunnerPoolConnectionService, ProvisioningLogRecorder, LoggingRunnerTransport, SLACK_CIPHER_INFO, SlackNotificationChannel, TicketTrackerService, IssueWritebackService, githubIssuesLogic, OBSERVABILITY_CIPHER_INFO, RegistryReleaseHealthProvider, defaultObservabilityRegistry, RegistrySubscriptionQuotaProvider, defaultSubscriptionQuotaRegistry, WorkspaceIncidentEnrichmentProvider, INCIDENT_ENRICHMENT_CIPHER_INFO, AccountSettingsService, ACCOUNT_SETTINGS_CIPHER_INFO, TestSecretsService, TEST_SECRETS_CIPHER_INFO, createEmailSender, } from '@cat-factory/integrations';
@@ -10,11 +10,12 @@ import { ConfluenceProvider, FigmaProvider, ZeplinProvider, GitHubDocsProvider,
 // custom CA (Node/local) — exactly like a private-CA `kubernetes` connection — so on the Worker
 // the kind is offered but a connection to such a cluster fails TLS at run time, not silently.
 import { resolveWorkerRegistries } from './container-registries.js';
-import { AgentContextObservabilityService, SearchQueryObservabilityService, createCore, PACKAGE_REGISTRY_CIPHER_INFO, resolvePackageRegistriesForDispatch, LlmObservabilityService, makeHarnessCallRecorder, resolvePresetModelForKind, } from '@cat-factory/orchestration';
+import { assembleWorkerContainer } from './container-assembly.js';
+import { AgentContextObservabilityService, SearchQueryObservabilityService, PACKAGE_REGISTRY_CIPHER_INFO, resolvePackageRegistriesForDispatch, LlmObservabilityService, makeHarnessCallRecorder, resolvePresetModelForKind, } from '@cat-factory/orchestration';
 import { ISOLATE_SAFE_APP_CACHES_PROFILE, createAppCaches } from '@cat-factory/caching';
 import { createLangfuseSink } from '@cat-factory/observability-langfuse';
 import { createOtelSink } from '@cat-factory/observability-otel';
-import { buildResolveRepoTarget as buildSharedResolveRepoTarget, buildResolveRepoTargets as buildSharedResolveRepoTargets, ContainerEnvConfigRepairer, makeResolveDeployCloneTarget, makeResolveRunRepoContext, RunnerJobClient, makeResolveRepoFilesForCoords, makeResolveBinaryArtifactStore, ensureWorkBranchViaRest, FanOutEventPublisher, InAppNotificationChannel, PatPreferringAppRegistry, runWithInitiator, WebCryptoPasswordHasher, logger, buildInfrastructureCapabilities, testEnvHasZeroConfigDefault, createDefaultWebSearchUpstream, createWebSearchUpstream, createScopedModelProviderResolver, wrapResolverWithLimiter, ENV_HELP, configProblem, GitHubIdentityResolver, resolveUrlSafetyPolicy, resolveWorkspaceCapabilities, noRunnerBackendAvailableError, } from '@cat-factory/server';
+import { buildResolveRepoTarget as buildSharedResolveRepoTarget, buildResolveRepoTargets as buildSharedResolveRepoTargets, ContainerEnvConfigRepairer, makeResolveDeployCloneTarget, makeResolveRunRepoContext, RunnerJobClient, makeResolveRepoFilesForCoords, makeResolveBinaryArtifactStore, ensureWorkBranchViaRest, FanOutEventPublisher, InAppNotificationChannel, PatPreferringAppRegistry, logger, buildInfrastructureCapabilities, createDefaultWebSearchUpstream, createWebSearchUpstream, createScopedModelProviderResolver, wrapResolverWithLimiter, ENV_HELP, configProblem, GitHubIdentityResolver, resolveUrlSafetyPolicy, noRunnerBackendAvailableError, } from '@cat-factory/server';
 import { loadConfig } from './config';
 import { loadLangfuseConfig } from './config/langfuse';
 import { loadObservabilityConfig } from './config/observability';
@@ -22,43 +23,28 @@ import { loadOtelConfig } from './config/otel';
 import { requireDb, requireTelemetryDb } from './env';
 import { baseUrlFor } from './ai/providerEndpoints';
 import { resolveExtraRegistries } from './ai/registries';
-import { DoRealtimeGateway } from './gateways/DoRealtimeGateway';
-import { CfGitHubWebhookIngest, WorkflowsBackfillScheduler } from './gateways/GitHubGateways';
-import { WorkersAiLlmUpstream } from './ai/WorkersAiLlmUpstream';
+import { CfGitHubWebhookIngest } from './gateways/GitHubGateways';
 import { ContainerAgentExecutor, } from './ai/ContainerAgentExecutor';
 import { CloudflareContainerTransport } from './containers/CloudflareContainerTransport';
 import { ContainerInstanceRegistry } from './containers/ContainerInstanceRegistry';
 import { D1LiveContainerRepository } from './repositories/D1LiveContainerRepository';
 import { HttpRunnerPoolProvider } from './runners/HttpRunnerPoolProvider';
 import { D1RunnerPoolConnectionRepository } from './repositories/D1RunnerPoolConnectionRepository';
-import { D1SubscriptionActivationRepository } from './repositories/D1PersonalSubscriptionRepository';
 import { D1UserRepoAccessRepository } from './repositories/D1UserRepoAccessRepository';
-import { D1SealedSecretInventory } from './repositories/D1SealedSecretInventory';
 import { ContainerRepoBootstrapper } from './ai/ContainerRepoBootstrapper';
 import { CompositeAgentExecutor } from './ai/CompositeAgentExecutor';
 import { ContainerSessionService } from './containers/ContainerSessionService';
 import { DurableObjectEventPublisher } from './events/DurableObjectEventPublisher';
-import { DurableObjectMachineEventRelay } from './events/DurableObjectMachineEventRelay';
 import { WorkflowsWorkRunner } from './workflows/WorkflowsWorkRunner';
-import { WorkflowsBootstrapRunner } from './workflows/WorkflowsBootstrapRunner';
-import { WorkflowsEnvConfigRepairRunner } from './workflows/WorkflowsEnvConfigRepairRunner';
-import { WorkflowsEnvironmentTestRunner } from './workflows/WorkflowsEnvironmentTestRunner';
 import { D1BlockRepository } from './repositories/D1BlockRepository';
-import { D1ExecutionRepository } from './repositories/D1ExecutionRepository';
-import { D1PipelineRepository } from './repositories/D1PipelineRepository';
 import { D1ServiceRepository } from './repositories/D1ServiceRepository';
 import { D1WorkspaceMountRepository } from './repositories/D1WorkspaceMountRepository';
-import { D1TokenUsageRepository } from './repositories/D1TokenUsageRepository';
 import { D1LlmCallMetricRepository } from './repositories/D1LlmCallMetricRepository';
 import { D1AgentContextSnapshotRepository } from './repositories/D1AgentContextSnapshotRepository';
 import { D1AgentSearchQueryRepository } from './repositories/D1AgentSearchQueryRepository';
 import { D1ProvisioningLogRepository } from './repositories/D1ProvisioningLogRepository';
 import { D1WorkspaceRepository } from './repositories/D1WorkspaceRepository';
-import { D1WorkspaceMemberRepository } from './repositories/D1WorkspaceMemberRepository';
 import { D1SlackConnectionRepository, D1SlackMemberMappingRepository, D1SlackSettingsRepository, } from './repositories/D1SlackRepositories';
-import { D1AccountRepository } from './repositories/D1AccountRepository';
-import { D1MembershipRepository } from './repositories/D1MembershipRepository';
-import { D1UserRepository } from './repositories/D1UserRepository';
 import { D1AccountInvitationRepository } from './repositories/D1AccountInvitationRepository';
 import { D1PasswordResetTokenRepository } from './repositories/D1PasswordResetTokenRepository';
 import { D1EmailConnectionRepository } from './repositories/D1EmailConnectionRepository';
@@ -75,12 +61,7 @@ import { D1DocumentRepository } from './repositories/D1DocumentRepository';
 import { D1EnvironmentConnectionRepository } from './repositories/D1EnvironmentConnectionRepository';
 import { D1CustomManifestTypeRepository } from './repositories/D1CustomManifestTypeRepository';
 import { D1EnvironmentRegistryRepository } from './repositories/D1EnvironmentRegistryRepository';
-import { D1ReferenceArchitectureRepository } from './repositories/D1ReferenceArchitectureRepository';
 import { D1BootstrapJobRepository } from './repositories/D1BootstrapJobRepository';
-import { D1EnvConfigRepairJobRepository } from './repositories/D1EnvConfigRepairJobRepository';
-import { D1EnvironmentTestRunRepository } from './repositories/D1EnvironmentTestRunRepository';
-import { D1AgentRunRepository } from './repositories/D1AgentRunRepository';
-import { D1PlatformMetricsRepository } from './repositories/D1PlatformMetricsRepository';
 import { D1BinaryArtifactMetadataStore } from './repositories/D1BinaryArtifactMetadataStore';
 import { R2BinaryBlobBackend } from './storage/R2BinaryBlobBackend';
 import { D1RequirementReviewRepository } from './repositories/D1RequirementReviewRepository';
@@ -112,7 +93,7 @@ import { D1ServiceFragmentDefaultsRepository } from './repositories/D1ServiceFra
 // The built-in polling-gate suite (ci / conflicts / post-release-health + on-call). The facade
 // builds an app-owned `GateRegistry` pre-loaded with the suite via `gateRegistryWithBuiltins()`,
 // then wires each gate's provider below.
-import { applyGateProviders, wireCiStatusProvider, wireMergeabilityProvider, wireReleaseHealthProvider, wireIncidentEnrichment, wirePullRequestReviewProvider, wireDocQualityProvider, warnUnwiredGates, } from '@cat-factory/gates';
+import { wireCiStatusProvider, wireMergeabilityProvider, wireReleaseHealthProvider, wireIncidentEnrichment, wirePullRequestReviewProvider, wireDocQualityProvider, } from '@cat-factory/gates';
 import { buildGitLabEngineClient, GitLabIdentityResolver, registerGitLab, StaticGitLabTokenSource, } from '@cat-factory/gitlab';
 import { GitHubDocQualityProvider, GitHubPullRequestReviewProvider } from '@cat-factory/server';
 import { GitHubCiStatusProvider } from './github/GitHubCiStatusProvider';
@@ -198,7 +179,7 @@ function buildResolveWorkspaceModelDefault(db) {
     const repo = new D1ModelPresetRepository({ db });
     return (workspaceId, agentKind, modelPresetId) => resolvePresetModelForKind(repo, workspaceId, agentKind, modelPresetId);
 }
-function selectAgentExecutor(deps) {
+export function selectAgentExecutor(deps) {
     const { env, config, db, agentKindRegistry } = deps;
     const inline = new AiAgentExecutor({
         modelProviderResolver: buildModelProviderResolver(env, db),
@@ -237,7 +218,7 @@ function isTruthy(value) {
  * a multi-model process, persisting + pushing the transcript. Off ⇒ returns `standard`
  * unchanged (no traits, no wrapping), so behaviour is identical to before.
  */
-function maybeWrapConsensus(standard, env, config, db, eventPublisher, agentKindRegistry) {
+export function maybeWrapConsensus(standard, env, config, db, eventPublisher, agentKindRegistry) {
     if (!isTruthy(env.CONSENSUS_ENABLED))
         return standard;
     registerConsensusTraits(agentKindRegistry);
@@ -333,7 +314,7 @@ function buildResolveTransport(deps) {
  * call routes correctly. Callers guard on `config.github.enabled`, which requires
  * GITHUB_APP_PRIVATE_KEY, so the default key is present.
  */
-function buildAppRegistry(env, config, db, clock) {
+export function buildAppRegistry(env, config, db, clock) {
     const installationRepository = new D1GitHubInstallationRepository({ db });
     const makeAuth = (appId, privateKeyPem) => new GitHubAppAuth({
         appId,
@@ -372,7 +353,7 @@ function buildAppRegistry(env, config, db, clock) {
  * behaviour. The shared GitHub sync/webhook services still receive the (pass-through)
  * handle via `createGitHubModule`, so their invalidation code path stays symmetric.
  */
-function buildResolveRepoTarget(db) {
+export function buildResolveRepoTarget(db) {
     return buildSharedResolveRepoTarget({
         installationRepository: new D1GitHubInstallationRepository({ db }),
         repoProjectionRepository: new D1RepoProjectionRepository({ db }),
@@ -437,7 +418,7 @@ function selectEngineVcsClient(env, config, db, clock, idGenerator) {
     }
     return undefined;
 }
-function selectMergeLifecycleDeps(env, config, db, clock, idGenerator, providerRegistry) {
+export function selectMergeLifecycleDeps(env, config, db, clock, idGenerator, providerRegistry) {
     const deps = {
         notificationRepository: new D1NotificationRepository({ db }),
         riskPolicyRepository: new D1RiskPolicyRepository({ db }),
@@ -507,7 +488,7 @@ function selectMergeLifecycleDeps(env, config, db, clock, idGenerator, providerR
  * and (optionally) the PagerDuty / incident.io enrichment providers. Off → the gate is a
  * pass-through and the release-health module isn't built.
  */
-function selectReleaseHealthDeps(env, config, db, providerRegistry) {
+export function selectReleaseHealthDeps(env, config, db, providerRegistry) {
     if (!config.releaseHealth.enabled || !config.releaseHealth.encryptionKey)
         return {};
     const observabilityConnectionRepository = new D1ObservabilityConnectionRepository({ db });
@@ -539,7 +520,7 @@ function selectReleaseHealthDeps(env, config, db, providerRegistry) {
  * to seal/unseal); a workspace with no entries is a no-op. The decrypted entries reach
  * agent containers via the executor's `resolvePackageRegistries` seam.
  */
-function selectPackageRegistryDeps(env, db) {
+export function selectPackageRegistryDeps(env, db) {
     const encryptionKey = env.ENCRYPTION_KEY?.trim();
     if (!encryptionKey)
         return {};
@@ -598,7 +579,7 @@ function buildTestSecretsService(env, db, clock) {
  * workspace-backed provider is wired into the gate suite via `wireIncidentEnrichment`;
  * the connection repo + cipher stay on CoreDependencies to power the management API.
  */
-function selectIncidentEnrichmentDeps(env, db, providerRegistry) {
+export function selectIncidentEnrichmentDeps(env, db, providerRegistry) {
     const encryptionKey = env.ENCRYPTION_KEY?.trim();
     if (!encryptionKey)
         return {};
@@ -722,7 +703,7 @@ function buildSlackChannel(config, db) {
  * the channel composed in by {@link selectMergeLifecycleDeps}. OAuth credentials
  * are optional — manual bot-token onboarding works without them.
  */
-function selectSlackDeps(config, db) {
+export function selectSlackDeps(config, db) {
     const infra = buildSlackInfra(config, db);
     if (!infra)
         return {};
@@ -739,7 +720,7 @@ function selectSlackDeps(config, db) {
  * cipher are wired only when EMAIL is enabled (an encryption key is mandatory), so
  * an account can onboard a SendGrid/Resend key in the UI and have invites emailed.
  */
-function selectEmailInvitationDeps(config, db) {
+export function selectEmailInvitationDeps(config, db) {
     const deps = {
         invitationRepository: new D1AccountInvitationRepository({ db }),
         // Password reset works without email (the link is logged in dev); the system
@@ -814,7 +795,7 @@ function buildOtelSink(otel) {
 function buildTraceSink(config) {
     return composeTraceSinks([buildLangfuseSink(config.langfuse), buildOtelSink(config.otel)]);
 }
-function selectTraceSink(config) {
+export function selectTraceSink(config) {
     const sink = buildTraceSink(config);
     return sink ? { llmTraceSink: sink } : {};
 }
@@ -827,7 +808,7 @@ function selectTraceSink(config) {
  * integration's encryption key is set (so it can read the workspace's stored Jira
  * credentials). With neither, the `tracker` step passes through.
  */
-function selectRecurringDeps(env, config, db, clock, idGenerator) {
+export function selectRecurringDeps(env, config, db, clock, idGenerator) {
     const trackerDeps = {
         trackerSettingsRepository: new D1TrackerSettingsRepository({ db }),
         // workerd exposes a global fetch; the Jira create call uses it.
@@ -1094,7 +1075,7 @@ function buildContainerExecutor(deps) {
  *   - otherwise                   → no-op (e.g. tests, which override this anyway)
  * Tests override `workRunner` with a fake and drive the engine via advanceInstance.
  */
-function selectWorkRunner(env) {
+export function selectWorkRunner(env) {
     if (env.EXECUTION_WORKFLOW) {
         return new WorkflowsWorkRunner({
             workflow: env.EXECUTION_WORKFLOW,
@@ -1123,7 +1104,7 @@ function selectEventPublisher(env, db) {
  * mirroring `selectWorkRunner`. Returns an empty object otherwise, so `createCore`
  * leaves the `github` module unassembled and the feature stays opt-in.
  */
-function selectGitHubDeps(env, config, db, clock, idGenerator, repoFilesCache) {
+export function selectGitHubDeps(env, config, db, clock, idGenerator, repoFilesCache) {
     if (!config.github.enabled) {
         // GitLab-only deployment: the App-shaped connect / projection / provisioning wiring stays
         // off (GitLab ingests via the neutral `/vcs/:provider/webhooks` route), but the checkout-free
@@ -1197,7 +1178,7 @@ function selectGitHubDeps(env, config, db, clock, idGenerator, repoFilesCache) {
  * just needs a provider credential); the planner degrades to its deterministic parser
  * if no model is usable.
  */
-function selectDocumentsDeps(env, config, db, clock, idGenerator) {
+export function selectDocumentsDeps(env, config, db, clock, idGenerator) {
     const providers = [];
     if (config.documents.sources.includes('confluence'))
         providers.push(new ConfluenceProvider());
@@ -1257,7 +1238,7 @@ function selectDocumentsDeps(env, config, db, clock, idGenerator) {
  * structure. Always on (config load fails loudly without the encryption key), so this
  * is wired on every deployment.
  */
-function selectTasksDeps(env, config, db, clock, idGenerator) {
+export function selectTasksDeps(env, config, db, clock, idGenerator) {
     // Jira and Linear are always registered (their credentials are per-workspace, entered in the UI).
     const providers = [new JiraProvider(), new LinearTaskProvider()];
     // GitHub Issues reuse the workspace's installed GitHub App, so this provider is
@@ -1300,7 +1281,7 @@ function selectTasksDeps(env, config, db, clock, idGenerator) {
  * heading-based planner: that planner only engages when `documentPlannerModel` is
  * also set, which this does not touch.)
  */
-function selectRequirementsDeps(env, config, db) {
+export function selectRequirementsDeps(env, config, db) {
     return {
         requirementReviewRepository: new D1RequirementReviewRepository({ db }),
         docInterviewRepository: new D1DocInterviewRepository({ db }),
@@ -1326,7 +1307,7 @@ function selectRequirementsDeps(env, config, db) {
  * id like a pipeline step). Mirrored by the Node facade's `createDrizzleSandboxDeps`
  * (a Postgres `sandbox` schema).
  */
-function selectSandboxDeps(sandboxDb) {
+export function selectSandboxDeps(sandboxDb) {
     if (!sandboxDb)
         return {};
     return {
@@ -1346,7 +1327,7 @@ function selectSandboxDeps(sandboxDb) {
  * enable flag: whether a workspace provisions anything is decided by its registered
  * connection + whether its pipeline runs a `deployer`/`tester` step.
  */
-function selectEnvironmentsDeps(env, config, db) {
+export function selectEnvironmentsDeps(env, config, db) {
     if (!config.environments.encryptionKey)
         return {};
     // The provider is resolved per-workspace from the env-backend registry by the stored
@@ -1385,7 +1366,7 @@ function selectEnvironmentsDeps(env, config, db) {
  * REST path is unaffected), exactly the unwired behaviour slice 9 shipped. Mirrors Node's pool
  * deploy wiring; the deploy container is the Worker's analogue of Node's self-hosted pool.
  */
-function selectDeployDeps(env, config, db, clock) {
+export function selectDeployDeps(env, config, db, clock) {
     if (!config.environments.encryptionKey ||
         !env.DEPLOY_CONTAINER ||
         !config.github.enabled ||
@@ -1411,7 +1392,7 @@ function selectDeployDeps(env, config, db, clock) {
  * `Core.runners` (the connection-management API); the per-job transport selection
  * lives in `buildResolveTransport` above. Returns `{}` when disabled.
  */
-function selectRunnersDeps(env, config, db) {
+export function selectRunnersDeps(env, config, db) {
     if (!config.runners.enabled)
         return {};
     const urlPolicy = resolveUrlSafetyPolicy(config.runners);
@@ -1437,7 +1418,7 @@ function selectRunnersDeps(env, config, db) {
  * undefined otherwise, leaving reference-architecture CRUD available while the run
  * path reports itself unavailable.
  */
-function selectRepoBootstrapper(env, config, db, clock, idGenerator, resolveTransport) {
+export function selectRepoBootstrapper(env, config, db, clock, idGenerator, resolveTransport) {
     if (!resolveTransport ||
         !config.github.enabled ||
         !env.GITHUB_APP_PRIVATE_KEY ||
@@ -1483,7 +1464,7 @@ function selectRepoBootstrapper(env, config, db, clock, idGenerator, resolveTran
  * provider the engine validates with. NOT to be confused with the repo bootstrapper: this
  * is an ordinary clone→edit→push coding job (no history reset / force-push).
  */
-function selectEnvConfigRepairer(deps) {
+export function selectEnvConfigRepairer(deps) {
     const { env, config, db, clock, resolveTransport, override, environmentBackendRegistry } = deps;
     const repairUrlPolicy = resolveUrlSafetyPolicy(config.environments);
     // Prefer the internal override (the conformance suite's fake repair provider) else scan
@@ -1533,7 +1514,7 @@ function selectEnvConfigRepairer(deps) {
  * tier's GitHub installation. Returns `{}` when disabled, so `createCore` leaves
  * the `fragmentLibrary` module unassembled and the engine uses manual fragmentIds.
  */
-function selectFragmentLibraryDeps(env, config, db) {
+export function selectFragmentLibraryDeps(env, config, db) {
     if (!config.fragmentLibrary.enabled)
         return {};
     const installationRepository = new D1GitHubInstallationRepository({ db });
@@ -1566,7 +1547,7 @@ function selectFragmentLibraryDeps(env, config, db) {
  * flag as the fragment library (both are the repo-sourced prompt library). Returns
  * `{}` when disabled, so `createCore` leaves the skill module unassembled.
  */
-function selectSkillLibraryDeps(_env, config, db) {
+export function selectSkillLibraryDeps(_env, config, db) {
     if (!config.fragmentLibrary.enabled)
         return {};
     const installationRepository = new D1GitHubInstallationRepository({ db });
@@ -1589,7 +1570,7 @@ function selectSkillLibraryDeps(_env, config, db) {
  * facade's `buildNodeVcsIdentityRegistry` per "keep the runtimes symmetric": a GitLab-only Worker
  * deployment must let a GitLab user sign in, not just gate/merge on GitLab under the hood.
  */
-function buildWorkerVcsIdentityRegistry(config) {
+export function buildWorkerVcsIdentityRegistry(config) {
     const registry = {
         github: { resolver: new GitHubIdentityResolver({ apiBase: config.github.apiBase, logger }) },
     };
@@ -1785,340 +1766,46 @@ export function buildContainer(env, overrides = {}, opts = {}) {
     // once so the engine's skill-freshness fan-out (slice 4) enqueues through the SAME seam the
     // gateway exposes, rather than reaching for the queue binding a second time.
     const githubWebhookIngest = new CfGitHubWebhookIngest(env.GITHUB_SYNC_QUEUE);
-    const dependencies = {
-        // App-owned backend registries (kind → provider) the connection services resolve through.
-        environmentBackendRegistry,
-        runnerBackendRegistry,
-        // The code-defined custom provision-type catalog, merged with the workspace rows by
-        // `listCustomTypes` so a programmatically-registered type surfaces in the infra editor + the
-        // per-service provisioning picker.
-        customManifestTypeRegistry,
-        // Resolves the per-account binary-artifact store (screenshots) for the
-        // visual-confirmation gate; resolving to null ⇒ the gate passes through.
-        resolveBinaryArtifactStore,
-        workspaceRepository: new D1WorkspaceRepository({ db }),
-        workspaceMemberRepository: new D1WorkspaceMemberRepository({ db }),
-        accountRepository: new D1AccountRepository({ db }),
-        membershipRepository: new D1MembershipRepository({ db }),
-        userRepository: new D1UserRepository({ db }),
-        passwordHasher: new WebCryptoPasswordHasher(),
-        blockRepository: new D1BlockRepository({ db }),
-        pipelineRepository: new D1PipelineRepository({ db }),
-        executionRepository: new D1ExecutionRepository({ db, clock }),
-        // Clear a finished run's personal-credential activation promptly (TTL sweep is the backstop).
-        subscriptionActivationRepository: new D1SubscriptionActivationRepository({ db }),
-        serviceRepository: new D1ServiceRepository({ db }),
-        workspaceMountRepository: new D1WorkspaceMountRepository({ db }),
-        tokenUsageRepository: new D1TokenUsageRepository({ db }),
-        // Telemetry lives in the dedicated TELEMETRY_DB database.
-        llmCallMetricRepository: new D1LlmCallMetricRepository({ db: telemetryDb }),
-        // Deployment-level rollups over `agent_runs` (MAIN db, not telemetry) for the operator dashboard.
-        platformMetricsRepository: new D1PlatformMetricsRepository({ db }),
-        // Unified provisioning event log (separate D1 binding). Threads the recorder into
-        // the env services and exposes the read service for the logs controller; undefined
-        // when PROVISIONING_DB isn't bound.
-        ...(provisioningLogRepository ? { provisioningLogRepository } : {}),
-        recordLlmPrompts: config.observability.recordPrompts,
-        // Re-exposed on the core for the agent-context read endpoint; the same instance is
-        // injected into the container executor below for the write path.
-        agentContextObservability,
-        // Re-exposed on the core for the search-query read endpoint AND the search proxy's
-        // write path (it reads it off the request container).
-        searchQueryObservability,
-        idGenerator,
-        clock,
-        // When a caller injects its own agentExecutor (tests pass a FakeAgentExecutor)
-        // skip selection entirely — selectAgentExecutor throws when a sandbox is opted
-        // in but its prerequisites are missing, which is the desired loud failure in
-        // production but must not fire for tests that never reach the real executor.
-        agentExecutor: overrides.agentExecutor ??
-            maybeWrapConsensus(selectAgentExecutor({
-                env,
-                config,
-                db,
-                clock,
-                resolveTransport,
-                agentKindRegistry,
-                subscriptions,
-                personalSubscriptions,
-                agentContextObservability,
-            }), env, config, db, eventPublisher, agentKindRegistry),
-        agentKindRegistry,
-        // The app-owned gate + step-resolver registries; the engine's gate machine + completion hub
-        // read them, and the gate registry is re-exposed on Core for the boot-time validation.
-        gateRegistry,
-        stepResolverRegistry,
-        // The app-owned provider registry the gate providers were wired onto above; the engine's gate
-        // machine reads the SAME instance through its GateContext.
-        providerRegistry,
-        initiativePresetRegistry,
-        workRunner: selectWorkRunner(env),
-        executionEventPublisher: eventPublisher,
-        spendPricing: config.spend,
-        // Price metered dynamic OpenRouter models at their real per-model rate (not the
-        // bare-`openrouter` fallback) using this workspace's enabled catalog.
-        dynamicModelPricesFor: openRouterCatalog
-            ? (ws) => openRouterCatalog.capabilitiesFor(ws)
-            : undefined,
-        // Repo-bootstrap repositories are wired unconditionally (reference-architecture
-        // CRUD is always available); the run path additionally needs the bootstrapper.
-        referenceArchitectureRepository: new D1ReferenceArchitectureRepository({ db }),
-        bootstrapJobRepository: new D1BootstrapJobRepository({ db }),
-        repoBootstrapper: selectRepoBootstrapper(env, config, db, clock, idGenerator, resolveTransport),
-        // Durably drive each bootstrap run's poll loop when the Workflows binding is
-        // present (mirrors the execution driver); without it a run still dispatches.
-        bootstrapRunner: env.BOOTSTRAP_WORKFLOW
-            ? new WorkflowsBootstrapRunner(env.BOOTSTRAP_WORKFLOW)
-            : undefined,
-        // Env-config-repair runs share the unified `agent_runs` table (kind-scoped). The
-        // job repository is wired unconditionally; the repairer (the agent fallback) is wired
-        // post-overrides below over the FINAL provider, and the durable runner when its
-        // Workflows binding is present (else the cron sweep re-drives a run left running).
-        envConfigRepairJobRepository: new D1EnvConfigRepairJobRepository({ db }),
-        envConfigRepairRunner: env.ENV_CONFIG_REPAIR_WORKFLOW
-            ? new WorkflowsEnvConfigRepairRunner(env.ENV_CONFIG_REPAIR_WORKFLOW)
-            : undefined,
-        // The ephemeral-environment self-test: its own run store + the durable driver when the
-        // Workflows binding is present. The Workflow self-finalizes on poll-budget exhaustion,
-        // and the cron `sweepStuckEnvTests` (index.ts scheduled) is the backstop for a lost or
-        // terminal instance — the run store is not agent_runs, so the unified run sweep never
-        // covers it.
-        environmentTestRunRepository: new D1EnvironmentTestRunRepository({ db }),
-        environmentTestRunner: env.ENV_TEST_WORKFLOW
-            ? new WorkflowsEnvironmentTestRunner(env.ENV_TEST_WORKFLOW)
-            : undefined,
-        ...selectGitHubDeps(env, config, db, clock, idGenerator, caches.repoFiles),
-        ...selectMergeLifecycleDeps(env, config, db, clock, idGenerator, providerRegistry),
-        // A fresh workspace's model-preset library is seeded with Kimi K2.7 as the default
-        // (Cloudflare-runnable on the bare AI binding). A deployment overrides the out-of-the-box
-        // default by passing `defaultModelPresetId` through `createApp`'s / `buildContainer`'s
-        // `overrides` (a `Partial<CoreDependencies>` field). Read explicitly here — rather than
-        // relying on the trailing `...overrides` spread — so the seam stays legible and robust to a
-        // future reorder. Applied only at first seed, so a user's later manual default choice wins.
-        defaultModelPresetId: overrides.defaultModelPresetId ?? DEFAULT_MODEL_PRESET_ID,
-        ...selectReleaseHealthDeps(env, config, db, providerRegistry),
-        // Fold the service frame's SENSITIVE test-credential refs (key + description, never values)
-        // into the tester prompt; present only when ENCRYPTION_KEY is set.
-        ...(testSecretsService
-            ? {
-                resolveTestSecretRefs: (workspaceId, blockId) => testSecretsService.resolveRefsForBlock(workspaceId, blockId),
-            }
-            : {}),
-        ...selectIncidentEnrichmentDeps(env, db, providerRegistry),
-        ...selectPackageRegistryDeps(env, db),
-        ...(accountSettings ? { accountSettings } : {}),
-        ...selectSlackDeps(config, db),
-        ...selectEmailInvitationDeps(config, db),
-        ...selectTraceSink(config),
-        ...selectRecurringDeps(env, config, db, clock, idGenerator),
-        ...selectDocumentsDeps(env, config, db, clock, idGenerator),
-        ...selectTasksDeps(env, config, db, clock, idGenerator),
-        ...selectRequirementsDeps(env, config, db),
-        ...selectSandboxDeps(env.SANDBOX_DB),
-        ...selectEnvironmentsDeps(env, config, db),
-        ...selectDeployDeps(env, config, db, clock),
-        ...selectRunnersDeps(env, config, db),
-        ...selectFragmentLibraryDeps(env, config, db),
-        ...selectSkillLibraryDeps(env, config, db),
-        // Push-webhook skill-source freshness fan-out (slice 4): resync affected sources via the
-        // sync Queue. No queue bound (local/dev) ⇒ no proactive resync; the dispatch-time probe
-        // is the freshness backstop.
-        enqueueSkillResync: async ({ accountId, sourceId }) => {
-            await githubWebhookIngest.queueSkillResync(accountId, sourceId);
-        },
-        // The app-owned cache bag (built above so the repo-files + account-policy resolvers share
-        // it). Distributed invalidation is a genuine Node-only concern, not a facade-parity gap: the
-        // Worker's cross-instance state already lives in globally-addressed DOs / D1.
-        caches,
-        // The pipeline-start guard resolves what's configured for a workspace + initiator.
-        resolveProviderCapabilities: (workspaceId, initiatedBy) => resolveWorkspaceCapabilities({
-            apiKeys,
-            subscriptions,
-            personalSubscriptions,
-            cloudflareModelsEnabled,
-            baseUrlFor: (provider) => baseUrlFor(provider, env),
-            localModelEndpoints,
-            openRouterCatalog,
-            accountSettings,
-            workspaceAccountOf: (workspaceId) => new D1WorkspaceRepository({ db }).accountOf(workspaceId),
-            modelPolicySupported: config.infrastructure?.modelPolicy?.supported ?? false,
-            caches,
-        }, workspaceId, initiatedBy),
-        // Run the engine's gate-probe / merge GitHub reads under the run initiator's ambient
-        // context, so a per-user PAT (when set) is preferred over the App token.
-        runInitiatorScope: runWithInitiator,
-        ...overrides,
-    };
-    // Wire the live env-config repair agent over the FINAL environment provider (after the
-    // `...overrides` above), so a native adapter injected via overrides — not the default
-    // manifest provider — is the one the repair dispatcher uses. Unwired on a stock deployment
-    // (the generic provider has no `describeRepairAgent`), exactly like the service guard.
-    const envConfigRepairer = selectEnvConfigRepairer({
+    return assembleWorkerContainer({
         env,
         config,
         db,
+        telemetryDb,
         clock,
-        resolveTransport,
-        override: dependencies.environmentProvider,
-        environmentBackendRegistry,
-    });
-    // Don't clobber an override-provided repairer (e.g. the conformance suite's fake): an
-    // explicit `overrides.envConfigRepairer` wins, exactly like `repoBootstrapper`.
-    if (envConfigRepairer && !dependencies.envConfigRepairer) {
-        dependencies.envConfigRepairer = envConfigRepairer;
-    }
-    // Apply any test-injected gate providers LAST, so they override the config wiring done by the
-    // `select*Deps` spreads above (the conformance suite drives the externalized CI gate over a
-    // faked verdict). Production leaves `gateProviders` undefined, so this is a no-op outside tests.
-    applyGateProviders(providerRegistry, opts.gateProviders);
-    // Surface any gate left as a silent pass-through (no provider wired) so a misconfigured
-    // deployment is visible in the logs instead of quietly auto-merging without checking CI.
-    warnUnwiredGates(providerRegistry, logger);
-    // The unified `agent_runs` reader (kind-spanning) — surfaced on the container for
-    // `AgentRunController` AND folded into the mothership `repositories` registry below (it is the
-    // one repo not carried by `CoreDependencies`). One instance shared by both.
-    const agentRunRepository = new D1AgentRunRepository({ db });
-    return {
-        ...createCore(dependencies),
-        config,
-        // The deployment-wide trusted web-search upstream (built from this facade's own `WEB_SEARCH_*`
-        // env), read by `WebSearchProxyController` as the fallback when a run's account has no keys.
-        // Surfaced on the ServerContainer here (not part of `CoreDependencies`, so `createCore` doesn't
-        // carry it) — kept symmetric with the Node facade.
-        ...(defaultWebSearchUpstream ? { defaultWebSearchUpstream } : {}),
-        // Hosted source-control PAT login: a user signs in with their OWN GitHub/GitLab PAT (the
-        // shared `/auth/pat` flow resolves it to an account, held to the login/org/domain allowlist).
-        // GitHub always; GitLab when configured. Mirrors the Node facade so a GitLab-only Worker
-        // deployment lets a GitLab user sign in (previously the Worker wired none, leaving it
-        // OAuth-only / GitHub-only for sign-in even though the engine gated/merged on GitLab).
-        vcsIdentity: buildWorkerVcsIdentityRegistry(config),
-        // The app-owned VCS provider registry the neutral webhook route resolves a provider from.
-        vcsRegistry,
-        // The same checkout-free repo resolver the engine binds pre/post-ops with, surfaced so
-        // the shared service-spec read controller can read the `spec/` artifact off main.
-        resolveRunRepoContext: dependencies.resolveRunRepoContext,
-        // The block→service→repo resolver, surfaced so the task-search controller can scope a
-        // GitHub-issue search to the originating service's repo (and refuse it when unlinked).
-        resolveRepoTarget: buildResolveRepoTarget(db),
-        agentRunRepository,
-        // Execution-scoped repo, surfaced for the conformance suite's compareAndSwap parity check.
-        executionRepository: dependencies.executionRepository,
-        // Mothership-side GitHub token delegation (`POST /internal/github/installation-token`):
-        // when this deployment's GitHub App is configured, a machine-authed mothership-mode node
-        // can mint the short-lived installation tokens its agent containers/gates need — the App
-        // private key never leaves this Worker. The registry satisfies the seam structurally.
-        // Wired symmetrically on the Node facade.
-        ...(config.github.enabled
-            ? { githubTokenDelegation: buildAppRegistry(env, config, db, clock) }
-            : {}),
-        // Mothership-side real-time UPSTREAM delivery (`POST /internal/events/publish`): when this
-        // Worker is a mothership (its WORKSPACE_EVENTS hub is bound), a machine-authed mothership-mode
-        // node's relayed engine events are injected into the per-workspace WorkspaceEventsHub Durable
-        // Object, so hosted teammates on the shared board see the local node's activity live. Wired
-        // symmetrically on the Node facade (the in-process hub / propagator). Absent binding ⇒ the
-        // endpoint 503s.
-        ...(env.WORKSPACE_EVENTS
-            ? { machineEventRelay: new DurableObjectMachineEventRelay(env.WORKSPACE_EVENTS) }
-            : {}),
-        // The repository registry the mothership-mode machine API (`/internal/persistence`) reflects
-        // over, so a Cloudflare deployment can act as a mothership for mothership-mode local nodes.
-        // The controller gates which repo+method is callable (allow-list) and account-scopes each
-        // call; exposing the whole `dependencies` (which carries every repo under its canonical name)
-        // is safe. `agentRunRepository` is the one repo NOT part of `CoreDependencies` (the engine's
-        // Core never reads it — it's surfaced separately above for `AgentRunController`), so fold it
-        // in explicitly, else the board's retry/stop `getRef` call comes back `... is not wired`.
-        // Sourced identically on both facades so they attach the same registry surface.
-        repositories: {
-            ...dependencies,
-            agentRunRepository,
-            // The binary-artifact METADATA store (visual-confirmation gate screenshots/references) is
-            // not part of `CoreDependencies` (it's composed into `resolveBinaryArtifactStore`, not the
-            // engine's Core), so fold it into the reflected registry explicitly — else a mothership-mode
-            // node's artifact reads/writes come back `... is not wired`. The blob BYTES stay per-account
-            // local; only the metadata is proxied.
-            binaryArtifactMetadataStore: new D1BinaryArtifactMetadataStore({ db }),
-            // The sensitive per-service test-credential store is org/durable state the engine reads via
-            // the `resolveTestSecretRefs` FUNCTION (never the repo directly), so it isn't in
-            // `CoreDependencies` either — fold it in explicitly, else a mothership-mode node's tester
-            // run-path read + the inspector CRUD come back `... is not wired`. Only the SEALED blob is
-            // proxied (decrypted service-side under the LOCAL key), like the observability/runner-pool
-            // connections.
-            testSecretsRepository: new D1TestSecretsRepository({ db }),
-            // GitHub projection + installation reads the mothership serves over the persistence RPC even
-            // when its OWN github service is off. A mothership-mode local node reaches GitHub by token
-            // DELEGATION (no local App), which enables `container.github`, so its board snapshot
-            // (`github.service.listRepos` → `repoProjectionRepository.list`) and run-path repo resolution
-            // (`githubInstallationRepository.getByWorkspace` + `repoProjectionRepository.list`) read the
-            // projection over RPC. Both are plain org tables the mothership owns (`selectGitHubDeps`
-            // folds them into `dependencies` only when the App is configured), so reflect them regardless
-            // of `config.github.enabled`, else a mothership without its own App 500s that board load with
-            // `... is not wired`. Allow-listed in `REMOTE_PERSISTENCE_METHODS`; folded in explicitly like
-            // the stores above. Sourced identically on both facades.
-            repoProjectionRepository: new D1RepoProjectionRepository({ db }),
-            githubInstallationRepository: new D1GitHubInstallationRepository({ db }),
+        idGenerator,
+        caches,
+        overrides,
+        gateProviders: opts.gateProviders,
+        cloudflareModelsEnabled,
+        registries: {
+            environmentBackendRegistry,
+            runnerBackendRegistry,
+            customManifestTypeRegistry,
+            userSecretKindRegistry,
+            agentKindRegistry,
+            gateRegistry,
+            stepResolverRegistry,
+            initiativePresetRegistry,
+            vcsRegistry,
+            providerRegistry,
         },
-        // App-owned backend registries, surfaced so the workspace snapshot's backend-kind
-        // selectors (`environmentBackendKinds` / `runnerBackendKinds`) read the registered kinds.
-        environmentBackendRegistry,
-        runnerBackendRegistry,
-        // The consensus transcript store, for the read endpoint (the SPA window's initial
-        // load / reload). Always wired; live updates ride the `consensus` workspace event.
-        consensusSessionRepository: new D1ConsensusSessionRepository({ db }),
-        // Resolves the per-account binary-artifact store (screenshots) for the artifact
-        // controllers + the visual-confirmation gate (configured per-account in the UI).
-        resolveBinaryArtifactStore,
-        // The Worker's only test-env backend is the `environment-provider` (its UI-test container is
-        // torn down with the run — no long-lived in-container compose default), so a missing provider
-        // IS a real gap the "test environment not configured" banner should surface. Derived from the
-        // capability descriptor for symmetry with the Node facade (`testEnvHasZeroConfigDefault`).
-        ephemeralEnvironmentsRequireProvider: !testEnvHasZeroConfigDefault(config.infrastructure),
-        // The sensitive per-service test-credential store the shared test-secrets controller reads;
-        // present when the shared ENCRYPTION_KEY is configured.
-        ...(testSecretsService ? { testSecrets: testSecretsService } : {}),
-        // The vendor-credential (subscription token pool) service the shared controller
-        // reads; present when the shared ENCRYPTION_KEY is configured.
+        provisioningLogRepository,
+        resolveTransport,
         subscriptions,
-        // The per-user individual-usage subscription store (Claude); present when the
-        // shared ENCRYPTION_KEY is configured.
+        testSecretsService,
         personalSubscriptions,
-        // The direct-provider API-key pool (account/workspace/user); present when the
-        // shared ENCRYPTION_KEY is configured.
         apiKeys,
-        // The inbound public-API key store; present when the shared ENCRYPTION_KEY is configured.
         publicApiKeys,
-        // Whether the opt-in Cloudflare Workers AI lib is enabled (the `AI` binding).
-        cloudflareModelsEnabled,
-        // The direct-provider base-URL resolver the catalog uses to gate selectability on a
-        // resolvable endpoint (e.g. LiteLLM stays unselectable until LITELLM_BASE_URL is set).
-        baseUrlFor: (provider) => baseUrlFor(provider, env),
-        // The per-user locally-run model endpoints store; present when ENCRYPTION_KEY is set.
         localModelEndpoints,
-        // The per-user generic secret store (GitHub PAT, …); present when ENCRYPTION_KEY is set.
         userSecrets,
-        // The per-user "repos my PAT can reach" projection (board redaction + picker expansion).
-        userRepoAccess: new D1UserRepoAccessRepository({ db }),
-        // The sealed-secret inventory the key-drift sweep + drop remediation use (ADR 0026 D6.2/D6.3);
-        // gated on ENCRYPTION_KEY (no key ⇒ nothing is sealed to scan).
-        ...(env.ENCRYPTION_KEY?.trim()
-            ? { sealedSecretInventory: new D1SealedSecretInventory({ db }) }
-            : {}),
-        // The per-workspace OpenRouter dynamic-catalog store; present when the API-key pool is.
         openRouterCatalog,
-        gateways: {
-            // Real-time event delivery via the per-workspace WorkspaceEventsHub DO (when
-            // the WORKSPACE_EVENTS namespace is bound; absent → the events route 501s).
-            realtime: new DoRealtimeGateway(env.WORKSPACE_EVENTS),
-            // GitHub backfill via Workflows; webhook/resync ingest via the sync Queue. Both
-            // fall back to inline handling when their binding is absent (local/dev/tests).
-            githubBackfill: new WorkflowsBackfillScheduler(env.GITHUB_BACKFILL_WORKFLOW),
-            githubWebhook: githubWebhookIngest,
-            // LLM proxy upstream: OpenAI-compatible providers from env keys + the in-process
-            // Workers AI binding path (the `workers-ai` provider).
-            llmUpstream: new WorkersAiLlmUpstream(env),
-            // Container web-search upstream is resolved per-account by the proxy controller
-            // (keys moved out of env into the per-account settings store), so no boot-time
-            // gateway upstream is wired here.
-        },
-    };
+        eventPublisher,
+        agentContextObservability,
+        searchQueryObservability,
+        accountSettings,
+        defaultWebSearchUpstream,
+        resolveBinaryArtifactStore,
+        githubWebhookIngest,
+    });
 }
 //# sourceMappingURL=container.js.map