engineering-memory 0.2.5 → 0.2.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engineering-memory",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "description": "Installs the Engineering Memory skill and its local MCP bridge. Sign in after installing; your organization and project are resolved from your account.",
   "license": "UNLICENSED",
   "type": "module",

package/runtime/dist/src/runtime/bridge-service.js

@@ -25,8 +25,26 @@ export const validationIds = [
 export class BridgeService {
     dependencies;
     taskQueues = new Map();
+    deferDeliveries;
+    backgroundDelivery = Promise.resolve();
     constructor(dependencies) {
         this.dependencies = dependencies;
+        this.deferDeliveries = dependencies.deferDeliveries ?? true;
+    }
+    deliverInBackground() {
+        if (!this.deferDeliveries)
+            return;
+        this.backgroundDelivery = this.backgroundDelivery.then(async () => {
+            try {
+                await this.flushOutbox();
+            }
+            catch {
+                return;
+            }
+        });
+    }
+    async settleDeliveries() {
+        await this.backgroundDelivery;
     }
     async sessionBootstrap(input) {
         return await this.execute(async () => {
@@ -676,15 +694,31 @@ export class BridgeService {
             }));
             assertSafeToPersist(cleanJson({ entries }));
             const snapshot = await this.activeTaskSnapshot(input.taskId, undefined, input.repoRoot);
+            const body = cleanJson({
+                taskId: input.taskId,
+                entries,
+                expectedTaskVersion: snapshot.taskVersion,
+            });
+            await this.dependencies.gate.invalidateTask(input.taskId);
+            if (this.deferDeliveries) {
+                const queued = await this.dependencies.outbox.enqueue({
+                    operation: 'task.reconcile',
+                    method: 'POST',
+                    path: endpoints.taskReconcile,
+                    body,
+                });
+                this.deliverInBackground();
+                return asJsonValue({
+                    reconciled: entries.map((entry) => entry.resourceId),
+                    queued: true,
+                    outboxId: queued.id,
+                    deliveryStatus: 'pending',
+                });
+            }
             const response = await this.dependencies.client.request(endpoints.taskReconcile, {
                 method: 'POST',
-                body: cleanJson({
-                    taskId: input.taskId,
-                    entries,
-                    expectedTaskVersion: snapshot.taskVersion,
-                }),
+                body,
             });
-            await this.dependencies.gate.invalidateTask(input.taskId);
             return asJsonValue({ reconciliations: response.data });
         });
     }
@@ -1363,7 +1397,10 @@ export class BridgeService {
             assertSafeToPersist(cleanJson(safeInput));
             return await this.taskExclusive(input.taskId, async () => {
                 await this.recoverJournalOutbox(input.projectId, input.taskSlug);
-                await this.flushOutbox();
+                if (this.deferDeliveries)
+                    this.deliverInBackground();
+                else
+                    await this.flushOutbox();
                 const journalInput = {
                     eventId: idempotencyKey,
                     taskId: input.taskId,
@@ -1426,7 +1463,8 @@ export class BridgeService {
                     await this.dependencies.activeContexts.updateTaskSnapshot(input.taskId, expectedTaskVersion + 1, pointer.lastSequence + 1);
                 }
                 const predecessorEntries = taskEntries.filter((entry) => entry.id !== queued.id);
-                if (predecessorEntries.length > 0) {
+                if (predecessorEntries.length > 0 || this.deferDeliveries) {
+                    this.deliverInBackground();
                     return asJsonValue({
                         local: { directory: staged.directory, applied: staged.applied },
                         queued: true,

package/skill/references/lifecycle.md

@@ -45,7 +45,9 @@ answer in the design; do not spend the read there.
 
 Do not pull history for everything. Pull it for the records the task actually touches, and for anything the header shows a surprising number of corrections on. Record `task.checkpoint` with type `discovery` and update STATE, DECISIONS, DISCOVERY, and HANDOFF projections through the bridge.
 
-Send calls that do not feed each other in one batch rather than one at a time: reads of any kind, and proposals for different records. Reconcile every record the task touched in a single `task.reconcile` call with `entries`, not one call per record. Keep in order only what moves the task version, and what genuinely waits on another answer.
+Send calls that do not feed each other in one batch rather than one at a time: reads of any kind, and proposals for different records. Reconcile every record the task touched in a single `task.reconcile` call with `entries`, not one call per record.
+
+Checkpoints, recorded corrections and reconciliations return before the backend has them, reporting `deliveryStatus: 'pending'` with the task version they will occupy. That is a completed call, not a pending one: the journal is already durable, delivery is already under way, and `task.verify` refuses while anything remains undelivered. Do not wait for it, poll it, or send it again. Wait only for what the next step uses — a proposal's identifiers, an approval's revision, a prepared lease, and verification itself.
 
 Temporary code written to reach or force a path — a pinned state, a fixed service response, a jump straight to the screen — is allowed and expected, carries the marker `ENGINEERING-MEMORY-TEMPORARY` with its reason, and is removed before verification. `task.verify` refuses while any marker is in the tree and names every line, and the commit gate refuses while one is staged.