@cat-factory/orchestration 0.124.0 → 0.124.2

package/dist/container/module-registry.d.ts

@@ -0,0 +1,55 @@
+import type { OptionalCoreModules } from '../container.js';
+/** The keys of every optional module a {@link ModuleRegistry} can assemble. */
+export type OptionalModuleKey = keyof OptionalCoreModules;
+/**
+ * A tiny, typed assembly registry for the domain composition root's OPTIONAL modules —
+ * the ~40 features (GitHub, documents, tasks, environments, requirements, notifications,
+ * sandbox, …) that are wired only when their prerequisites are configured.
+ *
+ * It replaces two footguns that grew with every added module in `createCore`:
+ *   1. the ~40 `const x = createX(...)` locals scattered through one 500-line function, and
+ *   2. the ~40 hand-written `...(x ? { x } : {})` conditional spreads in the return object.
+ *
+ * Instead each module is DECLARED once through {@link build} (key + factory), instantiated
+ * ONLY when its factory yields a value (prerequisites configured). The whole set is emitted in
+ * ONE place via {@link assemble} — so adding a module is a single `build(...)` call plus its
+ * `OptionalCoreModules` field, not a four-site edit. Registration order IS dependency order:
+ * `build` RETURNS the freshly-built value, so a module consumed downstream is kept in a local
+ * and passed into the later factories that need it (exactly where the old
+ * `const x = createX(...)` local sat). {@link get} additionally exposes any already-built module
+ * by key for a reader that holds no local. Either way a factory only ever reaches modules built
+ * before it, so ordering is explicit and local rather than positional across a giant function.
+ *
+ * The registry is deliberately a plain sequential builder, NOT a topological resolver: the
+ * composition root has genuine circular late-bindings in its core spine (account ⇄ spend,
+ * engine ⇄ initiative loop) that a declarative graph can't express cleanly, so the spine
+ * stays explicit and only the acyclic optional modules flow through here.
+ */
+export declare class ModuleRegistry {
+    private readonly built;
+    /**
+     * Declare an optional module: run its `factory`, store the result under `key` when it is
+     * defined (its prerequisites were configured), and return it so a downstream factory can keep
+     * it in a local and thread it in. A factory returning `undefined` is a clean no-op — the key is
+     * simply absent from the assembled set, exactly like the old conditional spread.
+     *
+     * Presence is keyed on `!== undefined`, NOT truthiness: every module factory returns an object
+     * or `undefined`, so this matches the removed `...(x ? { x } : {})` spread. A factory that
+     * yielded a defined-but-falsy value (`null` / `0` / `''`) would be KEPT here where the old
+     * spread dropped it — none does, so return `undefined` (never `null`) to mean "absent".
+     */
+    build<K extends OptionalModuleKey>(key: K, factory: () => OptionalCoreModules[K] | undefined): OptionalCoreModules[K] | undefined;
+    /** Read a previously-built optional module (undefined when unwired), for inter-module wiring. */
+    get<K extends OptionalModuleKey>(key: K): OptionalCoreModules[K] | undefined;
+    /**
+     * The assembled optional modules, with unwired keys absent — spread into the `Core` return
+     * alongside the always-present spine. This is the SINGLE site the optional set is emitted from.
+     *
+     * Returning the `Partial<OptionalCoreModules>` backing store AS `OptionalCoreModules` is sound
+     * ONLY because every field of `OptionalCoreModules` is optional, so the two types coincide.
+     * Keep it that way: a NON-optional field would make this a lie — the return type would promise
+     * a key the registry can legitimately omit. A new always-present service belongs on `CoreSpine`.
+     */
+    assemble(): OptionalCoreModules;
+}
+//# sourceMappingURL=module-registry.d.ts.map

