engineering-memory 1.10.0 → 1.10.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engineering-memory",
-  "version": "1.10.0",
+  "version": "1.10.2",
   "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/git/verification-gate.js

@@ -1,3 +1,4 @@
+import { sha256 } from '../utilities/hash.js';
 import { readdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { RepositoryResolver } from '../project/repository.js';
@@ -22,8 +23,10 @@ export class VerificationGate {
         }
         const verifiedAt = new Date();
         const taskChanges = await this.git.taskManifest(input.repoRoot, input.taskChanges);
-        await writeJson(this.pathFor(input.repoFingerprint), {
-            schemaVersion: 4,
+        const worktreeId = worktreeIdentity(await this.git.findRoot(input.repoRoot));
+        await writeJson(this.pathFor(input.repoFingerprint, worktreeId, input.taskId), {
+            schemaVersion: 5,
+            worktreeId,
             taskId: input.taskId,
             projectId: input.projectId,
             repoFingerprint: input.repoFingerprint,
@@ -39,16 +42,12 @@ export class VerificationGate {
         }, this.root);
     }
     async verify(repoRoot) {
-        const [repository, stagedChanges, pending, scaffolding] = await Promise.all([
+        const [repository, stagedChanges, scaffolding] = await Promise.all([
             this.repositories.resolve(repoRoot),
             this.git.stagedManifest(repoRoot),
-            this.outbox.list(),
             this.git.temporaryScaffolding(repoRoot),
         ]);
         const { repoFingerprint: fingerprint, git: manifest } = repository;
-        if (pending.length > 0) {
-            return { allowed: false, reason: 'offline_outbox_pending', diffHash: manifest.diffHash };
-        }
         const staged = scaffolding.filter((match) => match.staged);
         if (staged.length > 0) {
             return {
@@ -58,10 +57,29 @@ export class VerificationGate {
                 details: staged.map((match) => `${match.path}:${match.line}`),
             };
         }
-        const receipt = await readJson(this.pathFor(fingerprint), this.root);
+        const branch = await this.git.currentBranch(repository.repoRoot);
+        const candidates = await this.receiptsFor(fingerprint, worktreeIdentity(repository.repoRoot));
+        const relevant = candidates.filter((candidate) => !repository.projectId || candidate.projectId === repository.projectId);
+        relevant.sort((a, b) => b.verifiedAt.localeCompare(a.verifiedAt) || a.taskId.localeCompare(b.taskId));
+        const matchesBranch = (candidate) => !candidate.branch || candidate.branch === branch;
+        const receipt = relevant.find((candidate) => candidate.taskClosed &&
+            matchesBranch(candidate) &&
+            candidate.diffHash === manifest.diffHash &&
+            isTaskManifest(candidate.taskChanges) &&
+            stagedChanges.every((entry) => belongsToTask(entry, candidate.taskChanges))) ??
+            relevant.find(matchesBranch) ??
+            relevant[0];
         if (!receipt) {
             return { allowed: false, reason: 'task_verify_required', diffHash: manifest.diffHash };
         }
+        if ((await this.outbox.listForTask(receipt.taskId)).length > 0) {
+            return {
+                allowed: false,
+                reason: 'offline_outbox_pending',
+                diffHash: manifest.diffHash,
+                taskId: receipt.taskId,
+            };
+        }
         if (!receipt.taskClosed) {
             return {
                 allowed: false,
@@ -70,7 +88,7 @@ export class VerificationGate {
                 taskId: receipt.taskId,
             };
         }
-        if (receipt.schemaVersion !== 4 ||
+        if (![4, 5].includes(receipt.schemaVersion) ||
             !receipt.projectId ||
             typeof receipt.taskVersion !== 'number' ||
             !Number.isSafeInteger(receipt.taskVersion) ||
@@ -83,7 +101,6 @@ export class VerificationGate {
                 taskId: receipt.taskId,
             };
         }
-        const branch = await this.git.currentBranch(repoRoot);
         if (receipt.branch && branch !== receipt.branch) {
             return {
                 allowed: false,
@@ -191,10 +208,31 @@ export class VerificationGate {
             await removeFile(join(this.root, entry.name), this.root);
         }
     }
-    pathFor(repoFingerprint) {
-        return join(this.root, `${safeSegment(repoFingerprint)}.json`);
+    async receiptsFor(repoFingerprint, worktreeId) {
+        await ensureManagedDirectory(this.root, this.root);
+        const prefix = safeSegment(repoFingerprint);
+        const entries = await readdir(this.root, { withFileTypes: true });
+        const receipts = [];
+        for (const entry of entries) {
+            if (entry.name !== `${prefix}.json` &&
+                !(entry.name.startsWith(`${prefix}-`) && entry.name.endsWith('.json')))
+                continue;
+            if (!entry.isFile() || entry.isSymbolicLink())
+                throw new Error(`Unsafe verification gate entry: ${entry.name}`);
+            const receipt = await readJson(join(this.root, entry.name), this.root);
+            if (receipt?.repoFingerprint === repoFingerprint &&
+                (entry.name === `${prefix}.json` || receipt.worktreeId === worktreeId))
+                receipts.push(receipt);
+        }
+        return receipts;
+    }
+    pathFor(repoFingerprint, worktreeId, taskId) {
+        return join(this.root, `${safeSegment(repoFingerprint)}-${worktreeId}-${safeSegment(taskId)}.json`);
     }
 }
+function worktreeIdentity(repoRoot) {
+    return sha256(process.platform === 'win32' ? repoRoot.toLowerCase() : repoRoot);
+}
 function asObject(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : null;
 }

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

@@ -487,6 +487,7 @@ export function registerEngineeringMemoryTools(server, service) {
             projectName: z.string().min(2),
             projectSlug: z.string().min(2).optional(),
             framework: z.string().optional(),
+            developmentArea: z.enum(['backend', 'web', 'mobile']).nullable().optional(),
             figmaConfig: jsonObject,
             initialProjectProfile: z.object({
                 title: z.string().min(2),
@@ -701,6 +702,7 @@ export function registerEngineeringMemoryTools(server, service) {
                 expectedVersion: z.number().int().min(1),
                 name: z.string().min(2).max(160).optional(),
                 framework: z.string().min(2).max(80).nullable().optional(),
+                developmentArea: z.enum(['backend', 'web', 'mobile']).nullable().optional(),
                 repositoryUrl: z.string().url().nullable().optional(),
                 workItemPrefix: z
                     .string()

package/runtime/dist/src/project/repository.js

@@ -59,19 +59,24 @@ export class RepositoryResolver {
             projectId: explicitProjectId ?? binding?.projectId ?? null,
             schemaVersion: binding?.schemaVersion ?? null,
             repoFingerprint,
+            legacyFingerprints: binding ? [] : [await this.git.fingerprint(repoRoot, 1)],
             git,
         };
     }
-    async writeBinding(repoRoot, projectId) {
+    async writeBinding(repoRoot, projectId, fingerprint) {
         assertProjectId(projectId);
         const repository = await this.resolve(repoRoot, projectId);
+        const older = repository.legacyFingerprints.includes(fingerprint);
+        if (fingerprint !== repository.repoFingerprint && !older) {
+            throw new Error('The confirmed project fingerprint does not identify this repository');
+        }
         const repositoryKey = await this.keyFor(repository.repoRoot);
         const bindingPath = this.pathFor(repositoryKey);
         await writeJson(bindingPath, {
             projectId,
-            schemaVersion: repository.schemaVersion ?? this.markerSchemaVersion,
+            schemaVersion: older ? 1 : (repository.schemaVersion ?? this.markerSchemaVersion),
             repositoryKey,
-            repoFingerprint: repository.repoFingerprint,
+            repoFingerprint: fingerprint,
         }, this.stateRoot);
         return bindingPath;
     }

package/runtime/dist/src/runtime/api-client.js

@@ -7,6 +7,7 @@ export const backendRecoveryOperationNames = [
     'organization.member_list',
     'organization.member_upsert',
     'project.setup',
+    'project.update',
     'project.resolve',
     'project.list',
     'project.restore',

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

@@ -70,7 +70,10 @@ export class BridgeService {
             if (!repository.bindingPath) {
                 const resolved = await this.dependencies.client.request(endpoints.projectResolve, {
                     method: 'POST',
-                    body: { repoFingerprint: repository.repoFingerprint },
+                    body: {
+                        repoFingerprint: repository.repoFingerprint,
+                        legacyFingerprints: repository.legacyFingerprints,
+                    },
                 });
                 const project = objectValue(resolved.data);
                 const restoreRequired = Boolean(project?.archivedAt);
@@ -248,7 +251,7 @@ export class BridgeService {
                 });
             }
             const recoveredDeliveries = await this.recoverJournalOutbox(projectId, taskSlug);
-            const outbox = await this.flushOutbox();
+            const outbox = await this.flushOutbox(pointer?.taskId);
             const afterSequence = input.afterSequence ?? 0;
             const response = await this.dependencies.client.request(endpoints.sessionResume, {
                 method: 'POST',
@@ -278,7 +281,7 @@ export class BridgeService {
                     .release(backendTask.id);
             }
             let localJournal = await this.dependencies.journal.load(projectId, taskSlug);
-            let pendingOutbox = await this.dependencies.outbox.list();
+            let pendingOutbox = await this.dependencies.outbox.listForTask(backendTask.id);
             const responseSource = this.dependencies.client.getResponseSource(response);
             const recoveredVerification = responseSource !== 'stale_cache' && pointer
                 ? await this.retryVerificationRecovery(repository, pointer, backend)
@@ -306,7 +309,7 @@ export class BridgeService {
                     documents: backendDocuments,
                 });
                 blockedJournalEventIds = hydration.blockedEventIds;
-                const entries = await this.dependencies.outbox.list();
+                const entries = await this.dependencies.outbox.listForTask(backendTask.id);
                 for (const eventId of hydration.synchronizedEventIds) {
                     const entry = entries.find((value) => value.journalRef?.eventId === eventId);
                     if (entry) {
@@ -337,7 +340,7 @@ export class BridgeService {
                     }
                 }
                 localJournal = await this.dependencies.journal.load(projectId, taskSlug);
-                pendingOutbox = await this.dependencies.outbox.list();
+                pendingOutbox = await this.dependencies.outbox.listForTask(backendTask.id);
                 hydratedFromBackend = !hadLocalProjection;
                 mergedFromBackend = hadLocalProjection;
             }
@@ -437,10 +440,12 @@ export class BridgeService {
     async contextPrepareChange(input) {
         return await this.execute(async () => {
             const repository = await this.dependencies.repositories.resolve(input.repoRoot ?? process.cwd());
-            await this.recoverJournalOutbox();
-            const outbox = await this.flushOutbox();
-            const pendingOutbox = await this.dependencies.outbox.list();
             const pointer = await this.dependencies.activeContexts.loadForSession(repository.repoFingerprint, input.sessionId);
+            if (!pointer)
+                throw refuse('Resume this task before requesting a change lease.', 'session.resume');
+            await this.recoverJournalOutbox(pointer.projectId, pointer.taskSlug);
+            const outbox = await this.flushOutbox(pointer.taskId);
+            const pendingOutbox = await this.dependencies.outbox.listForTask(pointer.taskId);
             if (pointer?.verificationIntent || pointer?.closeIntent) {
                 throw refuse('A verification or close intent from an earlier session is still unsettled, so a new lease would be taken against the wrong state.', 'session.resume');
             }
@@ -992,8 +997,9 @@ export class BridgeService {
         return await this.execute(async () => {
             return await this.taskExclusive(input.taskId, async () => {
                 await this.recoverJournalOutbox();
-                const outbox = await this.flushOutbox();
-                const pendingOutboxCount = (await this.dependencies.outbox.list()).length;
+                const outbox = await this.flushOutbox(input.taskId);
+                const pendingOutboxCount = (await this.dependencies.outbox.listForTask(input.taskId))
+                    .length;
                 const repository = await this.dependencies.repositories.resolve(input.repoRoot ?? process.cwd());
                 if (pendingOutboxCount > 0) {
                     return asJsonValue({
@@ -1358,7 +1364,9 @@ export class BridgeService {
                 projectName: input.projectName,
                 projectSlug: input.projectSlug ?? slugify(input.projectName),
                 repoFingerprint: repository.repoFingerprint,
+                legacyFingerprints: repository.legacyFingerprints,
                 framework: input.framework,
+                developmentArea: input.developmentArea,
                 figmaConfig: input.figmaConfig,
                 initialProjectProfile: input.initialProjectProfile,
             });
@@ -1380,6 +1388,7 @@ export class BridgeService {
             const marker = objectValue(data?.marker);
             if (!project ||
                 typeof project.id !== 'string' ||
+                typeof project.repoFingerprint !== 'string' ||
                 !profileResource ||
                 !profileRevision ||
                 !policy ||
@@ -1388,7 +1397,7 @@ export class BridgeService {
                 readDiscoveryUnits(policy).length === 0) {
                 throw refuse('Project setup response is not policy-ready', 'project.setup');
             }
-            const bindingPath = await this.dependencies.repositories.writeBinding(repository.repoRoot, project.id);
+            const bindingPath = await this.dependencies.repositories.writeBinding(repository.repoRoot, project.id, project.repoFingerprint);
             return asJsonValue({ ...data, marker: null, markerPath: null, bindingPath });
         });
     }
@@ -1685,13 +1694,18 @@ export class BridgeService {
                 }
                 const response = await this.dependencies.client.request(endpoints.projectBind(input.projectId), {
                     method: 'POST',
-                    body: { repoFingerprint: repository.repoFingerprint },
+                    body: {
+                        repoFingerprint: repository.repoFingerprint,
+                        legacyFingerprints: repository.legacyFingerprints,
+                    },
                 });
                 const project = objectValue(response.data);
-                if (!project || project.id !== input.projectId) {
+                if (!project ||
+                    project.id !== input.projectId ||
+                    typeof project.repoFingerprint !== 'string') {
                     throw refuse('Project bind response does not match the selected project', 'project.resolve');
                 }
-                const bindingPath = await this.dependencies.repositories.writeBinding(repository.repoRoot, input.projectId);
+                const bindingPath = await this.dependencies.repositories.writeBinding(repository.repoRoot, input.projectId, project.repoFingerprint);
                 return asJsonValue({
                     resolved: true,
                     bound: true,
@@ -1704,7 +1718,10 @@ export class BridgeService {
             }
             const response = await this.dependencies.client.request(endpoints.projectResolve, {
                 method: 'POST',
-                body: { repoFingerprint: repository.repoFingerprint },
+                body: {
+                    repoFingerprint: repository.repoFingerprint,
+                    legacyFingerprints: repository.legacyFingerprints,
+                },
             });
             const project = objectValue(response.data);
             const restoreRequired = Boolean(project?.archivedAt);
@@ -2085,11 +2102,17 @@ export class BridgeService {
             return asJsonValue({ queued: true, outboxId: queued.id, idempotencyKey });
         }
     }
-    async flushOutbox() {
-        const entries = await this.dependencies.outbox.list();
+    async flushOutbox(taskId) {
+        const entries = taskId
+            ? await this.dependencies.outbox.listForTask(taskId)
+            : await this.dependencies.outbox.list();
         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,
@@ -2115,7 +2138,7 @@ export class BridgeService {
                     await this.dependencies.journal.markDeliveryAttempt(entry.journalRef.projectId, entry.journalRef.taskSlug, entry.journalRef.eventId, errorKind);
                 }
                 blocked.push({ id: entry.id, error: errorKind });
-                break;
+                blockedTasks.add(deliveryTaskId);
             }
         }
         return asJsonValue({

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

@@ -81,6 +81,12 @@ export class OfflineOutbox {
         }));
         return values.filter((entry) => entry !== null).sort(compareEntries);
     }
+    async listForTask(taskId) {
+        return (await this.list()).filter((entry) => {
+            const body = entry.body;
+            return (body !== null && typeof body === 'object' && !Array.isArray(body) && body.taskId === taskId);
+        });
+    }
     async markAttempt(id, errorKind) {
         await this.exclusive(id, async () => {
             const path = this.pathFor(id);

package/skill/references/lifecycle.md

@@ -4,7 +4,7 @@
 
 Sign-in decides nothing beyond who the user is. The organization and the project are chosen after it, through the questionnaires in `questionnaires.md`, and both listings end with an option to create a new one. Ask for both whenever this session has not already confirmed them, and ask again the moment the user says they want to change either — changing the organization always means choosing the project again.
 
-Use the binding returned by `session.entry` as the authority. The bridge stores the selected project and repository identity under `~/.engineering-memory/origins/<api-hash>/project-bindings/`, outside the installed runtime and working tree. It imports a legacy `.engineering-memory/project.json` once, preserving its schema and exact backend fingerprint for existing tasks and receipts. It leaves that file unchanged; after migration the file is optional and may be removed through the repository's normal Git workflow. New bindings never create it. Never infer a selection from a directory or remote, and never edit binding records by hand. Separate clones or a changed remote require a new explicit selection; worktrees of the same checkout share the local binding.
+Use the binding returned by `session.entry` as the authority. The bridge stores the selected project and repository identity under `~/.engineering-memory/origins/<api-hash>/project-bindings/`, outside the installed runtime and working tree. It imports a legacy `.engineering-memory/project.json` once, preserving its schema and exact backend fingerprint for existing tasks and receipts. It leaves that file unchanged; after migration the file is optional and may be removed through the repository's normal Git workflow. New bindings never create it. A checkout that never imported the marker still finds a project bound under the older identity: the bridge presents that identity alongside the current one and stores whichever the backend confirms. Never infer a selection from a directory or remote, and never edit binding records by hand. Separate clones or a changed remote require a new explicit selection; worktrees of the same checkout share the local binding.
 
 An archived project is recoverable state, not a missing or conflicting binding. When an owner receives `project.restore`, use the `projectId` and `expectedVersion` in its data and call that operation before retrying. A non-owner receives `project.member_list` instead: list the members, identify a project owner and explain that the owner must restore the exact project before this session can retry. Use `project.list` with `includeArchived: true` when an owner must first select the archived project. Never create or bind a replacement project to escape archive state.
 
@@ -184,4 +184,4 @@ When a pull request has been opened, keep going: check whether it merges cleanly
 
 ## Offline Behavior
 
-An unexpired cached context pack may be used for implementation. The bridge records checkpoints in its outbox. Permanent proposal review, strict verification, task close, and Git commit remain blocked until the backend is reachable and the outbox is synchronized.
+An unexpired cached context pack may be used for implementation. The bridge records checkpoints in its outbox. Permanent proposal review, strict verification, task close, and Git commit require the backend and synchronization of the relevant task deliveries. An unrelated task or repository queue does not block this task; account switching and logout still require all deliveries to be resolved. Commit receipts are retained per task and worktree and still require an online attestation for the selected closed task and exact staged content.