engineering-memory 1.11.1 → 1.11.3

package/dispatcher/sections.mjs

@@ -21,6 +21,8 @@ After compaction, a new chat, interruption, or handoff, call \`session.resume\`
 
 Do not edit until the skill lifecycle has completed discovery, its checkpoint, and \`context.prepare_change\`. Do not claim completion until \`task.verify\` succeeds.
 
+Do not block independent task work on \`memory.propose_revision\` drafting, submission or approval. Follow the skill's memory-updates reference: use background agents or concurrent tools when the host permits them, and continue useful work instead of immediately waiting. Without concurrency, checkpoint the pending draft and defer submission until needed. Collect the result only at the operation that depends on it; native approval and required task verification still apply.
+
 Use the host's native questionnaire for every question to the user, including implementation choices, names, clarification, branch/worktree decisions and delivery. For a required decision, use \`questionnaire.ask\` to open a durable native MCP form and \`questionnaire.resume\` to return to the same unanswered question. Read the skill's questionnaires reference first. Never use request_user_input_async for a required decision: it does not wait for an answer. When the durable form is unavailable, use a blocking native control only where the host permits it: request_user_input in Codex or AskUserQuestion in Claude. Never replace the questionnaire with a chat instruction such as 'type this', 'reply yes', or 'write X if you want Y'. Do not open a survey web page. If the required native control is unavailable or prohibited for that kind of question, follow the host's tool restrictions, explain the limitation, and continue only work already authorized; do not fabricate a survey or silently choose an answer. A timeout, dismissed form, empty response or ended turn is not an answer. Keep the decision pending and resume it; do not start dependent work or report it as resolved. Existing answers remain valid through retries and handoffs.
 
 When the repository is unbound, use the native questionnaire required by the skill. Do not silently create or bind a project. Do not open a survey web page.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engineering-memory",
-  "version": "1.11.1",
+  "version": "1.11.3",
   "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/mcp/server.js

@@ -5,6 +5,8 @@ export function createEngineeringMemoryServer(service) {
     const server = new McpServer({
         name: 'engineering-memory',
         version: '0.1.0',
+    }, {
+        instructions: 'Start with session.entry and follow the returned lifecycle. Do not block independent task work on memory.propose_revision drafting, submission or approval. If the host permits background agents or concurrent calls, dispatch independent proposals and continue useful work; otherwise checkpoint the draft and defer submission until needed. Checkpoint, correction, reconciliation, self-review and scaffold receipts use the durable local outbox; after deliveryStatus pending, continue independent work without polling or resending. Inventory upload, claim-bound evidence submission and test-result reporting may overlap independent analysis using host-permitted concurrent calls. Wait only when the next operation needs the result; required task deliveries must settle before verification. Preserve task/source identity and native user approval; never treat pending work as verified.',
     });
     registerEngineeringMemoryTools(server, service);
     registerQuestionnaireTools(server, service);

package/runtime/dist/src/mcp/tool-definitions.js

@@ -311,7 +311,7 @@ export function registerEngineeringMemoryTools(server, service) {
         }),
     }, async (input) => toolResult(await service.memoryHistory(input)));
     server.registerTool('memory.propose_revision', {
-        description: 'Create an inactive, reviewable proposal for a permanent project or organization engineering memory revision.',
+        description: 'Create an inactive, reviewable proposal for permanent product, organization or project memory. Do not block independent task work on drafting, submission or approval. Use authorized host background agents or concurrent tools and continue useful work; collect the result only before an operation needs its proposal or revision ID. Without concurrency, checkpoint the pending draft and defer this call until needed. Keep one writer per resource and preserve baseRevision and task/source identity. A response distinguishes stored (queued:false) from outbox-queued; neither means approved. Native user approval and task verification remain required.',
         inputSchema: z.object({
             repoRoot: optionalRepoRoot,
             sourceRunId: z.string().uuid().optional(),
@@ -397,7 +397,7 @@ export function registerEngineeringMemoryTools(server, service) {
         }),
     }, async (input) => toolResult(await service.taskRecordCorrection(input)));
     server.registerTool('task.self_review', {
-        description: 'Record that the changed code was read back against the rules that govern it, naming the knowledge resources reviewed and every conflict found with how it was resolved. task.verify refuses until this exists for the current diff, so any further edit requires reviewing again.',
+        description: 'Record that the changed code was read back against the rules that govern it, naming the knowledge resources reviewed and every conflict found with how it was resolved. Returns a durable pending receipt without waiting for backend delivery; continue independent local validation. task.verify waits for required delivery and refuses until this exists for the current diff, so any further edit requires reviewing again.',
         inputSchema: z.object({
             repoRoot: optionalRepoRoot,
             taskId: z.string().min(1),
@@ -411,7 +411,7 @@ export function registerEngineeringMemoryTools(server, service) {
         }),
     }, async (input) => toolResult(await service.taskSelfReview(input)));
     server.registerTool('task.reconcile', {
-        description: 'Reconcile changed screens and components with an approved revision or an explicit no-semantic-memory-change reason. Pass every record the task touched as `entries` in one call rather than calling once per record; the whole set is applied together and rejected together.',
+        description: 'Reconcile changed screens and components with an approved revision or an explicit no-semantic-memory-change reason. Pass every record the task touched as `entries` in one call rather than calling once per record; the whole set is applied together and rejected together. A pending result is a durable local receipt; continue independent work without polling. Required delivery is checked before verification.',
         inputSchema: z
             .object({
             repoRoot: optionalRepoRoot,
@@ -608,7 +608,7 @@ export function registerEngineeringMemoryTools(server, service) {
         }),
     }, async (input) => toolResult(await service.architectureModule(input)));
     server.registerTool('architecture.record_application', {
-        description: 'Record that a scaffold task wrote one architecture module, hashing each written file after the rename so verification can exempt untouched scaffolded files.',
+        description: 'Record that a scaffold task wrote one architecture module, hashing each written file after the rename so verification can exempt untouched scaffolded files. Returns a durable pending receipt; independent tests may run while it is delivered. Required delivery must finish before verification',
         inputSchema: z.object({
             repoRoot: optionalRepoRoot,
             taskId: z.string().min(1),

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

@@ -31,7 +31,10 @@ export class BridgeService {
     dependencies;
     taskQueues = new Map();
     deferDeliveries;
-    backgroundDelivery = Promise.resolve();
+    backgroundDeliveries = new Set();
+    deliveryQueues = new Map();
+    deliveryWaiters = [];
+    activeDeliveries = 0;
     constructor(dependencies) {
         this.dependencies = dependencies;
         this.deferDeliveries = dependencies.deferDeliveries ?? true;
@@ -121,20 +124,17 @@ export class BridgeService {
             nextAction: 'Call questionnaire.resume with this questionnaireId. No answer, elapsed time, dismissal or interruption is consent. If the user explicitly cancels this decision, call questionnaire.withdraw. Unrelated pending decisions never block independently authorized work.',
         }));
     }
-    deliverInBackground() {
+    deliverInBackground(taskId) {
         if (!this.deferDeliveries)
             return;
-        this.backgroundDelivery = this.backgroundDelivery.then(async () => {
-            try {
-                await this.flushOutbox();
-            }
-            catch {
-                return;
-            }
-        });
+        const delivery = this.flushOutbox(taskId).then(() => undefined, () => undefined);
+        this.backgroundDeliveries.add(delivery);
+        void delivery.finally(() => this.backgroundDeliveries.delete(delivery));
     }
     async settleDeliveries() {
-        await this.backgroundDelivery;
+        while (this.backgroundDeliveries.size) {
+            await Promise.all([...this.backgroundDeliveries]);
+        }
     }
     async sessionBootstrap(input) {
         return await this.execute(async () => {
@@ -154,7 +154,15 @@ export class BridgeService {
                 return asJsonValue({ authentication, repository: publicRepository(repository) });
             }
             const recoveredDeliveries = await this.recoverJournalOutbox();
-            const outbox = await this.flushOutbox();
+            const existingTask = await this.dependencies.activeContexts.loadForSlug(repository.repoFingerprint, input.externalTaskId);
+            this.deliverInBackground();
+            const outbox = existingTask
+                ? await this.flushOutbox(existingTask.taskId)
+                : asJsonValue({
+                    synchronized: [],
+                    blocked: [],
+                    pending: (await this.dependencies.outbox.list()).length,
+                });
             let projectId = repository.projectId;
             if (!repository.bindingPath) {
                 const resolved = await this.dependencies.client.request(endpoints.projectResolve, {
@@ -1133,7 +1141,19 @@ export class BridgeService {
     }
     async onboardingRequest(operation, body) {
         return this.execute(async () => {
-            assertSafeToPersist(body);
+            if (operation === 'next' || operation === 'submit') {
+                const { claimToken, ...persistentContent } = body;
+                if (operation === 'submit' || Object.hasOwn(body, 'claimToken')) {
+                    if (typeof claimToken !== 'string' ||
+                        !/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(claimToken)) {
+                        throw refuse('Use the claim UUID returned by memory.sync_next for this unit. Reclaim an expired or missing claim with memory.sync_next.', 'memory.sync_next');
+                    }
+                }
+                assertSafeToPersist(persistentContent);
+            }
+            else {
+                assertSafeToPersist(body);
+            }
             const routes = {
                 sources: '/memory/sources/catalog',
                 status: '/memory/sync/status',
@@ -1254,6 +1274,13 @@ export class BridgeService {
             const findings = normalizePersistentInput(input.findings, input.repoRoot ?? process.cwd());
             assertSafeToPersist(cleanJson({ findings }));
             const repository = await this.dependencies.repositories.resolve(input.repoRoot ?? process.cwd());
+            if (this.deferDeliveries) {
+                return this.enqueueTaskReceipt('task.self_review', endpoints.taskSelfReview, input.taskId, repository.repoRoot, cleanJson({
+                    diffHash: repository.git.diffHash,
+                    reviewedResourceIds: [...new Set(input.reviewedResourceIds)],
+                    findings,
+                }));
+            }
             const snapshot = await this.activeTaskSnapshot(input.taskId, undefined, input.repoRoot);
             const response = await this.dependencies.client.request(endpoints.taskSelfReview, {
                 method: 'POST',
@@ -1291,6 +1318,9 @@ export class BridgeService {
                 reason: normalizePersistentInput(entry.reason, repoRoot),
             }));
             assertSafeToPersist(cleanJson({ entries }));
+            if (this.deferDeliveries) {
+                return this.enqueueTaskReceipt('task.reconcile', endpoints.taskReconcile, input.taskId, repoRoot, cleanJson({ entries }));
+            }
             const snapshot = await this.activeTaskSnapshot(input.taskId, undefined, input.repoRoot);
             const body = cleanJson({
                 taskId: input.taskId,
@@ -1298,21 +1328,6 @@ export class BridgeService {
                 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,
@@ -2037,7 +2052,6 @@ export class BridgeService {
     async architectureRecordApplication(input) {
         return await this.execute(async () => {
             const repository = await this.dependencies.repositories.resolve(input.repoRoot ?? process.cwd());
-            const snapshot = await this.activeTaskSnapshot(input.taskId, input.projectId, repository.repoRoot);
             const files = await Promise.all(input.files.map(async (file) => {
                 const hash = await hashWorkingTreeFile(repository.repoRoot, file.path);
                 if (!hash) {
@@ -2045,6 +2059,15 @@ export class BridgeService {
                 }
                 return { templatePath: file.templatePath, path: file.path, sha256: hash };
             }));
+            if (this.deferDeliveries) {
+                return this.enqueueTaskReceipt('architecture.record_application', endpoints.taskScaffoldApplication, input.taskId, repository.repoRoot, cleanJson({
+                    projectId: input.projectId,
+                    templateResourceId: input.templateResourceId,
+                    templateRevisionId: input.templateRevisionId,
+                    files,
+                }));
+            }
+            const snapshot = await this.activeTaskSnapshot(input.taskId, input.projectId, repository.repoRoot);
             const body = cleanJson({
                 taskId: input.taskId,
                 projectId: input.projectId,
@@ -2411,7 +2434,7 @@ export class BridgeService {
             return await this.taskExclusive(input.taskId, async () => {
                 await this.recoverJournalOutbox(input.projectId, input.taskSlug);
                 if (this.deferDeliveries)
-                    this.deliverInBackground();
+                    this.deliverInBackground(input.taskId);
                 else
                     await this.flushOutbox();
                 const journalInput = {
@@ -2436,10 +2459,8 @@ export class BridgeService {
                         idempotencyKey,
                     });
                 }
-                const pointer = await this.resolveCheckpointPointer(input, repoRoot);
                 const taskEntries = (await this.dependencies.outbox.list()).filter((entry) => taskIdFromDeliverySafe(entry) === input.taskId);
-                const versionedTaskEntries = taskEntries.filter((entry) => entry.journalRef &&
-                    (entry.operation === 'task.checkpoint' || entry.operation === 'task.record_correction'));
+                const pointer = await this.resolveCheckpointPointer(input, repoRoot);
                 const blockedEntry = taskEntries.find((entry) => entry.lastError && entry.lastError !== 'backend_unavailable');
                 if (blockedEntry && blockedEntry.idempotencyKey !== idempotencyKey) {
                     throw refuse('A blocked task delivery must be explicitly resolved before checkpointing', 'task.resolve_pending_delivery');
@@ -2447,8 +2468,7 @@ export class BridgeService {
                 const existingExpected = pendingJournal
                     ? expectedTaskVersionFromBody(pendingJournal.body)
                     : null;
-                const expectedTaskVersion = existingExpected ??
-                    Math.max(pointer.taskVersion, ...versionedTaskEntries.map((entry) => (expectedTaskVersionFromBody(entry.body) ?? pointer.taskVersion - 1) + 1));
+                const expectedTaskVersion = existingExpected ?? pendingTaskVersion(pointer.taskVersion, taskEntries);
                 await this.dependencies.gate.invalidateTask(input.taskId);
                 const staged = await this.dependencies.journal.stage(journalInput, {
                     operation: correction ? 'task.record_correction' : 'task.checkpoint',
@@ -2477,7 +2497,7 @@ export class BridgeService {
                 }
                 const predecessorEntries = taskEntries.filter((entry) => entry.id !== queued.id);
                 if (predecessorEntries.length > 0 || this.deferDeliveries) {
-                    this.deliverInBackground();
+                    this.deliverInBackground(input.taskId);
                     return asJsonValue({
                         local: { directory: staged.directory, applied: staged.applied },
                         queued: true,
@@ -2551,51 +2571,168 @@ export class BridgeService {
             return asJsonValue({ queued: true, outboxId: queued.id, idempotencyKey });
         }
     }
+    async enqueueTaskReceipt(operation, path, taskId, repoRoot, content) {
+        const repository = await this.dependencies.repositories.resolve(repoRoot);
+        return this.taskExclusive(taskId, async () => {
+            const pointer = await this.requireActivePointer(repository.repoFingerprint, taskId);
+            if (repository.projectId && repository.projectId !== pointer.projectId)
+                throw refuse('The receipt does not belong to this repository project.', 'session.resume');
+            const fields = objectOrEmpty(content);
+            if (fields.projectId && fields.projectId !== pointer.projectId)
+                throw refuse('The receipt does not belong to this task project.', 'session.resume');
+            if (pointer.resumeConflicts.length || pointer.verificationIntent || pointer.closeIntent)
+                throw refuse('Resume a clean active task before recording this receipt.', 'session.resume');
+            await this.checkoutSource(repository, pointer.source);
+            await this.recoverJournalOutbox(pointer.projectId, pointer.taskSlug);
+            const entries = await this.dependencies.outbox.listForTask(taskId);
+            if (entries.some((entry) => entry.lastError && entry.lastError !== 'backend_unavailable'))
+                throw refuse('Resolve the blocked delivery for this task before adding a receipt.', 'task.resolve_pending_delivery');
+            const latest = await this.requireActivePointer(repository.repoFingerprint, taskId);
+            const expectedTaskVersion = pendingTaskVersion(latest.taskVersion, entries);
+            const body = cleanJson({ ...fields, taskId, expectedTaskVersion });
+            const idempotencyKey = sha256(stableStringify({ operation, body }));
+            await this.dependencies.gate.invalidateTask(taskId);
+            const queued = await this.dependencies.outbox.enqueue({
+                operation,
+                method: 'POST',
+                path,
+                body,
+                idempotencyKey,
+                projectId: pointer.projectId,
+            });
+            this.deliverInBackground(taskId);
+            return asJsonValue({
+                queued: true,
+                outboxId: queued.id,
+                idempotencyKey,
+                deliveryStatus: 'pending',
+                expectedTaskVersion,
+                nextAction: 'Continue independent work. Required delivery is checked before task.verify; session.resume reports pending failures.',
+            });
+        });
+    }
     async flushOutbox(taskId) {
         const entries = taskId
             ? await this.dependencies.outbox.listForTask(taskId)
             : await this.dependencies.outbox.list();
+        const groups = new Map();
+        for (const entry of entries) {
+            const owner = taskIdFromDeliverySafe(entry);
+            const body = objectOrEmpty(entry.body);
+            const key = owner ? 'task:' + owner : 'project:' + String(body.projectId ?? 'unscoped');
+            const group = groups.get(key) ?? [];
+            group.push(entry);
+            groups.set(key, group);
+        }
         const synchronized = [];
         const blocked = [];
-        const blockedTasks = new Set();
-        for (const entry of entries) {
-            const deliveryTaskId = taskIdFromDeliverySafe(entry);
-            if (blockedTasks.has(deliveryTaskId))
-                continue;
-            try {
-                const response = await this.dependencies.client.request(entry.path, {
-                    method: entry.method,
-                    body: entry.body,
-                    idempotencyKey: entry.idempotencyKey,
-                });
-                await this.captureTaskSnapshot(response.data);
-                if (entry.journalRef) {
-                    await this.dependencies.journal.markDeliverySynchronized(entry.journalRef.projectId, entry.journalRef.taskSlug, entry.journalRef.eventId);
-                    const deliveryTaskId = taskIdFromDeliverySafe(entry);
-                    if (deliveryTaskId) {
-                        const synchronizedPointer = await this.dependencies.activeContexts.findByTaskId(deliveryTaskId, entry.journalRef.projectId, false);
-                        await this.seedResumeSnapshot(synchronizedPointer, objectValue(response.data) ?? undefined);
+        await Promise.all([...groups].map(async ([key, group]) => {
+            const previous = this.deliveryQueues.get(key) ?? Promise.resolve();
+            const delivery = previous
+                .catch(() => undefined)
+                .then(async () => {
+                if (this.activeDeliveries >= 4)
+                    await new Promise((resolve) => this.deliveryWaiters.push(resolve));
+                else
+                    this.activeDeliveries += 1;
+                try {
+                    for (const candidate of group) {
+                        const entry = await this.dependencies.outbox.get(candidate.id);
+                        if (!entry)
+                            continue;
+                        try {
+                            await this.deliverEntry(entry);
+                            synchronized.push(entry.id);
+                        }
+                        catch (error) {
+                            const errorKind = classifyError(error);
+                            await this.dependencies.outbox.markAttempt(entry.id, errorKind);
+                            if (entry.journalRef)
+                                await this.dependencies.journal.markDeliveryAttempt(entry.journalRef.projectId, entry.journalRef.taskSlug, entry.journalRef.eventId, errorKind);
+                            blocked.push({ id: entry.id, error: errorKind });
+                            break;
+                        }
                     }
                 }
-                await this.dependencies.outbox.acknowledge(entry.id);
-                synchronized.push(entry.id);
-            }
-            catch (error) {
-                const errorKind = classifyError(error);
-                await this.dependencies.outbox.markAttempt(entry.id, errorKind);
-                if (entry.journalRef) {
-                    await this.dependencies.journal.markDeliveryAttempt(entry.journalRef.projectId, entry.journalRef.taskSlug, entry.journalRef.eventId, errorKind);
+                finally {
+                    const waiter = this.deliveryWaiters.shift();
+                    if (waiter)
+                        waiter();
+                    else
+                        this.activeDeliveries -= 1;
                 }
-                blocked.push({ id: entry.id, error: errorKind });
-                blockedTasks.add(deliveryTaskId);
+            });
+            this.deliveryQueues.set(key, delivery);
+            try {
+                await delivery;
             }
-        }
+            finally {
+                if (this.deliveryQueues.get(key) === delivery)
+                    this.deliveryQueues.delete(key);
+            }
+        }));
         return asJsonValue({
             synchronized,
             blocked,
             pending: (await this.dependencies.outbox.list()).length,
         });
     }
+    async deliverEntry(entry) {
+        let recovered = false;
+        let deliveredData = null;
+        if (entry.operation === 'task.self_review') {
+            const body = objectOrEmpty(entry.body);
+            if (!entry.projectId)
+                throw refuse('The receipt has no project identity; inspect and re-record it.', 'task.resolve_pending_delivery');
+            const pointer = await this.dependencies.activeContexts.findByTaskId(String(body.taskId), entry.projectId);
+            const response = await this.dependencies.client.request(endpoints.sessionResume, {
+                method: 'POST',
+                body: {
+                    sessionId: pointer.sessionId,
+                    repoFingerprint: pointer.repoFingerprint,
+                    source: pointer.source ?? null,
+                    afterSequence: 0,
+                },
+            });
+            const backend = objectValue(response.data);
+            const task = objectValue(backend?.task);
+            if (!task ||
+                task.id !== body.taskId ||
+                task.projectId !== entry.projectId ||
+                backend?.requiresContextRefresh === true)
+                throw refuse('Refresh the matching task context before delivering this review.', 'session.resume');
+            recovered = Boolean(task &&
+                task.id === body.taskId &&
+                task.lockVersion === Number(body.expectedTaskVersion) + 1 &&
+                task.selfReviewDiffHash === body.diffHash &&
+                stableStringify(asJsonValue(task.selfReviewResourceIds)) ===
+                    stableStringify(asJsonValue(body.reviewedResourceIds)) &&
+                stableStringify(asJsonValue(task.selfReviewFindings)) ===
+                    stableStringify(asJsonValue(body.findings)));
+            if (recovered)
+                await this.captureTaskSnapshot(response.data);
+        }
+        if (!recovered) {
+            const response = await this.dependencies.client.request(entry.path, {
+                method: entry.method,
+                body: entry.body,
+                idempotencyKey: entry.idempotencyKey,
+            });
+            deliveredData = response.data;
+            await this.captureTaskSnapshot(entry.operation === 'task.self_review'
+                ? asJsonValue({ task: response.data })
+                : response.data);
+        }
+        if (entry.journalRef) {
+            await this.dependencies.journal.markDeliverySynchronized(entry.journalRef.projectId, entry.journalRef.taskSlug, entry.journalRef.eventId);
+            const owner = taskIdFromDeliverySafe(entry);
+            if (owner) {
+                const pointer = await this.dependencies.activeContexts.findByTaskId(owner, entry.journalRef.projectId, false);
+                await this.seedResumeSnapshot(pointer, objectValue(deliveredData) ?? undefined);
+            }
+        }
+        await this.dependencies.outbox.acknowledge(entry.id);
+    }
     async recoverJournalOutbox(projectId, taskSlug) {
         const pending = await this.dependencies.journal.listPendingDeliveries(projectId, taskSlug);
         for (const delivery of pending) {
@@ -3367,6 +3504,15 @@ function expectedTaskVersionFromBody(value) {
         ? numericTaskVersion(body.expectedTaskVersion)
         : null;
 }
+function pendingTaskVersion(current, entries) {
+    return Math.max(current, ...entries.map((entry) => {
+        const version = expectedTaskVersionFromBody(entry.body);
+        if (version === null)
+            return current;
+        const advances = ['task.checkpoint', 'task.record_correction', 'task.self_review'].includes(entry.operation);
+        return version + (advances ? 1 : 0);
+    }));
+}
 function taskIdFromDeliverySafe(entry) {
     try {
         return taskIdFromDelivery(entry.body);

package/runtime/dist/src/runtime/offline-outbox.js

@@ -4,7 +4,9 @@ import { join } from 'node:path';
 import { assertManagedPath, ensureManagedDirectory, readJson, removeFile, writeJson, } from '../utilities/files.js';
 import { sha256, stableStringify } from '../utilities/hash.js';
 const sensitiveKeyPattern = /(authorization|password|passcode|secret|token|cookie|email|phone|mobile|customer|account|user.?id|user.?name)/i;
-const emailPattern = /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/i;
+const emailSource = '(?:^|[^\\p{L}\\p{N}._%+-])[\\p{L}\\p{N}._%+-]{1,64}@([\\p{L}\\p{N}.-]+\\.[\\p{L}]{2,63})(?=$|[^\\p{L}\\p{N}.-])';
+const emailPattern = new RegExp(emailSource, 'iu');
+const emailMatchPattern = new RegExp(emailSource, 'giu');
 const phonePattern = /\+\d[\d ()-]{7,}\d/;
 const repositoryPathFields = new Set([
     'path',
@@ -13,21 +15,128 @@ const repositoryPathFields = new Set([
     'changedPaths',
     'pathPatterns',
     'evidencePaths',
+    'screenPathPatterns',
+    'componentPathPatterns',
+    'pathChanges',
+    'templatePath',
 ]);
-const iosAssetScalePathPattern = /^(?:[\p{L}\p{N}_. -]+\/)*[\p{L}\p{N}_. -]+\.xcassets\/[\p{L}\p{N}_. -]+\.(?:appiconset|imageset)\/[\p{L}\p{N}_. -]+@[123]x\.(?:png|jpe?g)$/iu;
-function emailScanValue(value, key) {
-    if (!repositoryPathFields.has(key) ||
-        !iosAssetScalePathPattern.test(value) ||
-        value.split('/').some((part) => part === '.' || part === '..'))
-        return value;
-    return value.replace(/@[123]x(?=\.(?:png|jpe?g)$)/i, '');
+const topLevelDomains = new Set([
+    'com',
+    'net',
+    'org',
+    'edu',
+    'gov',
+    'mil',
+    'int',
+    'info',
+    'biz',
+    'name',
+    'pro',
+    'mobi',
+    'tel',
+    'asia',
+    'jobs',
+    'coop',
+    'aero',
+    'museum',
+    'travel',
+    'app',
+    'dev',
+    'cloud',
+    'online',
+    'site',
+    'store',
+    'tech',
+    'space',
+    'website',
+    'digital',
+    'agency',
+    'systems',
+    'solutions',
+    'email',
+    'xyz',
+    'top',
+    'club',
+    'live',
+    'life',
+    'world',
+    'today',
+    'network',
+    'group',
+    'company',
+    'center',
+    'media',
+    'studio',
+    'design',
+    'software',
+    'tools',
+    'works',
+    'team',
+    'zone',
+    'one',
+    'ltd',
+    'inc',
+    'llc',
+    'gmbh',
+    'shop',
+    'page',
+    'blog',
+    'wiki',
+    'news',
+    'art',
+    'link',
+    'host',
+    'press',
+    'fyi',
+    'test',
+    'example',
+    'invalid',
+    'local',
+    'localhost',
+    'internal',
+]);
+const countryCodeTopLevelDomains = new Set('ac ad ae af ag ai al am ao aq ar as at au aw ax az ba bb bd be bf bg bh bi bj bm bn bo br bs bt bw by bz ca cc cd cf cg ch ci ck cl cm cn co cr cu cv cw cx cy cz de dj dk dm do dz ec ee eg er es et eu fi fj fk fm fo fr ga gd ge gf gg gh gi gl gm gn gp gq gr gs gt gu gw gy hk hm hn hr ht hu id ie il im in io iq ir is it je jm jo jp ke kg kh ki km kn kp kr kw ky kz la lb lc li lk lr ls lt lu lv ly ma mc md me mg mh mk ml mm mn mo mp mq mr ms mt mu mv mw mx my mz na nc ne nf ng ni nl no np nr nu nz om pa pe pf pg ph pk pl pm pn pr ps pt pw py qa re ro rs ru rw sa sb sc sd se sg sh si sk sl sm sn so sr ss st su sv sx sy sz tc td tf tg th tj tk tl tm tn to tr tt tv tw tz ua ug uk us uy uz va vc ve vg vi vn vu wf ws ye yt za zm zw'.split(' '));
+function isTopLevelDomain(label) {
+    const value = label.toLowerCase();
+    return countryCodeTopLevelDomains.has(value) || topLevelDomains.has(value);
+}
+const extensionTopLevelDomains = new Set([
+    'ai',
+    'app',
+    'as',
+    'cc',
+    'md',
+    'ml',
+    'mm',
+    'pl',
+    'py',
+    'rs',
+    'sh',
+    'so',
+]);
+function hasEmailAddress(value, repositoryPath) {
+    if (!repositoryPath)
+        return emailPattern.test(value);
+    for (const match of value.matchAll(emailMatchPattern)) {
+        const labels = (match[1] ?? '').split('.');
+        const last = (labels[labels.length - 1] ?? '').toLowerCase();
+        if (isTopLevelDomain(last) && !extensionTopLevelDomains.has(last))
+            return true;
+        const beforeExtension = (labels[labels.length - 2] ?? '').toLowerCase();
+        if (labels.length >= 3 &&
+            topLevelDomains.has(beforeExtension) &&
+            !extensionTopLevelDomains.has(beforeExtension))
+            return true;
+    }
+    return false;
 }
+const knownCredentialPattern = /\b(?:A(?:KI|SI)A[0-9A-Z]{16}|gh[pousr]_[A-Z0-9]{30,}|github_pat_[A-Z0-9_]{30,}|sk_live_[A-Z0-9]{16,}|rk_live_[A-Z0-9]{16,}|xox[baprs]-[A-Z0-9-]{12,}|AIza[A-Z0-9_-]{35}|sk-(?:proj-)?[A-Z0-9_-]{20,})\b/i;
 const bearerPattern = /\bbearer\s+[a-z0-9._~-]+/i;
 const jwtPattern = /\beyJ[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+\b/;
 const privateKeyPattern = /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/;
 const credentialUrlPattern = /\b[a-z][a-z0-9+.-]*:\/\/[^\s/@:]+:[^\s/@]+@/i;
 const ipv4Pattern = /\b(?:\d{1,3}\.){3}\d{1,3}\b/;
-const personalHomePathPattern = /(?:^|[\s"'(])(?:[A-Z]:[\\/]+Users[\\/]+[^\\/\s"']+(?:[\\/]|(?=$|\s))|\/(?:Users|home)\/[^/\s"']+(?:\/|(?=$|\s)))/i;
+const personalHomePathPattern = /(?:[A-Z]:[\\/](?:Users|Documents and Settings)[\\/][^\\/\s"'<>:|?*]+|(?:^|[\s"'(<=])\/(?:Users|home)\/[^/\s"'<>*]+)(?:[\\/]|$)/i;
 export class OfflineOutbox {
     root;
     queues = new Map();
@@ -36,12 +145,14 @@ export class OfflineOutbox {
     }
     async enqueue(input) {
         assertSafeToPersist(input.body);
+        if (input.projectId)
+            assertSafeToPersist(input.projectId);
         if (input.journalRef) {
             assertSafeToPersist(JSON.parse(JSON.stringify(input.journalRef)));
         }
         const idempotencyKey = input.idempotencyKey ?? randomUUID();
         const id = sha256(`${input.operation}\n${idempotencyKey}`);
-        return await this.exclusive(id, async () => {
+        return await this.exclusive('enqueue', async () => {
             const path = this.pathFor(id);
             const existing = await readJson(path, this.root);
             if (existing) {
@@ -52,6 +163,7 @@ export class OfflineOutbox {
                     body: input.body,
                     idempotencyKey,
                     journalRef: input.journalRef ?? null,
+                    projectId: input.projectId ?? null,
                 });
                 const actual = stableStringify({
                     operation: existing.operation,
@@ -60,13 +172,17 @@ export class OfflineOutbox {
                     body: existing.body,
                     idempotencyKey: existing.idempotencyKey,
                     journalRef: existing.journalRef ?? null,
+                    projectId: existing.projectId ?? null,
                 });
                 if (actual !== expected) {
                     throw new Error('Outbox idempotency key was reused with different content');
                 }
                 return existing;
             }
+            const order = 1 + Math.max(0, ...(await this.list()).map((entry) => entry.queueOrder ?? 0));
             const entry = {
+                queueOrder: order,
+                ...(input.projectId ? { projectId: input.projectId } : {}),
                 id,
                 operation: input.operation,
                 method: input.method,
@@ -171,15 +287,17 @@ export function assertSafeToPersist(value, key = '') {
         throw new Error(`Sensitive field cannot be persisted: ${key}`);
     }
     if (typeof value === 'string') {
-        if (emailPattern.test(emailScanValue(value, key)) ||
+        const repositoryPath = repositoryPathFields.has(key);
+        if (hasEmailAddress(value, repositoryPath) ||
             phonePattern.test(value) ||
             bearerPattern.test(value) ||
             jwtPattern.test(value) ||
             privateKeyPattern.test(value) ||
+            knownCredentialPattern.test(value) ||
             credentialUrlPattern.test(value) ||
-            ipv4Pattern.test(value) ||
-            personalHomePathPattern.test(value)) {
-            throw new Error('PII or credentials cannot be persisted');
+            personalHomePathPattern.test(value) ||
+            (!repositoryPath && ipv4Pattern.test(value))) {
+            throw new Error(`PII or credentials cannot be persisted: ${key}`);
         }
         return;
     }
@@ -286,6 +404,10 @@ function compareEntries(left, right) {
         leftBody.expectedTaskVersion !== rightBody.expectedTaskVersion) {
         return leftBody.expectedTaskVersion - rightBody.expectedTaskVersion;
     }
+    if (left.queueOrder !== undefined &&
+        right.queueOrder !== undefined &&
+        left.queueOrder !== right.queueOrder)
+        return left.queueOrder - right.queueOrder;
     return left.createdAt === right.createdAt
         ? left.id.localeCompare(right.id)
         : left.createdAt.localeCompare(right.createdAt);

package/skill/SKILL.md

@@ -13,6 +13,8 @@ Mandatory behavior:
 
 Use the host's native questionnaire for every question to the user, including implementation choices, names, clarification, branch/worktree decisions and delivery. For a required decision, read [questionnaires.md](references/questionnaires.md), then use `questionnaire.ask` to open a durable native MCP form and `questionnaire.resume` to return to the same unanswered question. Never use request_user_input_async for a required decision: it does not wait for an answer. When the durable form is unavailable, use a blocking native control only where the host permits it: request_user_input in Codex or AskUserQuestion in Claude. Never replace the questionnaire with a chat instruction such as 'type this', 'reply yes', or 'write X if you want Y'. Do not open a survey web page. If the required native control is unavailable or prohibited for that kind of question, follow the host's tool restrictions, explain the limitation, and continue only work already authorized; do not fabricate a survey or silently choose an answer. A timeout, dismissed form, empty response or ended turn is not an answer. Keep the decision pending and resume it; do not start dependent work or report it as resolved. Existing answers remain valid through retries and handoffs.
 
+Do not block independent task work on `memory.propose_revision` drafting, submission or approval. Follow [memory-updates.md](references/memory-updates.md): use background agents or concurrent tools when the host permits them and continue useful work; without concurrency, checkpoint the pending draft and defer submission until needed. Wait only at the operation that depends on the proposal or revision. This scheduling rule applies to every project and AI host, while native approval and required task verification remain in force. Apply the same dependency rule to reconciliation, self-review, scaffold receipts, inventory upload, completed-unit evidence and test-result reporting. A bridge result with deliveryStatus pending means durable local recording, so continue independent work without polling or resending. Keep claim acquisition, required approval, edit leases and final verification as real dependencies.
+
 1. Discover the repository binding through `session.entry`. Bindings live in the user-level Engineering Memory state directory, outside the repository and installed runtime. No project settings file is required. For a bound repository, the project's knowledge is in the backend, so answer nothing about it before bootstrapping; the absence of local design files or records says nothing about its stored knowledge.
 2. Call `session.entry` before answering anything in a repository, and act on what it reports before the message itself: sign in when it says so, ask for organization and project when nothing has been decided, and stay completely silent about Engineering Memory in a repository where the user switched it off. Record every one of those answers with `session.set_decision`, and only ever from something the user actually said.
 3. Before planning or editing, call `session.bootstrap`. After compaction, a new chat, interruption, or handoff, call `session.resume` first.

package/skill/references/lifecycle.md

@@ -75,9 +75,9 @@ Name the areas this task works in, against the coverage map the core pack carrie
 
 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.
+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. Proposal drafting, submission and pending approval do not block independent task work. Use host-authorized background agents or concurrent tools and continue the next independent unit; do not immediately wait for the worker. If concurrency is unavailable, checkpoint the pending draft and defer submission until an operation needs it. Follow `references/memory-updates.md` for ownership, delivery tracking and recovery. 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.
+Checkpoints, recorded corrections, reconciliations, self-reviews and scaffold application receipts return before the backend has them, reporting `deliveryStatus: 'pending'` with the task version they will occupy. The local recording call is complete; backend delivery remains pending and is already under way. Do not wait for it, poll it, or send it again before a dependent operation. Collect a proposal's identifiers when its approval or reconciliation needs them, and an approved revision before work that depends on its changed contract. A prepared lease, required synchronization and verification must succeed before the operations that require them; unrelated proposal work is never a prerequisite for continuing this task.
 
 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` immediately followed by a colon and 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.
 

