engineering-memory 1.3.0 → 1.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engineering-memory",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "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/tool-definitions.js

@@ -363,6 +363,11 @@ export function registerEngineeringMemoryTools(server, service) {
                 resourceKey: z.string().min(2),
             }))
                 .optional(),
+            introducedStructures: z
+                .array(z.string().min(2).max(80))
+                .max(20)
+                .optional()
+                .describe('Architectural structures this task adds that the project did not have: a cache, a broker, a read replica, a second deployable, a projection, an event store. Verification refuses any the project profile has not recorded under architecture.adopted with the pressure it relieves.'),
         }),
     }, async (input) => toolResult(await service.taskVerify(input)));
     server.registerTool('task.close', {

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

@@ -957,6 +957,7 @@ export class BridgeService {
                 }
                 let taskChangedPaths = [];
                 let taskChanges = [];
+                let foreignChangedPaths = [];
                 const snapshotResponse = await this.dependencies.client.request(endpoints.sessionResume, {
                     method: 'POST',
                     body: {
@@ -994,7 +995,13 @@ export class BridgeService {
                     if (!baseline || activeLease?.baselineDiffHash !== baseline.diffHash) {
                         throw new Error('Write task verification requires its locally pinned change baseline');
                     }
-                    taskChanges = manifestDelta(baseline.changedPaths, repository.git.changedPaths);
+                    const wholeTreeDelta = manifestDelta(baseline.changedPaths, repository.git.changedPaths);
+                    const leased = new Set(normalizeChangedPaths([...baseline.leasePaths, ...leaseChangedPaths]));
+                    taskChanges = wholeTreeDelta.filter((entry) => leased.has(normalizeChangedPaths([entry.path])[0]));
+                    foreignChangedPaths = wholeTreeDelta
+                        .filter((entry) => !leased.has(normalizeChangedPaths([entry.path])[0]))
+                        .map((entry) => entry.path)
+                        .sort();
                     taskChangedPaths = taskChanges.map((entry) => entry.path).sort();
                     if (input.changedPaths &&
                         stableStringify(normalizeChangedPaths(input.changedPaths)) !==
@@ -1033,6 +1040,7 @@ export class BridgeService {
                     validations,
                     pendingOutboxCount,
                     newResources: input.newResources,
+                    introducedStructures: input.introducedStructures,
                 });
                 await this.dependencies.activeContexts.setVerificationIntent(repository.repoFingerprint, {
                     mode: taskMode,
@@ -1072,6 +1080,9 @@ export class BridgeService {
                 return asJsonValue({
                     ...objectOrEmpty(response.data),
                     mode: taskMode,
+                    ...(foreignChangedPaths.length > 0
+                        ? { changedPathsOutsideThisTask: foreignChangedPaths }
+                        : {}),
                     repository: publicRepository(repository),
                 });
             });

package/skill/references/lifecycle.md

@@ -128,6 +128,8 @@ For each changed screen or component, call `task.reconcile` with an approved pro
 
 Record `handoff_before`, then call `task.verify`. For a write task, verify the exact changed paths, current diff hash, validations, session, and lease. For a read-only task, send no changed paths, lease, or write baseline; the bridge supplies the current Git diff hash and the backend compares it with the baseline captured at bootstrap while also verifying bootstrap, discovery, validation-before, validation-after, handoff, pinned read receipts, and synchronized outbox evidence. If verification fails, resolve the reported gap and verify again. Do not state that the task is complete while verification is failing, and do not carry on writing code with the failure unaddressed — a task that never verifies never closes, and everything that depends on closing, including the commit gate, silently never happens.
 
+When a task adds a structure the system did not have — a cache, a broker, a read replica, a second deployable, a projection, an event store — name it in `introducedStructures` at verification. The backend refuses any the project profile has not recorded under `architecture.adopted`, with the pressure it relieves, and refuses with the stated reason any the project recorded as deliberately declined. Recording it is a project profile revision like any other: propose, have the user approve, reconcile. Do not reach for the structure first and record it afterwards — the point of the record is that somebody decided.
+
 A new screen or component fails verification until its memory exists, which takes four steps in order: `memory.propose_revision` for each new path, the user's explicit approval, `memory.review_proposal`, then `task.reconcile`. The error names the paths. Walk the chain rather than retrying the same verification.
 
 Call `task.close` only after verification and only when the current diff still matches. The Git hook performs a fresh authenticated commit-gate check against the closed task, current membership, repository fingerprint, diff hash, and knowledge revisions. A local receipt alone never authorizes commit. Closing a task does not authorize commit, push, publish, deploy, tag, or merge.