engineering-memory 1.11.25 → 1.11.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engineering-memory",
-  "version": "1.11.25",
+  "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": "487a37fd63becd1520c4e1f5e4ba13ed2de828e2"
+  "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/git/git-inspector.js

@@ -375,10 +375,10 @@ export class GitInspector {
             diffHash: sha256(`${head ?? '<unborn>'}\n${stableStringify(hashManifest)}\n`),
         };
     }
-    async manifestAgainst(repoRoot, baseCommit) {
+    async manifestAgainst(repoRoot, baseCommit, from = baseCommit) {
         const root = await this.findRoot(repoRoot);
         const head = await this.gitValue(root, ['rev-parse', 'HEAD']);
-        const changedPaths = await this.changedPathsAgainstHead(root, baseCommit);
+        const changedPaths = await this.changedPathsAgainstHead(root, from);
         const hashManifest = canonicalHashManifest(changedPaths);
         return {
             repoRoot: root,
@@ -386,9 +386,26 @@ export class GitInspector {
             baseCommit,
             changedPaths,
             worktreeHash: sha256(`${stableStringify(hashManifest)}\n`),
-            diffHash: sha256(`${baseCommit}\n${head ?? '<unborn>'}\n${stableStringify(hashManifest)}\n`),
+            diffHash: sha256(`${from}\n${head ?? '<unborn>'}\n${stableStringify(hashManifest)}\n`),
         };
     }
+    async taskBase(repoRoot, baseCommit, branch) {
+        const listed = await this.runner.run('git', ['rev-list', '--boundary', 'HEAD', '--not', baseCommit, `--exclude=*/${branch}`, '--remotes'], { cwd: repoRoot });
+        if (listed.exitCode !== 0)
+            return baseCommit;
+        const upstream = [];
+        for (const line of listed.stdout.split(/\r?\n/)) {
+            if (line.startsWith('-') && (await this.isAncestor(repoRoot, baseCommit, line.slice(1))))
+                upstream.push(line.slice(1));
+        }
+        if (upstream.length === 0)
+            return baseCommit;
+        const newest = await this.runner.run('git', ['merge-base', '--independent', ...upstream], {
+            cwd: repoRoot,
+        });
+        const tips = newest.exitCode === 0 ? newest.stdout.split(/\r?\n/).filter(Boolean) : [];
+        return tips.length === 1 ? tips[0] : baseCommit;
+    }
     async isAncestor(repoRoot, ancestor, descendant = 'HEAD') {
         const result = await this.runner.run('git', ['merge-base', '--is-ancestor', ancestor, descendant], { cwd: repoRoot });
         return result.exitCode === 0;
@@ -403,12 +420,6 @@ export class GitInspector {
             'refs/remotes/',
         ]);
     }
-    async committedPaths(repoRoot, baseCommit) {
-        const result = await this.runner.run('git', ['diff', '--name-only', '-z', '--find-renames', baseCommit, 'HEAD', '--'], { cwd: repoRoot });
-        if (result.exitCode !== 0)
-            throw new Error(`Git committed diff failed: ${result.stderr.trim()}`);
-        return result.stdout.split('\0').filter(Boolean).map(normalizeGitPath).sort();
-    }
     async stagedManifest(repoRoot) {
         const root = await this.findRoot(repoRoot);
         let result = await this.runner.run('git', ['diff', '--cached', '--name-status', '-z', '--find-renames', '--find-copies', 'HEAD', '--'], { cwd: root });

package/runtime/dist/src/git/verification-gate.js

@@ -155,9 +155,8 @@ export class VerificationGate {
             receipt.source &&
             actualSource &&
             actualSource.sourceCommit !== receipt.source.sourceCommit &&
-            (await this.git.isAncestor(repository.repoRoot, receipt.source.sourceCommit)) &&
-            (await this.git.committedPaths(repository.repoRoot, receipt.source.sourceCommit)).every((path) => receipt.taskChanges.some((change) => change.path === path))
-            ? await this.git.manifestAgainst(repository.repoRoot, receipt.source.sourceCommit)
+            (await this.git.isAncestor(repository.repoRoot, receipt.source.sourceCommit))
+            ? await this.git.manifestAgainst(repository.repoRoot, receipt.source.sourceCommit, await this.git.taskBase(repository.repoRoot, receipt.source.sourceCommit, receipt.branch))
             : null;
         const committedAhead = ahead?.diffHash === receipt.diffHash;
         const current = ahead && committedAhead ? ahead : manifest;

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

@@ -39,6 +39,7 @@ const closedSchema = z.object({
             pushUrl: z.string().nullable(),
             headCommit: z.string().nullable(),
         }),
+        alreadyDelivered: z.object({ commit: z.string(), ref: z.string() }).optional(),
     }),
     deliveryRecord: z
         .object({
@@ -65,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({
@@ -119,6 +121,16 @@ export function registerDeliveryTools(server, service) {
         const data = parsed.data;
         if (data.deliveryContext.mode === 'read_only')
             return output(closed);
+        const delivered = data.delivery.alreadyDelivered;
+        if (delivered)
+            return output({
+                ok: true,
+                data: {
+                    ...closed.data,
+                    deliveryStatus: 'delivered',
+                    nextAction: `Everything this task changed was already committed and pushed by hand: ${delivered.ref.replace(/^refs\/remotes\//, '')} contains ${delivered.commit.slice(0, 12)}. There is nothing left to deliver, so no delivery question is asked, and the delivery is recorded for the project. Call worktree.release in this folder with deliveryOutcome delivered to settle the folder.`,
+                },
+            });
         const destination = data.delivery.destination;
         if (!destination.branch)
             return output({
@@ -496,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,
@@ -1105,7 +1111,7 @@ export class BridgeService {
                     body: {
                         sessionId: input.sessionId,
                         repoFingerprint: repository.repoFingerprint,
-                        source: (await this.checkoutSource(repository, pointer.source)) ?? null,
+                        source: (await this.checkoutSource(await this.taskRepository(repository, pointer), pointer.source)) ?? null,
                         afterSequence: 0,
                     },
                 })).data);
@@ -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,
@@ -2388,6 +2415,7 @@ export class BridgeService {
                         taskChanges,
                     });
                     await this.dependencies.activeContexts.clearVerificationIntent(repository.repoFingerprint, input.taskId);
+                    await this.dependencies.activeContexts.updateTaskSnapshot(input.taskId, taskVersion, pointer.lastSequence);
                 }
                 else {
                     await this.dependencies.activeContexts.clearVerificationIntent(repository.repoFingerprint, input.taskId);
@@ -2412,11 +2440,12 @@ export class BridgeService {
     }
     async validationWaiverSubject(input) {
         return await this.execute(async () => {
-            const repository = await this.dependencies.repositories.resolve(input.repoRoot ?? process.cwd());
-            const pointer = await this.requireActivePointer(repository.repoFingerprint, input.taskId, false, 'verify');
+            const checkout = await this.dependencies.repositories.resolve(input.repoRoot ?? process.cwd());
+            const pointer = await this.requireActivePointer(checkout.repoFingerprint, input.taskId, false, 'verify');
             if (!pointer.changeBaseline) {
                 throw refuse('This task has no local change baseline, so what it changed cannot be measured. The baseline is restored from the task record.', 'session.resume');
             }
+            const repository = await this.taskRepository(checkout, pointer);
             const response = await this.dependencies.client.request(endpoints.sessionResume, {
                 method: 'POST',
                 body: {
@@ -4517,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');
@@ -4641,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));
@@ -4866,10 +4898,12 @@ export class BridgeService {
             !pointer.changeBaseline ||
             typeof pointer.branch !== 'string' ||
             (await git.currentBranch(repository.repoRoot)) !== pointer.branch ||
-            !(await git.isAncestor(repository.repoRoot, base)) ||
-            !pathsContainAll(pointer.changeBaseline.leasePaths, await git.committedPaths(repository.repoRoot, base)))
+            !(await git.isAncestor(repository.repoRoot, base)))
             return repository;
-        return { ...repository, git: await git.manifestAgainst(repository.repoRoot, base) };
+        return {
+            ...repository,
+            git: await git.manifestAgainst(repository.repoRoot, base, await git.taskBase(repository.repoRoot, base, pointer.branch)),
+        };
     }
     async checkoutSource(repository, expected, task) {
         const current = await this.dependencies.repositories.git.sourceIdentity(repository.repoRoot);
@@ -4881,8 +4915,15 @@ export class BridgeService {
                 repository.git.baseCommit === expected.sourceCommit &&
                 repository.git.head === current.sourceCommit)
                 return { ...expected };
-            const branch = await this.dependencies.repositories.git.currentBranch(repository.repoRoot);
-            throw refuse(`The checkout no longer matches this task source. ${task?.taskSlug ? 'Task ' + task.taskSlug : 'This task'} was opened${task?.branch ? ' on ' + task.branch : ''} at commit ${expected.sourceCommit.slice(0, 12)}; this checkout is on ${branch ?? 'detached HEAD'} at ${current?.sourceCommit.slice(0, 12) ?? 'no commit'}, which is not the task's own work committed on top of its source. Ask the user through the native questionnaire which way to go: switch this checkout back to ${task?.branch ?? 'that commit'} and continue the task, or end it with task.abandon.`, 'task.abandon');
+            const git = this.dependencies.repositories.git;
+            const branch = await git.currentBranch(repository.repoRoot);
+            const rewritten = branch !== null &&
+                branch === task?.branch &&
+                !(await git.isAncestor(repository.repoRoot, expected.sourceCommit));
+            const way = rewritten
+                ? `${branch} no longer contains that commit: it was rewritten onto another history (a rebase, reset or amend). Nothing of the task is lost and nothing has to be abandoned: once ${branch} contains that commit again, for example after rebasing it back onto the branch it started from if the user wants that, call session.resume and the task continues where it stopped.`
+                : `Nothing of the task is lost: switch this checkout back to ${task?.branch ?? 'a branch that contains that commit'} and call session.resume, and the task continues where it stopped. Commits, merges and rebases made on the task branch itself stay the task's work.`;
+            throw refuse(`The checkout no longer matches this task source. ${task?.taskSlug ? 'Task ' + task.taskSlug : 'This task'} was opened${task?.branch ? ' on ' + task.branch : ''} at commit ${expected.sourceCommit.slice(0, 12)}; this checkout is on ${branch ?? 'detached HEAD'} at ${current?.sourceCommit.slice(0, 12) ?? 'no commit'}. ${way}`, 'session.resume');
         }
         if (current && repository.git.head !== current.sourceCommit) {
             throw refuse('The Git source changed during the request. Retry session.resume with a stable checkout.', 'session.resume');
@@ -5170,6 +5211,19 @@ export class BridgeService {
             await this.dependencies.repositories.git
                 .branchStore(repository.repoRoot)
                 .release(String(body.taskId));
+        const git = this.dependencies.repositories.git;
+        const head = repository.git.head;
+        const onBranch = Boolean(head && head !== sourceFromContext(body.source)?.sourceCommit);
+        const clean = onBranch && (await git.manifest(repository.repoRoot)).changedPaths.length === 0;
+        const onRemote = clean && head ? await git.remoteRefContaining(repository.repoRoot, head) : null;
+        if (onRemote && head && repository.projectId && closedTask.deliveryRecord)
+            await this.reportDeliveryOutcome({
+                projectId: repository.projectId,
+                taskId: String(body.taskId),
+                outcome: 'delivered',
+                commit: head,
+                pushed: true,
+            });
         return asJsonValue({
             ...closedTask,
             repository: publicRepository(repository),
@@ -5180,7 +5234,7 @@ export class BridgeService {
                 diffHash: String(body.diffHash),
                 mode: normalizeTaskMode(closedPointer?.mode),
             },
-            delivery: deliveryQuestion(touchedContract, await this.dependencies.repositories.git.pushDestination(repository.repoRoot), objectValue(closedTask.sourcePublication)?.applicable === true),
+            delivery: deliveryQuestion(touchedContract, await git.pushDestination(repository.repoRoot), objectValue(closedTask.sourcePublication)?.applicable === true, { onBranch, clean, onRemote }),
         });
     }
     async seedResumeSnapshot(pointer, backendPatch) {
@@ -5591,9 +5645,24 @@ function entryNextAction(authenticated, decision) {
     }
     return 'Ask which organization and then which project, whatever the user asked for, listing what they already have with the option to create a new one last. Switching Engineering Memory off in this repository is the other answer, and it is remembered.';
 }
-function deliveryQuestion(touchedContract, destination, publishApplicable) {
+function deliveryQuestion(touchedContract, destination, publishApplicable, committed) {
     const { branch, remote, pushUrl, remoteDefaultBranch, headCommit } = destination;
+    const afterCommit = publishApplicable
+        ? "After the authorized delivery, call worktree.release in this folder with deliveryOutcome delivered: it publishes this task's source memory and then records the delivery for the project. Its sourcePublication says whether publication happened; call memory.publish_task only when it names a reason you can fix. A task without a worktree to release calls memory.publish_task after the commit instead."
+        : 'This task has nothing to publish (see sourcePublication on the close response); do not call memory.publish_task.';
+    if (committed.onRemote && headCommit)
+        return asJsonValue({
+            required: false,
+            destination,
+            alreadyDelivered: { commit: headCommit, ref: committed.onRemote },
+            afterCommit,
+        });
     const onto = branch ? `branch ${branch}` : 'a detached HEAD, which is on no branch';
+    const state = committed.clean
+        ? `Everything this task changed is already committed on ${onto}; nothing is left to commit.`
+        : committed.onBranch
+            ? `Part of this task's work is already committed on ${onto}; the rest is not committed yet.`
+            : 'The task is closed and nothing has been committed.';
     const target = branch && remote ? `${remote} (${pushUrl ?? 'no push URL'}) branch ${branch}` : null;
     const head = headCommit ? `, on top of ${headCommit.slice(0, 12)}` : '';
     const pushed = target ? `, and a push goes to ${target}` : '';
@@ -5609,7 +5678,7 @@ function deliveryQuestion(touchedContract, destination, publishApplicable) {
             : '');
     return asJsonValue({
         required: true,
-        question: `The task is closed and nothing has been committed. The commit goes on ${onto}${head}${pushed}. If the user already said in their own message which of these they want, that is the answer; do not ask it again. Otherwise ask, and do only what they choose.`,
+        question: `${state} The commit goes on ${onto}${head}${pushed}. If the user already said in their own message which of these they want, that is the answer; do not ask it again. Otherwise ask, and do only what they choose.`,
         destination,
         options: [
             { id: 'commit', label: `Commit on ${onto}` },
@@ -5630,10 +5699,8 @@ function deliveryQuestion(touchedContract, destination, publishApplicable) {
                 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.',
-        afterCommit: publishApplicable
-            ? "After the authorized delivery, call worktree.release in this folder with deliveryOutcome delivered: it publishes this task's source memory and then records the delivery for the project. Its sourcePublication says whether publication happened; call memory.publish_task only when it names a reason you can fix. A task without a worktree to release calls memory.publish_task after the commit instead."
-            : 'This task has nothing to publish (see sourcePublication on the close response); do not call memory.publish_task.',
+        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,
     });
 }
 function cleanJson(value) {
@@ -5695,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);
@@ -1169,9 +1178,11 @@ export class WorktreePool {
     }
     async assertIdentity(entry, allowBranchChange = false) {
         if (key(await this.git.findRoot(entry.repoRoot)) !== key(await canonicalPath(entry.repoRoot)) ||
-            (await this.commonDirectory(entry.repoRoot)) !== entry.commonDir ||
-            (!allowBranchChange && (await this.git.currentBranch(entry.repoRoot)) !== entry.branch))
+            (await this.commonDirectory(entry.repoRoot)) !== entry.commonDir)
             throw refuse('The worktree Git identity changed. Reconcile it before continuing; the task was not moved or reset.');
+        const branch = allowBranchChange ? entry.branch : await this.git.currentBranch(entry.repoRoot);
+        if (branch !== entry.branch)
+            throw new BridgeRecoveryError(`This folder is on ${branch ?? 'a detached HEAD'}, but its task works on ${entry.branch ?? 'a detached HEAD'}. Nothing of the task is lost: switch this folder back to ${entry.branch ?? 'the commit the task started from'} and call session.resume, and the task continues where it stopped.`, 'session.resume');
         const reservation = await this.git.branchStore(entry.repoRoot).read();
         if (reservation &&
             (reservation.decision.projectId !== entry.projectId ||

package/skill/references/lifecycle.md

@@ -214,6 +214,10 @@ proved against the current commit. When it cannot prove it, resume reports
 list, and do not edit the pointer file: say what happened, and let the user decide between
 reopening the task and abandoning it.
 
+## Work committed, merged or rebased by hand
+
+Anything Engineering Memory does in Git the developer may do by hand while the task is open: commit on the task branch, merge the base branch into it, rebase it, push it. None of that loses the task, and none of it is a reason to abandon or reset anything. The task's changes are measured the way a pull request of the task branch shows them: against the newest commit the branch took in from the remote's other branches, so a merged-in `develop` is not counted as the task's work, while the task's own commits and its uncommitted files still are. When the checkout is on another branch or a detached HEAD, the refusal names the task branch to switch back to; switch back and call `session.resume`, and the task continues where it stopped. Do not call `worktree.reconcile` for it: that quarantines the folder. When the task branch itself was rewritten so that it no longer contains the commit the task started from (a rebase onto another history, a reset, an amend of that commit), the refusal says so; once that commit is back in the branch, `session.resume` continues the task. When everything the task changed is already committed and a remote branch contains it, `task.close` asks no delivery question: it reports `deliveryStatus: 'delivered'` and records the delivery for the project, and `worktree.release` with `deliveryOutcome:'delivered'` settles the folder.
+
 ## Change Preparation
 
 Skip change preparation for a read-only task. Do not request an edit lease, send changed paths, record `pre_edit`, or reconcile code resources in that mode. If the user later authorizes a change, call `context.prepare_change` with `transitionToWrite: true`, the bridge-owned current task version, intended paths, and current baseline diff. Continue only after the bridge returns the updated write task and lease.
@@ -250,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.
@@ -280,6 +284,10 @@ When `context.prepare_change`'s `requirements` list a path under `mappings`, dra
 
 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, the refusal lists every unmet requirement at once; resolve all of them, then verify again. When `session.resume` reports `context_refresh_required`, call `context.refresh`, then `context.prepare_change` for the same paths; resume alone never reactivates a stale session, and the task baseline does not change. `context.refresh` sends in full only the revisions that changed since the session pinned them and lists the rest in `unchangedResources`; reread one of those with `memory.read_revisions` only when its text is no longer in view. 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.
 
+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.
@@ -288,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