@atolis-hq/wake 0.3.65 → 0.3.66

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

@@ -1,5 +1,5 @@
 import { ControlStreamKind, ScheduleService, createIntakePipeline, createRunnerPipeline, createWorkCancellationPolicy, } from '../control-plane/index.js';
-import { RunRepository } from '../execution/index.js';
+import { RunRepository, createRuntimeMemoryProfile, } 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';
@@ -18,6 +18,13 @@ function serializeRunRegisteredOnce(runner) {
     return runner;
 }
 export async function composeIntegrationRuntime(input) {
+    const memoryProfile = process.env.WAKE_MEMORY_PROFILE === 'runner'
+        ? createRuntimeMemoryProfile({
+            write: (line) => process.stderr.write(line),
+            now: () => input.clock.now().toISOString(),
+            memoryUsage: () => process.memoryUsage(),
+        })
+        : undefined;
     const registry = new ProviderRegistry();
     registry.register(fakeProviderDefinition);
     for (const definition of input.providerDefinitions)
@@ -121,24 +128,28 @@ export async function composeIntegrationRuntime(input) {
     // Tick needs a backing-off host; see bootstrap/surface-cli-applications.ts.
     const intakePipeline = createIntakePipeline({
         isPaused: input.isPaused,
-        catchUpProjections,
+        catchUpProjections: () => observeMemory(memoryProfile, 'intake.projections', catchUpProjections),
         poll: async (signal) => {
-            let appended = 0;
-            for (const provider of providers)
-                appended += await new PollService(input.journal, provider).pollOnce(signal);
-            return appended;
+            return observeMemory(memoryProfile, 'intake.poll', async () => {
+                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;
+            return observeMemory(memoryProfile, 'intake.translate', 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 () => {
+        catchUpProjections: () => observeMemory(memoryProfile, 'runner.projections', catchUpProjections),
+        runSchedules: () => observeMemory(memoryProfile, 'runner.schedules', async () => {
             for (const schedule of input.config.controlPlane.schedules)
                 await schedules.run(schedule, {
                     commandId: input.ids.next('command'),
@@ -146,8 +157,8 @@ export async function composeIntegrationRuntime(input) {
                     occurredAt: input.clock.now().toISOString(),
                     actor: { kind: EventActorKind.System, id: ControlStreamKind.Global },
                 });
-        },
-        react: async () => {
+        }),
+        react: () => observeMemory(memoryProfile, 'runner.react', async () => {
             await watch.runOnce();
             await watch.reconcileOnce();
             await resourceTransitions.runOnce();
@@ -155,14 +166,14 @@ export async function composeIntegrationRuntime(input) {
             await outcomes.runOnce();
             for (const provider of providers)
                 await provider.maintenance?.runOnce();
-        },
-        advance: input.advanceOnce,
-        publishAgentRuns: async () => {
+        }),
+        advance: (options) => observeMemory(memoryProfile, 'runner.advance', () => input.advanceOnce(options)),
+        publishAgentRuns: () => observeMemory(memoryProfile, 'runner.publish-agent-runs', async () => {
             await agentRunPublications.runOnce();
-        },
-        deliver: async (signal) => {
+        }),
+        deliver: (signal) => observeMemory(memoryProfile, 'runner.deliver', async () => {
             await delivery.deliverNext(signal);
-        },
+        }),
     });
     return {
         projectionRunner,
@@ -173,6 +184,15 @@ export async function composeIntegrationRuntime(input) {
         runnerPipeline,
     };
 }
+async function observeMemory(profile, phase, operation) {
+    profile?.sample(`${phase}.before`);
+    try {
+        return await operation();
+    }
+    finally {
+        profile?.sample(`${phase}.settled`);
+    }
+}
 // Configuration is the only routing authority: adapters ask, they never propose.
 function createWorkflowRouter(orchestration) {
     const selectors = compileWorkflowSelectors(orchestration.workflowSelectors);

package/dist/src/bootstrap/version.js

@@ -108,4 +108,4 @@ export function resolveWakeVersion(options = {}) {
         return `g${headHash.slice(0, 7)}`;
     return '0.1.0-dev';
 }
-export const wakeVersion = "gcf37d8a";
+export const wakeVersion = "gcfcc531";

package/dist/src/execution/infrastructure/runner-memory-profile.js

@@ -1,3 +1,21 @@
+export function createRuntimeMemoryProfile(options) {
+    return {
+        sample: (phase) => {
+            const memory = options.memoryUsage();
+            options.write(`${JSON.stringify({
+                type: 'wake.runtime-memory',
+                phase,
+                at: options.now(),
+                pid: process.pid,
+                rss: memory.rss,
+                heapTotal: memory.heapTotal,
+                heapUsed: memory.heapUsed,
+                external: memory.external,
+                arrayBuffers: memory.arrayBuffers,
+            })}\n`);
+        },
+    };
+}
 export function createRunnerMemoryProfileDecorator(options) {
     return (runner, name) => ({
         ...(runner.supportsSessionResume === undefined

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atolis-hq/wake",
-  "version": "0.3.65",
+  "version": "0.3.66",
   "description": "Local autonomous agent control plane for software development",
   "license": "Apache-2.0",
   "repository": {