engineering-memory 1.11.10 → 1.11.12

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';
@@ -12,6 +13,7 @@ import { startPhaseTimer } from './phase-timer.js';
 import { sha256, stableStringify } from '../utilities/hash.js';
 import { ApiResponseError, BackendUnavailableError, } from './api-client.js';
 import { assertSafeToPersist, normalizeRepositoryPaths } from './offline-outbox.js';
+import { restrictedValueKind } from './privacy-detector.js';
 import { principalFingerprint } from './principal-state.js';
 import { sameHolder, suggestedBranchNames, taskStartChoice } from './task-start.js';
 import { BridgeRecoveryError } from './recovery-error.js';
@@ -48,13 +50,21 @@ export class BridgeService {
     managesWorktrees() {
         return Boolean(this.dependencies.worktreePool);
     }
+    async language(told) {
+        const accessToken = await this.dependencies.credentials.get('access-token');
+        const principalHash = accessToken ? principalFingerprint(accessToken) : sha256('anonymous');
+        if (told)
+            await this.dependencies.languages.remember(principalHash, told);
+        return told ?? (await this.dependencies.languages.read(principalHash));
+    }
     async questionnaireAsk(input, previousDefinitions = [], owner) {
         const scope = await this.questionnaireScope(input.repoRoot, input.preparation);
         const { repoRoot: _repoRoot, preparation: _preparation, presentation: _presentation, ...definition } = input;
         const askingTask = owner || input.preparation
             ? null
             : await this.checkoutTask(scope.repoFingerprint, await this.dependencies.repositories.git.findRoot(input.repoRoot ?? process.cwd()));
-        return await this.dependencies.questionnaires.ask(scope, definition, previousDefinitions, owner ?? (askingTask ? { tool: 'questionnaire.ask', externalTaskId: askingTask } : undefined));
+        const record = await this.dependencies.questionnaires.ask(scope, definition, previousDefinitions, owner ?? (askingTask ? { tool: 'questionnaire.ask', externalTaskId: askingTask } : undefined));
+        return { ...record, language: record.language ?? (await this.language()) };
     }
     async checkoutTask(repoFingerprint, repoRoot) {
         const worktreeId = sha256(await canonicalPath(repoRoot));
@@ -70,7 +80,7 @@ export class BridgeService {
         const record = await this.dependencies.questionnaires.get(scope, input.questionnaireId);
         if (!record)
             throw refuse('No questionnaire exists for this account and repository binding.', 'session.entry');
-        return record;
+        return { ...record, language: record.language ?? (await this.language()) };
     }
     async questionnaireWithdraw(input) {
         const scope = await this.questionnaireScope(input.repoRoot, input.preparation);
@@ -263,13 +273,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 +287,7 @@ export class BridgeService {
                     projects: projects.data,
                     outbox: { recoveredDeliveries, ...objectOrEmpty(outbox) },
                     ...(restoreRequired ? restoreGuidance : {}),
+                    ...movedProjectGuidance(project),
                 });
             }
             if (!projectId) {
@@ -308,7 +313,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 +326,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 }
                         : {}),
@@ -1245,7 +1251,9 @@ export class BridgeService {
                     ? await this.dependencies.questionnaires.get(scope, input.questionnaireId)
                     : null;
                 const digest = sha256(stableStringify(input.choice));
-                if (question?.answer?.choice !== 'approve' || !question.message.includes(digest))
+                if (question?.answer?.choice !== 'approve' ||
+                    (question.binding?.choiceDigest !== digest &&
+                        !question.message.includes(digest)))
                     throw refuse('Approve the exact mode and profile through project.onboard before continuing.', 'session.entry');
                 return asJsonValue(await this.dependencies.onboarding.save(scope, input.choice));
             }
@@ -1612,14 +1620,45 @@ export class BridgeService {
         }
         return [...pending];
     }
