engineering-memory 1.11.26 → 1.11.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engineering-memory",
-  "version": "1.11.26",
+  "version": "1.11.27",
   "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/build.json

@@ -1,3 +1,3 @@
 {
-  "gitHead": "0f86f662e39b6ace530d89827a5b14018f1b68fe"
+  "gitHead": "9c67b478ebbb78293ac8fc7719baaf4a7b2970b7"
 }

package/runtime/dist/src/config.js

@@ -70,6 +70,7 @@ export const endpoints = {
     taskDeliveryAnswer: (projectId, taskId) => `/projects/${projectId}/tasks/${taskId}/delivery/answer`,
     taskDeliveryDeliver: (projectId, taskId) => `/projects/${projectId}/tasks/${taskId}/delivery/deliver`,
     taskDeliveryCancel: (projectId, taskId) => `/projects/${projectId}/tasks/${taskId}/delivery/cancel`,
+    taskReviewRequest: (projectId, taskId) => `/projects/${projectId}/tasks/${taskId}/review-request`,
     projectSetup: '/projects/setup',
     projectList: '/projects',
     projectResolve: '/projects/resolve',

package/runtime/dist/src/mcp/delivery-tools.js

@@ -66,6 +66,7 @@ const recordSchema = z.object({
 });
 export function registerDeliveryTools(server, service) {
     registerTaskDelivery(server, service);
+    registerTaskReviewRequest(server, service);
     server.registerTool('task.close', {
         description: 'Close the verified task, then open its durable mode-governed Git delivery selector in the same call. Memory publication is separate. Cancellation/feedback leave delivery pending; retry identical input to resume. PR/MR is one review-request concept, not an instruction to merge. No Git action is performed by this tool. Read-only tasks need no delivery. Supply complete copy when the product text catalogue lacks the conversation language. If the user already explicitly chose Git delivery in their own message, deliveryInstruction preserves that choice with its exact relevant excerpt; it is an agent-reported instruction, never a native answer or a substitute for missing user consent. Do not use it for agent decisions or memory-publication approval.',
         inputSchema: z.object({
@@ -507,6 +508,34 @@ function registerTaskDelivery(server, service) {
         });
     });
 }
+function registerTaskReviewRequest(server, service) {
+    server.registerTool('task.review_request', {
+        description: "Record the pull request (GitHub) or merge request (GitLab) a closed task's changes went into, and its state: draft, ready, merged or closed. Call it with the link copied from the provider as soon as the pull request is opened, and again when the user says it became ready, was merged or was closed. Engineering Memory then moves the task's work item as the project's workflow rules say, for example to PR when every pull request of the work item is ready and to READY FOR QA when they are all merged. It works from any chat, also for a delivery session.entry lists. What is recorded is what was reported: Engineering Memory does not check it with the provider, and performs no Git or provider action.",
+        inputSchema: z.strictObject({
+            projectId: z.string().uuid(),
+            taskId: z.string().uuid(),
+            url: z.string().trim().min(1).max(500),
+            state: z.enum(['draft', 'ready', 'merged', 'closed']),
+        }),
+    }, async (input) => {
+        const result = await service.taskReviewRequest(input);
+        if (!result.ok)
+            return output(result);
+        const recorded = result.data;
+        return output({
+            ok: true,
+            data: {
+                ...result.data,
+                nextAction: recorded.queued
+                    ? 'Engineering Memory is unreachable, so this report is queued. It is recorded, and the work item moves as the rules say, when Engineering Memory is reachable again.'
+                    : (recorded.data?.reviewEvent?.nextAction ??
+                        (recorded.data?.reviewEvent
+                            ? 'The pull request is recorded; the work item stays where it is.'
+                            : 'The pull request is recorded. The work item does not move yet: other work on it is still open or undelivered, or the task has no active work item.')),
+            },
+        });
+    });
+}
 function askPullRequestBase(server, service, context, input, language, copy, owner) {
     return askQuestionnaire(server, service, {
         repoRoot: input.repoRoot,

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

@@ -78,6 +78,7 @@ export const toolAnnotations = {
     'task.verify': write,
     'task.close': write,
     'task.delivery': write,
+    'task.review_request': repeatableWrite,
     'task.abandon': destructive,
     'task.branch': outward, // fetches the chosen base from the Git remote
     'architecture.plan': read,

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

@@ -117,6 +117,7 @@ export const engineeringMemoryToolNames = [
     'task.verify',
     'task.close',
     'task.delivery',
+    'task.review_request',
     'task.abandon',
     'task.branch',
     'architecture.plan',

package/runtime/dist/src/runtime/active-context-store.js

@@ -122,7 +122,7 @@ export class ActiveContextStore {
             }
         }
     }
-    async setChangeBaseline(repoFingerprint, sessionId, manifest, leasePaths, taskSnapshot) {
+    async setChangeBaseline(repoFingerprint, sessionId, manifest, leasePaths, taskSnapshot, selfReviewRequired) {
         const pointer = taskSnapshot
             ? await this.loadForTask(repoFingerprint, taskSnapshot.taskId)
             : await this.loadForSession(repoFingerprint, sessionId);
@@ -140,13 +140,12 @@ export class ActiveContextStore {
                     lastSequence: taskSnapshot.lastSequence,
                 }
                 : {}),
-            changeBaseline: pointer.changeBaseline
-                ? { ...pointer.changeBaseline, leasePaths }
-                : {
-                    diffHash: manifest.diffHash,
-                    changedPaths: manifest.changedPaths,
-                    leasePaths,
-                },
+            changeBaseline: {
+                diffHash: pointer.changeBaseline?.diffHash ?? manifest.diffHash,
+                changedPaths: pointer.changeBaseline?.changedPaths ?? manifest.changedPaths,
+                leasePaths,
+                ...(selfReviewRequired ? { selfReviewRequired } : {}),
+            },
         });
     }
     async setVerificationIntent(repoFingerprint, input) {
@@ -399,7 +398,11 @@ export class ActiveContextStore {
                 pointer.changeBaseline.changedPaths.some((entry) => !isChangedPath(entry)) ||
                 !Array.isArray(pointer.changeBaseline.leasePaths) ||
                 pointer.changeBaseline.leasePaths.some((path) => !isRepositoryRelative(path)) ||
-                new Set(pointer.changeBaseline.leasePaths).size !== pointer.changeBaseline.leasePaths.length) {
+                new Set(pointer.changeBaseline.leasePaths).size !==
+                    pointer.changeBaseline.leasePaths.length ||
+                (pointer.changeBaseline.selfReviewRequired !== undefined &&
+                    (!Array.isArray(pointer.changeBaseline.selfReviewRequired) ||
+                        !pointer.changeBaseline.selfReviewRequired.every(isSelfReviewRecord)))) {
                 throw new Error('Active Engineering Memory change baseline is invalid');
             }
         }
@@ -429,6 +432,13 @@ function isDurableIntent(value) {
         typeof value.createdAt === 'string' &&
         Number.isFinite(Date.parse(value.createdAt)));
 }
+function isSelfReviewRecord(value) {
+    return (typeof value?.resourceId === 'string' &&
+        typeof value.resourceKey === 'string' &&
+        typeof value.title === 'string' &&
+        Array.isArray(value.paths) &&
+        value.paths.every((path) => typeof path === 'string'));
+}
 function isChangedPath(value) {
     return (typeof value.path === 'string' &&
         isRepositoryRelative(value.path) &&

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

@@ -51,6 +51,7 @@ export const backendRecoveryOperationNames = [
     'task.branch',
     'task.resolve_pending_delivery',
     'task.delivery',
+    'task.review_request',
 ];
 const backendRecoveryOperations = new Set(backendRecoveryOperationNames);
 const browserSigninRecovery = 'auth.signin_browser';

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

@@ -987,6 +987,7 @@ export class BridgeService {
                 await this.live.taskStarted(backendTask.id);
             }
             const backendFresh = responseSource !== 'stale_cache';
+            const deliveryState = objectValue(backend.taskDelivery)?.state;
             return asJsonValue({
                 backend: resumeBackendView(backend, backendFresh || !localJournal.projection),
                 requirements: backend.requirements ?? null,
@@ -999,7 +1000,12 @@ export class BridgeService {
                         staleReason: backend.staleReason ?? null,
                         nextAction: contextRefreshAction(backend.staleReason, resumedBaseline),
                     }
-                    : {}),
+                    : backendTask.status === 'closed' &&
+                        (deliveryState === 'unanswered' || deliveryState === 'answered')
+                        ? {
+                            nextAction: 'This task is closed and its changes are not delivered yet. Its delivery continues as before: task.close in this folder asks the delivery question. If the user asks for a further change instead, call context.prepare_change with this sessionId and the paths the change touches: that reopens the task, and the next task.close asks the delivery question again for the new content.',
+                        }
+                        : {}),
                 repository: publicRepository(repository),
                 worktree: (await this.ownedAllocation(projectId, repository.repoRoot)) ?? null,
                 localJournal: backendFresh ? journalSummary(localJournal) : localJournal,
@@ -1165,6 +1171,9 @@ export class BridgeService {
             const response = await this.dependencies.client.request(endpoints.contextPrepareChange, {
                 method: 'POST',
                 body,
+                ...(this.dependencies.clientVersion
+                    ? { headers: { 'x-client-version': this.dependencies.clientVersion } }
+                    : {}),
                 ...(input.transitionToWrite
                     ? {}
                     : {
@@ -1174,6 +1183,8 @@ export class BridgeService {
             });
             const responseSource = this.dependencies.client.getResponseSource(response);
             if (responseSource === 'stale_cache') {
+                if (pointer.closedAt)
+                    throw refuse('This task is closed, and reopening it for a further change needs Engineering Memory, which cannot be reached now. Try again once it is reachable.', 'context.prepare_change');
                 validateOfflineLease(response.data, input.sessionId, changedPaths, baselineDiffHash);
                 await this.dependencies.activeContexts.setChangeBaseline(repository.repoFingerprint, input.sessionId, repository.git, changedPaths);
                 return asJsonValue({
@@ -1192,7 +1203,8 @@ export class BridgeService {
                     resumeConflicts: pointer.resumeConflicts.filter((value) => value !== 'backend_resume_is_stale'),
                 });
             }
-            const preparedTask = objectValue(objectValue(response.data)?.task);
+            const preparedData = objectValue(response.data);
+            const preparedTask = objectValue(preparedData?.task);
             await this.dependencies.activeContexts.setChangeBaseline(repository.repoFingerprint, input.sessionId, repository.git, changedPaths, preparedTask &&
                 typeof preparedTask.id === 'string' &&
                 typeof preparedTask.lockVersion === 'number'
@@ -1201,8 +1213,16 @@ export class BridgeService {
                     taskVersion: numericTaskVersion(preparedTask.lockVersion),
                     lastSequence: numericSequence(preparedTask.lastSequence),
                 }
-                : undefined);
-            const preparedPointer = await this.dependencies.activeContexts.loadForSession(repository.repoFingerprint, input.sessionId);
+                : undefined, selfReviewRecords(preparedData?.selfReviewRequired));
+            let preparedPointer = await this.dependencies.activeContexts.loadForSession(repository.repoFingerprint, input.sessionId);
+            if (preparedPointer?.closedAt && preparedTask?.status === 'open') {
+                const allocation = await this.ownedAllocation(preparedPointer.projectId, repository.repoRoot);
+                if (allocation && this.dependencies.worktreePool)
+                    await this.dependencies.worktreePool.reopen(preparedPointer.projectId, repository.repoRoot, allocation.generation);
+                const { closedAt: _closedAt, ...reopened } = preparedPointer;
+                await this.dependencies.activeContexts.save(reopened);
+                preparedPointer = reopened;
+            }
             if (preparedPointer) {
                 if (decision) {
                     await this.dependencies.repositories.git
@@ -1221,7 +1241,6 @@ export class BridgeService {
                         allocation.taskId = preparedPointer.taskId;
                     }
                 }
-                const preparedData = objectValue(response.data);
                 await this.seedResumeSnapshot(preparedPointer, {
                     ...objectOrEmpty(response.data),
                     ...(preparedData?.lease ? { activeLease: preparedData.lease } : {}),
@@ -1910,10 +1929,18 @@ export class BridgeService {
     }
     async taskSelfReview(input) {
         const reviewed = await this.execute(async () => {
+            const checkout = await this.dependencies.repositories.resolve(input.repoRoot ?? process.cwd());
+            const pointer = await this.dependencies.activeContexts.loadForTask(checkout.repoFingerprint, input.taskId);
+            const named = new Set(input.files.flatMap(({ rules }) => rules.map((rule) => rule.resourceId)));
+            const leasePaths = pointer?.changeBaseline?.leasePaths ?? [];
+            const unnamed = (pointer?.changeBaseline?.selfReviewRequired ?? []).filter(({ resourceId }) => !named.has(resourceId));
+            if (unnamed.length > 0)
+                throw refuse(`This self review leaves out records the change lease requires, so task.verify would refuse it: ${unnamed
+                    .map(({ resourceKey, title, paths }) => `${resourceKey} "${title}" (${paths.length === leasePaths.length ? 'every leased path' : paths.join(', ') || 'no single path'})`)
+                    .join('; ')}. Read the changed files against each of them and name it on a changed file it covers, or on any changed file when it covers no single path; then record task.self_review again. Nothing was recorded.`, 'task.self_review');
             const files = await this.approvedDeviations(input);
             assertSafeToPersist(cleanJson({ files }));
-            const checkout = await this.dependencies.repositories.resolve(input.repoRoot ?? process.cwd());
-            const repository = await this.taskRepository(checkout, await this.dependencies.activeContexts.loadForTask(checkout.repoFingerprint, input.taskId));
+            const repository = await this.taskRepository(checkout, pointer);
             if (this.deferDeliveries) {
                 return this.enqueueTaskReceipt('task.self_review', endpoints.taskSelfReview, input.taskId, repository.repoRoot, cleanJson({
                     diffHash: repository.git.diffHash,
@@ -4519,9 +4546,9 @@ export class BridgeService {
                 const taskEntries = (await this.dependencies.outbox.list()).filter((entry) => taskIdFromDeliverySafe(entry) === input.taskId);
                 const pointer = await this.resolveCheckpointPointer(input, repoRoot);
                 if (pointer.closedAt && correction)
-                    throw refuse(`Task ${pointer.taskSlug} is closed, so it takes no more corrections. Record the user's correction as a proposal for the rule it concerns with memory.propose_revision, or in the task that next changes this code.`, 'memory.propose_revision');
+                    throw refuse(`Task ${pointer.taskSlug} is closed, so it takes no more corrections. When the correction asks for a further code change and the task's changes are not delivered yet, call context.prepare_change in its session first: that reopens the task, and the correction is then recorded on it. Otherwise record it as a proposal for the rule it concerns with memory.propose_revision, or in the task that next changes this code.`, 'memory.propose_revision');
                 if (pointer.closedAt)
-                    throw refuse(`Task ${pointer.taskSlug} is closed, so it takes no more checkpoints. Further work belongs to a new task.`, 'session.bootstrap');
+                    throw refuse(`Task ${pointer.taskSlug} is closed, so it takes no more checkpoints. While its changes are not delivered, a further change continues it: call context.prepare_change in its session with the paths the change touches, which reopens it. Work after its delivery belongs to a new task.`, 'context.prepare_change');
                 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');
@@ -4643,6 +4670,9 @@ export class BridgeService {
     async taskDeliveryCancel(input) {
         return this.execute(() => this.mutateWithOutbox('task.delivery', endpoints.taskDeliveryCancel(input.projectId, input.taskId), { reason: input.reason }));
     }
+    async taskReviewRequest(input) {
+        return this.execute(() => this.mutateWithOutbox('task.review_request', endpoints.taskReviewRequest(input.projectId, input.taskId), { url: input.url, state: input.state }));
+    }
     async taskDeliveryRecord(input) {
         return this.execute(async () => {
             const response = await this.dependencies.client.request(endpoints.taskDelivery(input.projectId, input.taskId));
@@ -5669,7 +5699,7 @@ function deliveryQuestion(touchedContract, destination, publishApplicable, commi
                 alsoAsk: 'This task changed an endpoint contract. Ask whether to document the change for the linked project, and if so write what the other side must do differently with memory.propose_revision as an integration_note.',
             }
             : {}),
-        afterPullRequest: 'Do not end the turn once a pull request exists. Check whether it merges cleanly, report the conflicting files if it does not, and ask whether to resolve them before touching anything.',
+        afterPullRequest: 'Do not end the turn once a pull request exists. Record it with task.review_request: its link, and draft or ready as it was opened. Then check whether it merges cleanly, report the conflicting files if it does not, and ask whether to resolve them before touching anything. When the user later says it became ready, was merged or was closed, record that with task.review_request too.',
         afterCommit,
     });
 }
@@ -5732,6 +5762,27 @@ function checkpointView(checkpoint) {
         documents: documentViews(checkpoint.documents),
     };
 }
+function selfReviewRecords(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    return value.flatMap((entry) => {
+        const record = objectValue(entry);
+        return record &&
+            typeof record.resourceId === 'string' &&
+            typeof record.resourceKey === 'string' &&
+            typeof record.title === 'string' &&
+            Array.isArray(record.paths)
+            ? [
+                {
+                    resourceId: record.resourceId,
+                    resourceKey: record.resourceKey,
+                    title: record.title,
+                    paths: record.paths.filter((path) => typeof path === 'string'),
+                },
+            ]
+            : [];
+    });
+}
 function resumeBackendView(backend, includeDocuments) {
     const rest = Object.fromEntries(Object.entries(backend).filter(([key]) => key !== 'requirements'));
     const task = objectValue(backend.task);

package/runtime/dist/src/runtime/worktree-pool.js

@@ -588,6 +588,15 @@ export class WorktreePool {
             await this.save(registry);
         });
     }
+    async reopen(projectId, repoRoot, generation) {
+        return this.transaction(async (registry) => {
+            const entry = this.owned(registry, projectId, repoRoot, generation);
+            entry.phase = 'working';
+            entry.pendingDelivery = false;
+            entry.lastActivityAt = this.now();
+            await this.save(registry);
+        });
+    }
     async release(projectId, repoRoot, generation, deliveryOutcome) {
         return this.transaction(async (registry) => {
             const entry = await this.deliveryOwned(registry, projectId, repoRoot, generation);

package/skill/references/lifecycle.md

@@ -254,7 +254,7 @@ A project-specific correction is offered as task-only or permanent for this proj
 
 Before validation, read the changed code back against the rules that govern it. Not from memory: reread the returned records for the paths that changed, including anything the context pack deferred, and read the diff as the next person to open the file would. The restraint document is the first thing to hold it against.
 
-`context.prepare_change` returns `governingRules`: for each changed path, the rules its role in the project profile binds it to. Record `task.self_review` with one entry per changed file (deleted files excepted) that names every one of those rules, and for a file the profile maps to no role, the engineering rules you actually read it against. Each rule gets one outcome:
+`context.prepare_change` returns `governingRules`: for each changed path, the rules its role in the project profile binds it to. Record `task.self_review` with one entry per changed file (deleted files excepted) that names every one of those rules, and for a file the profile maps to no role, the engineering rules you actually read it against. It also returns `selfReviewRequired`: every record the change lease is taken against — the records of the leased paths, deferred ones included, and the project profile — each with the leased paths it covers. The review names each of them too, on a changed file it covers, or on any changed file when it covers no single path; `task.self_review` refuses a review that leaves one out and records nothing, and `task.verify` would refuse it as well. Each rule gets one outcome:
 
 - `follows`: the file does what the rule says.
 - `fixed`: it did not, and you changed it; record what was wrong and what you changed.
@@ -286,6 +286,8 @@ Record `handoff_before`, then call `task.verify`. For a write task, verify the e
 
 A verified task is not frozen. When a change is needed after verification — a product manager's update, a fix the user asks for, a correction — call `context.prepare_change` for the paths it touches: that reopens the task and keeps everything recorded so far. A correction, a checkpoint or a self review reopens it as well. `task.reconcile` and `memory.propose_revision` on a verified task refuse with `Task already verified` and recovery `context.prepare_change`; call it, then repeat the refused call. Make the change, review it with `task.self_review`, run the validations again with `validation_before`, `validation_after` and `handoff_before` recorded around them, and verify again before `task.close`.
 
+A closed task whose changes are not delivered yet is not frozen either. When the user asks for a further change before the delivery — after trying the branch, or a new request before the push — call `context.prepare_change` in the task's session with the paths the change touches; in a new chat, `session.resume` shows that session. It reopens the task (`reopenedFromClose: true`), keeps everything recorded so far and clears the delivery answer, so the next `task.close` asks the delivery question again for the new content. Until then a checkpoint, correction, self review or reconciliation on the closed task refuses with `Task closed before delivery` and recovery `context.prepare_change`. Once its delivery is recorded as delivered or concluded, the task stays closed: start the next change as new work with `task.branch`, which can continue on the same branch.
+
 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.
@@ -294,7 +296,9 @@ Call `task.close` only after verification and only when the current diff still m
 
 After memory approval, finish any required reconciliation and verification, then call `task.close` in the same turn; do not stop at publishing memory or at a successful verify result. Closing is not the end of the turn either. The MCP `task.close` call closes the verified task and opens its durable, mode-governed delivery selector itself: commit, commit and push, commit and push with a draft PR/MR, commit and push with a PR/MR, or keep it for now. Do not open a duplicate delivery questionnaire. Follow its pending/delegated/native result and retry the same call until a real decision is recorded. Cancellation and feedback preserve the closed worktree and pending delivery. PR/MR target selection is a second question when the target is not already explicitly supplied; merging is separate and never implied. An explicit Git delivery instruction already present in the user's own message can be passed as `deliveryInstruction` with its exact relevant `userRequestExcerpt`, choice and any explicit baseBranch. It is reported as an agent-reported user instruction, not a native answer; never use memory approval or an agent preference as that instruction. Read-only tasks have no Git delivery form. Perform only the selected and authorized Git action; the tool itself commits, pushes and merges nothing. When the host has to approve a push, follow the Delivery section of `questionnaires.md`; an Engineering Memory form is never the way past a host's denial.
 
-When a pull request has been opened, keep going: check whether it merges cleanly, report the result with the link, and if it conflicts, name the files and ask whether to resolve them. Never end the turn on a pull request whose mergeability was never checked, and never resolve a conflict without being told to.
+When a pull request has been opened, keep going: record it with `task.review_request` — its link as the provider shows it, and `draft` or `ready` as it was opened — then check whether it merges cleanly, report the result with the link, and if it conflicts, name the files and ask whether to resolve them. Never end the turn on a pull request whose mergeability was never checked, and never resolve a conflict without being told to.
+
+When the user later says a pull request became ready, was merged or was closed, record that state with `task.review_request` too; it works from any chat, also for a delivery `session.entry` lists. Engineering Memory then moves the task's work item as the project's workflow rules say: to the `pr_opened` target once every pull request of the work item is ready, to the `all_prs_merged` target (READY FOR QA by default) once they are all merged, and to the draft target when one is still a draft and the project names one. It waits while another task of the work item is still open, or closed with a delivery that has no pull request yet. Relay the returned `nextAction` in one line. The record is what was reported: Engineering Memory does not check it with the provider, so never report a merge the user has not confirmed. A merge is final, and a delivery keeps the first pull request recorded for it. GitHub pull request and GitLab merge request links are recorded; for another provider, move the work item with `work_item.update`.
 
 ## Code source and memory applicability