package/skill/references/memory-updates.md

@@ -4,6 +4,53 @@ Backend resources are immutable revisions. The local agent drafts structured con
 
 Use `memory.propose_revision` for project profiles, engineering rules, service contracts, localization contracts, navigation contracts, state contracts, screen logic, component mappings, Figma mappings, current deviations, quality gates, task history, and architecture templates.
 
+## Continue independent work while proposals progress
+
+Do not block independent task work on proposal drafting, submission or approval. This is the usage contract for every project, user and AI host, including Codex and Claude. Decide whether the next operation actually needs the proposal ID or its approved revision; the existence of a pending proposal is not itself a reason to wait.
+
+When the host permits background agents or concurrent tool calls, delegate a bounded set of independent proposals and immediately continue useful work. Collect that worker's result only at a real dependency, rather than spawning a worker and immediately waiting for it. Keep one writer per resource; proposals for different resources may progress together. Keep task-version-changing lifecycle mutations ordered under the owning agent, and handle a resulting version conflict through the normal recovery instead of weakening version checks.
+
+Pass the worker the exact project, task/session and source-run identity that applies, resource identity, baseRevision, verified evidence, proposed selectors and scope. Reuse the owning task's context; delegation neither opens another engineering task nor grants application-edit, approval or delivery authority. Do not pass credentials or claim tokens in prompts or saved documents. The main agent owns native questionnaires and may review or activate a proposal only after the user's explicit decision.
+
+If background execution is unavailable or prohibited, preserve the pending draft and its evidence through `task.checkpoint` documents and continue the independent work first. Submit the draft when an operation needs its result. Never claim a background worker exists on a serial-only host or skip the proposal permanently. An approved architectural or flow change that implementation depends on is still a prerequisite for that implementation.
+
+Track each draft, in-flight call, returned proposal ID, queued delivery and failure in the task's checkpoint documents, with its resource/base revision and the bridge-returned delivery identifiers when available. The MCP call still waits for its own real response: `queued: false` reports a stored inactive proposal, while `queued: true` reports a durable outbox entry, not an approved revision. Reuse the existing outbox delivery and its idempotency key through the supported recovery; do not invoke a fresh proposal call merely to retry an already queued one. If the response is lost, use `memory.list_proposals` to check for the exact proposed content before resubmitting. Compare a changed base revision rather than overwriting it.
+
+For example, while a worker records a finished screen's contract, the main agent can inspect an unrelated service or implement an already-approved component. If the next screen needs a changed flow contract, wait for that specific contract's native approval before implementing it. During adoption or refresh, pending proposals for one unit do not stop inspection of independent units. Required proposals, approvals and reconciliations must still be settled before claiming their dependent unit or the whole inspection complete. Unrelated proposal approval never becomes a prerequisite for another task.
+
+Before a dependent reconciliation, verification or handoff, collect the relevant results and report pending or failed work accurately. Do not close or describe unfinished required memory work as complete. A dismissed questionnaire, timeout or deferred submission is not consent.
+
+## Independent backend recording beyond proposals
+
+Use the same dependency test for every backend write. Recording finished work is not by itself a
+reason to idle the implementation agent. The local bridge durably queues checkpoints, corrections,
+reconciliations, self-reviews and scaffold receipts. Once it returns deliveryStatus pending,
+continue independent work; do not poll, resend or describe delivery as completed. Pending task
+mutations keep their own order. Different tasks have independent delivery lanes, and a new task
+does not wait for another task's outbox. Task-less entries retain project ordering.
+
+Self-review records the exact diff it reviewed; record it again after any later edit. Scaffold
+receipts name the actual file hashes. The backend still checks current authority and expected task
+versions when a receipt arrives. A failure is retained for session.resume and
+task.resolve_pending_delivery; only the affected task waits at its dependent verification.
+A response-lost self-review is acknowledged only when its authorized backend snapshot proves the
+exact recorded effect. Do not discard a failed receipt to make verification pass.
+
+Inventory upload, completed-unit evidence submission and test-result reporting still return their
+real server response. When the host supports concurrent execution, let those calls run while reading
+an independent source area or running an unrelated local validation. The owner tracks the in-flight
+operation and collects the result before the next operation needs it. Without concurrency, preserve
+safe pending evidence in checkpoints and schedule submission before its first dependency. Do not
+defer time-sensitive claim renewal; never save a claim token in a journal or generic outbox.
+
+A new run or task ID, sealed inventory required for planning, a claim required for ownership, an
+approved contract required for implementation, a lease and final verify/close are true dependencies.
+Likewise a work-item status or assignment change may govern the next action: use its result before
+that action. This is not permission to perform unapproved administrative writes or to invent an
+always-running worker. Background execution must use the host's permitted facilities.
+
+## Revision scope and review
+
 Knowledge is layered. `scope: product` proposes a change to the shared engineering core that every organization reads, `scope: organization` proposes one that only this organization reads and which hides the product text for that key, and `scope: project` proposes a record for this project alone. The nearest layer wins when context is delivered. A product-scope proposal is the way a developer improves the product itself from inside their own project, and it requires nothing but the skill. It remains inactive for the configured product release principal to review; waiting in that platform queue does not prevent the contributor's task from verifying or closing.
 
 An architecture template is organization-scoped source, not prose. When a task establishes or changes a shared architecture structure that the templates carry, the template is stale and needs its own revision. Its manifest and content must stay in step: one `files[]` entry per `## file:` block, same path, byte count, SHA-256 and order. See `scaffolding.md`.

package/skill/references/project-onboarding.md

@@ -235,3 +235,14 @@ required for verified delivery. Verified resume, close and commit attestation do
 counterpart memory or depend on a counterpart link/membership that was revoked after verification.
 Fresh linked-source selection and work still check current access. Publishing new source memory
 with memory.publish_task is a separate operation and still requires current linked authority.
+
+## Delivery while independent analysis continues
+
+Use the scheduling contract in memory-updates.md during adoption and refresh too. A committed
+source can be read independently while its inventory upload is in flight. Wait for sealed inventory
+before dependent planning/claims; never report the upload complete from a run identifier alone.
+A finished unit's memory.sync_submit can run alongside analysis of another independently claimed
+unit. Retain the exact request and returned result; renew claims before expiry through the owning
+agent, without sharing claim tokens in prompts or persisting them in the outbox. Collect all required
+submissions and exact approvals before coverage verification. Serial-only hosts schedule independent
+reading first when safe, and submit before the next dependency instead of pretending to run a worker.