-    ruleDeviationQuestions(input) {
+    async ruleDeviationQuestions(input) {
+        const files = reviewedFiles(input);
+        if (!files.some(({ rules }) => rules.some(isDeviation)))
+            return [];
         const language = input.language ?? 'en';
-        return reviewedFiles(input).flatMap(({ path, rules }) => rules.filter(isDeviation).map((rule) => ({
-            definition: ruleDeviationQuestion(input.taskId, path, rule, language),
-            previousDefinitions: ['en', 'tr']
-                .filter((other) => other !== language)
-                .map((other) => ruleDeviationQuestion(input.taskId, path, rule, other)),
-        })));
+        const other = language === 'tr' ? 'en' : 'tr';
+        const titles = await this.governingRuleTitles(input).catch(() => new Map());
+        return files.flatMap(({ path, rules }) => rules.filter(isDeviation).map((rule) => {
+            const title = titles.get(rule.resourceId);
+            return {
+                definition: ruleDeviationQuestion(input.taskId, path, rule, title, language),
+                previousDefinitions: [
+                    ruleDeviationQuestion(input.taskId, path, rule, title, other),
+                    earlierRuleDeviationQuestion(input.taskId, path, rule, 'en'),
+                    earlierRuleDeviationQuestion(input.taskId, path, rule, 'tr'),
+                ],
+            };
+        }));
+    }
+    async governingRuleTitles(input) {
+        const { repoFingerprint } = await this.dependencies.repositories.resolveIdentity(input.repoRoot ?? process.cwd());
+        const pointer = await this.dependencies.activeContexts.loadForTask(repoFingerprint, input.taskId);
+        const prepared = pointer
+            ? await this.dependencies.client.readCached(resumeCacheKey(pointer.sessionId, repoFingerprint, 0))
+            : null;
+        const groups = objectValue(prepared?.data)?.governingRules;
+        return new Map((Array.isArray(groups) ? groups : [])
+            .flatMap((group) => {
+            const rules = objectValue(group)?.rules;
+            return Array.isArray(rules) ? rules : [];
+        })
+            .flatMap((entry) => {
+            const rule = objectValue(entry);
+            return typeof rule?.resourceId === 'string' &&
+                typeof rule.title === 'string' &&
+                !restrictedValueKind(rule.title, 'message', true)
+                ? [[rule.resourceId, rule.title]]
+                : [];
+        }));
     }
     async taskSelfReview(input) {
         return await this.execute(async () => {
@@ -2305,15 +2344,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 +2406,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 +2936,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 +2948,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 +2991,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 +3298,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 +3311,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,28 +3324,105 @@ 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');
+            await this.language(input.language);
             const authentication = await this.dependencies.browserAuth.status();
             timer.mark('auth_status');
             let repository;
@@ -3301,7 +3457,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 +3475,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 +3514,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`);
@@ -4370,8 +4545,64 @@ export function ruleDeviationQuestionnaireId(taskId, path, rule) {
     return ('rule-deviation-' +
         sha256(stableStringify({ taskId, path, resourceKey: rule.resourceKey, issue: rule.issue })));
 }
-function ruleDeviationQuestion(taskId, path, rule, language) {
+function ruleDeviationQuestion(taskId, path, rule, title, language) {
     const copy = ruleDeviationCopy[language];
+    const named = rule.resourceKey && !/^[0-9a-f]{8}(-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i.test(rule.resourceKey)
+        ? rule.resourceKey
+        : undefined;
+    return {
+        questionnaireId: ruleDeviationQuestionnaireId(taskId, path, rule),
+        message: [
+            copy.ask(path),
+            `${copy.rule}: ${title ?? named ?? copy.unnamed}`,
+            `${copy.deviation}: ${rule.issue ?? ''}`,
+        ].join('\n'),
+        context: copy.context,
+        example: copy.example,
+        language,
+        options: [
+            { id: 'approve', label: copy.approve[0], description: copy.approve[1] },
+            { id: 'change', label: copy.change[0], description: copy.change[1] },
+        ],
+        binding: { taskId, path, resourceId: rule.resourceId },
+    };
+}
+const ruleDeviationCopy = {
+    en: {
+        ask: (path) => `${path} breaks a rule of this project. Keep the code as it is?`,
+        rule: 'Rule',
+        deviation: 'Deviation',
+        unnamed: 'an engineering rule whose name is not recorded',
+        context: "A rule conflict is yours to decide, not the agent's. Keeping the code records a deviation on this file against that rule: it travels with the self review, stays in the project memory and is what a later task reads before it touches this file.",
+        example: 'The next task that opens this file sees the rule and this recorded deviation together, instead of reading the code as if it followed the rule.',
+        approve: [
+            'Keep the code and record the deviation',
+            'The deviation is recorded for this file and the self review continues.',
+        ],
+        change: [
+            'Change the code to follow the rule',
+            'Nothing is recorded. The self review stops until the code follows the rule and is reviewed again.',
+        ],
+    },
+    tr: {
+        ask: (path) => `${path} dosyası bu projenin bir kuralına uymuyor. Kod olduğu gibi kalsın mı?`,
+        rule: 'Kural',
+        deviation: 'Sapma',
+        unnamed: 'adı kayıtlı olmayan bir mühendislik kuralı',
+        context: 'Kural çatışmasında kararı kodu yazan değil sen verirsin. Kodu olduğu gibi bırakırsan bu dosya için o kurala ait bir sapma kaydedilir: sapma incelemeyle birlikte gider, proje hafızasında kalır ve bu dosyaya sonradan dokunan görev önce onu okur.',
+        example: 'Bu dosyayı sonra açan görev, kuralı ve kaydedilen bu sapmayı birlikte görür; kodu kurala uyuyormuş gibi okumaz.',
+        approve: [
+            'Kodu olduğu gibi bırak ve sapmayı kaydet',
+            'Sapma bu dosya için kaydedilir ve inceleme devam eder.',
+        ],
+        change: [
+            'Kodu kurala uyacak şekilde değiştir',
+            'Hiçbir şey kaydedilmez. Kod kurala uyup yeniden incelenene kadar inceleme durur.',
+        ],
+    },
+};
+function earlierRuleDeviationQuestion(taskId, path, rule, language) {
+    const copy = earlierRuleDeviationCopy[language];
     return {
         questionnaireId: ruleDeviationQuestionnaireId(taskId, path, rule),
         message: copy.message(path, rule.resourceKey ?? rule.resourceId, rule.issue ?? ''),
@@ -4382,7 +4613,7 @@ function ruleDeviationQuestion(taskId, path, rule, language) {
         ],
     };
 }
-const ruleDeviationCopy = {
+const earlierRuleDeviationCopy = {
     en: {
         message: (path, resourceKey, issue) => `${path} does not follow ${resourceKey}: ${issue}`,
         approve: 'Keep the code as written and record the deviation',
@@ -4682,6 +4913,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 +5042,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/create-bridge-service.js

@@ -14,6 +14,7 @@ import { OfflineOutbox } from './offline-outbox.js';
 import { ActiveContextStore } from './active-context-store.js';
 import { RepositoryDecisionStore } from './repository-decision-store.js';
 import { ShadowNoticeStore } from './shadow-notice-store.js';
+import { LanguageStore } from './language-store.js';
 import { UpdateChoiceStore } from './update-choice-store.js';
 import { PrincipalStateGuard } from './principal-state.js';
 import { OnboardingStore } from './onboarding-store.js';
@@ -73,6 +74,7 @@ export function createBridgeService(options = {}) {
         repositoryDecisions,
         updateChoices,
         shadowNotices,
+        languages: new LanguageStore(stateRoot),
         questionnaires: new QuestionnaireStore(stateRoot),
         onboarding: new OnboardingStore(stateRoot),
         clientVersion: options.clientVersion === undefined ? config.clientVersion : options.clientVersion,

package/runtime/dist/src/runtime/language-store.js

@@ -0,0 +1,25 @@
+import { join } from 'node:path';
+import { readJson, writeJson } from '../utilities/files.js';
+export class LanguageStore {
+    path;
+    root;
+    constructor(stateRoot) {
+        this.root = join(stateRoot, 'client');
+        this.path = join(this.root, 'language.json');
+    }
+    async read(principalHash) {
+        const remembered = await readJson(this.path, this.root);
+        return remembered?.principals[principalHash] ?? remembered?.machine;
+    }
+    async remember(principalHash, language) {
+        const remembered = await readJson(this.path, this.root);
+        if (remembered?.machine === language && remembered.principals[principalHash] === language)
+            return;
+        await writeJson(this.path, {
+            schemaVersion: 1,
+            machine: language,
+            principals: { ...remembered?.principals, [principalHash]: language },
+        }, this.root);
+    }
+}
+//# sourceMappingURL=language-store.js.map