engineering-memory 1.2.0 → 1.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engineering-memory",
-  "version": "1.2.0",
+  "version": "1.3.1",
   "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/config.js

@@ -51,6 +51,7 @@ export const endpoints = {
     organizationCreate: '/organizations',
     taskVerify: '/runtime/task/verify',
     taskClose: '/runtime/task/close',
+    taskAbandon: '/runtime/task/abandon',
     taskCommitGate: '/runtime/task/commit-gate',
     projectSetup: '/projects/setup',
     projectList: '/projects',

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

@@ -64,6 +64,7 @@ export const engineeringMemoryToolNames = [
     'task.resolve_pending_delivery',
     'task.verify',
     'task.close',
+    'task.abandon',
     'architecture.plan',
     'architecture.module',
     'architecture.record_application',
@@ -371,6 +372,14 @@ export function registerEngineeringMemoryTools(server, service) {
             taskId: z.string().min(1),
         }),
     }, async (input) => toolResult(await service.taskClose(input)));
+    server.registerTool('task.abandon', {
+        description: "Abandon a task the user has said they are giving up on, so it stops holding its proposals and its local pointer. It has no effect on any other task: nobody else's work waits on this, and nothing already verified or closed is undone. Ask the user first; never abandon a task on your own judgement.",
+        inputSchema: z.object({
+            repoRoot: optionalRepoRoot,
+            taskId: z.string().min(1),
+            reason: z.string().min(1).max(2000),
+        }),
+    }, async (input) => toolResult(await service.taskAbandon(input)));
     server.registerTool('organization.create', {
         description: 'Create an organization the user named, with the short identifier they typed. Offer this underneath the organizations they already belong to; never invent the identifier from the name.',
         inputSchema: z.object({

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

@@ -1,8 +1,9 @@
 import { join } from 'node:path';
 import { readdir } from 'node:fs/promises';
-import { ensureManagedDirectory, readJson, removeFile, writeJson } from '../utilities/files.js';
+import { ensureManagedDirectory, pathExists, readJson, removeFile, writeJson, } from '../utilities/files.js';
 import { sha256, stableStringify } from '../utilities/hash.js';
 import { assertSafeToPersist } from './offline-outbox.js';
+const currentMarkerName = 'current.json';
 export class ActiveContextStore {
     root;
     queues = new Map();
@@ -11,42 +12,95 @@ export class ActiveContextStore {
     }
     async load(repoFingerprint) {
         assertFingerprint(repoFingerprint);
-        const pointer = await readJson(this.pathFor(repoFingerprint), this.root);
+        await this.adoptLegacyPointer(repoFingerprint);
+        const marker = await readJson(this.currentPathFor(repoFingerprint), this.root);
+        if (marker && isUuid(marker.taskId)) {
+            const pointer = await this.loadForTask(repoFingerprint, marker.taskId);
+            if (pointer) {
+                return pointer;
+            }
+        }
+        const pointers = await this.list(repoFingerprint);
+        if (pointers.length !== 1) {
+            return null;
+        }
+        await this.writeCurrentMarker(repoFingerprint, pointers[0].taskId);
+        return pointers[0];
+    }
+    async loadForTask(repoFingerprint, taskId) {
+        assertFingerprint(repoFingerprint);
+        if (!isUuid(taskId)) {
+            throw new Error('Engineering task identifier is invalid');
+        }
+        const pointer = await readJson(this.pathFor(repoFingerprint, taskId), this.root);
         if (!pointer) {
             return null;
         }
         this.validate(pointer, repoFingerprint);
         return pointer;
     }
+    async loadForSlug(repoFingerprint, taskSlug) {
+        const pointers = await this.list(repoFingerprint);
+        return pointers.find((pointer) => pointer.taskSlug === taskSlug) ?? null;
+    }
+    async list(repoFingerprint) {
+        assertFingerprint(repoFingerprint);
+        await this.adoptLegacyPointer(repoFingerprint);
+        const directory = this.directoryFor(repoFingerprint);
+        if (!(await pathExists(directory, this.root))) {
+            return [];
+        }
+        await ensureManagedDirectory(this.root, directory);
+        const pointers = [];
+        for (const name of await this.pointerFileNames(directory)) {
+            const pointer = await readJson(join(directory, name), this.root);
+            if (pointer) {
+                this.validate(pointer, repoFingerprint);
+                pointers.push(pointer);
+            }
+        }
+        return pointers.sort((left, right) => left.updatedAt.localeCompare(right.updatedAt));
+    }
     async save(input) {
         await this.exclusive(input.repoFingerprint, async () => {
-            const existing = await readJson(this.pathFor(input.repoFingerprint), this.root);
-            const sameTask = existing?.taskId === input.taskId && existing.sessionId === input.sessionId;
-            if (!sameTask && (existing?.verificationIntent || existing?.closeIntent)) {
-                throw new Error('Pending lifecycle intent prevents replacing the active task pointer');
+            const existing = await readJson(this.pathFor(input.repoFingerprint, input.taskId), this.root);
+            const sameSession = existing?.sessionId === input.sessionId;
+            if (!sameSession && (existing?.verificationIntent || existing?.closeIntent)) {
+                throw new Error('This task has an unsettled verification or close intent; resume it before starting a new session for the same task');
             }
             const { verificationIntent: _verificationIntent, closeIntent: _closeIntent, ...pointerInput } = input;
             await this.writePointer({
                 ...pointerInput,
-                ...(sameTask && existing?.verificationIntent
+                ...(sameSession && existing?.verificationIntent
                     ? { verificationIntent: existing.verificationIntent }
                     : {}),
-                ...(sameTask && existing?.closeIntent ? { closeIntent: existing.closeIntent } : {}),
+                ...(sameSession && existing?.closeIntent ? { closeIntent: existing.closeIntent } : {}),
             });
+            await this.writeCurrentMarker(input.repoFingerprint, input.taskId);
         });
     }
-    async updateTaskSnapshot(taskId, taskVersion, lastSequence) {
-        await ensureManagedDirectory(this.root, this.root);
-        const entries = await readdir(this.root, { withFileTypes: true });
-        for (const entry of entries) {
-            if (entry.name.endsWith('.json') && (!entry.isFile() || entry.isSymbolicLink())) {
-                throw new Error(`Unsafe active context entry: ${entry.name}`);
+    async forget(repoFingerprint, taskId) {
+        return await this.exclusive(repoFingerprint, async () => {
+            const path = this.pathFor(repoFingerprint, taskId);
+            if (!(await pathExists(path, this.root))) {
+                return false;
             }
-            if (!entry.isFile() || !entry.name.endsWith('.json')) {
-                continue;
+            await removeFile(path, this.root);
+            const remaining = await this.list(repoFingerprint);
+            if (remaining.length === 0) {
+                await removeFile(this.currentPathFor(repoFingerprint), this.root);
+                return true;
+            }
+            const marker = await readJson(this.currentPathFor(repoFingerprint), this.root);
+            if (!marker || marker.taskId === taskId) {
+                await this.writeCurrentMarker(repoFingerprint, remaining.at(-1).taskId);
             }
-            const pointer = await readJson(join(this.root, entry.name), this.root);
-            if (pointer?.taskId === taskId) {
+            return true;
+        });
+    }
+    async updateTaskSnapshot(taskId, taskVersion, lastSequence) {
+        for (const pointer of await this.allPointers()) {
+            if (pointer.taskId === taskId) {
                 await this.save({
                     ...pointer,
                     taskVersion,
@@ -56,10 +110,10 @@ export class ActiveContextStore {
         }
     }
     async setChangeBaseline(repoFingerprint, sessionId, manifest, leasePaths, taskSnapshot) {
-        const pointer = await this.load(repoFingerprint);
-        if (!pointer ||
-            pointer.sessionId !== sessionId ||
-            (taskSnapshot && pointer.taskId !== taskSnapshot.taskId)) {
+        const pointer = taskSnapshot
+            ? await this.loadForTask(repoFingerprint, taskSnapshot.taskId)
+            : await this.load(repoFingerprint);
+        if (!pointer || pointer.sessionId !== sessionId) {
             throw new Error('Change baseline does not match the active repository session');
         }
         if (pointer.changeBaseline?.leasePaths.some((path) => !leasePaths.includes(path))) {
@@ -84,12 +138,9 @@ export class ActiveContextStore {
     }
     async setVerificationIntent(repoFingerprint, input) {
         await this.exclusive(repoFingerprint, async () => {
-            const pointer = await this.readPointer(repoFingerprint);
+            const pointer = await this.readIntentPointer(repoFingerprint, input.body);
             const bodyHash = sha256(stableStringify(input.body));
-            if (!pointer ||
-                pointer.taskId !== input.body.taskId ||
-                pointer.sessionId !== input.body.sessionId ||
-                pointer.closeIntent) {
+            if (!pointer || pointer.closeIntent) {
                 throw new Error('Verification intent does not match the active task');
             }
             if (pointer.verificationIntent) {
@@ -110,9 +161,11 @@ export class ActiveContextStore {
             });
         });
     }
-    async clearVerificationIntent(repoFingerprint) {
+    async clearVerificationIntent(repoFingerprint, taskId) {
         await this.exclusive(repoFingerprint, async () => {
-            const pointer = await this.readPointer(repoFingerprint);
+            const pointer = taskId
+                ? await this.loadForTask(repoFingerprint, taskId)
+                : await this.load(repoFingerprint);
             if (!pointer?.verificationIntent) {
                 return;
             }
@@ -122,12 +175,9 @@ export class ActiveContextStore {
     }
     async setCloseIntent(repoFingerprint, input) {
         await this.exclusive(repoFingerprint, async () => {
-            const pointer = await this.readPointer(repoFingerprint);
+            const pointer = await this.readIntentPointer(repoFingerprint, input.body);
             const bodyHash = sha256(stableStringify(input.body));
-            if (!pointer ||
-                pointer.taskId !== input.body.taskId ||
-                pointer.sessionId !== input.body.sessionId ||
-                pointer.verificationIntent) {
+            if (!pointer || pointer.verificationIntent) {
                 throw new Error('Close intent does not match the active task');
             }
             if (pointer.closeIntent) {
@@ -147,9 +197,11 @@ export class ActiveContextStore {
             });
         });
     }
-    async clearCloseIntent(repoFingerprint) {
+    async clearCloseIntent(repoFingerprint, taskId) {
         await this.exclusive(repoFingerprint, async () => {
-            const pointer = await this.readPointer(repoFingerprint);
+            const pointer = taskId
+                ? await this.loadForTask(repoFingerprint, taskId)
+                : await this.load(repoFingerprint);
             if (!pointer?.closeIntent) {
                 return;
             }
@@ -158,24 +210,7 @@ export class ActiveContextStore {
         });
     }
     async findByTaskId(taskId, projectId, requireClean = true) {
-        await ensureManagedDirectory(this.root, this.root);
-        const entries = await readdir(this.root, { withFileTypes: true });
-        const matches = [];
-        for (const entry of entries) {
-            if (entry.name.endsWith('.json') && (!entry.isFile() || entry.isSymbolicLink())) {
-                throw new Error(`Unsafe active context entry: ${entry.name}`);
-            }
-            if (!entry.isFile() || !entry.name.endsWith('.json')) {
-                continue;
-            }
-            const pointer = await readJson(join(this.root, entry.name), this.root);
-            if (pointer) {
-                this.validate(pointer, pointer.repoFingerprint);
-                if (pointer.taskId === taskId && pointer.projectId === projectId) {
-                    matches.push(pointer);
-                }
-            }
-        }
+        const matches = (await this.allPointers()).filter((pointer) => pointer.taskId === taskId && pointer.projectId === projectId);
         if (matches.length !== 1 ||
             (requireClean &&
                 (matches[0].resumeConflicts.length > 0 ||
@@ -189,18 +224,9 @@ export class ActiveContextStore {
         if (taskIds.length === 0) {
             return;
         }
-        await ensureManagedDirectory(this.root, this.root);
         const targetIds = new Set(taskIds);
-        const entries = await readdir(this.root, { withFileTypes: true });
-        for (const entry of entries) {
-            if (entry.name.endsWith('.json') && (!entry.isFile() || entry.isSymbolicLink())) {
-                throw new Error(`Unsafe active context entry: ${entry.name}`);
-            }
-            if (!entry.isFile() || !entry.name.endsWith('.json')) {
-                continue;
-            }
-            const pointer = await readJson(join(this.root, entry.name), this.root);
-            if (pointer && targetIds.has(pointer.taskId)) {
+        for (const pointer of await this.allPointers()) {
+            if (targetIds.has(pointer.taskId)) {
                 await this.save({
                     ...pointer,
                     resumeConflicts: [...new Set([...pointer.resumeConflicts, conflict])],
@@ -212,17 +238,8 @@ export class ActiveContextStore {
         if (!isUuid(sessionId)) {
             throw new Error('Context session identifier is invalid');
         }
-        await ensureManagedDirectory(this.root, this.root);
-        const entries = await readdir(this.root, { withFileTypes: true });
-        for (const entry of entries) {
-            if (entry.name.endsWith('.json') && (!entry.isFile() || entry.isSymbolicLink())) {
-                throw new Error(`Unsafe active context entry: ${entry.name}`);
-            }
-            if (!entry.isFile() || !entry.name.endsWith('.json')) {
-                continue;
-            }
-            const pointer = await readJson(join(this.root, entry.name), this.root);
-            if (pointer?.sessionId === sessionId) {
+        for (const pointer of await this.allPointers()) {
+            if (pointer.sessionId === sessionId) {
                 await this.save({
                     ...pointer,
                     resumeConflicts: pointer.resumeConflicts.filter((value) => value !== conflict),
@@ -232,20 +249,90 @@ export class ActiveContextStore {
     }
     async clear() {
         await ensureManagedDirectory(this.root, this.root);
-        const entries = await readdir(this.root, { withFileTypes: true });
-        for (const entry of entries) {
-            if (!entry.isFile() || entry.isSymbolicLink() || !entry.name.endsWith('.json')) {
+        for (const entry of await readdir(this.root, { withFileTypes: true })) {
+            if (entry.isSymbolicLink()) {
+                throw new Error(`Unsafe active context entry: ${entry.name}`);
+            }
+            if (entry.isFile() && entry.name.endsWith('.json')) {
+                await removeFile(join(this.root, entry.name), this.root);
+                continue;
+            }
+            if (!entry.isDirectory() || !/^[0-9a-f]{64}$/.test(entry.name)) {
+                throw new Error(`Unsafe active context entry: ${entry.name}`);
+            }
+            const directory = join(this.root, entry.name);
+            for (const name of await this.jsonFileNames(directory)) {
+                await removeFile(join(directory, name), this.root);
+            }
+        }
+    }
+    async allPointers() {
+        await ensureManagedDirectory(this.root, this.root);
+        const pointers = [];
+        for (const entry of await readdir(this.root, { withFileTypes: true })) {
+            if (entry.isSymbolicLink()) {
+                throw new Error(`Unsafe active context entry: ${entry.name}`);
+            }
+            if (!entry.isDirectory() || !/^[0-9a-f]{64}$/.test(entry.name)) {
+                continue;
+            }
+            pointers.push(...(await this.list(entry.name)));
+        }
+        return pointers;
+    }
+    async adoptLegacyPointer(repoFingerprint) {
+        const legacyPath = join(this.root, `${repoFingerprint}.json`);
+        if (!(await pathExists(legacyPath, this.root))) {
+            return;
+        }
+        const pointer = await readJson(legacyPath, this.root);
+        if (pointer) {
+            this.validate(pointer, repoFingerprint);
+            const target = this.pathFor(repoFingerprint, pointer.taskId);
+            if (!(await pathExists(target, this.root))) {
+                await writeJson(target, pointer, this.root);
+                await this.writeCurrentMarker(repoFingerprint, pointer.taskId);
+            }
+        }
+        await removeFile(legacyPath, this.root);
+    }
+    async readIntentPointer(repoFingerprint, body) {
+        if (typeof body.taskId !== 'string' || !isUuid(body.taskId)) {
+            return null;
+        }
+        const pointer = await this.loadForTask(repoFingerprint, body.taskId);
+        return pointer && pointer.sessionId === body.sessionId ? pointer : null;
+    }
+    async pointerFileNames(directory) {
+        return (await this.jsonFileNames(directory)).filter((name) => name !== currentMarkerName);
+    }
+    async jsonFileNames(directory) {
+        const names = [];
+        for (const entry of await readdir(directory, { withFileTypes: true })) {
+            if (entry.name.endsWith('.json') && (!entry.isFile() || entry.isSymbolicLink())) {
                 throw new Error(`Unsafe active context entry: ${entry.name}`);
             }
-            await removeFile(join(this.root, entry.name), this.root);
+            if (entry.isFile() && entry.name.endsWith('.json')) {
+                names.push(entry.name);
+            }
         }
+        return names;
     }
-    pathFor(repoFingerprint) {
+    directoryFor(repoFingerprint) {
         assertFingerprint(repoFingerprint);
-        return join(this.root, `${repoFingerprint}.json`);
+        return join(this.root, repoFingerprint);
+    }
+    pathFor(repoFingerprint, taskId) {
+        if (!isUuid(taskId)) {
+            throw new Error('Engineering task identifier is invalid');
+        }
+        return join(this.directoryFor(repoFingerprint), `${taskId}.json`);
+    }
+    currentPathFor(repoFingerprint) {
+        return join(this.directoryFor(repoFingerprint), currentMarkerName);
     }
-    async readPointer(repoFingerprint) {
-        return await readJson(this.pathFor(repoFingerprint), this.root);
+    async writeCurrentMarker(repoFingerprint, taskId) {
+        await writeJson(this.currentPathFor(repoFingerprint), { schemaVersion: 1, taskId }, this.root);
     }
     async writePointer(input) {
         const pointer = {
@@ -255,7 +342,7 @@ export class ActiveContextStore {
         };
         this.validate(pointer, input.repoFingerprint);
         assertSafeToPersist(JSON.parse(JSON.stringify(pointer)));
-        await writeJson(this.pathFor(input.repoFingerprint), pointer, this.root);
+        await writeJson(this.pathFor(input.repoFingerprint, input.taskId), pointer, this.root);
     }
     async exclusive(repoFingerprint, action) {
         const previous = this.queues.get(repoFingerprint) ?? Promise.resolve();

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

@@ -162,7 +162,25 @@ export class BridgeService {
             if (authentication) {
                 return asJsonValue({ authentication, repository: publicRepository(repository) });
             }
-            let pointer = await this.dependencies.activeContexts.load(repository.repoFingerprint);
+            const live = await this.dependencies.activeContexts.list(repository.repoFingerprint);
+            let pointer = input.taskSlug
+                ? (live.find((entry) => entry.taskSlug === input.taskSlug) ?? null)
+                : await this.dependencies.activeContexts.load(repository.repoFingerprint);
+            if (!pointer && input.taskSlug) {
+                return asJsonValue({
+                    taskChoiceRequired: true,
+                    requestedTaskSlug: input.taskSlug,
+                    liveTasks: live.map(describePointer),
+                    repository: publicRepository(repository),
+                });
+            }
+            if (!pointer && !input.sessionId && live.length > 1) {
+                return asJsonValue({
+                    taskChoiceRequired: true,
+                    liveTasks: live.map(describePointer),
+                    repository: publicRepository(repository),
+                });
+            }
             const projectId = input.projectId ?? repository.projectId ?? pointer?.projectId;
             const taskSlug = input.taskSlug ?? pointer?.taskSlug;
             const sessionId = input.sessionId ?? pointer?.sessionId;
@@ -939,6 +957,7 @@ export class BridgeService {
                 }
                 let taskChangedPaths = [];
                 let taskChanges = [];
+                let foreignChangedPaths = [];
                 const snapshotResponse = await this.dependencies.client.request(endpoints.sessionResume, {
                     method: 'POST',
                     body: {
@@ -976,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)) !==
@@ -1030,7 +1055,7 @@ export class BridgeService {
                 }
                 catch (error) {
                     if (!isBackendUnavailableError(error)) {
-                        await this.dependencies.activeContexts.clearVerificationIntent(repository.repoFingerprint);
+                        await this.dependencies.activeContexts.clearVerificationIntent(repository.repoFingerprint, input.taskId);
                     }
                     throw error;
                 }
@@ -1046,14 +1071,17 @@ export class BridgeService {
                         taskVersion,
                         taskChanges,
                     });
-                    await this.dependencies.activeContexts.clearVerificationIntent(repository.repoFingerprint);
+                    await this.dependencies.activeContexts.clearVerificationIntent(repository.repoFingerprint, input.taskId);
                 }
                 else {
-                    await this.dependencies.activeContexts.clearVerificationIntent(repository.repoFingerprint);
+                    await this.dependencies.activeContexts.clearVerificationIntent(repository.repoFingerprint, input.taskId);
                 }
                 return asJsonValue({
                     ...objectOrEmpty(response.data),
                     mode: taskMode,
+                    ...(foreignChangedPaths.length > 0
+                        ? { changedPathsOutsideThisTask: foreignChangedPaths }
+                        : {}),
                     repository: publicRepository(repository),
                 });
             });
@@ -1097,6 +1125,29 @@ export class BridgeService {
             });
         });
     }
+    async taskAbandon(input) {
+        return await this.execute(async () => {
+            return await this.taskExclusive(input.taskId, async () => {
+                const repository = await this.dependencies.repositories.resolve(input.repoRoot ?? process.cwd());
+                const response = await this.dependencies.client.request(endpoints.taskAbandon, {
+                    method: 'POST',
+                    body: { taskId: input.taskId, reason: input.reason },
+                });
+                const abandoned = objectValue(response.data);
+                if (!abandoned || abandoned.abandoned !== true) {
+                    throw new Error('The backend did not abandon the task');
+                }
+                const forgotten = await this.dependencies.activeContexts.forget(repository.repoFingerprint, input.taskId);
+                await this.dependencies.gate.invalidateTask(input.taskId);
+                return asJsonValue({
+                    ...abandoned,
+                    localPointerRemoved: forgotten,
+                    remainingTasks: (await this.dependencies.activeContexts.list(repository.repoFingerprint)).map(describePointer),
+                    repository: publicRepository(repository),
+                });
+            });
+        });
+    }
     async projectSetup(input) {
         return await this.execute(async () => {
             const repository = await this.dependencies.repositories.resolve(input.repoRoot ?? process.cwd());
@@ -1731,7 +1782,7 @@ export class BridgeService {
         return refreshed;
     }
     async requireActivePointer(repoFingerprint, taskId, allowOfflineWarnings = false, allowedIntent) {
-        const pointer = await this.dependencies.activeContexts.load(repoFingerprint);
+        const pointer = await this.dependencies.activeContexts.loadForTask(repoFingerprint, taskId);
         const blockingConflicts = pointer?.resumeConflicts.filter((conflict) => !(allowOfflineWarnings && isOfflineDevelopmentWarning(conflict)));
         const lifecycleIntentBlocked = (pointer?.verificationIntent && allowedIntent !== 'verify') ||
             (pointer?.closeIntent && allowedIntent !== 'close');
@@ -1832,13 +1883,13 @@ export class BridgeService {
         }
         catch (error) {
             if (!isBackendUnavailableError(error)) {
-                await this.dependencies.activeContexts.clearVerificationIntent(repository.repoFingerprint);
+                await this.dependencies.activeContexts.clearVerificationIntent(repository.repoFingerprint, pointer.taskId);
             }
             throw error;
         }
         const responseData = objectValue(response.data);
         if (responseData?.verified !== true || responseData.diffHash !== body.diffHash) {
-            await this.dependencies.activeContexts.clearVerificationIntent(repository.repoFingerprint);
+            await this.dependencies.activeContexts.clearVerificationIntent(repository.repoFingerprint, pointer.taskId);
             throw new Error('Verification retry did not confirm the durable verification intent');
         }
         const taskVersion = numericTaskVersion(responseData.taskVersion);
@@ -1851,7 +1902,7 @@ export class BridgeService {
             taskVersion,
             taskChanges: intent.taskChanges,
         });
-        await this.dependencies.activeContexts.clearVerificationIntent(repository.repoFingerprint);
+        await this.dependencies.activeContexts.clearVerificationIntent(repository.repoFingerprint, pointer.taskId);
         await this.dependencies.activeContexts.updateTaskSnapshot(pointer.taskId, taskVersion, pointer.lastSequence);
         return { ...responseData, recoveredAfterResponseLoss: true };
     }
@@ -1885,13 +1936,13 @@ export class BridgeService {
         }
         catch (error) {
             if (!isBackendUnavailableError(error)) {
-                await this.dependencies.activeContexts.clearCloseIntent(repository.repoFingerprint);
+                await this.dependencies.activeContexts.clearCloseIntent(repository.repoFingerprint, String(body.taskId));
             }
             throw error;
         }
         const closedTask = objectValue(response.data);
         if (closedTask?.closed !== true) {
-            await this.dependencies.activeContexts.clearCloseIntent(repository.repoFingerprint);
+            await this.dependencies.activeContexts.clearCloseIntent(repository.repoFingerprint, String(body.taskId));
             throw new Error('Task close response does not confirm task closure');
         }
         const closedTaskVersion = numericTaskVersion(closedTask.taskVersion);
@@ -1905,7 +1956,7 @@ export class BridgeService {
             taskVersion: closedTaskVersion,
             taskChanges,
         });
-        await this.dependencies.activeContexts.clearCloseIntent(repository.repoFingerprint);
+        await this.dependencies.activeContexts.clearCloseIntent(repository.repoFingerprint, String(body.taskId));
         return asJsonValue({
             ...closedTask,
             repository: publicRepository(repository),
@@ -2122,6 +2173,17 @@ async function buildPathChangeManifest(repoRoot, changes) {
         });
     }));
 }
+function describePointer(pointer) {
+    return asJsonValue({
+        taskSlug: pointer.taskSlug,
+        taskId: pointer.taskId,
+        projectId: pointer.projectId,
+        sessionId: pointer.sessionId,
+        updatedAt: pointer.updatedAt,
+        resumeConflicts: pointer.resumeConflicts,
+        unsettledIntent: pointer.verificationIntent ? 'verify' : pointer.closeIntent ? 'close' : null,
+    });
+}
 function publicRepository(repository) {
     return asJsonValue({
         repoRoot: repository.repoRoot,

package/skill/references/lifecycle.md

@@ -10,6 +10,10 @@ For a bound repository, call `session.bootstrap` before producing a plan or chan
 
 Before the first edit of a write task, settle the branch. Ask the user through the native questionnaire whether to open a branch for this task and which name to use, offering the convention the returned rules carry. Do this once, at the start, not at commit time — the commit gate runs long after the work is written, and by then the wrong branch has already cost something. A read-only task never creates a branch.
 
+A repository holds as many tasks as the people working in it. Never treat somebody else's unfinished task as a reason this one cannot proceed: no task waits on another task's review, reconciliation, verification or close, and nothing that is already verified or closed is undone by what happens elsewhere. When `session.resume` reports more than one live task for this repository, it lists them and the right move is to ask the user which one this is, never to guess and never to adopt the one that happens to be most recent.
+
+A task nobody is going to finish is abandoned rather than inherited. Ask the user first, then call `task.abandon` with the task ID and their reason: it records the task as abandoned, withdraws the proposals it left waiting for review, releases its lease and session, and removes its local pointer. It changes nothing about any other task. Never abandon a task on your own judgement, and never abandon one to get past an error in your own.
+
 If an existing task is identified or execution resumes after compaction, call `session.resume`. Reconcile backend sequence, local outbox, Markdown projections, current Git diff, pinned revisions, and the active lease before any further action.
 
 ## Discovery

package/skill/references/questionnaires.md

@@ -40,7 +40,7 @@ Switching off records the decision and ends the subject. Switching back on clear
 
 Changing the organization always means asking for the project again afterwards, because a project belongs to exactly one organization and the old answer cannot survive the change. Run the organization questionnaire, then the project one, then bind the repository to the chosen project with `project.resolve` so the marker matches what the user just said.
 
-A task that is still open blocks the switch, and says so plainly. Its lease, its journal and its checkpoints all belong to the project it was opened against, and carrying them into another one records work under a project it did not happen in. Close the open task first, or say explicitly that it is being abandoned, and only then switch.
+A task that is still open blocks the switch, and says so plainly. Its lease, its journal and its checkpoints all belong to the project it was opened against, and carrying them into another one records work under a project it did not happen in. Close the open task first, or abandon it with `task.abandon` once the user has said that is what they want, and only then switch. This is about this session's own task and nothing else: another person's unfinished task in the same repository never blocks anything.
 
 ## Unbound Repository