@cat-factory/orchestration 0.138.0 → 0.140.0

package/dist/container/dependencies.d.ts

@@ -0,0 +1,684 @@
+import type { AgentKindRegistry, ResolveFragmentInstallationId, ResolveSkillInstallationId } from '@cat-factory/agents';
+import type { OpenRouterModelMeta, ResolvedValidationChecks } from '@cat-factory/contracts';
+import type { AccountSettingsService, ComposeRuntime, CustomManifestTypeRegistry, DeployJobClient, DetectionConventions, EnvironmentBackendRegistry, RegisterHandlerInput, RunnerBackendRegistry, UserSecretKindRegistry, VcsPatConnectionService } from '@cat-factory/integrations';
+import type { AccountInvitationRepository, AccountRepository, AccountSkillRepository, AgentExecutor, AppCaches, BlockRepository, BootstrapJobRepository, BootstrapRunner, BrainstormSessionRepository, BranchProjectionRepository, BranchUpdater, CheckRunProjectionRepository, ClarityReviewRepository, Clock, CommitProjectionRepository, CustomManifestTypeRepository, DeployCloneTarget, DocInterviewRepository, DocumentConnectionRepository, DocumentContentResolver, DocumentRepository, DocumentSourceProvider, EmailConnectionRepository, EmailSender, EnvConfigRepairJobRepository, EnvConfigRepairRunner, EnvConfigRepairer, EnvironmentConnectionRepository, EnvironmentProvider, EnvironmentRegistryRepository, EnvironmentTestRunRepository, EnvironmentTestRunner, EnvironmentUserHandlerRepository, ExecutionEventPublisher, ExecutionRepository, FragmentSelector, FragmentSourceRepository, GateRegistry, GitHubClient, GitHubInstallation, GitHubInstallationRepository, GitHubProvisioningClient, IdGenerator, IncidentEnrichmentConnectionRepository, InitiativePresetRegistry, InitiativeRepository, IssueProjectionRepository, IssueWritebackProvider, KaizenGradingRepository, KaizenVerifiedComboRepository, LlmCallMetricRepository, LlmTraceSink, MembershipRepository, ModelPresetRepository, ModelProvider, ModelProviderResolver, ModelRef, NotificationChannel, NotificationRepository, ObservabilityConnectionRepository, PackageRegistryConnectionRepository, PasswordHasher, PasswordResetTokenRepository, PipelineRegistry, PipelineRepository, PipelineScheduleRepository, PlatformMetricsRepository, PrVerificationReportPublisher, PreflightHostProbes, PreviewTransport, PromptFragmentRepository, ProviderCapabilities, ProviderRegistry, ProvisioningLogRepository, PullRequestMerger, PullRequestProjectionRepository, ReferenceArchitectureRepository, ReleaseHealthConfigRepository, RepoBootstrapper, RepoProjectionRepository, RequirementReviewRepository, ResolveBinaryArtifactStore, ResolveRunRepoContext, RiskPolicyRepository, RunInitiatorScope, RunRepoContext, RunnerPoolConnectionRepository, RunnerPoolProvider, SandboxExperimentRepository, SandboxFixtureRepository, SandboxGradeRepository, SandboxPromptVersionRepository, SandboxRunRepository, SecretCipher, ServiceFragmentDefaultsRepository, ServiceRepository, SharedStackRepository, SkillSourceRepository, SkillSourceResyncRequest, SlackConnectionRepository, SlackMemberMappingRepository, SlackSettingsRepository, StepResolverRegistry, SubscriptionActivationRepository, TaskConnectionRepository, TaskRepository, TaskSourceProvider, TaskSourceSettingsRepository, TaskTypeRegistry, TestSecretRef, TicketTrackerProvider, TokenUsageRepository, TrackerSettingsRepository, UrlSafetyPolicy, UserRepoAccessRepository, UserRepository, UserSettingsRepository, VcsProviderRegistry, WebhookVerifier, WorkRunner, WorkspaceMemberRepository, WorkspaceMountRepository, WorkspaceRepository, WorkspaceSettingsRepository } from '@cat-factory/kernel';
+import type { SpendPricing } from '@cat-factory/spend';
+import type { TesterQualityReviewer } from '../modules/execution/TesterQualityReviewService.js';
+import type { AgentContextObservabilityService } from '../modules/observability/AgentContextObservabilityService.js';
+import type { SearchQueryObservabilityService } from '../modules/observability/SearchQueryObservabilityService.js';
+import type { BuildPreviewJob } from '../modules/preview/PreviewService.js';
+export interface CoreDependencies {
+    workspaceRepository: WorkspaceRepository;
+    /**
+     * Workspace-level RBAC roster (workspace-rbac initiative). Threaded into
+     * `WorkspaceService` so the gate can resolve a caller's effective role + the creator
+     * auto-enroll can seed an admin row. Optional: absent (unwired / tests) ⇒ resolution
+     * falls back to the account tier and auto-enroll is skipped.
+     */
+    workspaceMemberRepository?: WorkspaceMemberRepository;
+    /** Account tenancy: accounts own workspaces; memberships grant access (0017). */
+    accountRepository: AccountRepository;
+    membershipRepository: MembershipRepository;
+    /** Canonical user identity (`users` + `user_identities`); keyed off by everything. */
+    userRepository: UserRepository;
+    /** Hashes/verifies email-password credentials (WebCrypto PBKDF2). */
+    passwordHasher: PasswordHasher;
+    /** Account invitations (email-based org onboarding). Optional: opt-in feature. */
+    invitationRepository?: AccountInvitationRepository;
+    /** Per-account email-sender connections (UI-onboarded, DB-stored). Optional. */
+    emailConnectionRepository?: EmailConnectionRepository;
+    /** Master-key cipher sealing the per-account email API key at rest. */
+    emailSecretCipher?: SecretCipher;
+    /** Password-reset tokens ("forgot my password"). Optional: opt-in feature. */
+    passwordResetTokenRepository?: PasswordResetTokenRepository;
+    /**
+     * Resolve the deployment's system email sender (auth emails like password reset),
+     * independent of the per-account connections. Absent ⇒ reset links are logged, not
+     * emailed.
+     */
+    resolveSystemEmailSender?: () => Promise<EmailSender | null>;
+    /**
+     * Base URL of the SPA (its origin) — the invite-accept / password-reset links point at it,
+     * and the PR verification report builds its observability deep link from it. Absent ⇒ those
+     * surfaces omit the link rather than emitting a dead one.
+     */
+    appBaseUrl?: string;
+    /**
+     * Optional structural logger (the facade's pino logger) for best-effort diagnostics.
+     * `warn` is required alongside `info` because the paths that need it most are the ones
+     * designed to swallow their failures (the PR verification report) — a logger that can only
+     * report success is no use to them.
+     */
+    logger?: {
+        info(obj: Record<string, unknown>, msg?: string): void;
+        warn(obj: Record<string, unknown>, msg?: string): void;
+    };
+    blockRepository: BlockRepository;
+    pipelineRepository: PipelineRepository;
+    executionRepository: ExecutionRepository;
+    /**
+     * In-org shared services (account-owned services + per-workspace mounts, 0030).
+     * Optional so facades/tests without them wired keep the feature cleanly opt-in.
+     */
+    serviceRepository?: ServiceRepository;
+    workspaceMountRepository?: WorkspaceMountRepository;
+    idGenerator: IdGenerator;
+    clock: Clock;
+    /**
+     * Performs each pipeline step. Wire AiAgentExecutor (optionally composed with
+     * the container executor for repo-operating steps) for real work, or a fake in
+     * tests.
+     */
+    agentExecutor: AgentExecutor;
+    /**
+     * The app-owned agent-kind registry (built-ins + any a deployment registered by
+     * reference). Optional + defaulted to `defaultAgentKindRegistry()` so existing
+     * construction sites (tests, harnesses) don't break; each facade injects the SAME
+     * instance it threads into its executors so custom kinds resolve consistently
+     * everywhere. Read by the engine (traits / inline-surface / pre-post-op hooks) and
+     * re-exposed on {@link Core} for the HTTP layer's snapshot projection.
+     */
+    agentKindRegistry?: AgentKindRegistry;
+    /**
+     * The app-owned polling-gate registry. Optional + defaulted to `defaultGateRegistry()`
+     * (EMPTY — the built-in `@cat-factory/gates` suite lives in that package, so the facade
+     * installs it via `registerBuiltinGates(gateRegistry)` before injecting the SAME instance
+     * here). A deployment registers custom gates by reference on that instance. Read by the
+     * engine's gate machine (see {@link ExecutionService}); a facade that injects it also passes
+     * the same instance to `validateRegistrations`. Existing construction sites (tests /
+     * harnesses) that omit it get a bare registry, so gate steps pass through.
+     */
+    gateRegistry?: GateRegistry;
+    /**
+     * The app-owned step-completion-resolver registry (deployment-registered resolvers).
+     * Optional + defaulted to `defaultStepResolverRegistry()` (EMPTY — the built-in `merger`
+     * resolver is a privileged engine built-in, not a registry entry). Each facade injects the
+     * SAME instance it registers custom resolvers on. Read by the engine's completion hub.
+     */
+    stepResolverRegistry?: StepResolverRegistry;
+    /**
+     * The app-owned provider registry (the deployment-supplied data sources a gate probes, keyed
+     * by {@link ProviderToken}). Optional + defaulted to `defaultProviderRegistry()`. The engine's
+     * gate machine reads it through the {@link GateContext} it builds (`RunDispatcher.makeGateContext`);
+     * each facade news ONE instance, wires its configured gate providers on it (the
+     * `@cat-factory/gates` `wireX` handles), and injects the SAME instance here. Existing
+     * construction sites (tests / harnesses) that omit it get a fresh empty registry, so every gate
+     * passes through.
+     */
+    providerRegistry?: ProviderRegistry;
+    /**
+     * The app-owned pipeline registry (deployment-registered extra pipelines). Optional + defaulted
+     * to `defaultPipelineRegistry()` (empty). Threaded into the workspace + pipeline services so a
+     * deployment's custom pipelines are seeded into every new workspace and resolvable by id; a
+     * facade injects the SAME instance it registers custom pipelines on. Existing construction sites
+     * (tests / harnesses) that omit it get an empty registry (built-in catalog only).
+     */
+    pipelineRegistry?: PipelineRegistry;
+    /**
+     * The app-owned custom task-type registry (deployment-registered namespaced task types).
+     * Optional + defaulted to `defaultTaskTypeRegistry()` (EMPTY — there are no built-in custom
+     * task types). Threaded into the board service so a custom-typed task resolves its default
+     * pipeline, and re-exposed on {@link Core} for the HTTP layer's snapshot projection
+     * (`customTaskTypes`); a facade injects the SAME instance it registers custom task types on.
+     * Existing construction sites (tests / harnesses) that omit it get an empty registry.
+     */
+    taskTypeRegistry?: TaskTypeRegistry;
+    /**
+     * The app-owned initiative-preset registry (built-in generic / docs-refresh / tech-migration
+     * plus any a deployment registered by reference). Optional + defaulted to
+     * `defaultInitiativePresetRegistry()` so existing construction sites (tests, harnesses) don't
+     * break; each facade injects the SAME instance so custom presets resolve consistently everywhere.
+     * Read by the initiative services (create / ingest / interviewer steering) + the spawned-run
+     * preset context, and re-exposed on {@link Core} for the HTTP layer's snapshot descriptors + the
+     * preset probe.
+     */
+    initiativePresetRegistry?: InitiativePresetRegistry;
+    /**
+     * The app-owned VCS provider registry (the neutral webhook receiver resolves a provider
+     * bundle through it). Optional + defaulted to `defaultVcsRegistry()`. NOT read by the engine
+     * (like `userSecretKindRegistry`): it rides `CoreDependencies` purely so each facade reads the
+     * SAME instance off `overrides` (the conformance-injection seam) and surfaces it on the
+     * `ServerContainer` for the neutral webhook controller. A facade news one, registers the
+     * providers its config enables on it, and threads that instance here.
+     */
+    vcsRegistry?: VcsProviderRegistry;
+    /**
+     * Optional: resolve a block's run repo (installation + repo + default branch) bound to
+     * a checkout-free {@link RepoFiles}, so a registered custom kind's pre/post-op hooks
+     * read a targeted subset of the repo and commit rendered artifacts WITHOUT a checkout.
+     * A facade composes it from its wired `GitHubClient` + `resolveRepoTarget`
+     * (`makeResolveRunRepoContext`). Absent (tests / GitHub not connected) → the engine
+     * skips every kind's pre/post-ops, exactly as a built-in kind has none.
+     */
+    resolveRunRepoContext?: ResolveRunRepoContext;
+    /**
+     * Optional: resolve a VCS-neutral, repo-bound {@link RepoFiles} from explicit repo
+     * coordinates (no block context), so the environments module can validate / bootstrap
+     * a provider's config file in a repo the operator names. A facade composes it from its
+     * wired `GitHubClient` + the workspace's installation/repo projection
+     * (`makeResolveRepoFilesForCoords`). Absent → repo validation/bootstrap report "no VCS
+     * connection".
+     */
+    resolveRepoFilesForCoords?: (workspaceId: string, coords: {
+        owner: string;
+        repo: string;
+        provider?: 'github' | 'gitlab';
+    }) => Promise<RunRepoContext | null>;
+    /**
+     * Optional: dispatch / poll / release a CONTAINER-backed deploy job (real
+     * `kubectl`/`kustomize`/`helm`) through the workspace's runner transport — the async
+     * provisioning lifecycle the Kubernetes render path uses. A facade passes its
+     * `RunnerJobClient` (structurally a {@link DeployJobClient}). Absent → container provisioning
+     * is unavailable, so a render-needing config fails loudly (the raw-manifest REST path is
+     * unaffected). See docs/initiatives/per-service-provision-types.md (phase 2).
+     */
+    deployJobClient?: DeployJobClient;
+    /**
+     * Optional: resolve the manifests-repo clone target (HTTPS URL + ref + short-lived token) a
+     * deploy container clones — VCS-specific, server-layer work the stateless provider can't do.
+     * A facade composes it from its wired `GitHubClient` + `resolveRepoTarget`. Absent → no clone
+     * target, so a render-needing config fails loudly (the synchronous raw path never needs it).
+     */
+    resolveDeployCloneTarget?: (workspaceId: string, blockId: string, ref?: string) => Promise<DeployCloneTarget | null>;
+    /**
+     * Optional: the kind-scoped `agent_runs` rows for env-config-repair runs. Wired by a
+     * facade alongside {@link envConfigRepairer}; absent → no durable repair runs.
+     */
+    envConfigRepairJobRepository?: EnvConfigRepairJobRepository;
+    /**
+     * Optional: the side-effecting dispatch/poll/release of the repair container (the
+     * server's `ContainerEnvConfigRepairer`). When wired (with the job repository), the
+     * environments module builds an {@link EnvConfigRepairService} and routes the connection
+     * service's `dispatchConfigRepair` seam through it (start the durable run, return its id).
+     * Absent → the bootstrap op has no agent fallback.
+     */
+    envConfigRepairer?: EnvConfigRepairer;
+    /**
+     * Optional: durably drives an env-config-repair run's poll loop (the worker's
+     * `EnvConfigRepairWorkflow` / Node pg-boss). Absent → tests poll `pollJob` directly.
+     */
+    envConfigRepairRunner?: EnvConfigRepairRunner;
+    /**
+     * Optional: the `environment_test_runs` rows backing the ephemeral-environment
+     * self-test. Wired (with `resolveRunRepoContext` + the environments module) → the
+     * environments module builds an {@link EnvironmentTestService}; absent → no self-test.
+     */
+    environmentTestRunRepository?: EnvironmentTestRunRepository;
+    /**
+     * Optional: durably drives a self-test run's poll loop (the worker's
+     * `EnvironmentTestWorkflow` / Node pg-boss). Absent → tests poll `pollEnvTest` directly.
+     */
+    environmentTestRunner?: EnvironmentTestRunner;
+    /**
+     * Optional: runs the engine's gate-probe / merge GitHub reads under the run
+     * initiator's ambient context so a per-user PAT is preferred (see
+     * `RunInitiatorScope`). A facade injects the server's `runWithInitiator`. Absent →
+     * pass-through (no per-user PAT preference; the deployment default is used).
+     */
+    runInitiatorScope?: RunInitiatorScope;
+    /** Ledger backing the spend safeguard (per-call token usage). */
+    tokenUsageRepository: TokenUsageRepository;
+    /**
+     * Sink backing LLM observability (full per-call prompt/response, output-limit
+     * headroom, transport-vs-execution latency). Optional and default-off: when
+     * present the proxy records every container-agent call and the engine rolls the
+     * aggregates onto pipeline steps; absent → no observability is collected and
+     * tests/unconfigured facades are unaffected.
+     */
+    llmCallMetricRepository?: LlmCallMetricRepository;
+    /**
+     * Deployment-level rollup port over `agent_runs` (run outcomes, failure taxonomy, live/parked
+     * depth, duration + trend) backing the platform-operator dashboard. Optional: when wired,
+     * `createCore` builds {@link PlatformObservabilityService} and re-exposes it for the admin read
+     * endpoint; absent (tests / unconfigured facades) → no platform view, engine unaffected.
+     */
+    platformMetricsRepository?: PlatformMetricsRepository;
+    /**
+     * Whether the LLM observability sink persists the full prompt body with each metric.
+     * Defaults to true; set false (via `LLM_RECORD_PROMPTS=false`) to keep the numeric
+     * telemetry while storing the complete prompts empty. Only meaningful when
+     * `llmCallMetricRepository` is wired.
+     */
+    recordLlmPrompts?: boolean;
+    /**
+     * Agent-context observability sink, built by the facade (it needs the same
+     * snapshot repository the executor records through). When present the engine
+     * re-exposes it for the read endpoint; the facade also injects it into the
+     * container-agent executor for the write path. Absent → no agent context is stored.
+     */
+    agentContextObservability?: AgentContextObservabilityService;
+    /**
+     * Agent-search-query observability sink, built by the facade (it needs the same
+     * search-query repository the search proxy records through). When present the engine
+     * re-exposes it for the read endpoint; the facade also injects it into the web-search
+     * proxy for the write path. Absent → no search queries are stored.
+     */
+    searchQueryObservability?: SearchQueryObservabilityService;
+    /**
+     * Optional external LLM trace sink (e.g. Langfuse). When wired, the observability
+     * service fans every recorded call out to it as a generation. Opt-in and default-off;
+     * a facade wires it only when configured (`selectLangfuseSink`).
+     */
+    llmTraceSink?: LlmTraceSink;
+    /**
+     * Drives runs durably outside the starting request. Defaults to a no-op (tests);
+     * the worker wires WorkflowsWorkRunner when the Workflows binding is present.
+     */
+    workRunner?: WorkRunner;
+    /**
+     * Pushes execution/board changes to connected clients in real time, replacing
+     * the browser's `tick` polling. Defaults to a no-op (tests, or any deployment
+     * without the WORKSPACE_EVENTS binding); the worker wires
+     * DurableObjectEventPublisher when that binding is present.
+     */
+    executionEventPublisher?: ExecutionEventPublisher;
+    /**
+     * Pricing and budget for the spend safeguard. Defaults to the built-in
+     * approximate EUR prices and a ~100 EUR/month limit; the worker overrides
+     * this from env, and tests can inject a tiny limit to exercise pausing.
+     */
+    spendPricing?: SpendPricing;
+    /**
+     * Optional resolver for a workspace's enabled OpenRouter dynamic-catalog models, so the
+     * spend safeguard prices a metered `openrouter:<slug>` call at its real per-model rate
+     * instead of the bare-`openrouter` fallback. Wired by each facade from its
+     * `OpenRouterCatalogService`; absent → the static price table is used.
+     */
+    dynamicModelPricesFor?: (workspaceId: string) => Promise<OpenRouterModelMeta[]>;
+    githubClient?: GitHubClient;
+    githubInstallationRepository?: GitHubInstallationRepository;
+    /**
+     * The per-workspace VCS PAT connect service (GitLab today), injected by a facade when GitLab
+     * connect is wired (a sealing key + GitLab config). Exposed on {@link Core} and surfaced on the
+     * ServerContainer, where the GitLab connect controller drives it. Absent ⇒ the connect endpoints
+     * 503, exactly like the App-based `github` module when unconfigured.
+     */
+    vcsConnectionService?: VcsPatConnectionService;
+    repoProjectionRepository?: RepoProjectionRepository;
+    branchProjectionRepository?: BranchProjectionRepository;
+    pullRequestProjectionRepository?: PullRequestProjectionRepository;
+    issueProjectionRepository?: IssueProjectionRepository;
+    commitProjectionRepository?: CommitProjectionRepository;
+    checkRunProjectionRepository?: CheckRunProjectionRepository;
+    /**
+     * The per-user "repos my PAT can reach" projection. When wired, the repo picker expands with
+     * the viewer's PAT-reachable repos (recording their access for the board redaction). Optional.
+     */
+    userRepoAccessRepository?: UserRepoAccessRepository;
+    webhookVerifier?: WebhookVerifier;
+    /**
+     * Bounds the initial commit backfill window (see GitHubSyncService). The worker
+     * sets this from the commit retention horizon so backfill and retention agree;
+     * undefined backfills the full history.
+     */
+    commitBackfillHorizonMs?: number;
+    /**
+     * The privileged App's provisioning client (ADR 0005). Present only when a
+     * privileged App is configured; backs the create-repo endpoint. Absent → the
+     * `github` module exposes no `provisioningService` and creation stays manual.
+     */
+    repoProvisioningClient?: GitHubProvisioningClient;
+    /**
+     * Whether the privileged App tier can create repos for an installation (ADR
+     * 0005) — true when its owning App is the privileged one. Surfaced on the
+     * connection so the UI drops the manual create step; absent → always false.
+     */
+    canCreateRepos?: (installation: GitHubInstallation) => boolean;
+    /**
+     * Whether an installation actually granted `workflows: write`. Surfaced on the
+     * connection so the UI can warn that agent pushes touching `.github/workflows/*`
+     * would be rejected; absent → always false.
+     */
+    workflowsGranted?: (installation: GitHubInstallation) => Promise<boolean>;
+    modelProvider?: ModelProvider;
+    /**
+     * Resolve a {@link ModelProvider} for a run's credential scope (the DB-backed API-key
+     * pool, account/workspace/user). Preferred over the static `modelProvider` by the
+     * inline consumers (document planner, requirements reviewer); the facade supplies it
+     * so inline calls use the same per-scope pool the container LLM proxy does.
+     */
+    modelProviderResolver?: ModelProviderResolver;
+    /** Model the document planner uses (the agents' default model ref). */
+    documentPlannerModel?: ModelRef;
+    documentSourceProviders?: DocumentSourceProvider[];
+    documentConnectionRepository?: DocumentConnectionRepository;
+    documentRepository?: DocumentRepository;
+    taskSourceProviders?: TaskSourceProvider[];
+    taskConnectionRepository?: TaskConnectionRepository;
+    /** Per-workspace on/off toggle for each task source (absent row ⇒ enabled). */
+    taskSourceSettingsRepository?: TaskSourceSettingsRepository;
+    taskRepository?: TaskRepository;
+    environmentConnectionRepository?: EnvironmentConnectionRepository;
+    environmentRegistryRepository?: EnvironmentRegistryRepository;
+    /**
+     * A deployment's pre-declared environment-handler SEEDS (each a `RegisterHandlerInput`). When
+     * supplied (and the environments module is wired), `createCore` builds an
+     * `EnvironmentHandlerSeeder` over them and exposes it on the container: the runtime
+     * boot-backfills every existing workspace and `WorkspaceService.create` seeds each new one, so a
+     * deployment (e.g. a Kargo adapter) supplies the infra handler from its config instead of a human
+     * filling the Infrastructure → Test environments form. Seeding is idempotent + per-seed
+     * fault-tolerant. Absent / empty ⇒ no seeding.
+     */
+    seedEnvironmentHandlers?: RegisterHandlerInput[];
+    /**
+     * The browsable-frontend-PREVIEW container transport (slice 5c) — the per-runtime half that
+     * publishes a served app's port to a host port and keeps the container alive. Wired ONLY on a
+     * runtime with a host-port-publish primitive (local Docker/Apple); the Worker never wires it,
+     * so the preview module stays absent there and the controller 503s. Assembles the preview
+     * module only alongside {@link buildPreviewJob} + {@link environmentRegistryRepository}.
+     */
+    previewTransport?: PreviewTransport;
+    /**
+     * Builds the harness `mode: 'preview'` job for a `frontend` frame (repo/token/session + the
+     * frontend infra spec) — a facade-provided seam because it needs the server-layer repo/auth
+     * resolution. Paired with {@link previewTransport}.
+     */
+    buildPreviewJob?: BuildPreviewJob;
+    /**
+     * Workspace-defined custom-manifest-type catalog (the UI-editable half of the custom
+     * provision-type catalog). Absent ⇒ the catalog is the registered code types only.
+     */
+    customManifestTypeRepository?: CustomManifestTypeRepository;
+    /**
+     * Per-USER infra handler overrides (local mode): the per-user layer over a workspace's
+     * per-type handlers. Persisted in both runtimes; the local-only behaviour is enforced at
+     * the controller mount (slice 4). Absent ⇒ no per-user overrides.
+     */
+    environmentUserHandlerRepository?: EnvironmentUserHandlerRepository;
+    /** The app-owned registry of code-defined custom manifest types (merged into the catalog). */
+    customManifestTypeRegistry?: CustomManifestTypeRegistry;
+    secretCipher?: SecretCipher;
+    /**
+     * INTERNAL override: when set, this provider is used for every env operation instead of
+     * the kind registry. NOT a public facade seam (a native backend registers into the
+     * injected `environmentBackendRegistry`) — it exists only for the cross-runtime conformance
+     * suite, which must inject a fake provider (validate-repo / config-repair) through a
+     * schema-locked connect API. Production facades leave it unset → the registry path.
+     */
+    environmentProvider?: EnvironmentProvider;
+    /**
+     * The app-owned environment-backend registry (kind → provider). A facade builds it via
+     * `createBackendRegistries()` and registers any custom backends by reference before
+     * injecting it here. Absent ⇒ a fresh registry with just the built-in `manifest` +
+     * `kubernetes` kinds (`defaultEnvironmentBackendRegistry()`).
+     */
+    environmentBackendRegistry?: EnvironmentBackendRegistry;
+    provisioningLogRepository?: ProvisioningLogRepository;
+    environmentCustomTlsSupported?: boolean;
+    environmentUrlSafetyPolicy?: UrlSafetyPolicy;
+    detectionConventions?: DetectionConventions;
+    runnerPoolConnectionRepository?: RunnerPoolConnectionRepository;
+    runnerSecretCipher?: SecretCipher;
+    runnerPoolProvider?: RunnerPoolProvider;
+    /**
+     * The app-owned runner-backend registry (kind → provider). A facade builds it via
+     * `createBackendRegistries()` and registers any custom backends by reference before
+     * injecting it here. Absent ⇒ a fresh registry with just the built-in `manifest` +
+     * `kubernetes` kinds (`defaultRunnerBackendRegistry()`).
+     */
+    runnerBackendRegistry?: RunnerBackendRegistry;
+    /**
+     * The app-owned registry of per-user secret KINDS (a GitHub PAT built-in today). Carried on
+     * the dependency bag so each facade reads the SAME instance off `overrides` and threads it
+     * into its `UserSecretService` (an integrations service built directly by the facade, not by
+     * `createCore`). A deployment registers a custom kind by reference. Absent ⇒ a fresh registry
+     * with just the built-in `github_pat` kind (`defaultUserSecretKindRegistry()`).
+     */
+    userSecretKindRegistry?: UserSecretKindRegistry;
+    runnerUrlSafetyPolicy?: UrlSafetyPolicy;
+    runnerCustomTlsSupported?: boolean;
+    referenceArchitectureRepository?: ReferenceArchitectureRepository;
+    bootstrapJobRepository?: BootstrapJobRepository;
+    repoBootstrapper?: RepoBootstrapper;
+    /** Durably drives a bootstrap run's poll loop; without it, runs aren't auto-driven. */
+    bootstrapRunner?: BootstrapRunner;
+    requirementReviewRepository?: RequirementReviewRepository;
+    /**
+     * Persistence for the interactive document-interview feature (WS5). Mirrors
+     * `requirementReviewRepository`: both runtime facades wire it unconditionally. The
+     * doc-interview service reuses the requirements reviewer's model config below, and it is
+     * also read by the agent-context builder to fold the synthesized brief into the writer's
+     * context. The interviewer LLM is optional within the module (a document pipeline runs off
+     * the raw outline when no model is wired).
+     */
+    docInterviewRepository?: DocInterviewRepository;
+    /**
+     * Persistence for the Kaizen agent (post-run grading of agent steps + the verified-combo
+     * library). Both runtime facades wire both repos unconditionally. The Kaizen module
+     * assembles whenever they are present; the LLM grader resolves its model for the `kaizen`
+     * kind exactly like the requirements reviewer (block pin > workspace default > routing).
+     */
+    kaizenGradingRepository?: KaizenGradingRepository;
+    kaizenVerifiedComboRepository?: KaizenVerifiedComboRepository;
+    /**
+     * Persistence for the clarity-review (bug-report triage) feature. Mirrors
+     * `requirementReviewRepository`: both runtime facades wire it unconditionally. The
+     * clarity service reuses the requirements reviewer's model config below.
+     */
+    clarityReviewRepository?: ClarityReviewRepository;
+    /**
+     * Persistence for the brainstorm (structured-dialogue) feature. Mirrors
+     * `requirementReviewRepository`: both runtime facades wire it unconditionally. The two
+     * brainstorm services (one per stage) reuse the requirements reviewer's model config below.
+     */
+    brainstormSessionRepository?: BrainstormSessionRepository;
+    /**
+     * Optional: per-run personal-credential activations (individual-usage subscriptions).
+     * Passed through to the ExecutionService so a finished run's activation is cleared
+     * promptly. Both runtime facades wire it when ENCRYPTION_KEY is present.
+     */
+    subscriptionActivationRepository?: SubscriptionActivationRepository;
+    /**
+     * Default model the requirements reviewer uses when a block pins none.
+     * Independent of the documents config so the reviewer works whenever a model
+     * provider is wired; the worker sets it to the agents' routing default (which
+     * resolves to Cloudflare Workers AI unless a direct key is set). Falls back to
+     * `documentPlannerModel` when absent.
+     */
+    requirementReviewModel?: ModelRef;
+    /**
+     * Resolve a block's pinned model id to a ref for the reviewer, honouring the
+     * direct/Cloudflare fallback — the same resolver the agent executor uses. The
+     * worker wires `config.agents.resolveBlockModel`; absent → the reviewer always
+     * uses the default ref above.
+     */
+    requirementReviewResolveModel?: (modelId: string | undefined) => ModelRef | undefined;
+    /**
+     * Override the test quality-control companion's inline reviewer. Normally `createCore`
+     * builds a {@link TesterQualityReviewService} from the model-provider deps; injecting a
+     * reviewer here replaces that (the cross-runtime conformance suite drives the full QC loop
+     * through a deterministic fake reviewer this way). Absent ⇒ the reviewer is built from the
+     * model deps, or is a pass-through when no model resolves.
+     */
+    testerQualityReviewer?: TesterQualityReviewer;
+    /**
+     * Whether a container-only subscription harness ref (`claude-code` / `codex`) can run as
+     * an INLINE LLM call in this deployment — true only in local mode, where the developer's
+     * ambient CLI login is driven as a host subprocess. Threaded into every inline service
+     * (requirements/clarity reviewers, brainstorm, kaizen, sandbox) so an ambient-eligible
+     * harness ref is kept (served by the harness-aware model provider) instead of degraded to
+     * the routing default, and into the start guard's inline-model check. From
+     * `config.agents.inlineHarnessRef`; absent on Node/Worker (no inline harness path).
+     */
+    inlineHarnessRef?: (ref: ModelRef) => boolean;
+    /**
+     * The app-owned cache bag (docs/initiatives/caching-layer.md). A facade builds
+     * it once per process via `createAppCaches` — Node threads in the Redis-backed
+     * invalidation notifications in multi-node deployments, the Worker passes the
+     * isolate-safe profile. Absent (tests / harnesses) ⇒ `createCore` builds bare
+     * in-memory defaults, whose coherence the services' own invalidation calls keep.
+     */
+    caches?: AppCaches;
+    promptFragmentRepository?: PromptFragmentRepository;
+    fragmentSourceRepository?: FragmentSourceRepository;
+    fragmentSelector?: FragmentSelector;
+    resolveFragmentInstallationId?: ResolveFragmentInstallationId;
+    /**
+     * Live document reader for **document-backed** fragments (Confluence/Notion/
+     * GitHub files linked as living best-practice fragments). Wired by a facade
+     * from its document-source registry + connection service; absent → linking a
+     * document as a fragment is rejected and run resolution uses cached bodies.
+     */
+    documentContentResolver?: DocumentContentResolver;
+    accountSkillRepository?: AccountSkillRepository;
+    skillSourceRepository?: SkillSourceRepository;
+    resolveSkillInstallationId?: ResolveSkillInstallationId;
+    /**
+     * Enqueues a targeted skill-source resync onto the runtime's GitHub-sync queue — the
+     * push-webhook freshness fan-out (slice 4). Facade-provided (Worker Queue / Node pg-boss);
+     * absent (no queue, or a pure-logic test) ⇒ no proactive resync, and freshness is guaranteed
+     * at dispatch by the resolver's head-commit probe instead.
+     */
+    enqueueSkillResync?: (request: SkillSourceResyncRequest) => Promise<void>;
+    notificationRepository?: NotificationRepository;
+    notificationChannel?: NotificationChannel;
+    slackConnectionRepository?: SlackConnectionRepository;
+    slackSettingsRepository?: SlackSettingsRepository;
+    slackMemberMappingRepository?: SlackMemberMappingRepository;
+    slackSecretCipher?: SecretCipher;
+    /**
+     * Per-account deployment settings (Slack OAuth / web-search / Langfuse creds + tuning).
+     * Built in the facade (it needs the repo + cipher, and the facade also wires the
+     * Langfuse sink + web-search proxy off it before Core is built). When present, Core
+     * exposes it for the admin controller and derives the Slack OAuth resolver from it.
+     */
+    accountSettings?: AccountSettingsService;
+    /** Merges the repo default branch into a block's PR branch (human-test "pull main"). */
+    branchUpdater?: BranchUpdater;
+    /**
+     * Resolves the binary-artifact store (UI screenshots + reference designs) for a
+     * workspace's account; the blob backend is configured per-account in the UI. The
+     * visual-confirmation gate calls this with the run's workspace id. Absent (or resolving to
+     * null — storage not configured) → the gate passes through (auto-advances).
+     */
+    resolveBinaryArtifactStore?: ResolveBinaryArtifactStore;
+    /** Performs the real GitHub merge so a task's `done` means "PR merged". */
+    pullRequestMerger?: PullRequestMerger;
+    /**
+     * Publishes the engine's verification report (CI verdict, tester report, ephemeral
+     * environment lifecycle, merge assessment, run metadata + observability deep link) onto the
+     * run's pull request, as a marker-delimited section updated idempotently in place. Composed
+     * per facade from its ENGINE VCS client, so a GitLab deployment publishes through the same
+     * port. Absent → the engine behaves exactly as it did before the feature.
+     */
+    prVerificationReportPublisher?: PrVerificationReportPublisher;
+    /** Stores a workspace's observability connection (provider + sealed credentials). */
+    observabilityConnectionRepository?: ObservabilityConnectionRepository;
+    /** Stores per-block monitor/SLO mappings the post-release-health gate reads. */
+    releaseHealthConfigRepository?: ReleaseHealthConfigRepository;
+    /**
+     * Resolve the NON-secret refs (key + description) of the sensitive test credentials for a run
+     * block's service frame, folded into the tester prompt. Wired from the facade's
+     * `TestSecretsService`; absent ⇒ no advertised secrets. NEVER returns a value.
+     */
+    resolveTestSecretRefs?: (workspaceId: string, blockId: string) => Promise<TestSecretRef[]>;
+    /**
+     * Resolve the PRE-PR VALIDATION CHECKS configured for a SERVICE FRAME — the commands the
+     * harness runs against the checkout before opening a PR. Wired from the facade's
+     * `ValidationConfigService`; absent (or resolving to `null`) ⇒ no checks travel on the job
+     * body and the harness runs its existing path unchanged.
+     *
+     * Keyed by the frame, not the run block: `AgentContextBuilder` walks the frame→module→task
+     * ancestry exactly ONCE per dispatch and threads that frame into every frame-scoped resolver,
+     * so this one reuses it rather than paying a second walk.
+     */
+    resolveValidationChecks?: (workspaceId: string, frameId: string) => Promise<ResolvedValidationChecks | null>;
+    /** Seals observability credentials at rest (domain tag 'cat-factory:observability'). */
+    observabilitySecretCipher?: SecretCipher;
+    /** Stores a workspace's incident-enrichment connection (sealed PagerDuty + incident.io). */
+    incidentEnrichmentConnectionRepository?: IncidentEnrichmentConnectionRepository;
+    /** Seals incident-enrichment creds at rest (domain tag 'cat-factory:incident-enrichment'). */
+    incidentEnrichmentSecretCipher?: SecretCipher;
+    /** Stores a workspace's private package-registry entries (sealed npm/GitHub Packages tokens). */
+    packageRegistryConnectionRepository?: PackageRegistryConnectionRepository;
+    /** Seals registry tokens at rest (domain tag 'cat-factory:package-registries'). */
+    packageRegistrySecretCipher?: SecretCipher;
+    /** Resolves a task's merge threshold preset (auto-merge ceilings + CI attempt budget). */
+    riskPolicyRepository?: RiskPolicyRepository;
+    /** A workspace's shared stacks (long-lived compose infra a consumer environment attaches to). */
+    sharedStackRepository?: SharedStackRepository;
+    /**
+     * The host Docker seam a shared stack's bring-up/teardown drives. Wired ONLY on the local
+     * facade (host daemon); absent elsewhere ⇒ shared-stack CRUD works but the lifecycle endpoints
+     * refuse (the documented compose runtime-binding exception).
+     */
+    composeRuntime?: ComposeRuntime;
+    /**
+     * The VCS token a shared stack's bring-up clones its repo with (for a private `cloneUrl`). Wired
+     * on the local facade from the same source-control PAT the agent containers push with; absent ⇒
+     * unauthenticated clone (public repos only).
+     */
+    sharedStackCloneToken?: string;
+    /**
+     * The host-bound PREFLIGHT probes (docker daemon / disk / RAM / registry login / reachability /
+     * mkcert / hosts / secrets marker). Wired ONLY on the local facade (a host daemon); present ⇒ the
+     * preflight module + API are built and a stack recipe's `prerequisites` are enforced at provision
+     * start. Absent ⇒ the preflight API 503s and a recipe that declares prerequisites fails loudly.
+     */
+    preflightHostProbes?: PreflightHostProbes;
+    sandboxPromptVersionRepository?: SandboxPromptVersionRepository;
+    sandboxFixtureRepository?: SandboxFixtureRepository;
+    sandboxExperimentRepository?: SandboxExperimentRepository;
+    sandboxRunRepository?: SandboxRunRepository;
+    sandboxGradeRepository?: SandboxGradeRepository;
+    /**
+     * Stores a workspace's runtime settings (the human-wait escalation threshold + the
+     * per-service running-task limit policy). Optional and default-off: absent → the
+     * `settings` module isn't assembled, the limit is never enforced, and the escalation
+     * sweep falls back to the built-in default threshold.
+     */
+    workspaceSettingsRepository?: WorkspaceSettingsRepository;
+    /**
+     * Stores per-user settings (today: the user-tier spend budget). Wired by every
+     * persistence-backed facade; absent → the user budget tier is inert (tests/conformance).
+     */
+    userSettingsRepository?: UserSettingsRepository;
+    /**
+     * Stores a workspace's model presets (the named model→agent mappings a task picks
+     * from; each is a base model applied to every agent kind plus per-kind overrides).
+     * Optional and default-off: absent → the `modelPresets` module isn't assembled and
+     * the env routing is used everywhere. When wired, an unpinned step resolves to the
+     * task's selected/default preset (the built-in default points everything at Kimi K2.7).
+     */
+    modelPresetRepository?: ModelPresetRepository;
+    /**
+     * The catalog id of the built-in model preset a fresh workspace is seeded with as its
+     * DEFAULT: Cloudflare/Node deploy `mdp_kimi` (Cloudflare-runnable on the bare baseline),
+     * local deploy `mdp_claude`. Deployment-level, applied only at first seed, so a user's
+     * later manual default choice is always preserved. Absent → the catalog default (Kimi).
+     */
+    defaultModelPresetId?: string;
+    /**
+     * Resolve the provider capabilities (configured direct API keys + subscription
+     * vendors + whether Cloudflare AI is enabled) for a workspace and the run initiator.
+     * The pipeline-start guard uses it to block a run whose steps' canonical models have
+     * no usable provider. Wired by each facade from its API-key + subscription services;
+     * absent → the guard is skipped.
+     */
+    resolveProviderCapabilities?: (workspaceId: string, initiatedBy?: string | null) => Promise<ProviderCapabilities>;
+    /**
+     * Stores a workspace's default service-fragment selection (the best-practice
+     * fragment ids new services inherit). Optional and default-off: absent → the
+     * `serviceFragmentDefaults` module isn't assembled, new services start with no
+     * service-level fragments, and `code-aware` agents only see the block's own pins.
+     */
+    serviceFragmentDefaultsRepository?: ServiceFragmentDefaultsRepository;
+    /**
+     * Persistence for initiatives (the long-running multi-task work container).
+     * When present the initiatives module assembles: the create/read API, the
+     * planning pipeline's plan ingest, and the committer step's tracker mirror.
+     * Absent → the module is off and the initiative pipeline steps fail loudly.
+     */
+    initiativeRepository?: InitiativeRepository;
+    pipelineScheduleRepository?: PipelineScheduleRepository;
+    trackerSettingsRepository?: TrackerSettingsRepository;
+    ticketTrackerProvider?: TicketTrackerProvider;
+    issueWritebackProvider?: IssueWritebackProvider;
+    /**
+     * Optional: assert the workspace has a usable container-agent backend before a run
+     * starts (local mode delegating agents to an unregistered runner pool throws here).
+     * Absent → no start-time check (Cloudflare/Node have a fixed backend).
+     */
+    assertAgentBackendConfigured?: (workspaceId: string) => Promise<void>;
+}
+//# sourceMappingURL=dependencies.d.ts.map