@atolis-hq/wake 0.3.19 → 0.3.20

package/dist/src/activities/pr/application.js

@@ -1,6 +1,6 @@
 import { resourceStream, } from '../../resources/index.js';
 import { workItemStream } from '../../work/index.js';
-import { ActivityEventType } from '../contracts/events.js';
+import { ActivityEventType, selectActivityEvent, } from '../contracts/events.js';
 import { ActivityResourceRole } from '../contracts/vocabulary.js';
 import { isReviewAuthorized } from '../review/authorization.js';
 import { isPullRequestLikeResource } from './capability.js';
@@ -24,6 +24,10 @@ class JournalPullRequestService {
         const events = await this.journal.readStream(resourceStream(resourceId));
         return events.reduce((view, event) => pullRequestProjection.project(view, event), pullRequestProjection.initial(resourceId));
     }
+    async factsFor(resourceId) {
+        const events = await this.journal.readStream(resourceStream(resourceId));
+        return events.map(selectActivityEvent).filter(isPresent);
+    }
     async observe(command, context) {
         if (!(await this.hasVerifiedPrimaryCorrelation(command)))
             throw new Error('Pull request lacks verified primary correlation');

package/dist/src/activities/pr/policy.js

@@ -55,6 +55,16 @@ function hasPrimaryCorrelationConflict(resource, workItemId) {
         primary.length !== 1 ||
         primary[0].workItemId !== workItemId);
 }