package/dist/container/module-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-registry.d.ts","sourceRoot":"","sources":["../../src/container/module-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AAE1D,+EAA+E;AAC/E,MAAM,MAAM,iBAAiB,GAAG,MAAM,mBAAmB,CAAA;AAEzD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAmC;IAEzD;;;;;;;;;;OAUG;IACH,KAAK,CAAC,CAAC,SAAS,iBAAiB,EAC/B,GAAG,EAAE,CAAC,EACN,OAAO,EAAE,MAAM,mBAAmB,CAAC,CAAC,CAAC,GAAG,SAAS,GAChD,mBAAmB,CAAC,CAAC,CAAC,GAAG,SAAS,CAIpC;IAED,iGAAiG;IACjG,GAAG,CAAC,CAAC,SAAS,iBAAiB,EAAE,GAAG,EAAE,CAAC,GAAG,mBAAmB,CAAC,CAAC,CAAC,GAAG,SAAS,CAE3E;IAED;;;;;;;;OAQG;IACH,QAAQ,IAAI,mBAAmB,CAE9B;CACF"}

package/dist/container/module-registry.js

@@ -0,0 +1,61 @@
+/**
+ * A tiny, typed assembly registry for the domain composition root's OPTIONAL modules —
+ * the ~40 features (GitHub, documents, tasks, environments, requirements, notifications,
+ * sandbox, …) that are wired only when their prerequisites are configured.
+ *
+ * It replaces two footguns that grew with every added module in `createCore`:
+ *   1. the ~40 `const x = createX(...)` locals scattered through one 500-line function, and
+ *   2. the ~40 hand-written `...(x ? { x } : {})` conditional spreads in the return object.
+ *
+ * Instead each module is DECLARED once through {@link build} (key + factory), instantiated
+ * ONLY when its factory yields a value (prerequisites configured). The whole set is emitted in
+ * ONE place via {@link assemble} — so adding a module is a single `build(...)` call plus its
+ * `OptionalCoreModules` field, not a four-site edit. Registration order IS dependency order:
+ * `build` RETURNS the freshly-built value, so a module consumed downstream is kept in a local
+ * and passed into the later factories that need it (exactly where the old
+ * `const x = createX(...)` local sat). {@link get} additionally exposes any already-built module
+ * by key for a reader that holds no local. Either way a factory only ever reaches modules built
+ * before it, so ordering is explicit and local rather than positional across a giant function.
+ *
+ * The registry is deliberately a plain sequential builder, NOT a topological resolver: the
+ * composition root has genuine circular late-bindings in its core spine (account ⇄ spend,
+ * engine ⇄ initiative loop) that a declarative graph can't express cleanly, so the spine
+ * stays explicit and only the acyclic optional modules flow through here.
+ */
+export class ModuleRegistry {
+    built = {};
+    /**
+     * Declare an optional module: run its `factory`, store the result under `key` when it is
+     * defined (its prerequisites were configured), and return it so a downstream factory can keep
+     * it in a local and thread it in. A factory returning `undefined` is a clean no-op — the key is
+     * simply absent from the assembled set, exactly like the old conditional spread.
+     *
+     * Presence is keyed on `!== undefined`, NOT truthiness: every module factory returns an object
+     * or `undefined`, so this matches the removed `...(x ? { x } : {})` spread. A factory that
+     * yielded a defined-but-falsy value (`null` / `0` / `''`) would be KEPT here where the old
+     * spread dropped it — none does, so return `undefined` (never `null`) to mean "absent".
+     */
+    build(key, factory) {
+        const value = factory();
+        if (value !== undefined)
+            this.built[key] = value;
+        return value;
+    }
+    /** Read a previously-built optional module (undefined when unwired), for inter-module wiring. */
+    get(key) {
+        return this.built[key];
+    }
+    /**
+     * The assembled optional modules, with unwired keys absent — spread into the `Core` return
+     * alongside the always-present spine. This is the SINGLE site the optional set is emitted from.
+     *
+     * Returning the `Partial<OptionalCoreModules>` backing store AS `OptionalCoreModules` is sound
+     * ONLY because every field of `OptionalCoreModules` is optional, so the two types coincide.
+     * Keep it that way: a NON-optional field would make this a lie — the return type would promise
+     * a key the registry can legitimately omit. A new always-present service belongs on `CoreSpine`.
+     */
+    assemble() {
+        return this.built;
+    }
+}
+//# sourceMappingURL=module-registry.js.map

