engineering-memory 1.11.10 → 1.11.11

package/dispatcher/sections.mjs

@@ -8,6 +8,7 @@ Call \`session.entry\` before you answer anything in a repository, whatever the
 - No decision recorded: ask which organization and then which project, whatever the message was. The other answer is switching Engineering Memory off in this repository, and it is remembered with \`session.set_decision\`.
 - Switched off: say nothing about Engineering Memory, offer nothing, hint at nothing, however useful it would be for what was asked. They turned it off; raising it again is what this prevents. Record it back on only when they ask.
 - Bound: continue into the lifecycle.
+- Project lives elsewhere: binding the chosen project is refused because its code moved to another repository, or \`session.entry\` reports the project moved away from this checkout. Follow the skill's lifecycle reference: a project owner moves the project here with \`project.move_repository\`, anyone else is told that an owner has to. Never create a second project for moved code and never bind a different one to get past the refusal.
 
 \`session.entry\` also reports this client's version. When it says an update is available, offer once to run \`npx engineering-memory@latest install\` and tell the user that the running bridge switches to the new release by itself on its next call, so nothing needs restarting; only a bridge older than 1.11.9 needs the client restarted once after that install. If they decline, record it with \`session.decline_update\` and never raise that version again. When it says an update is required, there is no choice to offer: say that this client is older than the backend supports, give the command, and do not carry on as though the lifecycle works.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engineering-memory",
-  "version": "1.11.10",
+  "version": "1.11.11",
   "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": "875304dd11735e1bf2817ae59e75b54186e5071a"
+  "gitHead": "d515ff32869833254d52677e2b9927fd3925295c"
 }

package/runtime/dist/src/config.js

@@ -67,6 +67,7 @@ export const endpoints = {
     projectList: '/projects',
     projectResolve: '/projects/resolve',
     projectBind: (projectId) => `/projects/${projectId}/bind`,
+    projectRepository: (projectId) => `/projects/${projectId}/repository`,
     projectUpdate: (projectId) => `/projects/${projectId}`,
     workItemRuns: (projectId, workItemId) => `/projects/${projectId}/work-items/${workItemId}/runs`,
     workItemRestore: (projectId, workItemId) => `/projects/${projectId}/work-items/${workItemId}/restore`,

package/runtime/dist/src/git/git-inspector.js

@@ -4,6 +4,7 @@ import { isAbsolute, relative, resolve, sep } from 'node:path';
 import { assertManagedPath, canonicalPath } from '../utilities/files.js';
 import { sha256, stableStringify } from '../utilities/hash.js';
 import { NativeCommandRunner } from '../utilities/process.js';
+import { restrictedValueKind } from '../runtime/privacy-detector.js';
 import { TaskBranchStore } from '../runtime/task-branch-store.js';
 export const temporaryScaffoldingMarker = 'ENGINEERING-MEMORY-TEMPORARY';
 export const temporaryScaffoldingPattern = `${temporaryScaffoldingMarker}:`;
@@ -35,6 +36,18 @@ export class GitInspector {
         }
         return sha256(identity);
     }
+    async remoteIdentity(repoRoot) {
+        const remote = await this.gitValue(repoRoot, ['config', '--get', 'remote.origin.url']);
+        if (!remote)
+            return null;
+        const identity = canonicalRemoteIdentity(remote);
+        return !identity.startsWith('local/') &&
+            identity.length <= 500 &&
+            /^[a-z0-9][a-z0-9.-]*(:\d{1,5})?\/[^\s@\\]+$/.test(identity) &&
+            !restrictedValueKind(identity, 'remoteIdentity')
+            ? identity
+            : null;
+    }
     branchStore(repoRoot) {
         return new TaskBranchStore(repoRoot, this.runner);
     }
@@ -72,11 +85,13 @@ export class GitInspector {
             throw new Error('The worktree directory already belongs to another repository or branch. Choose a different directory');
         }
         const exists = await this.branchExists(repoRoot, name);
+        const lost = (await this.lostRegistration(repoRoot, path, name)) ? ['-f'] : [];
         const args = exists
-            ? ['worktree', 'add', '--', path, name]
+            ? ['worktree', 'add', ...lost, '--', path, name]
             : [
                 'worktree',
                 'add',
+                ...lost,
                 '--no-track',
                 '-b',
                 name,
@@ -89,6 +104,22 @@ export class GitInspector {
             throw new Error(`Git could not create the worktree: ${result.stderr.trim()}`);
         return await this.findRoot(path);
     }
+    async lostRegistration(repoRoot, path, name) {
+        const listed = await this.runner.run('git', ['worktree', 'list', '--porcelain'], {
+            cwd: repoRoot,
+        });
+        if (listed.exitCode !== 0)
+            return false;
+        const registered = listed.stdout.split(/\r?\n\r?\n/).map((block) => ({
+            path: /^worktree (.+)$/m.exec(block)?.[1] ?? '',
+            branch: /^branch refs\/heads\/(.+)$/m.exec(block)?.[1] ?? null,
+        }));
+        const same = (left, right) => process.platform === 'win32'
+            ? resolve(left).toLowerCase() === resolve(right).toLowerCase()
+            : resolve(left) === resolve(right);
+        return (registered.some((entry) => entry.path && same(entry.path, path)) &&
+            !registered.some((entry) => entry.branch === name && !same(entry.path, path)));
+    }
     async fetchBranchCommit(repoRoot, remote, branch) {
         await this.validateBranch(repoRoot, branch);
         if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/.test(remote))

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

@@ -133,7 +133,114 @@ const onboardingInput = z.strictObject({
     projectId: uuid.optional(),
     reworkBehavior: z.enum(['preserve', 'redesign']).optional(),
 });
+const moveCopy = {
+    tr: {
+        ask: (name) => `"${name}" projesini bu depoya taşıyalım mı?`,
+        from: 'Projenin şu anki deposu',
+        to: 'Bu klasörün deposu',
+        unknown: 'adresi kayıtlı değil',
+        keeps: (tasks, records, items) => `Proje olduğu gibi devam eder: ${tasks} görev, ${records} hafıza kaydı ve ${items} iş kalemi projede kalır, hiçbir şey silinmez ve yeniden öğrenilmez.`,
+        after: 'Eski depo projenin geçmişinde saklanır. Hâlâ eski depoda çalışan ekip arkadaşları açık görevlerini bitirebilir, yeni görevi yeni depodan açar. Proje ileride yeniden taşınabilir.',
+        approve: 'Projeyi bu depoya taşı',
+        decline: 'Taşıma',
+    },
+    en: {
+        ask: (name) => `Move the project "${name}" to this repository?`,
+        from: 'The project lives in',
+        to: 'This folder points at',
+        unknown: 'address not recorded',
+        keeps: (tasks, records, items) => `The project continues as it is: ${tasks} tasks, ${records} memory records and ${items} work items stay with it; nothing is deleted or learned again.`,
+        after: 'The old repository is kept in the project history. Teammates still working in it can finish their open tasks and start new ones from the new repository. The project can be moved again later.',
+        approve: 'Move the project here',
+        decline: 'Do not move',
+    },
+};
 export function registerOnboardingTools(server, service) {
+    server.registerTool('project.move_repository', {
+        description: 'Move an existing project to the repository this checkout points at, after its code moved (another host, a new remote, a history restart). Project owners only. Opens ONE durable native form naming the old and the new repository; on approval the project keeps every task, memory record, work item and open session, the old repository is kept in its history, and this checkout is bound. Use it when project.resolve with bind refuses with recovery project.move_repository; never create a second project for moved code. Reconsider a declined move with a new decisionAttempt; retries keep the same attempt.',
+        inputSchema: z.strictObject({
+            repoRoot,
+            projectId: uuid,
+            decisionAttempt: z.number().int().min(1).max(10000).optional(),
+            language: z.enum(['tr', 'en']).default('en'),
+            presentation: z.enum(['host_native']).optional(),
+        }),
+    }, async (input, context) => {
+        const preflight = await service.projectRepositoryMovePreflight(input);
+        if (!preflight.ok)
+            return output(preflight);
+        const flight = preflight.data;
+        if (flight.authentication)
+            return output(preflight);
+        if (flight.alreadyHere || !flight.history.current)
+            return output(await service.projectResolve({
+                repoRoot: input.repoRoot,
+                bind: true,
+                projectId: input.projectId,
+            }));
+        if (flight.history.role !== 'owner')
+            return output({
+                ok: false,
+                error: {
+                    kind: 'bridge_error',
+                    message: 'Only a project owner can move a project to another repository. List the members with project.member_list and ask an owner to run project.move_repository from a checkout of the new repository. Nothing was changed.',
+                    retryable: false,
+                    recovery: 'project.member_list',
+                },
+            });
+        const copy = moveCopy[input.language];
+        const questionnaireId = 'project-move-' +
+            sha256(stableStringify({
+                projectId: input.projectId,
+                from: flight.history.current.repoFingerprint,
+                to: flight.checkout.repoFingerprint,
+                version: flight.history.lockVersion,
+                ...(input.decisionAttempt ? { decisionAttempt: input.decisionAttempt } : {}),
+            }));
+        const form = await askQuestionnaire(server, service, {
+            repoRoot: input.repoRoot,
+            questionnaireId,
+            presentation: input.presentation,
+            language: input.language,
+            message: [
+                copy.ask(flight.history.name),
+                `${copy.from}: ${flight.history.current.remoteIdentity ?? copy.unknown}`,
+                `${copy.to}: ${flight.checkout.remoteIdentity ?? copy.unknown}`,
+                copy.keeps(flight.history.records.tasks, flight.history.records.memoryRecords, flight.history.records.workItems),
+                copy.after,
+            ].join('\n'),
+            options: [
+                { id: 'approve', label: copy.approve },
+                { id: 'decline', label: copy.decline },
+            ],
+        }, context, [], {
+            tool: 'project.move_repository',
+            ...(input.decisionAttempt ? { decisionAttempt: input.decisionAttempt } : {}),
+            retryArguments: { projectId: input.projectId, language: input.language },
+        });
+        const record = await service.questionnaireResume({
+            repoRoot: input.repoRoot,
+            questionnaireId,
+        });
+        if (record.status !== 'answered')
+            return form;
+        if (record.answer?.choice !== 'approve')
+            return output({
+                ok: true,
+                data: {
+                    moved: false,
+                    status: 'declined',
+                    nextAction: 'The project was not moved and nothing changed. Tell the user in one line. If they later want the move, call project.move_repository with decisionAttempt ' +
+                        ((input.decisionAttempt ?? 0) + 1) +
+                        '.',
+                },
+            });
+        return output(await service.projectMoveRepository({
+            repoRoot: input.repoRoot,
+            projectId: input.projectId,
+            expectedVersion: flight.history.lockVersion,
+        }));
+    });
     server.registerTool('memory.source_targets', {
         description: 'Read bounded Git ref candidates without assuming environment roles from their names. Confirm only the chosen committed sources with native memory.sync_start questionnaires; an explicit ref can select a source outside this preview.',
         inputSchema: z.object({ repoRoot: z.string().optional() }),

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

@@ -84,6 +84,7 @@ export const toolAnnotations = {
     'project.setup': write,
     'project.list': read,
     'project.resolve': repeatableWrite, // binds an explicitly selected project
+    'project.move_repository': write,
     'project.archive': destructive,
     'project.restore': write,
     'project.member_add': write,

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

@@ -114,6 +114,7 @@ export const engineeringMemoryToolNames = [
     'project.setup',
     'project.list',
     'project.resolve',
+    'project.move_repository',
     'project.archive',
     'project.restore',
     'project.member_add',
@@ -772,7 +773,7 @@ export function registerEngineeringMemoryTools(server, service) {
         inputSchema: z.object({ includeArchived: z.boolean().optional() }),
     }, async (input) => toolResult(await service.projectList(input)));
     server.registerTool('project.resolve', {
-        description: 'Resolve the current repository fingerprint or bind an explicitly selected project, then store the user-local binding only after backend authorization succeeds.',
+        description: 'Resolve the project this checkout belongs to, or bind an explicitly selected project, then store the user-local binding only after backend authorization succeeds. A result with projectMoved means this checkout points at a repository the project left; a bind refused with recovery project.move_repository means the project lives in another repository and an owner can move it here.',
         inputSchema: z.object({
             repoRoot: optionalRepoRoot,
             bind: z.boolean().optional(),

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

@@ -1,8 +1,9 @@
 import { basename } from 'node:path';
 import * as z from 'zod/v4';
-import { cancelledDeliveryQuestionId, } from '../runtime/bridge-service.js';
+import { cancelledDeliveryQuestionId, forgetUnreadableQuestionId, } from '../runtime/bridge-service.js';
 import { configuredBase, sourceLabel, taskStartChoice, taskStartDefinition, } from '../runtime/task-start.js';
 import { sha256, stableStringify } from '../utilities/hash.js';
+import { unreadableWorktree } from '../runtime/worktree-pool.js';
 import { askQuestionnaire } from './questionnaire-tools.js';
 const repo = z.string().min(1);
 const branch = z.string().min(1).max(255);
@@ -336,18 +337,89 @@ export function registerWorktreeTools(server, service) {
         inputSchema: locationSchema,
     }, async (input) => output(await service.worktreeOperation('list', input)));
     server.registerTool('worktree.reconcile', {
-        description: 'Reconcile Git with the local registry, including unregistered legacy checkouts. Use releaseUnowned only on a selected unreserved recovered checkout after prior work has finished; a native source-bound confirmation and fresh safety checks precede reuse. Use retireLegacy only when the user wants old-location slots gone: each retired folder is removed with git worktree remove after its own native approval, and the branch stays. Otherwise never delete files or reset branches.',
+        description: 'Reconcile Git with the local registry, including unregistered legacy checkouts. Use releaseUnowned only on a selected unreserved recovered checkout after prior work has finished; a native source-bound confirmation and fresh safety checks precede reuse. Use retireLegacy only when the user wants old-location slots gone: each retired folder is removed with git worktree remove after its own native approval, and the branch stays. Use forgetUnreadable with the externalTaskId of a checkout that is gone or can no longer be read as a Git worktree, called from a working checkout of the same project: after its own native approval Engineering Memory stops tracking that entry, so it no longer counts toward the limit, and no file in the folder is read, moved or deleted. Otherwise never delete files or reset branches.',
         inputSchema: z.strictObject({
             repoRoot: repo,
             releaseUnowned: z.boolean().optional(),
             retireLegacy: z.boolean().optional(),
+            forgetUnreadable: z.strictObject({ externalTaskId: z.string().min(2).max(160) }).optional(),
             decisionAttempt: z.number().int().min(0).default(0),
             language: z.enum(['tr', 'en']).default('en'),
         }),
     }, async (input, context) => {
         const inspection = await service.worktreeOperation('reconcile', input);
-        if (!inspection.ok || (!input.releaseUnowned && !input.retireLegacy))
+        if (!inspection.ok ||
+            (!input.releaseUnowned && !input.retireLegacy && !input.forgetUnreadable))
             return output(inspection);
+        if (input.forgetUnreadable) {
+            const item = inspection.data.items.find((entry) => entry.externalTaskId === input.forgetUnreadable.externalTaskId);
+            if (!item || item.activity === 'retired' || !unreadableWorktree(item))
+                return output({
+                    ok: false,
+                    error: {
+                        kind: 'bridge_error',
+                        retryable: false,
+                        recovery: 'worktree.list',
+                        message: 'Only a checkout that is missing or can no longer be read as a Git worktree is forgotten. Call worktree.list to see this task: a readable one is freed with worktree.release, and a retired slot is removed with worktree.reconcile and retireLegacy.',
+                    },
+                });
+            const questionnaireId = forgetUnreadableQuestionId(item, input.decisionAttempt);
+            const folder = basename(item.repoRoot);
+            const tr = input.language === 'tr';
+            const form = await askQuestionnaire(server, service, {
+                repoRoot: input.repoRoot,
+                questionnaireId,
+                language: input.language,
+                allowFreeText: false,
+                message: tr
+                    ? item.externalTaskId +
+                        ' görevinin ' +
+                        folder +
+                        ' klasörü artık bir Git çalışma kopyası olarak okunamıyor. Engineering Memory bu klasörü takip etmeyi bıraksın mı? Klasördeki hiçbir dosyaya dokunulmaz, hiçbiri silinmez.' +
+                        (item.pendingDelivery
+                            ? ' Bu görev teslimi sonuçlanmadan kapandı; teslim edilmemiş iş varsa yalnızca bu klasörde duruyor.'
+                            : '')
+                    : 'The ' +
+                        folder +
+                        ' folder of task ' +
+                        item.externalTaskId +
+                        ' can no longer be read as a Git checkout. Should Engineering Memory stop tracking it? No file in the folder is touched or deleted.' +
+                        (item.pendingDelivery
+                            ? ' That task closed without its delivery being settled, so any undelivered work exists only in that folder.'
+                            : ''),
+                options: [
+                    {
+                        id: 'forget',
+                        label: tr
+                            ? 'Takip etmeyi bırak; dosyalara dokunma'
+                            : 'Stop tracking it; leave the files alone',
+                    },
+                    { id: 'keep', label: tr ? 'Takip etmeye devam et' : 'Keep tracking it' },
+                ],
+            }, context, [], {
+                tool: 'worktree.reconcile',
+                ...(input.decisionAttempt ? { decisionAttempt: input.decisionAttempt } : {}),
+                retryArguments: json({
+                    forgetUnreadable: input.forgetUnreadable,
+                    language: input.language,
+                }),
+            });
+            const decision = await service.questionnaireResume({
+                repoRoot: input.repoRoot,
+                questionnaireId,
+            });
+            if (decision.status !== 'answered')
+                return form;
+            if (decision.answer?.choice !== 'forget')
+                return output({ ok: true, data: json({ kept: item.externalTaskId }) });
+            return output(await service.worktreeOperation('forget_unreadable', {
+                repoRoot: input.repoRoot,
+                externalTaskId: item.externalTaskId,
+                generation: item.generation,
+                decisionAttempt: input.decisionAttempt,
+                decisionId: questionnaireId,
+            }));
+        }
         if (input.retireLegacy) {
             const items = inspection.data.items.filter((item) => item.activity === 'retired');
             const retired = [];

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

@@ -69,11 +69,23 @@ export class RepositoryResolver {
             legacyFingerprints: binding ? [] : [await this.git.fingerprint(repoRoot, 1)],
         };
     }
-    async writeBinding(repoRoot, projectId, fingerprint) {
+    async checkoutFingerprints(repoRoot) {
+        return [
+            ...new Set([
+                await this.git.fingerprint(repoRoot, 2),
+                await this.git.fingerprint(repoRoot, 1),
+            ]),
+        ];
+    }
+    async writeBinding(repoRoot, projectId, fingerprint, livesIn) {
         assertProjectId(projectId);
-        const repository = await this.resolve(repoRoot, projectId);
+        const root = await this.git.findRoot(repoRoot);
+        const home = livesIn !== undefined &&
+            /^[0-9a-f]{64}$/.test(fingerprint) &&
+            (await this.checkoutFingerprints(root)).includes(livesIn);
+        const repository = await this.resolve(root, home ? undefined : projectId);
         const older = repository.legacyFingerprints.includes(fingerprint);
-        if (fingerprint !== repository.repoFingerprint && !older) {
+        if (fingerprint !== repository.repoFingerprint && !older && !home) {
             throw new Error('The confirmed project fingerprint does not identify this repository');
         }
         const repositoryKey = await this.keyFor(repository.repoRoot);

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

@@ -15,6 +15,7 @@ export const backendRecoveryOperationNames = [
     'project.resolve',
     'project.list',
     'project.restore',
+    'project.move_repository',
     'project.member_list',
     'organization.list',
     'project.member_add',

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

@@ -1,3 +1,4 @@
+import { unreadableWorktree, } from './worktree-pool.js';
 import { validWorktreePolicy } from './worktree-policy.js';
 import { resolveTaskBase } from './branch-preferences.js';
 import { randomUUID } from 'node:crypto';
@@ -263,13 +264,7 @@ export class BridgeService {
                 });
             let projectId = repository.projectId;
             if (!repository.bindingPath) {
-                const resolved = await this.dependencies.client.request(endpoints.projectResolve, {
-                    method: 'POST',
-                    body: {
-                        repoFingerprint: repository.repoFingerprint,
-                        legacyFingerprints: repository.legacyFingerprints,
-                    },
-                });
+                const resolved = await this.dependencies.client.request(endpoints.projectResolve, { method: 'POST', body: await this.checkoutIdentity(repository) });
                 const project = objectValue(resolved.data);
                 const restoreRequired = Boolean(project?.archivedAt);
                 const restoreGuidance = archivedProjectGuidance(project);
@@ -283,6 +278,7 @@ export class BridgeService {
                     projects: projects.data,
                     outbox: { recoveredDeliveries, ...objectOrEmpty(outbox) },
                     ...(restoreRequired ? restoreGuidance : {}),
+                    ...movedProjectGuidance(project),
                 });
             }
             if (!projectId) {
@@ -308,7 +304,7 @@ export class BridgeService {
                 this.poolAllocations.set(repository.repoRoot, poolAllocation);
             }
             const checkpointId = deterministicUuid('session.bootstrap', projectId, repository.repoFingerprint, input.externalTaskId);
-            const response = await this.dependencies.client.request(endpoints.sessionBootstrap, {
+            const response = await this.requestWithNewerFields(endpoints.sessionBootstrap, ['checkoutFingerprints'], {
                 method: 'POST',
                 idempotencyKey: checkpointId,
                 body: cleanJson({
@@ -321,6 +317,7 @@ export class BridgeService {
                     workItemId: persistedBootstrap.workItemId,
                     mode: persistedBootstrap.mode ?? 'write',
                     repoFingerprint: repository.repoFingerprint,
+                    checkoutFingerprints: await this.dependencies.repositories.checkoutFingerprints(repository.repoRoot),
                     ...(input.mode === 'read_only'
                         ? { baselineDiffHash: repository.git.worktreeHash }
                         : {}),
@@ -2305,15 +2302,19 @@ export class BridgeService {
                         ? {
                             nextAction: 'worktree.reconcile with retireLegacy when the user wants the old folder removed; it is never reused.',
                         }
-                        : item.phase === 'delivery'
+                        : unreadableWorktree(item)
                             ? {
-                                nextAction: 'Ask the user whether it was delivered; call worktree.release with deliveryOutcome delivered or cancelled (the product asks the user what happens to the folder).',
+                                nextAction: `This checkout can no longer be read as a Git worktree. worktree.reconcile with forgetUnreadable {"externalTaskId": "${item.externalTaskId}"} asks the user whether Engineering Memory stops tracking it; no file in the folder is touched.`,
                             }
-                            : !item.managed && item.phase !== 'released'
+                            : item.phase === 'delivery'
                                 ? {
-                                    nextAction: 'The user’s own folder, held by this task. Resume the task here to continue it. For another task here, task.branch asks whether this one should move out; a closed or abandoned task is let go when the next task starts here.',
+                                    nextAction: 'Ask the user whether it was delivered; call worktree.release with deliveryOutcome delivered or cancelled (the product asks the user what happens to the folder).',
                                 }
-                                : {}),
+                                : !item.managed && item.phase !== 'released'
+                                    ? {
+                                        nextAction: 'The user’s own folder, held by this task. Resume the task here to continue it. For another task here, task.branch asks whether this one should move out; a closed or abandoned task is let go when the next task starts here.',
+                                    }
+                                    : {}),
                 }));
                 const retired = items.some((item) => item.activity === 'retired');
                 const selected = await pool.forPath(projectId, repository.repoRoot);
@@ -2363,6 +2364,42 @@ export class BridgeService {
                 await pool.releaseUnowned(projectId, repository.repoRoot, input.generation, input.sourceCommit);
                 return asJsonValue({ operation, complete: true, repoRoot: repository.repoRoot });
             }
+            if (operation === 'forget_unreadable') {
+                const entry = input.externalTaskId
+                    ? await pool.forSlug(projectId, input.externalTaskId)
+                    : null;
+                if (!entry || entry.generation !== input.generation || !input.decisionId)
+                    throw refuse('The unreadable checkout changed after it was asked about. Call worktree.list again before forgetting it.', 'worktree.list');
+                if (input.decisionId !== forgetUnreadableQuestionId(entry, input.decisionAttempt ?? 0))
+                    throw refuse('The decision does not match this task and checkout. Repeat worktree.reconcile with forgetUnreadable.', 'worktree.reconcile');
+                const decision = await this.questionnaireResume({
+                    repoRoot: repository.repoRoot,
+                    questionnaireId: input.decisionId,
+                });
+                if (decision.status !== 'answered' || decision.answer?.choice !== 'forget')
+                    throw refuse('A checkout stops being tracked only after the user approves it in the native worktree.reconcile form.', 'worktree.reconcile');
+                const forgotten = await pool.forgetUnreadable(projectId, entry.externalTaskId, entry.generation);
+                this.poolAllocations.delete(forgotten.repoRoot);
+                const folderPresent = await lstat(forgotten.repoRoot).then(() => true, () => false);
+                const pointer = await this.dependencies.activeContexts.loadForSlug(forgotten.repoFingerprint, forgotten.externalTaskId);
+                if (pointer?.worktreeId === sha256(forgotten.repoRoot))
+                    await this.parkPointer(pointer);
+                return asJsonValue({
+                    operation,
+                    complete: true,
+                    forgotten: {
+                        externalTaskId: forgotten.externalTaskId,
+                        repoRoot: forgotten.repoRoot,
+                        branch: forgotten.branch,
+                        pendingDelivery: forgotten.pendingDelivery,
+                    },
+                    filesTouched: false,
+                    folderPresent,
+                    nextAction: folderPresent
+                        ? `Engineering Memory no longer tracks that folder and it no longer counts toward the worktree limit. Nothing in it was deleted or changed; the task itself stays open. Tell the user that its files are still on disk in that folder, and start its next worktree with task.branch when they want to continue.`
+                        : `Engineering Memory no longer tracks that folder and it no longer counts toward the worktree limit. The folder was already gone before this call, so anything in it that was never committed is not on disk any more${forgotten.pendingDelivery ? '; this task closed with its delivery unsettled, so say that plainly' : ''}. Whatever was committed is still on${forgotten.branch ? ' branch ' + forgotten.branch : ' its branch'}. The task itself stays open; start its next worktree with task.branch when the user wants to continue.`,
+                });
+            }
             if (operation === 'retire') {
                 const entry = input.worktreePath ? await pool.forPath(projectId, input.worktreePath) : null;
                 if (!entry ||
@@ -2857,8 +2894,8 @@ export class BridgeService {
                 organizationId: input.organizationId,
                 projectName: input.projectName,
                 projectSlug: input.projectSlug ?? slugify(input.projectName),
-                repoFingerprint: repository.repoFingerprint,
-                legacyFingerprints: repository.legacyFingerprints,
+                ...(await this.checkoutIdentity(repository)),
+                remoteIdentity: await this.dependencies.repositories.git.remoteIdentity(repository.repoRoot),
                 framework: input.framework,
                 developmentArea: input.developmentArea,
                 figmaConfig: input.figmaConfig,
@@ -2869,7 +2906,7 @@ export class BridgeService {
             }
             const persistentBody = normalizeRepositoryPaths(body, repository.repoRoot);
             assertSafeToPersist(persistentBody);
-            const response = await this.dependencies.client.request(endpoints.projectSetup, {
+            const response = await this.requestWithNewerFields(endpoints.projectSetup, ['remoteIdentity'], {
                 method: 'POST',
                 body: persistentBody,
             });
@@ -2912,7 +2949,7 @@ export class BridgeService {
                 else if (stableStringify(current.branches) !== stableStringify(choice.gitPreferences))
                     throw refuse('The project already has different shared branch preferences. Review them before changing the project settings.', 'project.git_preferences');
             }
-            const bindingPath = await this.dependencies.repositories.writeBinding(repository.repoRoot, project.id, project.repoFingerprint);
+            const bindingPath = await this.dependencies.repositories.writeBinding(repository.repoRoot, project.id, project.repoFingerprint, livesIn(project));
             return asJsonValue({ ...data, marker: null, markerPath: null, bindingPath });
         });
     }
@@ -3219,12 +3256,12 @@ export class BridgeService {
                         repository: publicRepository(repository),
                     });
                 }
-                const response = await this.dependencies.client.request(endpoints.projectBind(input.projectId), {
+                const response = await this.requestWithNewerFields(endpoints.projectBind(input.projectId), ['remoteIdentity'], {
                     method: 'POST',
-                    body: {
-                        repoFingerprint: repository.repoFingerprint,
-                        legacyFingerprints: repository.legacyFingerprints,
-                    },
+                    body: cleanJson({
+                        ...(await this.checkoutIdentity(repository)),
+                        remoteIdentity: await this.dependencies.repositories.git.remoteIdentity(repository.repoRoot),
+                    }),
                 });
                 const project = objectValue(response.data);
                 if (!project ||
@@ -3232,7 +3269,7 @@ export class BridgeService {
                     typeof project.repoFingerprint !== 'string') {
                     throw refuse('Project bind response does not match the selected project', 'project.resolve');
                 }
-                const bindingPath = await this.dependencies.repositories.writeBinding(repository.repoRoot, input.projectId, project.repoFingerprint);
+                const bindingPath = await this.dependencies.repositories.writeBinding(repository.repoRoot, input.projectId, project.repoFingerprint, livesIn(project));
                 return asJsonValue({
                     resolved: true,
                     bound: true,
@@ -3245,25 +3282,101 @@ export class BridgeService {
             }
             const response = await this.dependencies.client.request(endpoints.projectResolve, {
                 method: 'POST',
-                body: {
-                    repoFingerprint: repository.repoFingerprint,
-                    legacyFingerprints: repository.legacyFingerprints,
-                },
+                body: await this.checkoutIdentity(repository),
             });
             const project = objectValue(response.data);
             const restoreRequired = Boolean(project?.archivedAt);
             const restoreGuidance = archivedProjectGuidance(project);
+            const moved = project?.checkout === 'retired';
             return asJsonValue({
-                resolved: project !== null && !restoreRequired,
+                resolved: project !== null && !restoreRequired && !moved,
                 project,
                 markerPath: null,
                 repository: publicRepository(repository),
                 selectionRequired: project === null,
                 restoreRequired,
                 ...(restoreRequired ? restoreGuidance : {}),
+                ...movedProjectGuidance(project),
+            });
+        });
+    }
+    async projectRepositoryMovePreflight(input) {
+        return await this.execute(async () => {
+            const authentication = await this.dependencies.browserAuth.ensureAuthenticated();
+            if (authentication)
+                return asJsonValue({ authentication });
+            const repository = await this.dependencies.repositories.resolve(input.repoRoot);
+            const history = await this.dependencies.client.request(endpoints.projectRepository(input.projectId));
+            const identity = await this.checkoutIdentity(repository);
+            const current = objectValue(objectValue(history.data)?.current);
+            return asJsonValue({
+                history: history.data,
+                checkout: {
+                    ...identity,
+                    remoteIdentity: await this.dependencies.repositories.git.remoteIdentity(repository.repoRoot),
+                },
+                alreadyHere: typeof current?.repoFingerprint === 'string' &&
+                    [identity.repoFingerprint, ...identity.legacyFingerprints].includes(current.repoFingerprint),
+            });
+        });
+    }
+    async projectMoveRepository(input) {
+        return await this.execute(async () => {
+            const repository = await this.dependencies.repositories.resolve(input.repoRoot);
+            const response = await this.dependencies.client.request(endpoints.projectRepository(input.projectId), {
+                method: 'POST',
+                body: cleanJson({
+                    ...(await this.checkoutIdentity(repository)),
+                    remoteIdentity: await this.dependencies.repositories.git.remoteIdentity(repository.repoRoot),
+                    expectedVersion: input.expectedVersion,
+                }),
+            });
+            const project = objectValue(response.data);
+            if (!project ||
+                project.id !== input.projectId ||
+                typeof project.repoFingerprint !== 'string' ||
+                !livesIn(project)) {
+                throw refuse('Project move response does not match the selected project', 'project.move_repository');
+            }
+            const bindingPath = await this.dependencies.repositories.writeBinding(repository.repoRoot, input.projectId, project.repoFingerprint, livesIn(project));
+            return asJsonValue({
+                moved: true,
+                bound: true,
+                project,
+                bindingPath,
+                repository: publicRepository(await this.dependencies.repositories.resolve(repository.repoRoot)),
+                nextAction: 'The project now lives in this repository and this checkout is bound to it. Every task, memory record and work item stayed with the project. Continue with session.bootstrap or session.resume.',
             });
         });
     }
+    async checkoutIdentity(repository) {
+        const [current, ...older] = await this.dependencies.repositories.checkoutFingerprints(repository.repoRoot);
+        return {
+            repoFingerprint: current,
+            legacyFingerprints: [
+                ...new Set([...older, repository.repoFingerprint, ...repository.legacyFingerprints]),
+            ]
+                .filter((fingerprint) => fingerprint !== current)
+                .slice(0, 4),
+        };
+    }
+    async requestWithNewerFields(path, newer, options) {
+        try {
+            return await this.dependencies.client.request(path, options);
+        }
+        catch (error) {
+            const body = objectValue(options.body);
+            if (!body ||
+                !(error instanceof ApiResponseError) ||
+                error.httpStatus !== 400 ||
+                !newer.some((name) => error.message.includes(`property ${name} should not exist`)))
+                throw error;
+            return await this.dependencies.client.request(path, {
+                ...options,
+                body: Object.fromEntries(Object.entries(body).filter(([name]) => !newer.includes(name))),
+            });
+        }
+    }
     async sessionEntry(input = {}) {
         return await this.execute(async () => {
             const timer = startPhaseTimer('session.entry');
@@ -3301,7 +3414,7 @@ export class BridgeService {
             const livePointers = authenticated && state === 'bound'
                 ? this.dependencies.activeContexts.list(repository.repoFingerprint)
                 : Promise.resolve([]);
-            const [client, liveTasksRaw, workItems, gitPreferences, worktrees, pendingQuestionnaires] = await Promise.all([
+            const [client, liveTasksRaw, workItems, gitPreferences, worktrees, pendingQuestionnaires, moved,] = await Promise.all([
                 this.clientUpdate(authenticated),
                 livePointers,
                 authenticated && state === 'bound' && projectId
@@ -3319,6 +3432,9 @@ export class BridgeService {
                         this.checkoutTask(repository.repoFingerprint, repository.repoRoot),
                     ]).then(([pointers, workedTask]) => this.questionnaireOverview(repository.repoRoot, workedTask, new Set(pointers.map((pointer) => pointer.taskSlug))))
                     : Promise.resolve({ mine: [], other: [], deferred: [] }),
+                authenticated && state === 'bound' && projectId
+                    ? this.movedAway(repository, projectId)
+                    : Promise.resolve({}),
             ]);
             timer.mark('independent_lookups');
             const liveTasks = liveTasksRaw.map(describePointer);
@@ -3355,19 +3471,35 @@ export class BridgeService {
                     ? { deferredTaskStarts: pendingQuestionnaires.deferred }
                     : {}),
                 client,
+                ...moved,
                 ...(incomplete && state === 'bound'
                     ? {
                         shippedKnowledgeWarning: 'The backend is not serving all of the knowledge this release ships. Tell the user before relying on the rules: some are missing from the running server, so a review against them is incomplete. The counts and the reason are in client.shippedKnowledge.',
                     }
                     : {}),
-                nextAction: pendingQuestionnaires.mine.length > 0
-                    ? 'Resume only the pending questionnaire for this work with questionnaire.resume before taking action that depends on its answer. Unrelated pending questions never block opening a separate task. Never infer consent from a timeout, dismissal, interrupted turn or missing answer.'
-                    : taskSelectionRequired
-                        ? 'Present the live runs and actionable project work items, then ask which one this chat should handle. Resume only the run they choose, or start a separate run for the chosen work item: task.branch first for write work, then session.bootstrap with its workItemId in the returned repoRoot. Another live task never blocks opening this one.'
-                        : entryNextAction(authenticated, state),
+                nextAction: typeof moved.nextAction === 'string'
+                    ? moved.nextAction
+                    : pendingQuestionnaires.mine.length > 0
+                        ? 'Resume only the pending questionnaire for this work with questionnaire.resume before taking action that depends on its answer. Unrelated pending questions never block opening a separate task. Never infer consent from a timeout, dismissal, interrupted turn or missing answer.'
+                        : taskSelectionRequired
+                            ? 'Present the live runs and actionable project work items, then ask which one this chat should handle. Resume only the run they choose, or start a separate run for the chosen work item: task.branch first for write work, then session.bootstrap with its workItemId in the returned repoRoot. Another live task never blocks opening this one.'
+                            : entryNextAction(authenticated, state),
             });
         });
     }
+    async movedAway(repository, projectId) {
+        try {
+            const response = await this.dependencies.client.request(endpoints.projectResolve, {
+                method: 'POST',
+                body: await this.checkoutIdentity(repository),
+            });
+            const project = objectValue(response.data);
+            return project?.id === projectId ? movedProjectGuidance(project, true) : {};
+        }
+        catch {
+            return {};
+        }
+    }
     async actionableWorkItems(projectId) {
         try {
             const response = await this.dependencies.client.request(`${endpoints.workItemList(projectId)}?limit=100`);
@@ -4682,6 +4814,26 @@ function archivedProjectGuidance(project) {
         nextAction: 'Call project.member_list with this project id, identify an owner, and ask that owner to restore the archived project.',
     };
 }
+function livesIn(project) {
+    const repository = objectValue(project?.repository);
+    return typeof repository?.repoFingerprint === 'string' ? repository.repoFingerprint : undefined;
+}
+function movedProjectGuidance(project, bound = false) {
+    if (project?.checkout !== 'retired')
+        return {};
+    const home = objectValue(project.repository)?.remoteIdentity;
+    return {
+        projectMoved: true,
+        movedTo: typeof home === 'string' ? home : null,
+        nextAction: bound
+            ? `The project "${String(project.name)}" no longer lives in the repository this checkout points at` +
+                (typeof home === 'string' ? `; it moved to ${home}` : '') +
+                '. Tell the user before anything else. A task already open here can be resumed and finished. Do not call task.branch or open a new task here: new work starts from a checkout of the new repository, where the project is selected again. A project owner calls project.move_repository from here only when the code really lives in this repository again.'
+            : `This checkout points at a repository the project "${String(project.name)}" left` +
+                (typeof home === 'string' ? `; it now lives in ${home}` : '') +
+                '. Tell the user. To keep working on that project, point this checkout at its new repository (or clone it) and select the project again. A project owner calls project.move_repository only when the code of the project really lives in this repository again. Do not create a second project for it.',
+    };
+}
 function slugify(value) {
     return value
         .trim()
@@ -4791,6 +4943,17 @@ function isOfflineLeaseUsable(lease, sessionId, changedPaths, baselineDiffHash)
         return false;
     }
 }
+export function forgetUnreadableQuestionId(entry, decisionAttempt) {
+    return ('worktree-forget-unreadable-' +
+        sha256(stableStringify({
+            projectId: entry.projectId,
+            externalTaskId: entry.externalTaskId,
+            repoRoot: entry.repoRoot,
+            generation: entry.generation,
+            pendingDelivery: entry.pendingDelivery,
+            decisionAttempt,
+        })));
+}
 export function cancelledDeliveryQuestionId(entry, clean) {
     return ('worktree-delivery-cancel-' +
         sha256(entry.generation + ':' + (clean ? 'clean' : entry.managed ? 'modified' : 'own-folder')));

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

@@ -283,6 +283,10 @@ export class WorktreePool {
         return this.transaction(async (registry) => structuredClone(registry.projects[projectId]?.entries.find((e) => key(e.repoRoot) === key(repoRoot)) ??
             null));
     }
+    async forSlug(projectId, externalTaskId) {
+        return this.transaction(async (registry) => structuredClone(registry.projects[projectId]?.entries.find((e) => e.externalTaskId === externalTaskId) ??
+            null));
+    }
     async validateCommit(projectId, taskId, repoRoot, generation) {
         return this.transaction(async (registry) => {
             const entry = registry.projects[projectId]?.entries.find((e) => key(e.repoRoot) === key(repoRoot));
@@ -457,6 +461,34 @@ export class WorktreePool {
             await this.save(registry);
         });
     }
+    async forgetUnreadable(projectId, externalTaskId, generation) {
+        return this.transaction(async (registry) => {
+            const project = registry.projects[projectId];
+            const entry = project?.entries.find((e) => e.externalTaskId === externalTaskId && e.generation === generation);
+            if (!project || !entry)
+                throw refuse('This is no longer the same registry entry for that task. List the checkouts again with worktree.list before forgetting one.');
+            if (await this.ownedElsewhere(entry))
+                throw refuse('Another live client still owns this task. Stop or pause it there first; worktree.list shows the checkout meanwhile.');
+            if (!(await this.unreadable(entry)))
+                throw new BridgeRecoveryError('This checkout can still be read as a Git worktree, so it is not forgotten. Settle its delivery and free it with worktree.release.', 'worktree.release');
+            project.entries = project.entries.filter((e) => e !== entry);
+            await this.save(registry);
+            return structuredClone(entry);
+        });
+    }
+    async unreadable(entry) {
+        if (!(await pathExists(entry.repoRoot)))
+            return true;
+        try {
+            if (key(await this.git.findRoot(entry.repoRoot)) !== key(await canonicalPath(entry.repoRoot)))
+                return true;
+            await this.commonDirectory(entry.repoRoot);
+            return false;
+        }
+        catch {
+            return true;
+        }
+    }
     async releaseUnowned(projectId, repoRoot, generation, sourceCommit) {
         await this.transaction(async (registry) => {
             const entry = registry.projects[projectId]?.entries.find((e) => key(e.repoRoot) === key(repoRoot));
@@ -832,12 +864,12 @@ export class WorktreePool {
     }
     async fileProtection(entry, allowBranchChange = false) {
         if (!(await pathExists(entry.repoRoot)))
-            return ['worktree directory missing'];
+            return [missingDirectory];
         try {
             await this.assertIdentity(entry, allowBranchChange);
         }
         catch {
-            return ['Git identity or reservation changed or unreadable; reconcile this checkout'];
+            return [(await this.unreadable(entry)) ? unreadableGit : changedIdentity];
         }
         const status = await this.runner.run('git', ['status', '--porcelain=v1', '--untracked-files=all'], { cwd: entry.repoRoot });
         const reasons = [];
@@ -877,7 +909,7 @@ export class WorktreePool {
                 activity: 'retired',
                 reasons: [
                     'outside the managed root ' + managedBase(activeRoot, 2) + '; not reused',
-                    ...((await pathExists(entry.repoRoot)) ? [] : ['worktree directory missing']),
+                    ...((await pathExists(entry.repoRoot)) ? [] : [missingDirectory]),
                 ],
             };
         const reasons = await this.fileProtection(entry);
@@ -1314,6 +1346,12 @@ function processAlive(pid) {
 }
 const changedFiles = 'uncommitted, staged or untracked files';
 const pendingTaskWork = 'task delivery or intent pending';
+const missingDirectory = 'worktree directory missing';
+const changedIdentity = 'Git identity or reservation changed; reconcile this checkout';
+const unreadableGit = 'Git metadata missing or unreadable; this folder is no longer a checkout';
+export function unreadableWorktree(view) {
+    return view.reasons.includes(missingDirectory) || view.reasons.includes(unreadableGit);
+}
 function protectedRefusal(reasons, next) {
     if (reasons.every((reason) => reason === pendingTaskWork))
         return new BridgeRecoveryError('Engineering Memory still holds an undelivered record for this task: a checkpoint, correction or close waiting in its local outbox, or an unfinished verification or close. The folder was left as it is. Settle it with task.resolve_pending_delivery (session.resume finishes an interrupted verification or close), then call worktree.release again.', 'task.resolve_pending_delivery');

package/skill/references/lifecycle.md

@@ -6,6 +6,14 @@ Sign-in decides nothing beyond who the user is. The organization and the project
 
 Use the binding returned by `session.entry` as the authority. The bridge stores the selected project and repository identity under `~/.engineering-memory/origins/<api-hash>/project-bindings/`, outside the installed runtime and working tree. It imports a legacy `.engineering-memory/project.json` once, preserving its schema and exact backend fingerprint for existing tasks and receipts. It leaves that file unchanged; after migration the file is optional and may be removed through the repository's normal Git workflow. New bindings never create it. A checkout that never imported the marker still finds a project bound under the older identity: the bridge presents that identity alongside the current one and stores whichever the backend confirms. Never infer a selection from a directory or remote, and never edit binding records by hand. Separate clones or a changed remote require a new explicit selection; worktrees of the same checkout share the local binding.
 
+A project is not tied to one repository forever. When its code moves — to another host, under a new remote, into a history that starts again from one commit — the project moves with it and keeps everything: tasks, memory, work items, open sessions, the local state of every checkout. The old repository stays in the project's history. Recognise the three shapes this takes and never answer any of them by creating a second project:
+
+- Binding the selected project is refused with recovery `project.move_repository`. The project lives in another repository and the user is one of its owners. Call `project.move_repository` with the project id; it opens one native form that names both repositories and what stays with the project, and on approval moves the project and binds this checkout. A declined form changes nothing.
+- The same refusal arrives with recovery `project.member_list`. Moving needs project-owner authority, which the organization owner also holds. Check the roles, say that an owner has to run the move from a checkout of the new repository, and continue only work that does not need the binding. Do not name a person.
+- `session.entry`, `project.resolve` or bootstrap reports `projectMoved`, or bootstrap refuses with "Project moved". This checkout still points at a repository the project has left; the message names where it lives now. Tasks already open here can be resumed and finished. New work starts from the new repository: the user points this checkout's origin at it, or clones it, and selects the project again. An owner calls `project.move_repository` from here only when the code truly lives in this repository again.
+
+After a move nothing else changes for the agent. The binding keeps reporting the identity the project has always had, so resume, verification, receipts and the commit gate behave as they did before.
+
 An archived project is recoverable state, not a missing or conflicting binding. When an owner receives `project.restore`, use the `projectId` and `expectedVersion` in its data and call that operation before retrying. A non-owner receives `project.member_list` instead: check the available roles and explain that project-owner authority is required to restore this exact project before retrying. Do not name a person or disclose contact details. Use `project.list` with `includeArchived: true` when an owner must first select the archived project. Never create or bind a replacement project to escape archive state.
 
 For a bound repository, call `session.bootstrap` before producing a plan or changing files. Supply the current repository root, project ID, task ID or stable local task slug, objective, task kind, task mode, and current Git diff hash. `externalTaskId`, `objective`, `taskKind` and `workItemKey` are each one line with a fixed maximum length (160/240/80/120 characters); the bridge refuses an over-length or multi-line value locally, in milliseconds, before any Git or backend work, and names the limit in the refusal — put detail that does not fit in checkpoints, not in the objective. Use `read_only` for review, diagnosis, planning, or reporting without write authority; use `scaffold` when the task applies organization architecture templates to a new project; use `write` when the request authorizes repository changes. The bridge records the read-only Git diff hash as the immutable task baseline, including a pre-existing dirty worktree. Use the returned task ID, task version, context session ID, project profile, engineering rules, prior task documents, quality gates, and current deviations; `deferredResources` names what did not fit, each with the `revisionId` to read it by.
@@ -295,6 +303,13 @@ ownership generation. Cancellation leaves it protected. Git reservation, dirty f
 Git operations and pending work are checked again before release. A changed source requires a new
 inspection and answer. This recovery never deletes files or branches or interrupts another agent.
 
+When a recorded checkout is gone or can no longer be read as a Git worktree — its `.git` was
+deleted, or the repository it was linked to was removed — `worktree.list` names `worktree.reconcile`
+with `forgetUnreadable` and that task's `externalTaskId`, called from a working checkout of the same
+project. After its own native approval Engineering Memory only stops tracking that entry, so it
+stops counting toward the limit; no file in the folder is moved or deleted, the branch and the task
+stay, and a readable checkout is still freed with `worktree.release`.
+
 If the running client predates the pool tools, inspect `git worktree list` and the existing task
 reservations before any explicit allocation. Do not treat an unavailable tool or an empty registry
 as an empty filesystem. Preserve uncertain checkouts and report the client limitation.

package/skill/references/questionnaires.md

@@ -119,6 +119,8 @@ Once the organization is chosen, call `project.list` and offer that organization
 
 The normal list omits archived projects. If repository entry, setup, binding or task open reports `project.restore`, use the project id and expected version returned with that refusal and restore it before continuing. If it reports `project.member_list`, the current member cannot restore the project: call that operation to check the available roles and explain that the versioned restore requires project-owner authority. Do not identify a person, reconstruct an identity from an account identifier or disclose contact details. If an owner does not yet have the project id and expected version, call `project.list` with `includeArchived: true` and let them select the archived project. Archive state never authorizes creating a duplicate project.
 
+When the user picks an existing project and binding it is refused because the project lives in another repository, do not offer to create a new project for the same code. An owner is asked once, through the form `project.move_repository` opens, whether the project moves to this repository; the form already says which repository it leaves, which one it joins and how many tasks, memory records and work items stay with it, so add no second question of your own. Anyone else is told that a project owner runs the move, and is not asked anything.
+
 Ask both questions again whenever a chat starts in a repository whose binding you have not confirmed in this session.
 
 ## Switching Organization or Project
@@ -359,5 +361,12 @@ safety checks still decide whether reuse is possible. Cancellation or choosing t
 release it. Resume the same form via the same operation. A changed source/generation needs a fresh
 decision, and an old answer cannot release a newly owned task.
 
+A checkout that is gone, or that can no longer be read as a Git worktree, is left with
+`worktree.reconcile` and `forgetUnreadable: {"externalTaskId": "..."}` from a working checkout of the
+same project: its native question names the task and the folder name, says that Engineering Memory
+only stops tracking it and touches no file, and warns when that task closed with its delivery
+unsettled. Cancelling or keeping it leaves it tracked, and a readable checkout is refused there and
+freed with `worktree.release` instead.
+
 If the user later reconsiders a preserved legacy checkout, repeat `worktree.reconcile` with a new
 `decisionAttempt`; never reinterpret the previous preserve answer as approval.