+// Happy-path wrapper over the same primary-resource and pull-request
+// selection rules `decidePullRequestAuthority` uses, for callers that only
+// need the selected pair and not a specific denial code.
+export function selectPrimaryPullRequest(input, workItemId) {
+    const resource = selectResource(input, workItemId, ActivityResourceRole.Primary);
+    if (isDenial(resource))
+        return null;
+    const pullRequest = selectPullRequest(input, resource, workItemId);
+    return isDenial(pullRequest) ? null : { resource, pullRequest };
+}
 function selectResource(input, workItemId, target) {
     const resources = input.resources.filter((entry) => isPrimaryPullRequest(entry, workItemId) &&
         (target === ActivityResourceRole.Primary || entry.resource.resourceId === target.resourceId));

package/dist/src/bootstrap/activity-registry.js

@@ -0,0 +1,32 @@
+import { ActivityRegistry, agentActivityDefinition, createAgentActivity, createIssueCompleteActivity, createPullRequestApproveActivity, createPullRequestMergeActivity, } from '../activities/index.js';
+import { loadPromptTemplate, renderPromptTemplate } from '../execution/index.js';
+import { createStatusPublishActivity } from './status-publish-activity.js';
+export function createBuiltInActivityRegistry(journal, pullRequests, resources, wakeRoot, contextReader) {
+    const activities = new ActivityRegistry();
+    activities.register({
+        ...agentActivityDefinition,
+        handler: createAgentActivity({
+            async render(name, context) {
+                const template = await loadPromptTemplate(wakeRoot, name);
+                return {
+                    prompt: renderPromptTemplate(template, context),
+                    ...(template.frontmatter.model === undefined || template.frontmatter.model === null
+                        ? {}
+                        : { model: template.frontmatter.model }),
+                    ...(template.frontmatter.allowedTools === undefined ||
+                        template.frontmatter.allowedTools === null
+                        ? {}
+                        : { allowedTools: template.frontmatter.allowedTools }),
+                    ...(template.frontmatter.maxTurns === undefined
+                        ? {}
+                        : { maxTurns: template.frontmatter.maxTurns }),
+                };
+            },
+        }, contextReader),
+    });
+    activities.register(createStatusPublishActivity(journal));
+    activities.register(createIssueCompleteActivity(journal, resources));
+    activities.register(createPullRequestApproveActivity(journal, pullRequests));
+    activities.register(createPullRequestMergeActivity(journal, pullRequests));
+    return activities;
+}

package/dist/src/bootstrap/composition-root.js

@@ -1,25 +1,21 @@
-import { ActivityRegistry, agentActivityDefinition, createAgentActivity, createIssueCompleteActivity, createPullRequestApproveActivity, createPullRequestMergeActivity, createPullRequestService, } from '../activities/index.js';
-import { ControlStreamKind, DispatchPolicy, ScheduleService, createAdvanceOnce, createControlPlaneService, createIntakePipeline, createRunnerControlService, createRunnerPipeline, createWorkCancellationPolicy, ineligibleRunners, } from '../control-plane/index.js';
-import { ExternalExecutionState, GitWorkspaceProvider, RecoveryService, RunRepository, TranscriptStore, createExecutionService, loadPromptTemplate, renderPromptTemplate, } from '../execution/index.js';
-import { AgentRunPublicationReactor, ArtifactRegistrationReactor, DeliveryOutcomeReactor, DeliveryService, IntegrationStreamKind, PollService, ProviderRegistry, fakeProviderDefinition, } from '../integrations/index.js';
-import { EventActorKind, SystemClock, UlidIdGenerator, } from '../kernel/index.js';
-import { compileWorkflow, compileWorkflowSelectors, createOrchestrationService, createWatchReactor, selectWorkflow, workflowName, } from '../orchestration/index.js';
-import { FileCheckpointStore, FileEventJournal, FileProjectionStore, } from '../persistence/index.js';
-import { createResourceLookup, createResourceService, resourceId, } from '../resources/index.js';
-// The shared Integration barrel must not re-export a provider namespace
-// (see provider-locality); composition-root is the exempt production
-// composition point that is allowed to name it directly.
+import { createPullRequestService } from '../activities/index.js';
+import { ControlStreamKind, DispatchPolicy, createAdvanceOnce, createControlPlaneService, createRunnerControlService, ineligibleRunners, } from '../control-plane/index.js';
+import { ExternalExecutionState, GitWorkspaceProvider, RecoveryService, TranscriptStore, createExecutionService, } from '../execution/index.js';
 import { createGitHubAgentContextReader, gitHubProviderDefinition, resolveGitHubResourceUrl, } from '../integrations/github/index.js';
-import { WorkStatus, createWorkService } from '../work/index.js';
+import { SystemClock, UlidIdGenerator, } from '../kernel/index.js';
+import { compileWorkflow, createOrchestrationService } from '../orchestration/index.js';
+import { createResourceLookup, createResourceService, resourceId, } from '../resources/index.js';
+import { createWorkService } from '../work/index.js';
+import { createBuiltInActivityRegistry } from './activity-registry.js';
 import { loadConfig } from './config/load-config.js';
-import { hydrateFakeProviderEvidence } from './fake-provider-files.js';
 import { loadFakeScenarios } from './fake-scenarios.js';
+import { composeIntegrationRuntime } from './integration-runtime.js';
 import { resolveWakePaths } from './paths.js';
-import { createRuntimeProjectionRunner } from './projection-runtime.js';
+import { composePersistence } from './persistence-composition.js';
 import { createRunnerQuotaReporter } from './runner-quota-reporter.js';
 import { createRunnerRegistry } from './runner-registry.js';
 import { FileScheduleCheckpointStore } from './schedule-checkpoint-store.js';
-import { createStatusPublishActivity } from './status-publish-activity.js';
+import { createTranscriptRetention } from './transcript-retention.js';
 import { createUpdateMaintenanceLease, } from './update-maintenance-lease.js';
 const resourceLinkResolvers = {
     github: resolveGitHubResourceUrl,
@@ -27,7 +23,6 @@ const resourceLinkResolvers = {
 function resolveResourceLink(externalKey) {
     return resourceLinkResolvers[externalKey.adapter]?.(externalKey) ?? null;
 }
-// Composition is deliberately the one place that assembles every module.
 // eslint-disable-next-line complexity
 export async function createCompositionRoot(wakeRoot, options = {}) {
     const config = options.config ?? (await loadConfig(wakeRoot));
@@ -36,12 +31,13 @@ export async function createCompositionRoot(wakeRoot, options = {}) {
     const maintenance = createUpdateMaintenanceLease(paths.wakeRoot);
     const clock = options.clock ?? new SystemClock();
     const ids = new UlidIdGenerator();
-    const { journal, projections, checkpoints } = composePersistence(paths, clock, options);
+    const { journal, projections, checkpoints, resourceTransitionOrdering, resourceTransitionTriggers, } = composePersistence(paths, clock, options);
     const work = createWorkService(journal);
     const lookup = createResourceLookup({ journal, projections });
     const resources = createResourceService(journal, lookup);
     const pullRequests = createPullRequestService(journal, work, resources);
-    const activities = options.activities ?? createBuiltInActivityRegistry(journal, pullRequests, resources, wakeRoot);
+    const activities = options.activities ??
+        createBuiltInActivityRegistry(journal, pullRequests, resources, wakeRoot, createGitHubAgentContextReader(journal, resources));
     const definitions = Object.fromEntries(Object.entries(config.orchestration.workflows).map(([name, definition]) => [
         name,
         compileWorkflow(name, definition, activities, Object.keys(config.orchestration.workflows)),
@@ -76,9 +72,7 @@ export async function createCompositionRoot(wakeRoot, options = {}) {
     });
     const recovery = new RecoveryService(journal, clock, {
         async inspect() {
-            // Runner adapters do not yet expose a portable process-inspection API.
-            // Preserve safety on restart: unknown external work is reconciled through
-            // the existing ambiguity path rather than being guessed as absent.
+            // Unknown external work follows the safe ambiguity path until runners expose inspection.
             return {
                 kind: ExternalExecutionState.Unknown,
                 reason: 'External execution inspection is not configured for this runtime',
@@ -86,7 +80,7 @@ export async function createCompositionRoot(wakeRoot, options = {}) {
         },
     }, activities, config.execution, orchestration);
     const controlPlane = createControlPlaneService({ journal, clock, ids });
-    const isRuntimePaused = async () => (await controlPlane.isPaused()) || (await maintenanceBlocksRuntime(maintenance));
+    const isRuntimePaused = async () => (await controlPlane.isPaused()) || (await maintenance.read()) !== null;
     const runnerControls = createRunnerControlService({
         journal,
         clock,
@@ -104,29 +98,7 @@ export async function createCompositionRoot(wakeRoot, options = {}) {
         work,
         ...(transcriptStore === undefined
             ? {}
-            : {
-                transcriptRetention: {
-                    async markClosedWorkItem(workItemId) {
-                        try {
-                            await transcriptStore.markWorkItemCleaned(workItemId, config.transcripts.retentionMs, clock.now().toISOString());
-                            return true;
-                        }
-                        catch (error) {
-                            console.error('Transcript retention failed', error);
-                            return false;
-                        }
-                    },
-                    async sweep() {
-                        try {
-                            await transcriptStore.sweepExpired(config.transcripts.retentionMs, clock.now().toISOString(), (_workItemId, error) => console.error('Transcript retention failed', error));
-                        }
-                        catch (error) {
-                            console.error('Transcript retention failed', error);
-                        }
-                    },
-                },
-                closedWorkItemIds: () => closedWorkItemIds(projections),
-            }),
+            : createTranscriptRetention(transcriptStore, projections, config, clock)),
         runnerIneligibility: async () => {
             const stored = await projections.read(ControlStreamKind.Global, 'global');
             return stored === null
@@ -153,12 +125,15 @@ export async function createCompositionRoot(wakeRoot, options = {}) {
         ids,
         wakeRoot,
         scheduleCheckpoints: options.scheduleCheckpoints ?? new FileScheduleCheckpointStore(paths.dataRoot),
+        resourceTransitionOrdering,
+        resourceTransitionTriggers,
         ...(options.decorateDeliveryAdapter === undefined
             ? {}
             : { decorateDeliveryAdapter: options.decorateDeliveryAdapter }),
         ...(options.fakeDeliveryProvider === undefined
             ? {}
             : { fakeDeliveryProvider: options.fakeDeliveryProvider }),
+        providerDefinitions: [gitHubProviderDefinition],
     });
     return {
         config,
@@ -183,202 +158,3 @@ export async function createCompositionRoot(wakeRoot, options = {}) {
         ...runtime,
     };
 }
-async function maintenanceBlocksRuntime(maintenance) {
-    return (await maintenance.read()) !== null;
-}
-async function closedWorkItemIds(projections) {
-    return (await projections.list('work')).flatMap(({ value }) => value?.state === WorkStatus.Closed ? [value.workItemId] : []);
-}
-function serializeRunRegisteredOnce(runner) {
-    let queue = Promise.resolve();
-    const runRegisteredOnce = runner.runRegisteredOnce.bind(runner);
-    runner.runRegisteredOnce = (limit) => {
-        const result = queue.then(() => runRegisteredOnce(limit));
-        queue = result.catch(() => { });
-        return result;
-    };
-    return runner;
-}
-async function composeIntegrationRuntime(input) {
-    const registry = new ProviderRegistry();
-    registry.register(fakeProviderDefinition);
-    registry.register(gitHubProviderDefinition);
-    const { instances, failures: providerFailures } = registry.compose(await hydrateFakeProviderEvidence(input.wakeRoot, input.config.integrations), {
-        publicUiUrl: input.config.surfaces.web.publicUrl,
-        work: input.work,
-        resources: input.resources,
-        resourceLookup: input.lookup,
-        pullRequests: input.pullRequests,
-        runs: new RunRepository(input.journal),
-        orchestration: input.orchestration,
-        ids: input.ids,
-        clock: input.clock,
-        journal: input.journal,
-        checkpoints: input.checkpoints,
-        routing: createWorkflowRouter(input.config.orchestration),
-        conclusion: createWorkCancellationPolicy(input.work, input.orchestration, input.execution, input.clock, input.ids),
-    });
-    const composedProviders = input.fakeDeliveryProvider === undefined
-        ? instances
-        : instances.map((provider) => provider.adapter === 'fake'
-            ? { ...provider, delivery: input.fakeDeliveryProvider }
-            : provider);
-    const providers = input.decorateDeliveryAdapter
-        ? composedProviders.map((provider) => ({
-            ...provider,
-            delivery: input.decorateDeliveryAdapter(provider.delivery, provider),
-        }))
-        : composedProviders;
-    // FileCheckpointStore.save throws on any regression (persistence/filesystem/
-    // file-checkpoint-store.ts), so two concurrent runRegisteredOnce calls that
-    // interleave can race a slower caller's stale checkpoint save against a
-    // faster one that already advanced past it. Every caller (the tick
-    // pipeline's own catchUpProjections, the API's manual tick, and the
-    // resident's standalone projection pump) shares this one instance, so
-    // serializing it here in-process covers all of them without a file lock.
-    const projectionRunner = serializeRunRegisteredOnce(createRuntimeProjectionRunner(input.journal, input.projections, input.checkpoints));
-    const delivery = new DeliveryService({
-        journal: input.journal,
-        intents: async () => (await input.projections.list(IntegrationStreamKind.Delivery)).map(({ value }) => value),
-        resource: async (id) => {
-            const resource = await input.resources.get(resourceId(id));
-            return resource === null
-                ? null
-                : { resourceId: resource.resourceId, adapter: resource.externalKey.adapter };
-        },
-        adapter: (name) => {
-            const provider = providers.find((candidate) => candidate.adapter === name);
-            if (provider === undefined)
-                throw new Error(`Delivery provider ${name} is not configured`);
-            return provider.delivery;
-        },
-        now: () => input.clock.now().toISOString(),
-    });
-    const schedules = new ScheduleService({
-        checkpoint: input.scheduleCheckpoints,
-        ids: input.ids,
-        work: input.work,
-        orchestration: input.orchestration,
-        now: () => input.clock.now().toISOString(),
-    });
-    const artifacts = new ArtifactRegistrationReactor({
-        journal: input.journal,
-        checkpoints: input.checkpoints,
-        resources: input.resources,
-        ids: input.ids,
-        providers,
-        runs: input.execution,
-    });
-    const runs = new RunRepository(input.journal);
-    const agentRunPublications = new AgentRunPublicationReactor({
-        journal: input.journal,
-        checkpoints: input.checkpoints,
-        runs,
-        resources: input.resources,
-        orchestration: input.orchestration,
-    });
-    const watch = createWatchReactor(input.orchestration, input.journal, input.checkpoints, runs);
-    const outcomes = new DeliveryOutcomeReactor(input.journal, input.checkpoints, input.orchestration);
-    const catchUpProjections = async () => {
-        await projectionRunner.runRegisteredOnce();
-    };
-    // Only poll hits a rate-limited external API, so only this half of the
-    // tick needs a backing-off host — see bootstrap/surface-cli-applications.ts.
-    const intakePipeline = createIntakePipeline({
-        isPaused: input.isPaused,
-        catchUpProjections,
-        poll: async (signal) => {
-            let appended = 0;
-            for (const provider of providers)
-                appended += await new PollService(input.journal, provider).pollOnce(signal);
-            return appended;
-        },
-        translateInbound: async () => {
-            let translated = 0;
-            for (const provider of providers)
-                translated += await provider.inbound.runOnce();
-            return translated;
-        },
-    });
-    const runnerPipeline = createRunnerPipeline({
-        isPaused: input.isPaused,
-        catchUpProjections,
-        runSchedules: async () => {
-            for (const schedule of input.config.controlPlane.schedules)
-                await schedules.run(schedule, {
-                    commandId: input.ids.next('command'),
-                    correlationId: 'schedule-tick',
-                    occurredAt: input.clock.now().toISOString(),
-                    actor: { kind: EventActorKind.System, id: ControlStreamKind.Global },
-                });
-        },
-        react: async () => {
-            await watch.runOnce();
-            await artifacts.runOnce();
-            await outcomes.runOnce();
-            for (const provider of providers)
-                await provider.maintenance?.runOnce();
-        },
-        advance: input.advanceOnce,
-        publishAgentRuns: async () => {
-            await agentRunPublications.runOnce();
-        },
-        deliver: async (signal) => {
-            await delivery.deliverNext(signal);
-        },
-    });
-    return {
-        projectionRunner,
-        providers,
-        providerFailures,
-        delivery,
-        intakePipeline,
-        runnerPipeline,
-    };
-}
-function identity(value) {
-    return value;
-}
-function composePersistence(paths, clock, options) {
-    return {
-        journal: (options.decorateJournal ?? identity)(options.journal ?? new FileEventJournal(paths.dataRoot, clock)),
-        projections: (options.decorateProjections ?? identity)(options.projections ?? new FileProjectionStore(paths.dataRoot)),
-        checkpoints: (options.decorateCheckpoints ?? identity)(options.checkpoints ?? new FileCheckpointStore(paths.dataRoot)),
-    };
-}
-function createBuiltInActivityRegistry(journal, pullRequests, resources, wakeRoot) {
-    const activities = new ActivityRegistry();
-    const contextReader = createGitHubAgentContextReader(journal, resources);
-    activities.register({
-        ...agentActivityDefinition,
-        handler: createAgentActivity({
-            async render(name, context) {
-                const template = await loadPromptTemplate(wakeRoot, name);
-                return {
-                    prompt: renderPromptTemplate(template, context),
-                    ...(template.frontmatter.model === undefined || template.frontmatter.model === null
-                        ? {}
-                        : { model: template.frontmatter.model }),
-                    ...(template.frontmatter.allowedTools === undefined ||
-                        template.frontmatter.allowedTools === null
-                        ? {}
-                        : { allowedTools: template.frontmatter.allowedTools }),
-                    ...(template.frontmatter.maxTurns === undefined
-                        ? {}
-                        : { maxTurns: template.frontmatter.maxTurns }),
-                };
-            },
-        }, contextReader),
-    });
-    activities.register(createStatusPublishActivity(journal));
-    activities.register(createIssueCompleteActivity(journal, resources));
-    activities.register(createPullRequestApproveActivity(journal, pullRequests));
-    activities.register(createPullRequestMergeActivity(journal, pullRequests));
-    return activities;
-}
-// Configuration is the only routing authority: adapters ask, they never propose.
-function createWorkflowRouter(orchestration) {
-    const selectors = compileWorkflowSelectors(orchestration.workflowSelectors);
-    const fallback = workflowName(orchestration.default);
-    return { select: (candidate) => selectWorkflow(candidate, selectors, fallback) };
-}

package/dist/src/bootstrap/index.js

@@ -32,6 +32,8 @@ export function composeControlPlaneHosts(advanceOnce, sleep) {
     return { tick, resident: new ResidentHost(tick, sleep) };
 }
 export * from './composition-root.js';
+export * from './resource-transition-evidence.js';
+export * from './resource-transition-ordering.js';
 export * from './analytics-projection.js';
 export * from './board-projection.js';
 export * from './config/load-config.js';

package/dist/src/bootstrap/integration-runtime.js

@@ -0,0 +1,184 @@
+import { ControlStreamKind, ScheduleService, createIntakePipeline, createRunnerPipeline, createWorkCancellationPolicy, } from '../control-plane/index.js';
+import { RunRepository } from '../execution/index.js';
+import { AgentRunPublicationReactor, ArtifactRegistrationReactor, DeliveryOutcomeReactor, DeliveryService, IntegrationStreamKind, PollService, ProviderRegistry, fakeProviderDefinition, } from '../integrations/index.js';
+import { EventActorKind, } from '../kernel/index.js';
+import { compileWorkflowSelectors, createPullRequestTransitionEvidence, createResourceTransitionReactor, createWatchReactor, selectWorkflow, workflowName, } from '../orchestration/index.js';
+import { BuiltInResourceCapability, resourceId, } from '../resources/index.js';
+import { hydrateFakeProviderEvidence } from './fake-provider-files.js';
+import { createRuntimeProjectionRunner } from './projection-runtime.js';
+import { createCapabilityResourceTransitionEvidence } from './resource-transition-evidence.js';
+function serializeRunRegisteredOnce(runner) {
+    let queue = Promise.resolve();
+    const runRegisteredOnce = runner.runRegisteredOnce.bind(runner);
+    runner.runRegisteredOnce = (limit) => {
+        const result = queue.then(() => runRegisteredOnce(limit));
+        queue = result.catch(() => { });
+        return result;
+    };
+    return runner;
+}
+export async function composeIntegrationRuntime(input) {
+    const registry = new ProviderRegistry();
+    registry.register(fakeProviderDefinition);
+    for (const definition of input.providerDefinitions)
+        registry.register(definition);
+    const { instances, failures: providerFailures } = registry.compose(await hydrateFakeProviderEvidence(input.wakeRoot, input.config.integrations), {
+        publicUiUrl: input.config.surfaces.web.publicUrl,
+        work: input.work,
+        resources: input.resources,
+        resourceLookup: input.lookup,
+        pullRequests: input.pullRequests,
+        runs: new RunRepository(input.journal),
+        orchestration: input.orchestration,
+        ids: input.ids,
+        clock: input.clock,
+        journal: input.journal,
+        checkpoints: input.checkpoints,
+        routing: createWorkflowRouter(input.config.orchestration),
+        conclusion: createWorkCancellationPolicy(input.work, input.orchestration, input.execution, input.clock, input.ids),
+    });
+    const composedProviders = input.fakeDeliveryProvider === undefined
+        ? instances
+        : instances.map((provider) => provider.adapter === 'fake'
+            ? { ...provider, delivery: input.fakeDeliveryProvider }
+            : provider);
+    const providers = input.decorateDeliveryAdapter
+        ? composedProviders.map((provider) => ({
+            ...provider,
+            delivery: input.decorateDeliveryAdapter(provider.delivery, provider),
+        }))
+        : composedProviders;
+    // FileCheckpointStore.save throws on any regression (persistence/filesystem/
+    // file-checkpoint-store.ts), so two concurrent runRegisteredOnce calls that
+    // interleave can race a slower caller's stale checkpoint save against a
+    // faster one that already advanced past it. Every caller (the tick
+    // pipeline's own catchUpProjections, the API's manual tick, and the
+    // resident's standalone projection pump) shares this one instance, so
+    // serializing it here in-process covers all of them without a file lock.
+    const projectionRunner = serializeRunRegisteredOnce(createRuntimeProjectionRunner(input.journal, input.projections, input.checkpoints));
+    const delivery = new DeliveryService({
+        journal: input.journal,
+        intents: async () => (await input.projections.list(IntegrationStreamKind.Delivery)).map(({ value }) => value),
+        resource: async (id) => {
+            const resource = await input.resources.get(resourceId(id));
+            return resource === null
+                ? null
+                : { resourceId: resource.resourceId, adapter: resource.externalKey.adapter };
+        },
+        adapter: (name) => {
+            const provider = providers.find((candidate) => candidate.adapter === name);
+            if (provider === undefined)
+                throw new Error(`Delivery provider ${name} is not configured`);
+            return provider.delivery;
+        },
+        now: () => input.clock.now().toISOString(),
+    });
+    const schedules = new ScheduleService({
+        checkpoint: input.scheduleCheckpoints,
+        ids: input.ids,
+        work: input.work,
+        orchestration: input.orchestration,
+        now: () => input.clock.now().toISOString(),
+    });
+    const artifacts = new ArtifactRegistrationReactor({
+        journal: input.journal,
+        checkpoints: input.checkpoints,
+        resources: input.resources,
+        ids: input.ids,
+        providers,
+        runs: input.execution,
+    });
+    const runs = new RunRepository(input.journal);
+    const agentRunPublications = new AgentRunPublicationReactor({
+        journal: input.journal,
+        checkpoints: input.checkpoints,
+        runs,
+        resources: input.resources,
+        orchestration: input.orchestration,
+    });
+    const watch = createWatchReactor(input.orchestration, input.journal, input.checkpoints, runs);
+    const resourceTransitionEvidence = createCapabilityResourceTransitionEvidence({
+        resources: input.resources,
+        policies: [
+            {
+                capabilities: [
+                    BuiltInResourceCapability.Mergeable,
+                    BuiltInResourceCapability.Reviewable,
+                    BuiltInResourceCapability.Approvable,
+                ],
+                policy: createPullRequestTransitionEvidence(input.pullRequests),
+            },
+        ],
+    });
+    input.resourceTransitionTriggers.register(resourceTransitionEvidence.triggers);
+    input.resourceTransitionTriggers.freeze();
+    const resourceTransitions = createResourceTransitionReactor(input.orchestration, resourceTransitionEvidence, input.journal, input.checkpoints, input.resourceTransitionOrdering);
+    input.orchestration.setAcceptSignalOperationCoordinator((operation) => input.resourceTransitionOrdering(async () => {
+        await resourceTransitions.drain();
+        return operation();
+    }));
+    const outcomes = new DeliveryOutcomeReactor(input.journal, input.checkpoints, input.orchestration);
+    const catchUpProjections = async () => {
+        await projectionRunner.runRegisteredOnce();
+    };
+    // Only poll hits a rate-limited external API, so only this half of the
+    // Tick needs a backing-off host; see bootstrap/surface-cli-applications.ts.
+    const intakePipeline = createIntakePipeline({
+        isPaused: input.isPaused,
+        catchUpProjections,
+        poll: async (signal) => {
+            let appended = 0;
+            for (const provider of providers)
+                appended += await new PollService(input.journal, provider).pollOnce(signal);
+            return appended;
+        },
+        translateInbound: async () => {
+            let translated = 0;
+            for (const provider of providers)
+                translated += await provider.inbound.runOnce();
+            return translated;
+        },
+    });
+    const runnerPipeline = createRunnerPipeline({
+        isPaused: input.isPaused,
+        catchUpProjections,
+        runSchedules: async () => {
+            for (const schedule of input.config.controlPlane.schedules)
+                await schedules.run(schedule, {
+                    commandId: input.ids.next('command'),
+                    correlationId: 'schedule-tick',
+                    occurredAt: input.clock.now().toISOString(),
+                    actor: { kind: EventActorKind.System, id: ControlStreamKind.Global },
+                });
+        },
+        react: async () => {
+            await watch.runOnce();
+            await resourceTransitions.runOnce();
+            await artifacts.runOnce();
+            await outcomes.runOnce();
+            for (const provider of providers)
+                await provider.maintenance?.runOnce();
+        },
+        advance: input.advanceOnce,
+        publishAgentRuns: async () => {
+            await agentRunPublications.runOnce();
+        },
+        deliver: async (signal) => {
+            await delivery.deliverNext(signal);
+        },
+    });
+    return {
+        projectionRunner,
+        providers,
+        providerFailures,
+        delivery,
+        intakePipeline,
+        runnerPipeline,
+    };
+}
+// Configuration is the only routing authority: adapters ask, they never propose.
+function createWorkflowRouter(orchestration) {
+    const selectors = compileWorkflowSelectors(orchestration.workflowSelectors);
+    const fallback = workflowName(orchestration.default);
+    return { select: (candidate) => selectWorkflow(candidate, selectors, fallback) };
+}

package/dist/src/bootstrap/persistence-composition.js

@@ -0,0 +1,19 @@
+import { FileCheckpointStore, FileEventJournal, FileProjectionStore, } from '../persistence/index.js';
+import { createResourceTransitionOrdering, createTriggerAwareEventJournal, createTriggerRegistry, } from './resource-transition-ordering.js';
+function identity(value) {
+    return value;
+}
+export function composePersistence(paths, clock, options) {
+    const resourceTransitionOrdering = createResourceTransitionOrdering(options.journal === undefined
+        ? `${paths.locksRoot}/resource-transition-ordering.lock`
+        : undefined);
+    const resourceTransitionTriggers = createTriggerRegistry();
+    const journal = createTriggerAwareEventJournal((options.decorateJournal ?? identity)(options.journal ?? new FileEventJournal(paths.dataRoot, clock)), resourceTransitionTriggers, resourceTransitionOrdering);
+    return {
+        journal,
+        projections: (options.decorateProjections ?? identity)(options.projections ?? new FileProjectionStore(paths.dataRoot)),
+        checkpoints: (options.decorateCheckpoints ?? identity)(options.checkpoints ?? new FileCheckpointStore(paths.dataRoot)),
+        resourceTransitionOrdering,
+        resourceTransitionTriggers,
+    };
+}

package/dist/src/bootstrap/resource-transition-evidence.js

@@ -0,0 +1,17 @@
+import { ResourceCorrelationRole } from '../resources/index.js';
+export function createCapabilityResourceTransitionEvidence(input) {
+    return {
+        triggers: [...new Set(input.policies.flatMap(({ policy }) => policy.triggers))],
+        async resolve(evidence) {
+            const correlations = await input.resources.correlationsForWork(evidence.workItemId);
+            const primaries = correlations.filter(({ role }) => role === ResourceCorrelationRole.Primary);
+            if (primaries.length !== 1)
+                return null;
+            const resource = await input.resources.get(primaries[0].resourceId);
+            if (resource === null)
+                return null;
+            const registration = input.policies.find(({ capabilities }) => capabilities.some((capability) => resource.capabilities.includes(capability)));
+            return registration?.policy.resolve(evidence) ?? null;
+        },
+    };
+}