package/dist/container/module-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-registry.js","sourceRoot":"","sources":["../../src/container/module-registry.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,OAAO,cAAc;IACR,KAAK,GAAiC,EAAE,CAAA;IAEzD;;;;;;;;;;OAUG;IACH,KAAK,CACH,GAAM,EACN,OAAiD;QAEjD,MAAM,KAAK,GAAG,OAAO,EAAE,CAAA;QACvB,IAAI,KAAK,KAAK,SAAS;YAAE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;QAChD,OAAO,KAAK,CAAA;IACd,CAAC;IAED,iGAAiG;IACjG,GAAG,CAA8B,GAAM;QACrC,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;IACxB,CAAC;IAED;;;;;;;;OAQG;IACH,QAAQ;QACN,OAAO,IAAI,CAAC,KAAK,CAAA;IACnB,CAAC;CACF"}

package/dist/container/modules.d.ts

@@ -0,0 +1,194 @@
+/**
+ * Optional-module FACTORY functions for the domain composition root.
+ *
+ * Extracted verbatim from `container.ts` (no behaviour change): each `createXModule` assembles
+ * one optional feature's services when its prerequisites (repositories / cipher / provider) are
+ * configured, else returns `undefined`. `createCore` declares each through the
+ * {@link ModuleRegistry} and reads them back for the engine wiring. Kept in their own file so the
+ * composition root (`container.ts`) holds the `CoreDependencies`/`Core` contract + the spine
+ * assembly, and the ~30 leaf factories live next to each other here.
+ *
+ * The module INTERFACES and the `CoreDependencies`/`Core` types stay in `container.ts` (imported
+ * back here type-only), so the value dependency is one-way `container.ts` → this file.
+ */
+import type { AppCaches, Block, ExecutionEventPublisher } from '@cat-factory/kernel';
+import { type AgentKindRegistry } from '@cat-factory/agents';
+import { PreflightService, ProvisioningLogRecorder, SharedStackService, TaskConnectionService } from '@cat-factory/integrations';
+import { BoardService } from '../modules/board/BoardService.js';
+import { ExecutionService } from '../modules/execution/ExecutionService.js';
+import { DocInterviewService } from '../modules/docInterview/DocInterviewService.js';
+import { ForkChatService } from '../modules/execution/ForkChatService.js';
+import { TesterQualityReviewService } from '../modules/execution/TesterQualityReviewService.js';
+import { NotificationService } from '../modules/notifications/NotificationService.js';
+import type { BootstrapModule, BrainstormModule, ClarityModule, CoreDependencies, DocumentsModule, EnvironmentsModule, FragmentLibraryModule, GitHubModule, IncidentEnrichmentModule, KaizenModule, ModelPresetsModule, NotificationsModule, PackageRegistriesModule, PreflightsModule, PreviewModule, RecurringModule, ReleaseHealthModule, RequirementsModule, RiskPoliciesModule, RunnersModule, SandboxModule, ServiceFragmentDefaultsModule, ServicesModule, SharedStacksModule, SlackModule, TasksModule, TrackerModule, WorkspaceSettingsModule } from '../container.js';
+export declare function createServicesModule(deps: CoreDependencies): ServicesModule | undefined;
+/**
+ * Assemble the GitHub module when every dependency it needs is present;
+ * otherwise return undefined so the feature stays cleanly opt-in.
+ */
+export declare function createGitHubModule(deps: CoreDependencies, caches: AppCaches): GitHubModule | undefined;
+/**
+ * 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.
+ */
+export declare function createDocumentsModule(deps: CoreDependencies, boardService: BoardService): DocumentsModule | undefined;
+/**
+ * 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.
+ */
+export declare function createTasksModule(deps: CoreDependencies, boardService: BoardService): TasksModule | undefined;
+/**
+ * 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).
+ */
+export declare function createEnvironmentsModule(deps: CoreDependencies, provisioningLog: ProvisioningLogRecorder | undefined, eventPublisher: ExecutionEventPublisher | undefined, sharedStackService: SharedStackService | undefined, preflightService: PreflightService | undefined): EnvironmentsModule | undefined;
+/**
+ * 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.
+ */
+export declare function createRunnersModule(deps: CoreDependencies): RunnersModule | undefined;
+/**
+ * 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.
+ */
+export declare function createBootstrapModule(deps: CoreDependencies, eventPublisher: ExecutionEventPublisher, onBootstrapSucceeded?: (workspaceId: string, blockId: string) => Promise<void>): BootstrapModule | undefined;
+/**
+ * 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.
+ */
+/**
+ * Build the inline reviewer for the test quality-control companion. It resolves its model
+ * exactly like the requirements reviewer (block pin → workspace per-kind default → routing
+ * default). Returns `undefined` when no model provider is configured, so the Tester gate's QC
+ * step is a pass-through in unconfigured facades / tests.
+ */
+export declare function createTesterQualityReviewer(deps: CoreDependencies): TesterQualityReviewService | undefined;
+/**
+ * Build the interactive document-interview service (WS5). Self-contained (owns its session
+ * store + the inline LLM); resolves its model exactly like the requirements reviewer (block
+ * pin → workspace per-kind default → routing default). Returns `undefined` when no session
+ * store is wired, so the `doc-interviewer` step passes through in unconfigured facades / tests.
+ * The LLM is optional within the service (the `enabled` getter is false without a model), so a
+ * store-but-no-model deployment still short-circuits the interviewer.
+ */
+export declare function createDocInterviewService(deps: CoreDependencies): DocInterviewService | undefined;
+/**
+ * Build the inline grounded-chat responder for the implementation-fork decision phase. Resolves
+ * its model exactly like the requirements reviewer / doc interviewer (block pin → workspace
+ * per-kind default → routing default). Returns `undefined` when no model provider is configured,
+ * so the fork chat degrades to a canned "chat unavailable" reply in unconfigured facades / tests
+ * while pick / custom keep working. Stateless — the chat rides the coder step, no session store.
+ */
+export declare function createForkChatService(deps: CoreDependencies): ForkChatService | undefined;
+/**
+ * Resolve a block's active run (execution id + initiator) for the iterative reviewers, so an
+ * inline subscription reviewer served through a leased per-run activation can lease it. Reads
+ * the block's `executionId` and the run's `initiatedBy`; `{}` when the block has no active run
+ * (an off-path inspector review with no pipeline) — the reviewer then resolves on a
+ * workspace-only scope (pooled lease), unchanged.
+ */
+export declare function resolveBlockRunContext(deps: CoreDependencies): (workspaceId: string, block: Block) => Promise<{
+    executionId?: string;
+    userId?: string;
+}>;
+export declare function createRequirementsModule(deps: CoreDependencies, notificationService?: NotificationService, fragmentLibrary?: FragmentLibraryModule): RequirementsModule | undefined;
+/**
+ * Assemble the brainstorm (structured-dialogue) module when its repository is present (both
+ * runtime facades wire it unconditionally). Mirrors {@link createClarityModule}: it builds ONE
+ * {@link BrainstormService} per stage (sharing the repository) and reuses the requirements
+ * reviewer's model config since all the inline reviewers resolve their model identically. The
+ * architecture stage seeds from the refined requirements (a requirements review's incorporated
+ * doc, else the requirements-brainstorm's converged direction).
+ */
+export declare function createBrainstormModule(deps: CoreDependencies, notificationService?: NotificationService): BrainstormModule | undefined;
+/**
+ * Assemble the Kaizen module when its repositories are wired (both runtime facades wire them
+ * unconditionally). The grader resolves its model for the `kaizen` kind the same way the
+ * requirements reviewer does — block pin > workspace per-kind default > routing default —
+ * so operators configure it in Model Configuration alongside every other agent. Needs the
+ * telemetry repos (LLM-call metrics + agent-context snapshots) to read what each step was
+ * given; absent → the module isn't built and no grading is scheduled.
+ */
+export declare function createKaizenModule(deps: CoreDependencies): KaizenModule | undefined;
+/**
+ * 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.
+ */
+export declare function createClarityModule(deps: CoreDependencies, notificationService?: NotificationService): ClarityModule | undefined;
+/**
+ * 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.
+ */
+export declare function createNotificationsModule(deps: CoreDependencies): NotificationsModule | undefined;
+/**
+ * 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.
+ */
+export declare function createSlackModule(deps: CoreDependencies): SlackModule | undefined;
+/** Assemble the merge-preset module when its repository is present. */
+export declare function createRiskPoliciesModule(deps: CoreDependencies, caches: AppCaches): RiskPoliciesModule | undefined;
+/**
+ * Assemble the shared-stacks module when its repository is present. The `composeRuntime` is
+ * optional — wired only on the local facade, so CRUD works everywhere but the lifecycle
+ * (ensureUp/teardown) refuses without a host daemon (the documented compose runtime-binding
+ * exception). Persistence is fully runtime-symmetric.
+ */
+export declare function createSharedStacksModule(deps: CoreDependencies, preflightService: PreflightService | undefined): SharedStacksModule | undefined;
+/**
+ * Assemble the preflight module when the host-probe seam is present — wired ONLY on the local
+ * facade (a host Docker daemon), the documented compose runtime-binding exception. Absent elsewhere
+ * ⇒ the preflight API 503s and a stack recipe that declares `prerequisites` fails loudly at
+ * provision (rather than silently skipping a declared machine-prerequisite gate).
+ */
+export declare function createPreflightModule(deps: CoreDependencies): PreflightsModule | undefined;
+/**
+ * Assemble the Sandbox module when its five repositories are present (both runtime
+ * facades wire them together). Reuses the requirements reviewer's inline model config —
+ * the per-scope provider resolver, the routing default ref, and the block-model resolver
+ * — so a Sandbox cell (and the judge) resolves its catalog id exactly like a pipeline step.
+ */
+export declare function createSandboxModule(deps: CoreDependencies, agentKindRegistry: AgentKindRegistry): SandboxModule | undefined;
+/** Assemble the workspace-settings module when its repository is present. */
+export declare function createWorkspaceSettingsModule(deps: CoreDependencies, workspaceSettingsCache: AppCaches['workspaceSettings']): WorkspaceSettingsModule | undefined;
+/** Assemble the release-health (observability) module when its repos + cipher are present. */
+export declare function createReleaseHealthModule(deps: CoreDependencies): ReleaseHealthModule | undefined;
+/** Assemble the package-registries module when its repo + cipher are present. */
+export declare function createPackageRegistriesModule(deps: CoreDependencies): PackageRegistriesModule | undefined;
+/**
+ * Assemble the browsable-frontend-preview module when its per-runtime transport + the facade's
+ * job builder + the env registry are all wired (local/node with a host-port-publish runtime).
+ * Absent on the Worker (no preview transport) ⇒ the controller 503s there.
+ */
+export declare function createPreviewModule(deps: CoreDependencies): PreviewModule | undefined;
+/** Assemble the incident-enrichment settings module when its repo + cipher are present. */
+export declare function createIncidentEnrichmentModule(deps: CoreDependencies): IncidentEnrichmentModule | undefined;
+/** Assemble the model-presets module when its repository is present. */
+export declare function createModelPresetsModule(deps: CoreDependencies): ModelPresetsModule | undefined;
+/** Assemble the service-fragment-defaults module when its repository is present. */
+export declare function createServiceFragmentDefaultsModule(deps: CoreDependencies): ServiceFragmentDefaultsModule | undefined;
+/** Assemble the tracker-settings module when its repository is present. */
+export declare function createTrackerModule(deps: CoreDependencies): TrackerModule | undefined;
+/**
+ * Assemble the recurring-pipeline module when its repository is present. Built
+ * after the execution engine since each fire starts a pipeline through it.
+ */
+export declare function createRecurringModule(deps: CoreDependencies, executionService: ExecutionService, executionEventPublisher: ExecutionEventPublisher, taskConnectionService?: TaskConnectionService): RecurringModule | undefined;
+//# sourceMappingURL=modules.d.ts.map

package/dist/container/modules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modules.d.ts","sourceRoot":"","sources":["../../src/container/modules.ts"],"names":[],"mappings":"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"}