@cat-factory/orchestration 0.6.0

package/dist/container.js

@@ -0,0 +1,657 @@
+import { ServiceMountService } from './modules/services/ServiceMountService.js';
+import { NoopWorkRunner } from '@cat-factory/kernel';
+import { NoopEventPublisher } from '@cat-factory/kernel';
+import { BoardService } from './modules/board/BoardService.js';
+import { ExecutionService } from './modules/execution/ExecutionService.js';
+import { PipelineService } from './modules/pipelines/PipelineService.js';
+import { WorkspaceService } from '@cat-factory/workspaces';
+import { AccountService } from '@cat-factory/workspaces';
+import { UserService } from '@cat-factory/workspaces';
+import { InvitationService } from '@cat-factory/workspaces';
+import { EmailConnectionService } from '@cat-factory/integrations';
+import { SpendService, DEFAULT_SPEND_PRICING } from '@cat-factory/spend';
+import { LlmObservabilityService } from './modules/observability/LlmObservabilityService.js';
+import { GitHubInstallationService, RepoProvisioningService, GitHubService, GitHubSyncService, WebhookService, DocumentConnectionService, DocumentImportService, DocumentPlannerService, DocumentLinkService, MapDocumentSourceRegistry, TaskConnectionService, TaskImportService, TaskLinkService, MapTaskSourceRegistry, EnvironmentConnectionService, EnvironmentProvisioningService, EnvironmentTeardownService, RunnerPoolConnectionService, SlackConnectionService, SlackSettingsService, SlackMemberMappingService, } from '@cat-factory/integrations';
+import { BootstrapService } from './modules/bootstrap/BootstrapService.js';
+import { BoardScanService } from './modules/boardScan/BoardScanService.js';
+import { RequirementReviewService } from './modules/requirements/RequirementReviewService.js';
+import { ClarityReviewService } from './modules/clarity/ClarityReviewService.js';
+import { NotificationService } from './modules/notifications/NotificationService.js';
+import { MergePresetService } from './modules/merge/MergePresetService.js';
+import { WorkspaceSettingsService } from './modules/settings/WorkspaceSettingsService.js';
+import { ReleaseHealthService } from './modules/releaseHealth/ReleaseHealthService.js';
+import { ModelDefaultsService } from './modules/modelDefaults/ModelDefaultsService.js';
+import { ServiceFragmentDefaultsService } from './modules/serviceFragmentDefaults/ServiceFragmentDefaultsService.js';
+import { RecurringPipelineService } from './modules/recurring/RecurringPipelineService.js';
+import { TrackerSettingsService } from './modules/recurring/TrackerSettingsService.js';
+import { BLUEPRINT_PIPELINE_ID } from '@cat-factory/kernel';
+import { FragmentLibraryService, FragmentSourceService, } from '@cat-factory/agents';
+/** Assemble the in-org service-sharing module when its repositories are wired. */
+function createServicesModule(deps) {
+    const { serviceRepository, workspaceMountRepository } = deps;
+    if (!serviceRepository || !workspaceMountRepository)
+        return undefined;
+    const service = new ServiceMountService({
+        serviceRepository,
+        workspaceMountRepository,
+        workspaceRepository: deps.workspaceRepository,
+        idGenerator: deps.idGenerator,
+        clock: deps.clock,
+    });
+    return { service };
+}
+/**
+ * Assemble the GitHub module when every dependency it needs is present;
+ * otherwise return undefined so the feature stays cleanly opt-in.
+ */
+function createGitHubModule(deps) {
+    const { githubClient, githubInstallationRepository, repoProjectionRepository, branchProjectionRepository, pullRequestProjectionRepository, issueProjectionRepository, commitProjectionRepository, checkRunProjectionRepository, webhookVerifier, } = deps;
+    if (!githubClient ||
+        !githubInstallationRepository ||
+        !repoProjectionRepository ||
+        !branchProjectionRepository ||
+        !pullRequestProjectionRepository ||
+        !issueProjectionRepository ||
+        !commitProjectionRepository ||
+        !checkRunProjectionRepository ||
+        !webhookVerifier) {
+        return undefined;
+    }
+    const installationService = new GitHubInstallationService({
+        githubClient,
+        githubInstallationRepository,
+        workspaceRepository: deps.workspaceRepository,
+        clock: deps.clock,
+        canCreateRepos: deps.canCreateRepos,
+        workflowsGranted: deps.workflowsGranted,
+    });
+    const syncService = new GitHubSyncService({
+        githubClient,
+        githubInstallationRepository,
+        repoProjectionRepository,
+        branchProjectionRepository,
+        pullRequestProjectionRepository,
+        issueProjectionRepository,
+        commitProjectionRepository,
+        checkRunProjectionRepository,
+        clock: deps.clock,
+        commitBackfillHorizonMs: deps.commitBackfillHorizonMs,
+    });
+    const webhookService = new WebhookService({
+        githubInstallationRepository,
+        repoProjectionRepository,
+        branchProjectionRepository,
+        pullRequestProjectionRepository,
+        issueProjectionRepository,
+        commitProjectionRepository,
+        checkRunProjectionRepository,
+        clock: deps.clock,
+    });
+    const service = new GitHubService({
+        githubClient,
+        repoProjectionRepository,
+        branchProjectionRepository,
+        pullRequestProjectionRepository,
+        issueProjectionRepository,
+        clock: deps.clock,
+    });
+    const provisioningService = deps.repoProvisioningClient
+        ? new RepoProvisioningService({ client: deps.repoProvisioningClient })
+        : undefined;
+    return {
+        installationService,
+        syncService,
+        webhookService,
+        service,
+        webhookVerifier,
+        provisioningService,
+    };
+}
+/**
+ * Assemble the document-source module when at least one provider + both
+ * repositories are present. The model provider is optional: with it the planner
+ * uses an LLM, and without it the deterministic heading parser — so the module
+ * stays usable for import/link/spawn even when no LLM is configured.
+ */
+function createDocumentsModule(deps, boardService) {
+    const { documentSourceProviders, documentConnectionRepository, documentRepository } = deps;
+    if (!documentSourceProviders ||
+        documentSourceProviders.length === 0 ||
+        !documentConnectionRepository ||
+        !documentRepository) {
+        return undefined;
+    }
+    const registry = new MapDocumentSourceRegistry(documentSourceProviders);
+    const connectionService = new DocumentConnectionService({
+        documentConnectionRepository,
+        registry,
+        workspaceRepository: deps.workspaceRepository,
+        clock: deps.clock,
+    });
+    const importService = new DocumentImportService({
+        registry,
+        documentRepository,
+        connectionService,
+        workspaceRepository: deps.workspaceRepository,
+        clock: deps.clock,
+    });
+    const plannerService = new DocumentPlannerService({
+        modelProviderResolver: deps.modelProviderResolver,
+        modelProvider: deps.modelProvider,
+        modelRef: deps.documentPlannerModel,
+    });
+    const linkService = new DocumentLinkService({
+        boardService,
+        blockRepository: deps.blockRepository,
+        documentRepository,
+    });
+    return { connectionService, importService, plannerService, linkService };
+}
+/**
+ * Assemble the task-source module when at least one provider + both repositories
+ * are present; otherwise return undefined so the feature stays cleanly opt-in.
+ * Unlike the documents module there is no planner — issues are linked for
+ * context, not expanded into board structure.
+ */
+function createTasksModule(deps, boardService) {
+    const { taskSourceProviders, taskConnectionRepository, taskRepository } = deps;
+    if (!taskSourceProviders ||
+        taskSourceProviders.length === 0 ||
+        !taskConnectionRepository ||
+        !taskRepository) {
+        return undefined;
+    }
+    const registry = new MapTaskSourceRegistry(taskSourceProviders);
+    const connectionService = new TaskConnectionService({
+        taskConnectionRepository,
+        registry,
+        workspaceRepository: deps.workspaceRepository,
+        clock: deps.clock,
+    });
+    const importService = new TaskImportService({
+        registry,
+        taskRepository,
+        connectionService,
+        workspaceRepository: deps.workspaceRepository,
+        clock: deps.clock,
+    });
+    const linkService = new TaskLinkService({
+        boardService,
+        blockRepository: deps.blockRepository,
+        taskRepository,
+    });
+    return { connectionService, importService, linkService };
+}
+/**
+ * Assemble the environment integration when its provider, both repositories and
+ * the secret cipher are present; otherwise return undefined so the feature stays
+ * cleanly opt-in (the deterministic deployer and env discovery in the engine are
+ * gated on the provisioning service being wired).
+ */
+function createEnvironmentsModule(deps) {
+    const { environmentProvider, environmentConnectionRepository, environmentRegistryRepository, secretCipher, } = deps;
+    if (!environmentProvider ||
+        !environmentConnectionRepository ||
+        !environmentRegistryRepository ||
+        !secretCipher) {
+        return undefined;
+    }
+    const connectionService = new EnvironmentConnectionService({
+        environmentConnectionRepository,
+        workspaceRepository: deps.workspaceRepository,
+        secretCipher,
+        clock: deps.clock,
+        ...(deps.environmentUrlSafetyPolicy ? { urlPolicy: deps.environmentUrlSafetyPolicy } : {}),
+    });
+    const provisioningService = new EnvironmentProvisioningService({
+        connectionService,
+        environmentProvider,
+        environmentRegistryRepository,
+        secretCipher,
+        idGenerator: deps.idGenerator,
+        clock: deps.clock,
+        ...(deps.environmentUrlSafetyPolicy ? { urlPolicy: deps.environmentUrlSafetyPolicy } : {}),
+    });
+    const teardownService = new EnvironmentTeardownService({
+        connectionService,
+        environmentProvider,
+        environmentRegistryRepository,
+        secretCipher,
+        clock: deps.clock,
+    });
+    return { connectionService, provisioningService, teardownService };
+}
+/**
+ * Assemble the self-hosted runner-pool module when its connection repository and
+ * the secret cipher are present; otherwise return undefined so the feature stays
+ * cleanly opt-in. Per-tenant scheduler-API secrets are encrypted via the cipher.
+ */
+function createRunnersModule(deps) {
+    const { runnerPoolConnectionRepository, runnerSecretCipher } = deps;
+    if (!runnerPoolConnectionRepository || !runnerSecretCipher)
+        return undefined;
+    const connectionService = new RunnerPoolConnectionService({
+        runnerPoolConnectionRepository,
+        workspaceRepository: deps.workspaceRepository,
+        secretCipher: runnerSecretCipher,
+        clock: deps.clock,
+        ...(deps.runnerUrlSafetyPolicy ? { urlPolicy: deps.runnerUrlSafetyPolicy } : {}),
+    });
+    return { connectionService };
+}
+/**
+ * Assemble the repo-bootstrap module when both its repositories are present (the
+ * worker wires them unconditionally). The `repoBootstrapper` is passed through
+ * but optional: the service exposes CRUD regardless and only gates the run path
+ * on its presence.
+ */
+function createBootstrapModule(deps, eventPublisher, onBootstrapSucceeded) {
+    const { referenceArchitectureRepository, bootstrapJobRepository } = deps;
+    if (!referenceArchitectureRepository || !bootstrapJobRepository)
+        return undefined;
+    const service = new BootstrapService({
+        referenceArchitectureRepository,
+        bootstrapJobRepository,
+        workspaceRepository: deps.workspaceRepository,
+        blockRepository: deps.blockRepository,
+        serviceRepository: deps.serviceRepository,
+        workspaceMountRepository: deps.workspaceMountRepository,
+        serviceFragmentDefaultsRepository: deps.serviceFragmentDefaultsRepository,
+        idGenerator: deps.idGenerator,
+        clock: deps.clock,
+        repoBootstrapper: deps.repoBootstrapper,
+        bootstrapRunner: deps.bootstrapRunner,
+        eventPublisher,
+        ...(onBootstrapSucceeded ? { onBootstrapSucceeded } : {}),
+    });
+    return { service };
+}
+/**
+ * Assemble the requirements-review module when its repository is present (the
+ * worker wires it unconditionally). The model provider/ref are optional within
+ * the module — reads work without them and the run paths surface a clear error —
+ * and the document/task repositories are reused, when wired, to fold linked PRDs
+ * and tracker issues into the reviewed requirements.
+ */
+function createRequirementsModule(deps, notificationService) {
+    const { requirementReviewRepository } = deps;
+    if (!requirementReviewRepository)
+        return undefined;
+    const service = new RequirementReviewService({
+        requirementReviewRepository,
+        blockRepository: deps.blockRepository,
+        idGenerator: deps.idGenerator,
+        clock: deps.clock,
+        // Tell product people + the task creator to react to a review's findings (when
+        // the notifications subsystem is wired). Best-effort; absent → no notification.
+        notificationService,
+        modelProviderResolver: deps.modelProviderResolver,
+        modelProvider: deps.modelProvider,
+        // The dedicated reviewer ref, else the document planner's (both the agents' default).
+        modelRef: deps.requirementReviewModel ?? deps.documentPlannerModel,
+        // Honour a block's pinned model with the direct/Cloudflare fallback, like the executor.
+        resolveBlockModel: deps.requirementReviewResolveModel,
+        // Honour the workspace's per-kind default for the `requirements` kind too, so the
+        // reviewer resolves its model exactly like a pipeline step. Reuses the already
+        // wired model-defaults repository; absent → only block-pin + routing default.
+        resolveWorkspaceModelDefault: deps.modelDefaultsRepository
+            ? (workspaceId, agentKind) => deps
+                .modelDefaultsRepository.getForKind(workspaceId, agentKind)
+                .then((v) => v ?? undefined)
+            : undefined,
+        documentRepository: deps.documentRepository,
+        taskRepository: deps.taskRepository,
+    });
+    return { service };
+}
+/**
+ * Assemble the clarity-review module when its repository is present (both runtime facades
+ * wire it unconditionally). Mirrors {@link createRequirementsModule}: it reuses the
+ * requirements reviewer's model config (the same routing default) since both reviewers
+ * resolve their model identically.
+ */
+function createClarityModule(deps, notificationService) {
+    const { clarityReviewRepository } = deps;
+    if (!clarityReviewRepository)
+        return undefined;
+    const service = new ClarityReviewService({
+        clarityReviewRepository,
+        blockRepository: deps.blockRepository,
+        idGenerator: deps.idGenerator,
+        clock: deps.clock,
+        notificationService,
+        modelProviderResolver: deps.modelProviderResolver,
+        modelProvider: deps.modelProvider,
+        modelRef: deps.requirementReviewModel ?? deps.documentPlannerModel,
+        resolveBlockModel: deps.requirementReviewResolveModel,
+        resolveWorkspaceModelDefault: deps.modelDefaultsRepository
+            ? (workspaceId, agentKind) => deps
+                .modelDefaultsRepository.getForKind(workspaceId, agentKind)
+                .then((v) => v ?? undefined)
+            : undefined,
+    });
+    return { service };
+}
+/**
+ * Assemble the prompt-fragment library when its fragment repository is present.
+ * The library service (CRUD + the per-run catalog resolver) always assembles;
+ * the repo-source service additionally needs the GitHub client, the source
+ * repository and an installation resolver. The selector is optional — absent it
+ * falls back to deterministic matching. Returns undefined so the feature stays
+ * cleanly opt-in (the engine then uses the block's manual fragmentIds).
+ */
+function createFragmentLibraryModule(deps) {
+    const { promptFragmentRepository } = deps;
+    if (!promptFragmentRepository)
+        return undefined;
+    const libraryService = new FragmentLibraryService({
+        promptFragmentRepository,
+        workspaceRepository: deps.workspaceRepository,
+        clock: deps.clock,
+        selector: deps.fragmentSelector,
+    });
+    const sourceService = deps.fragmentSourceRepository && deps.githubClient && deps.resolveFragmentInstallationId
+        ? new FragmentSourceService({
+            fragmentSourceRepository: deps.fragmentSourceRepository,
+            promptFragmentRepository,
+            githubClient: deps.githubClient,
+            resolveInstallationId: deps.resolveFragmentInstallationId,
+            idGenerator: deps.idGenerator,
+            clock: deps.clock,
+        })
+        : undefined;
+    return { libraryService, sourceService };
+}
+/**
+ * Assemble the notifications module when its repository is present (the worker
+ * wires it unconditionally). The delivery channel is optional within the module —
+ * without it the rows still persist (the inbox + snapshot work) but nothing is
+ * pushed; the worker wires the in-app channel, and email/Slack compose in later.
+ */
+function createNotificationsModule(deps) {
+    const { notificationRepository } = deps;
+    if (!notificationRepository)
+        return undefined;
+    const service = new NotificationService({
+        notificationRepository,
+        workspaceRepository: deps.workspaceRepository,
+        idGenerator: deps.idGenerator,
+        clock: deps.clock,
+        channel: deps.notificationChannel,
+    });
+    return { service };
+}
+/**
+ * Assemble the Slack integration module when its three repositories and the
+ * secret cipher are present. Powers the management API (connect/settings/member
+ * map); the actual Slack delivery is a `notificationChannel` composed in by the
+ * facade. OAuth is optional — manual-token onboarding works without it.
+ */
+function createSlackModule(deps) {
+    const { slackConnectionRepository, slackSettingsRepository, slackMemberMappingRepository, slackSecretCipher, } = deps;
+    if (!slackConnectionRepository ||
+        !slackSettingsRepository ||
+        !slackMemberMappingRepository ||
+        !slackSecretCipher) {
+        return undefined;
+    }
+    return {
+        connectionService: new SlackConnectionService({
+            slackConnectionRepository,
+            workspaceRepository: deps.workspaceRepository,
+            secretCipher: slackSecretCipher,
+            clock: deps.clock,
+            oauth: deps.slackOAuth,
+        }),
+        settingsService: new SlackSettingsService({
+            slackSettingsRepository,
+            workspaceRepository: deps.workspaceRepository,
+            clock: deps.clock,
+        }),
+        memberMappingService: new SlackMemberMappingService({
+            slackMemberMappingRepository,
+            workspaceRepository: deps.workspaceRepository,
+            clock: deps.clock,
+        }),
+    };
+}
+/** Assemble the merge-preset module when its repository is present. */
+function createMergePresetsModule(deps) {
+    const { mergePresetRepository } = deps;
+    if (!mergePresetRepository)
+        return undefined;
+    const service = new MergePresetService({
+        mergePresetRepository,
+        workspaceRepository: deps.workspaceRepository,
+        idGenerator: deps.idGenerator,
+        clock: deps.clock,
+    });
+    return { service };
+}
+/** Assemble the workspace-settings module when its repository is present. */
+function createWorkspaceSettingsModule(deps) {
+    const { workspaceSettingsRepository } = deps;
+    if (!workspaceSettingsRepository)
+        return undefined;
+    const service = new WorkspaceSettingsService({
+        workspaceSettingsRepository,
+        workspaceRepository: deps.workspaceRepository,
+    });
+    return { service };
+}
+/** Assemble the release-health (Datadog) module when its repos + cipher are present. */
+function createReleaseHealthModule(deps) {
+    const { datadogConnectionRepository, releaseHealthConfigRepository, datadogSecretCipher } = deps;
+    if (!datadogConnectionRepository || !releaseHealthConfigRepository || !datadogSecretCipher) {
+        return undefined;
+    }
+    const service = new ReleaseHealthService({
+        datadogConnectionRepository,
+        releaseHealthConfigRepository,
+        datadogSecretCipher,
+        workspaceRepository: deps.workspaceRepository,
+        blockRepository: deps.blockRepository,
+        clock: deps.clock,
+    });
+    return { service };
+}
+/** Assemble the model-defaults module when its repository is present. */
+function createModelDefaultsModule(deps) {
+    const { modelDefaultsRepository } = deps;
+    if (!modelDefaultsRepository)
+        return undefined;
+    const service = new ModelDefaultsService({
+        modelDefaultsRepository,
+        workspaceRepository: deps.workspaceRepository,
+    });
+    return { service };
+}
+/** Assemble the service-fragment-defaults module when its repository is present. */
+function createServiceFragmentDefaultsModule(deps) {
+    const { serviceFragmentDefaultsRepository } = deps;
+    if (!serviceFragmentDefaultsRepository)
+        return undefined;
+    const service = new ServiceFragmentDefaultsService({
+        serviceFragmentDefaultsRepository,
+        workspaceRepository: deps.workspaceRepository,
+    });
+    return { service };
+}
+/** Assemble the tracker-settings module when its repository is present. */
+function createTrackerModule(deps) {
+    const { trackerSettingsRepository } = deps;
+    if (!trackerSettingsRepository)
+        return undefined;
+    const service = new TrackerSettingsService({
+        trackerSettingsRepository,
+        workspaceRepository: deps.workspaceRepository,
+        clock: deps.clock,
+    });
+    return { service };
+}
+/**
+ * Assemble the recurring-pipeline module when its repository is present. Built
+ * after the execution engine since each fire starts a pipeline through it.
+ */
+function createRecurringModule(deps, executionService) {
+    const { pipelineScheduleRepository } = deps;
+    if (!pipelineScheduleRepository)
+        return undefined;
+    const service = new RecurringPipelineService({
+        pipelineScheduleRepository,
+        workspaceRepository: deps.workspaceRepository,
+        pipelineRepository: deps.pipelineRepository,
+        blockRepository: deps.blockRepository,
+        executionRepository: deps.executionRepository,
+        executionService,
+        idGenerator: deps.idGenerator,
+        clock: deps.clock,
+        serviceRepository: deps.serviceRepository,
+        workspaceMountRepository: deps.workspaceMountRepository,
+    });
+    return { service };
+}
+export function createCore(dependencies) {
+    const workRunner = dependencies.workRunner ?? new NoopWorkRunner();
+    const executionEventPublisher = dependencies.executionEventPublisher ?? new NoopEventPublisher();
+    const boardService = new BoardService(dependencies);
+    const workspaceService = new WorkspaceService(dependencies);
+    const accountService = new AccountService({
+        accountRepository: dependencies.accountRepository,
+        membershipRepository: dependencies.membershipRepository,
+        userRepository: dependencies.userRepository,
+        idGenerator: dependencies.idGenerator,
+        clock: dependencies.clock,
+    });
+    const userService = new UserService({
+        userRepository: dependencies.userRepository,
+        passwordHasher: dependencies.passwordHasher,
+        idGenerator: dependencies.idGenerator,
+        clock: dependencies.clock,
+    });
+    const email = dependencies.emailConnectionRepository && dependencies.emailSecretCipher
+        ? new EmailConnectionService({
+            emailConnectionRepository: dependencies.emailConnectionRepository,
+            secretCipher: dependencies.emailSecretCipher,
+            clock: dependencies.clock,
+        })
+        : undefined;
+    const invitations = dependencies.invitationRepository
+        ? new InvitationService({
+            invitationRepository: dependencies.invitationRepository,
+            accountRepository: dependencies.accountRepository,
+            membershipRepository: dependencies.membershipRepository,
+            idGenerator: dependencies.idGenerator,
+            clock: dependencies.clock,
+            // Resolve the inviting account's own (DB-stored) email sender at send time.
+            resolveEmailSender: email ? (accountId) => email.resolveSender(accountId) : undefined,
+            appBaseUrl: dependencies.appBaseUrl,
+        })
+        : undefined;
+    const pipelineService = new PipelineService(dependencies);
+    const spendService = new SpendService({
+        tokenUsageRepository: dependencies.tokenUsageRepository,
+        idGenerator: dependencies.idGenerator,
+        clock: dependencies.clock,
+        pricing: dependencies.spendPricing ?? DEFAULT_SPEND_PRICING,
+    });
+    const llmObservability = dependencies.llmCallMetricRepository
+        ? new LlmObservabilityService({
+            llmCallMetricRepository: dependencies.llmCallMetricRepository,
+            idGenerator: dependencies.idGenerator,
+            clock: dependencies.clock,
+            recordPrompts: dependencies.recordLlmPrompts ?? true,
+            traceSink: dependencies.llmTraceSink,
+        })
+        : undefined;
+    const environments = createEnvironmentsModule(dependencies);
+    const fragmentLibrary = createFragmentLibraryModule(dependencies);
+    // Reconciles a `blueprints` step's decomposition onto the board. Needs only the
+    // board service + block repository (both always present), so it is wired
+    // unconditionally — there is no standalone scan command or persisted blueprint store.
+    const blueprintReconciler = new BoardScanService({
+        boardService,
+        blockRepository: dependencies.blockRepository,
+    });
+    // Built before the execution engine so it can raise merge-review / CI-failed /
+    // pipeline-complete notifications during a run (when the module is configured).
+    const notifications = createNotificationsModule(dependencies);
+    const slack = createSlackModule(dependencies);
+    const mergePresets = createMergePresetsModule(dependencies);
+    // Built before the execution engine so the per-service running-task limit can be
+    // enforced at start() (and the escalation sweep can read the waiting threshold).
+    const settings = createWorkspaceSettingsModule(dependencies);
+    const releaseHealth = createReleaseHealthModule(dependencies);
+    const modelDefaults = createModelDefaultsModule(dependencies);
+    const serviceFragmentDefaults = createServiceFragmentDefaultsModule(dependencies);
+    // Built before the execution engine so the special `requirements-review` gate step can
+    // drive the inline reviewer + the iterative answer → incorporate → re-review loop.
+    const requirements = createRequirementsModule(dependencies, notifications?.service);
+    const clarity = createClarityModule(dependencies, notifications?.service);
+    const executionService = new ExecutionService({
+        ...dependencies,
+        workRunner,
+        executionEventPublisher,
+        boardService,
+        spendService,
+        requirementReviewService: requirements?.service,
+        clarityReviewService: clarity?.service,
+        environmentProvisioning: environments?.provisioningService,
+        blueprintReconciler,
+        notificationService: notifications?.service,
+        workspaceSettingsService: settings?.service,
+        llmObservability,
+        ticketTrackerProvider: dependencies.ticketTrackerProvider,
+        // Let the personal-credential gate resolve the workspace per-kind default model the
+        // same way dispatch does, so a run whose block has no pin but an individual-usage
+        // workspace default is still gated up-front. Reuses the model-defaults repository.
+        resolveWorkspaceModelDefault: dependencies.modelDefaultsRepository
+            ? (workspaceId, agentKind) => dependencies
+                .modelDefaultsRepository.getForKind(workspaceId, agentKind)
+                .then((v) => v ?? undefined)
+            : undefined,
+    });
+    const github = createGitHubModule(dependencies);
+    const documents = createDocumentsModule(dependencies, boardService);
+    const tasks = createTasksModule(dependencies, boardService);
+    const runners = createRunnersModule(dependencies);
+    // After a bootstrap succeeds, map the new repo into a blueprint + the board by
+    // starting the blueprint-only pipeline against the service frame.
+    const bootstrap = createBootstrapModule(dependencies, executionEventPublisher, (ws, blockId) => executionService.start(ws, blockId, BLUEPRINT_PIPELINE_ID).then(() => undefined));
+    const tracker = createTrackerModule(dependencies);
+    const recurring = createRecurringModule(dependencies, executionService);
+    const services = createServicesModule(dependencies);
+    return {
+        workspaceService,
+        accountService,
+        userService,
+        ...(invitations ? { invitations } : {}),
+        ...(email ? { email } : {}),
+        boardService,
+        pipelineService,
+        executionService,
+        spendService,
+        executionEventPublisher,
+        ...(llmObservability ? { llmObservability } : {}),
+        ...(github ? { github } : {}),
+        ...(documents ? { documents } : {}),
+        ...(tasks ? { tasks } : {}),
+        ...(environments ? { environments } : {}),
+        ...(runners ? { runners } : {}),
+        ...(bootstrap ? { bootstrap } : {}),
+        ...(requirements ? { requirements } : {}),
+        ...(clarity ? { clarity } : {}),
+        ...(notifications ? { notifications } : {}),
+        ...(slack ? { slack } : {}),
+        ...(mergePresets ? { mergePresets } : {}),
+        ...(settings ? { settings } : {}),
+        ...(releaseHealth ? { releaseHealth } : {}),
+        ...(modelDefaults ? { modelDefaults } : {}),
+        ...(serviceFragmentDefaults ? { serviceFragmentDefaults } : {}),
+        ...(fragmentLibrary ? { fragmentLibrary } : {}),
+        ...(recurring ? { recurring } : {}),
+        ...(tracker ? { tracker } : {}),
+        ...(services ? { services } : {}),
+    };
+}
+//# sourceMappingURL=container.js.map