engineering-memory 1.11.8 → 1.11.10

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

@@ -8,10 +8,12 @@ import { ProjectIntake } from '../project/project-intake.js';
 import { canonicalPath } from '../utilities/files.js';
 import { minimatch } from 'minimatch';
 import { endpoints } from '../config.js';
+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 { principalFingerprint } from './principal-state.js';
+import { sameHolder, suggestedBranchNames, taskStartChoice } from './task-start.js';
 import { BridgeRecoveryError } from './recovery-error.js';
 export const validationIds = [
     'format',
@@ -38,6 +40,7 @@ export class BridgeService {
     deliveryQueues = new Map();
     deliveryWaiters = [];
     activeDeliveries = 0;
+    workedTasks = new Map();
     constructor(dependencies) {
         this.dependencies = dependencies;
         this.deferDeliveries = dependencies.deferDeliveries ?? true;
@@ -45,10 +48,22 @@ export class BridgeService {
     managesWorktrees() {
         return Boolean(this.dependencies.worktreePool);
     }
-    async questionnaireAsk(input, previousDefinitions = []) {
+    async questionnaireAsk(input, previousDefinitions = [], owner) {
         const scope = await this.questionnaireScope(input.repoRoot, input.preparation);
-        const { repoRoot: _repoRoot, preparation: _preparation, ...definition } = input;
-        return await this.dependencies.questionnaires.ask(scope, definition, previousDefinitions);
+        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));
+    }
+    async checkoutTask(repoFingerprint, repoRoot) {
+        const worktreeId = sha256(await canonicalPath(repoRoot));
+        const task = this.workedTasks.get(worktreeId);
+        if (!task)
+            return null;
+        return (await this.dependencies.activeContexts.list(repoFingerprint)).some((pointer) => pointer.taskSlug === task && pointer.worktreeId === worktreeId)
+            ? task
+            : null;
     }
     async questionnaireResume(input) {
         const scope = await this.questionnaireScope(input.repoRoot, input.preparation);
@@ -66,18 +81,38 @@ export class BridgeService {
         if (stableStringify(scope) !== stableStringify(input.scope)) {
             throw refuse('The account or repository binding changed while the questionnaire was open.', 'session.entry');
         }
-        return await this.dependencies.questionnaires.accept(scope, input.questionnaireId, input.requestKey, input.answer, input.answerSource);
+        return await this.acceptWithScope(scope, input.questionnaireId, input.requestKey, input.answer, input.answerSource);
+    }
+    async acceptWithScope(scope, questionnaireId, requestKey, answer, answerSource) {
+        return this.dependencies.questionnaires.accept(scope, questionnaireId, requestKey, answer, answerSource);
+    }
+    retryHint(record, repoRoot, attemptOffset = 0) {
+        if (!record.owner || record.owner.tool === 'questionnaire.ask')
+            return undefined;
+        const attempt = (record.owner.decisionAttempt ?? 0) + attemptOffset;
+        return {
+            tool: record.owner.tool,
+            arguments: {
+                ...record.owner.retryArguments,
+                repoRoot,
+                ...(record.owner.externalTaskId ? { externalTaskId: record.owner.externalTaskId } : {}),
+                ...(attempt > 0 ? { decisionAttempt: attempt } : {}),
+            },
+        };
     }
     async questionnaireAnswerFromHost(input) {
-        const record = await this.questionnaireResume(input);
+        const scope = await this.questionnaireScope(input.repoRoot, input.preparation);
+        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');
         if (record.requestKey !== input.requestKey || record.contentHash !== input.contentHash) {
             throw refuse('The host answer belongs to a different question or content. Read the original with questionnaire.resume; do not reuse this answer for a changed decision.', 'questionnaire.resume');
         }
-        return this.questionnaireAccept({
-            ...input,
-            scope: record.scope,
-            answerSource: { kind: 'host_native_relay', hostTool: input.hostTool },
-        });
+        const resolved = await this.acceptWithScope(scope, input.questionnaireId, input.requestKey, (input.answer ?? input.answers), { kind: 'host_native_relay', hostTool: input.hostTool });
+        return {
+            ...resolved,
+            retry: this.retryHint(resolved.record, input.repoRoot ?? process.cwd()),
+        };
     }
     async questionnaireScope(repoRoot, preparation = false) {
         await this.dependencies.principalState?.ensure();
@@ -99,7 +134,7 @@ export class BridgeService {
         }
         let repository;
         try {
-            repository = await this.dependencies.repositories.resolve(lookup);
+            repository = await this.dependencies.repositories.resolveIdentity(lookup);
         }
         catch (error) {
             if (!preparation ||
@@ -128,18 +163,64 @@ export class BridgeService {
             projectId: preparation ? null : repository.projectId,
         };
     }
-    async pendingQuestionnaires(repoRoot) {
+    async questionnaireOverview(repoRoot, currentExternalTaskId, liveTaskSlugs = new Set()) {
         const scope = await this.questionnaireScope(repoRoot);
-        return (await this.dependencies.questionnaires.pending(scope)).map((record) => ({
-            questionnaireId: record.questionnaireId,
-            message: record.message,
-            options: record.options,
-            allowFreeText: record.allowFreeText,
-            ...(record.textField ? { textField: record.textField } : {}),
-            createdAt: record.createdAt,
-            status: record.status,
-            nextAction: 'Call questionnaire.resume with this questionnaireId. No answer, elapsed time, dismissal or interruption is consent. If the user explicitly cancels this decision, call questionnaire.withdraw. Unrelated pending decisions never block independently authorized work.',
+        const records = await this.dependencies.questionnaires.list(scope);
+        const mine = [];
+        const other = [];
+        for (const record of records.filter((item) => item.status === 'pending')) {
+            const ownerTask = record.owner?.externalTaskId;
+            if (!ownerTask || ownerTask === currentExternalTaskId)
+                mine.push(asJsonValue({
+                    questionnaireId: record.questionnaireId,
+                    message: record.message,
+                    ...(record.questions
+                        ? {
+                            questions: record.questions,
+                            ...(record.terminalChoices ? { terminalChoices: record.terminalChoices } : {}),
+                        }
+                        : {
+                            options: record.options,
+                            allowFreeText: record.allowFreeText,
+                            ...(record.textField ? { textField: record.textField } : {}),
+                        }),
+                    createdAt: record.createdAt,
+                    status: record.status,
+                    nextAction: 'Call questionnaire.resume with this questionnaireId. No answer, elapsed time, dismissal or interruption is consent. If the user explicitly cancels this decision, call questionnaire.withdraw. Unrelated pending decisions never block independently authorized work.',
+                }));
+            else
+                other.push(asJsonValue({
+                    questionnaireId: record.questionnaireId,
+                    ownerTask,
+                    createdAt: record.createdAt,
+                    summary: record.message.slice(0, 120),
+                    nextAction: `A pending question of task ${ownerTask}. Resume it with questionnaire.resume only in the chat working on ${ownerTask}, or once the user picks ${ownerTask} here; otherwise leave it alone.`,
+                }));
+        }
+        const latestStart = new Map();
+        for (const record of records) {
+            const task = record.owner?.tool === 'task.branch' ? record.owner.externalTaskId : undefined;
+            const current = task ? latestStart.get(task) : undefined;
+            if (task &&
+                record.status !== 'withdrawn' &&
+                (!current || (record.owner?.decisionAttempt ?? 0) >= (current.owner?.decisionAttempt ?? 0)))
+                latestStart.set(task, record);
+        }
+        const deferred = [...latestStart.entries()]
+            .filter(([task, record]) => !liveTaskSlugs.has(task) &&
+            (taskStartChoice(record)?.status === 'deferred' ||
+                (record.questionnaireId.startsWith('task-branch-fallback-') &&
+                    record.status === 'answered' &&
+                    record.answer?.choice === 'defer')))
+            .sort(([, left], [, right]) => (left.answeredAt ?? left.createdAt).localeCompare(right.answeredAt ?? right.createdAt))
+            .slice(-5)
+            .map(([externalTaskId, record]) => asJsonValue({
+            externalTaskId,
+            deferredAt: record.answeredAt ?? record.createdAt,
+            reconsider: this.retryHint(record, repoRoot, 1),
+            nextAction: `Starting ${externalTaskId} is on hold. Mention it only if the user brings that task up, and call reconsider only when they ask to start it.`,
         }));
+        return { mine, other, deferred };
     }
     deliverInBackground(taskId) {
         if (!this.deferDeliveries)
@@ -274,6 +355,10 @@ export class BridgeService {
                 poolAllocation.taskId = task.id;
                 this.poolAllocations.set(repository.repoRoot, poolAllocation);
             }
+            const replayedPointer = existingTask?.taskId === task.id ? existingTask : null;
+            const recordedBaselineDiffHash = typeof data.changeBaselineDiffHash === 'string' ? data.changeBaselineDiffHash : undefined;
+            const repairedBaseline = repairChangeBaseline(replayedPointer?.changeBaseline, recordedBaselineDiffHash, repository.git.head);
+            const replayedBaseline = repairedBaseline ?? replayedPointer?.changeBaseline;
             const pointer = {
                 repoFingerprint: repository.repoFingerprint,
                 projectId,
@@ -289,9 +374,21 @@ export class BridgeService {
                 sessionId: session.id,
                 lastSequence: numericSequence(task.lastSequence),
                 taskVersion: numericTaskVersion(task.lockVersion),
-                resumeConflicts: [],
+                resumeConflicts: [
+                    ...new Set([
+                        ...(replayedPointer?.resumeConflicts.filter((conflict) => contextRefreshConflicts.includes(conflict)) ?? []),
+                        ...(data.requiresContextRefresh === true ? ['context_refresh_required'] : []),
+                        ...(recordedBaselineDiffHash &&
+                            replayedBaseline &&
+                            replayedBaseline.diffHash !== recordedBaselineDiffHash
+                            ? ['task_change_baseline_recaptured']
+                            : []),
+                    ]),
+                ],
+                ...(repairedBaseline ? { changeBaseline: repairedBaseline } : {}),
             };
             await this.dependencies.activeContexts.save(pointer);
+            this.workedTasks.set(sha256(repository.repoRoot), input.externalTaskId);
             await this.dependencies.journal.apply({
                 eventId: checkpointId,
                 taskId: task.id,
@@ -312,9 +409,10 @@ export class BridgeService {
             await this.seedResumeSnapshot(pointer, data);
             return asJsonValue({
                 ...data,
+                checkpoint: checkpointView(checkpoint),
                 repository: publicRepository(repository),
-                localJournal: await this.dependencies.journal.load(projectId, input.externalTaskId),
-                outbox: { recoveredDeliveries, ...objectOrEmpty(outbox) },
+                localJournal: journalSummary(await this.dependencies.journal.load(projectId, input.externalTaskId)),
+                outbox: { recoveredDeliveries, ...outboxSummary(outbox) },
             });
         });
     }
@@ -328,12 +426,12 @@ export class BridgeService {
                     nextAction: entryNextAction(false, 'disabled'),
                 });
             }
-            const pendingQuestionnaires = await this.pendingQuestionnaires(repository.repoRoot);
+            const earlyPendingQuestionnaires = await this.questionnaireOverview(repository.repoRoot, input.taskSlug ?? null);
             const signedIn = (await this.dependencies.browserAuth.status()).authenticated;
-            if (!signedIn && pendingQuestionnaires.length > 0) {
+            if (!signedIn && earlyPendingQuestionnaires.mine.length > 0) {
                 return asJsonValue({
                     authenticated: false,
-                    pendingQuestionnaires,
+                    ...pendingQuestionnairesFields(earlyPendingQuestionnaires),
                     repository: publicRepository(repository),
                     nextAction: 'Resume only the pending sign-in questionnaire for this work. Signing in is still required before accessing project memory.',
                 });
@@ -357,7 +455,7 @@ export class BridgeService {
                 return asJsonValue({
                     taskChoiceRequired: true,
                     requestedTaskSlug: input.taskSlug,
-                    pendingQuestionnaires,
+                    ...pendingQuestionnairesFields(earlyPendingQuestionnaires),
                     liveTasks: live.map(describePointer),
                     repository: publicRepository(repository),
                 });
@@ -366,7 +464,7 @@ export class BridgeService {
                 return asJsonValue({
                     taskChoiceRequired: true,
                     requestedSessionId: input.sessionId,
-                    pendingQuestionnaires,
+                    ...pendingQuestionnairesFields(earlyPendingQuestionnaires),
                     liveTasks: live.map(describePointer),
                     repository: publicRepository(repository),
                 });
@@ -374,7 +472,7 @@ export class BridgeService {
             if (!pointer && live.length > 1) {
                 return asJsonValue({
                     taskChoiceRequired: true,
-                    pendingQuestionnaires,
+                    ...pendingQuestionnairesFields(earlyPendingQuestionnaires),
                     liveTasks: live.map(describePointer),
                     repository: publicRepository(repository),
                 });
@@ -382,10 +480,13 @@ export class BridgeService {
             const projectId = input.projectId ?? repository.projectId ?? pointer?.projectId;
             const taskSlug = input.taskSlug ?? pointer?.taskSlug;
             const sessionId = input.sessionId ?? pointer?.sessionId;
+            const pendingQuestionnaires = taskSlug && taskSlug !== (input.taskSlug ?? null)
+                ? await this.questionnaireOverview(repository.repoRoot, taskSlug)
+                : earlyPendingQuestionnaires;
             if (!projectId || !taskSlug || !sessionId) {
-                if (pendingQuestionnaires.length > 0) {
+                if (pendingQuestionnaires.mine.length > 0) {
                     return asJsonValue({
-                        pendingQuestionnaires,
+                        ...pendingQuestionnairesFields(pendingQuestionnaires),
                         repository: publicRepository(repository),
                         nextAction: 'Resume only the pending questionnaire for this work. Unrelated pending questions never block a separate task; continue independently authorized work.',
                     });
@@ -405,7 +506,17 @@ export class BridgeService {
                 this.dependencies.worktreePool
                 ? await this.dependencies.worktreePool.find(projectId, taskSlug, repository.repoRoot)
                 : null;
-            if (pointer && this.dependencies.worktreePool && (pointer.worktreeGeneration || adoptable)) {
+            const parked = pointer &&
+                !pointer.worktreeId &&
+                !pointer.worktreeGeneration &&
+                !pointer.closedAt &&
+                normalizeTaskMode(pointer.mode) !== 'read_only' &&
+                typeof pointer.branch === 'string' &&
+                (await this.dependencies.repositories.git.currentBranch(repository.repoRoot)) !==
+                    pointer.branch;
+            if (pointer &&
+                this.dependencies.worktreePool &&
+                (pointer.worktreeGeneration || adoptable || parked)) {
                 const pool = this.dependencies.worktreePool;
                 const previous = adoptable ?? (await pool.find(projectId, taskSlug, repository.repoRoot));
                 if (previous && previous.repoRoot !== repository.repoRoot)
@@ -416,10 +527,14 @@ export class BridgeService {
                         sessionId,
                         nextAction: 'Call session.resume from this returned repoRoot and use it for every subsequent command.',
                     });
-                const sourceCommit = previous?.baseCommit ?? pointer.source?.sourceCommit;
                 const branch = pointer.worktreeGeneration
                     ? pointer.branch
                     : (previous?.branch ?? pointer.branch);
+                const sourceCommit = previous?.baseCommit ??
+                    pointer.source?.sourceCommit ??
+                    (parked && branch
+                        ? (await this.dependencies.repositories.git.sourceIdentity(repository.repoRoot, 'refs/heads/' + branch))?.sourceCommit
+                        : undefined);
                 if ((!sourceCommit && !(previous && previous.baseCommit === null && !previous.managed)) ||
                     branch === undefined)
                     throw refuse('The task branch and base must be restored before resuming its worktree.', 'worktree.reconcile');
@@ -455,12 +570,13 @@ export class BridgeService {
                     });
                 await this.dependencies.gate.rebindWorktreeOwnership(repository.repoRoot, pointer.taskId, oldGeneration, allocation.generation);
             }
+            const checkout = await this.taskRepository(repository, pointer);
             if (pointer?.closeIntent) {
-                const recoveredClose = await this.retryCloseIntent(repository, pointer);
+                const recoveredClose = await this.retryCloseIntent(checkout, pointer);
                 return asJsonValue({
                     backend: { close: recoveredClose },
-                    worktree: this.poolAllocations.get(repository.repoRoot) ?? null,
-                    pendingQuestionnaires,
+                    worktree: (await this.ownedAllocation(projectId, repository.repoRoot)) ?? null,
+                    ...pendingQuestionnairesFields(pendingQuestionnaires),
                     repository: publicRepository(repository),
                     localJournal: await this.dependencies.journal.load(projectId, taskSlug),
                     synchronization: {
@@ -474,7 +590,7 @@ export class BridgeService {
             const recoveredDeliveries = await this.recoverJournalOutbox(projectId, taskSlug);
             const outbox = await this.flushOutbox(pointer?.taskId);
             const afterSequence = input.afterSequence ?? 0;
-            const source = await this.checkoutSource(repository, pointer?.source);
+            const source = await this.checkoutSource(checkout, pointer?.source, pointer ?? undefined);
             const response = await this.dependencies.client.request(endpoints.sessionResume, {
                 method: 'POST',
                 cacheKey: resumeCacheKey(sessionId, repository.repoFingerprint, afterSequence),
@@ -512,7 +628,7 @@ export class BridgeService {
             let pendingOutbox = await this.dependencies.outbox.listForTask(backendTask.id);
             const responseSource = this.dependencies.client.getResponseSource(response);
             const recoveredVerification = responseSource !== 'stale_cache' && pointer
-                ? await this.retryVerificationRecovery(repository, pointer, backend)
+                ? await this.retryVerificationRecovery(checkout, pointer, backend)
                 : null;
             if (recoveredVerification) {
                 pointer = await this.dependencies.activeContexts.loadForTask(repository.repoFingerprint, pointer.taskId);
@@ -576,6 +692,11 @@ export class BridgeService {
                 ? await this.dependencies.journal.readDocuments(projectId, taskSlug)
                 : {};
             const conflicts = resumeConflicts(backend, backendTask, pointer, localJournal, localDocuments, pendingOutbox, responseSource);
+            if (backend.requiresContextRefresh === true)
+                conflicts.push('context_refresh_required');
+            if (pointer?.resumeConflicts.includes('approved_memory_revision_requires_refresh'))
+                conflicts.push('approved_memory_revision_requires_refresh');
+            const contextRefreshRequired = conflicts.some((conflict) => contextRefreshConflicts.includes(conflict));
             const resumedLease = objectValue(backend.activeLease);
             const resumeIdentityMatches = pointer !== null &&
                 pointer.repoFingerprint === repository.repoFingerprint &&
@@ -607,11 +728,12 @@ export class BridgeService {
             const resumedTaskVersion = responseSource === 'stale_cache' && pointer
                 ? Math.max(pointer.taskVersion, numericTaskVersion(backendTask.lockVersion))
                 : numericTaskVersion(backendTask.lockVersion);
-            const hasBlockingConflict = conflicts.some((conflict) => !isOfflineDevelopmentWarning(conflict));
+            const hasBlockingConflict = conflicts.some((conflict) => !isOfflineDevelopmentWarning(conflict) && !contextRefreshConflicts.includes(conflict));
             if (pointer && (!resumeIdentityMatches || hasBlockingConflict)) {
                 await this.dependencies.activeContexts.save({ ...pointer, resumeConflicts: conflicts });
             }
             else {
+                this.workedTasks.set(sha256(repository.repoRoot), taskSlug);
                 await this.dependencies.activeContexts.save({
                     repoFingerprint: repository.repoFingerprint,
                     projectId,
@@ -637,22 +759,33 @@ export class BridgeService {
                         ? { verificationIntent: pointer.verificationIntent }
                         : {}),
                     ...(pointer?.closeIntent ? { closeIntent: pointer.closeIntent } : {}),
+                    ...(backendTask.status === 'closed'
+                        ? { closedAt: pointer?.closedAt ?? new Date().toISOString() }
+                        : {}),
                 });
             }
+            const backendFresh = responseSource !== 'stale_cache';
             return asJsonValue({
-                backend,
+                backend: resumeBackendView(backend, backendFresh || !localJournal.projection),
+                requirements: backend.requirements ?? null,
+                ...(contextRefreshRequired
+                    ? {
+                        staleReason: backend.staleReason ?? null,
+                        nextAction: contextRefreshAction(backend.staleReason, resumedBaseline),
+                    }
+                    : {}),
                 repository: publicRepository(repository),
-                worktree: this.poolAllocations.get(repository.repoRoot) ?? null,
-                localJournal,
-                pendingQuestionnaires,
+                worktree: (await this.ownedAllocation(projectId, repository.repoRoot)) ?? null,
+                localJournal: backendFresh ? journalSummary(localJournal) : localJournal,
+                ...pendingQuestionnairesFields(pendingQuestionnaires),
                 synchronization: {
                     backendSource: responseSource,
-                    backendFresh: responseSource !== 'stale_cache',
+                    backendFresh,
                     hydratedFromBackend,
                     mergedFromBackend,
                     blockedJournalEventIds,
                     recoveredDeliveries,
-                    outbox,
+                    outbox: outboxSummary(outbox),
                     pendingOutboxCount: pendingOutbox.length,
                     pendingOutbox: pendingOutbox.map((entry) => ({
                         id: entry.id,
@@ -670,6 +803,15 @@ export class BridgeService {
                         (conflicts.length === 0 || offlineDevelopmentAllowed),
                     offlineDevelopmentOnly: offlineDevelopmentAllowed,
                     recoveredVerification,
+                    ...(checkout.git.baseCommit
+                        ? {
+                            taskWorkCommitted: {
+                                baseCommit: checkout.git.baseCommit,
+                                headCommit: checkout.git.head,
+                                branch: pointer?.branch ?? null,
+                            },
+                        }
+                        : {}),
                 },
             });
         });
@@ -720,9 +862,44 @@ export class BridgeService {
                     conflicts: [...new Set(blockingConflicts)],
                     outbox,
                     repository: publicRepository(repository),
+                    ...(blockingConflicts.some((conflict) => contextRefreshConflicts.includes(conflict))
+                        ? { nextAction: contextRefreshAction(undefined, pointer.changeBaseline) }
+                        : {}),
                 });
             }
-            const activeBaseline = pointer?.sessionId === input.sessionId ? pointer.changeBaseline : undefined;
+            let activeBaseline = pointer?.sessionId === input.sessionId ? pointer.changeBaseline : undefined;
+            if (!activeBaseline) {
+                const snapshot = objectValue((await this.dependencies.client.request(endpoints.sessionResume, {
+                    method: 'POST',
+                    cacheKey: resumeCacheKey(input.sessionId, repository.repoFingerprint, 0),
+                    allowStaleOnUnavailable: true,
+                    body: {
+                        sessionId: input.sessionId,
+                        repoFingerprint: repository.repoFingerprint,
+                        source: (await this.checkoutSource(repository, pointer.source)) ?? null,
+                        afterSequence: 0,
+                    },
+                })).data);
+                const recordedBaselineDiffHash = typeof snapshot?.changeBaselineDiffHash === 'string'
+                    ? snapshot.changeBaselineDiffHash
+                    : undefined;
+                if (recordedBaselineDiffHash) {
+                    activeBaseline = repairChangeBaseline(undefined, recordedBaselineDiffHash, repository.git.head);
+                    if (!activeBaseline) {
+                        return asJsonValue({
+                            editLeaseGranted: false,
+                            conflicts: ['task_change_baseline_recaptured'],
+                            outbox,
+                            repository: publicRepository(repository),
+                            nextAction: `This task started from baseline ${short(recordedBaselineDiffHash)}, which cannot be proved against the current commit, so a lease taken now would measure only part of the work. Say what happened and let the user decide between reopening the task and abandoning it.`,
+                        });
+                    }
+                    await this.dependencies.activeContexts.save({
+                        ...pointer,
+                        changeBaseline: activeBaseline,
+                    });
+                }
+            }
             const changedPaths = normalizeChangedPaths([
                 ...(activeBaseline?.leasePaths ?? []),
                 ...input.changedPaths,
@@ -741,7 +918,7 @@ export class BridgeService {
                 transitionTaskVersion = refreshed.taskVersion;
             }
             if (decision && this.dependencies.worktreePool) {
-                const allocation = this.poolAllocations.get(repository.repoRoot);
+                const allocation = await this.ownedAllocation(pointer.projectId, repository.repoRoot);
                 if (!allocation || allocation.externalTaskId !== pointer.taskSlug)
                     throw refuse('Choose this task branch and use its allocated repoRoot before transitioning to write.', 'task.branch');
                 await this.dependencies.worktreePool.assertOwnership(pointer.projectId, repository.repoRoot, allocation.generation);
@@ -750,7 +927,7 @@ export class BridgeService {
                 sessionId: input.sessionId,
                 changedPaths,
                 baselineDiffHash,
-                source: await this.checkoutSource(repository, pointer?.source),
+                source: await this.checkoutSource(await this.taskRepository(repository, pointer), pointer.source, pointer),
                 ...(decision ? { branch: decision.branch } : {}),
                 ...(input.transitionToWrite
                     ? { transitionToWrite: true, expectedTaskVersion: transitionTaskVersion }
@@ -802,16 +979,14 @@ export class BridgeService {
                     await this.dependencies.repositories.git
                         .branchStore(repository.repoRoot)
                         .bind(preparedPointer.projectId, preparedPointer.taskSlug, preparedPointer.taskId);
+                    const allocation = await this.ownedAllocation(preparedPointer.projectId, repository.repoRoot);
                     await this.dependencies.activeContexts.save({
                         ...preparedPointer,
                         worktreeId: sha256(repository.repoRoot),
                         branch: typeof preparedTask?.branch === 'string' ? preparedTask.branch : decision.branch,
                         mode: 'write',
-                        ...(this.poolAllocations.get(repository.repoRoot)
-                            ? { worktreeGeneration: this.poolAllocations.get(repository.repoRoot).generation }
-                            : {}),
+                        ...(allocation ? { worktreeGeneration: allocation.generation } : {}),
                     });
-                    const allocation = this.poolAllocations.get(repository.repoRoot);
                     if (allocation && this.dependencies.worktreePool) {
                         await this.dependencies.worktreePool.bind(preparedPointer.projectId, repository.repoRoot, allocation.generation, preparedPointer.taskId);
                         allocation.taskId = preparedPointer.taskId;
@@ -964,13 +1139,14 @@ export class BridgeService {
             if (pointer && repository && pointer.mode !== 'read_only')
                 await this.assertPoolPointer(repository, pointer);
             const source = repository
-                ? await this.checkoutSource(repository, pointer?.source)
+                ? await this.checkoutSource(await this.taskRepository(repository, pointer), pointer?.source, pointer ?? undefined)
                 : undefined;
             const response = await this.dependencies.client.request(endpoints.contextRefresh, {
                 method: 'POST',
                 body: cleanJson({ sessionId: input.sessionId, source }),
             });
-            await this.dependencies.activeContexts.clearSessionConflict(input.sessionId, 'approved_memory_revision_requires_refresh');
+            for (const conflict of contextRefreshConflicts)
+                await this.dependencies.activeContexts.clearSessionConflict(input.sessionId, conflict);
             return asJsonValue({
                 ...objectOrEmpty(response.data),
                 requiresPrepareChange: true,
@@ -986,7 +1162,9 @@ export class BridgeService {
                 cacheKey: sha256(`memory.query\n${stableStringify(body)}`),
                 allowStaleOnUnavailable: true,
             });
-            return asJsonValue({ resources: response.data });
+            return Array.isArray(response.data)
+                ? asJsonValue({ resources: response.data })
+                : response.data;
         });
     }
     async memoryHistory(input) {
@@ -994,15 +1172,31 @@ export class BridgeService {
             const body = cleanJson({
                 sessionId: input.sessionId,
                 resourceKeys: input.resourceKeys,
+                resourceIds: input.resourceIds,
                 paths: input.paths,
+                required: input.required,
                 depth: input.depth,
             });
-            const response = await this.dependencies.client.request(endpoints.memoryHistory, {
-                method: 'POST',
-                body,
-            });
+            let response;
+            try {
+                response = await this.dependencies.client.request(endpoints.memoryHistory, {
+                    method: 'POST',
+                    body,
+                });
+            }
+            catch (error) {
+                if (backendRejectsField(error, ['required', 'resourceIds']))
+                    throw refuse('This Engineering Memory server is older than this client and does not accept required or resourceIds in memory.history yet. Call memory.history with the resourceKeys or paths of the records this change touches.', 'memory.history');
+                throw error;
+            }
+            const data = objectValue(response.data);
             const relatedBranches = await this.branchTaskReferences(input.repoRoot ?? process.cwd(), input.paths ?? []);
-            return asJsonValue({ history: response.data, relatedBranches });
+            return asJsonValue({
+                history: Array.isArray(response.data) ? response.data : (data?.histories ?? []),
+                uncoveredPaths: data?.uncoveredPaths ?? [],
+                historyReadsRequired: data?.historyReadsRequired ?? [],
+                relatedBranches,
+            });
         });
     }
     async branchTaskReferences(repoRoot, paths) {
@@ -1343,7 +1537,7 @@ export class BridgeService {
     async memoryListProposals(input) {
         return await this.execute(async () => {
             const response = await this.dependencies.client.request(endpoints.memoryListProposals, { method: 'POST', body: cleanJson(input) });
-            return asJsonValue({ proposals: response.data });
+            return asJsonValue(response.data);
         });
     }
     async memoryReviewProposal(input) {
@@ -1418,16 +1612,25 @@ export class BridgeService {
         }
         return [...pending];
     }
+    ruleDeviationQuestions(input) {
+        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)),
+        })));
+    }
     async taskSelfReview(input) {
         return await this.execute(async () => {
-            const findings = normalizePersistentInput(input.findings, input.repoRoot ?? process.cwd());
-            assertSafeToPersist(cleanJson({ findings }));
-            const repository = await this.dependencies.repositories.resolve(input.repoRoot ?? process.cwd());
+            const files = await this.approvedDeviations(input);
+            assertSafeToPersist(cleanJson({ files }));
+            const checkout = await this.dependencies.repositories.resolve(input.repoRoot ?? process.cwd());
+            const repository = await this.taskRepository(checkout, await this.dependencies.activeContexts.loadForTask(checkout.repoFingerprint, input.taskId));
             if (this.deferDeliveries) {
                 return this.enqueueTaskReceipt('task.self_review', endpoints.taskSelfReview, input.taskId, repository.repoRoot, cleanJson({
                     diffHash: repository.git.diffHash,
-                    reviewedResourceIds: [...new Set(input.reviewedResourceIds)],
-                    findings,
+                    files,
                 }));
             }
             const snapshot = await this.activeTaskSnapshot(input.taskId, undefined, input.repoRoot);
@@ -1437,20 +1640,50 @@ export class BridgeService {
                     taskId: input.taskId,
                     expectedTaskVersion: snapshot.taskVersion,
                     diffHash: repository.git.diffHash,
-                    reviewedResourceIds: input.reviewedResourceIds,
-                    findings,
+                    files,
                 }),
             });
             await this.captureTaskSnapshot(asJsonValue({ task: response.data }));
             return asJsonValue({
                 selfReview: {
                     diffHash: repository.git.diffHash,
-                    reviewedResourceIds: input.reviewedResourceIds,
-                    findings: findings.length,
+                    files: files.map(({ path, rules }) => ({
+                        path,
+                        rules: rules.map(({ resourceId, outcome }) => ({ resourceId, outcome })),
+                    })),
                 },
             });
         });
     }
+    async approvedDeviations(input) {
+        const files = reviewedFiles(input);
+        if (!files.some(({ rules }) => rules.some(isDeviation)))
+            return files;
+        const scope = await this.questionnaireScope(input.repoRoot);
+        return await Promise.all(files.map(async ({ path, rules }) => ({
+            path,
+            rules: await Promise.all(rules.map(async (rule) => {
+                if (!isDeviation(rule))
+                    return rule;
+                const questionnaireId = ruleDeviationQuestionnaireId(input.taskId, path, rule);
+                const question = await this.dependencies.questionnaires.get(scope, questionnaireId);
+                const choice = question?.status === 'answered' ? question.answer?.choice : undefined;
+                if (choice === 'change')
+                    throw refuse(`The user chose to change ${path} so it follows ${rule.resourceKey}. Change the code, then record task.self_review again with that rule as fixed.`, 'task.self_review');
+                if (choice !== 'approve' || !question?.answeredAt)
+                    throw refuse(`The user has not answered whether ${path} may keep deviating from ${rule.resourceKey}. Call the task.self_review tool so it asks the rule-deviation question natively, then retry.`, 'task.self_review');
+                return {
+                    ...rule,
+                    questionnaireId,
+                    deviationApproval: {
+                        questionnaireId,
+                        answeredAt: question.answeredAt,
+                        hostTool: question.answerSource?.hostTool ?? null,
+                    },
+                };
+            })),
+        })));
+    }
     async taskReconcile(input) {
         return await this.execute(async () => {
             const repoRoot = input.repoRoot ?? process.cwd();
@@ -1569,7 +1802,7 @@ export class BridgeService {
                 method: 'POST',
                 body: cleanJson({
                     sessionId: pointer.sessionId,
-                    source: await this.checkoutSource(repository, pointer.source),
+                    source: await this.checkoutSource(await this.taskRepository(repository, pointer), pointer.source, pointer),
                 }),
             });
             const refreshData = objectValue(refreshed.data);
@@ -1594,13 +1827,18 @@ export class BridgeService {
     }
     async taskVerify(input) {
         return await this.execute(async () => {
+            const timer = startPhaseTimer('task.verify');
             return await this.taskExclusive(input.taskId, async () => {
                 await this.recoverJournalOutbox();
+                timer.mark('recover_journal_outbox');
                 const outbox = await this.flushOutbox(input.taskId);
+                timer.mark('flush_outbox');
                 const pendingOutboxCount = (await this.dependencies.outbox.listForTask(input.taskId))
                     .length;
-                const repository = await this.dependencies.repositories.resolve(input.repoRoot ?? process.cwd());
+                let repository = await this.dependencies.repositories.resolve(input.repoRoot ?? process.cwd());
+                timer.mark('resolve_repository');
                 if (pendingOutboxCount > 0) {
+                    timer.finish();
                     return asJsonValue({
                         verified: false,
                         reason: 'pending_outbox',
@@ -1610,6 +1848,7 @@ export class BridgeService {
                     });
                 }
                 const pointer = await this.requireActivePointer(repository.repoFingerprint, input.taskId, false, 'verify');
+                repository = await this.taskRepository(repository, pointer);
                 const pendingCorrectionScopes = await this.pendingCorrectionScopes(pointer.projectId, pointer.taskSlug);
                 if (pendingCorrectionScopes.length > 0) {
                     return asJsonValue({
@@ -1642,7 +1881,7 @@ export class BridgeService {
                     body: {
                         sessionId: input.sessionId,
                         repoFingerprint: repository.repoFingerprint,
-                        source: (await this.checkoutSource(repository, pointer.source)) ?? null,
+                        source: (await this.checkoutSource(repository, pointer.source, pointer)) ?? null,
                         afterSequence: 0,
                     },
                 });
@@ -1663,6 +1902,10 @@ export class BridgeService {
                 await this.assertTaskWorktree(repository, snapshotTask, pointer);
                 const resourceDiscoveryPolicy = readResourceDiscoveryPolicy(snapshot, activeLease);
                 const validations = normalizePersistentInput(input.validations, repository.repoRoot);
+                const waivers = normalizePersistentInput(input.waivers ?? [], repository.repoRoot);
+                if (snapshot?.requiresContextRefresh === true) {
+                    throw refuse(contextRefreshAction(snapshot.staleReason, pointer.changeBaseline), 'context.refresh');
+                }
                 if (taskMode === 'read_only') {
                     if (input.leaseId || input.changedPaths?.length) {
                         throw refuse('This task is read-only, so it has no lease and no changed paths to report.', 'task.verify');
@@ -1670,48 +1913,114 @@ export class BridgeService {
                 }
                 else {
                     const baseline = pointer.changeBaseline;
-                    const leaseChangedPaths = Array.isArray(activeLease?.changedPaths)
-                        ? activeLease.changedPaths.filter((path) => typeof path === 'string')
-                        : [];
                     if (!baseline) {
                         throw refuse('This task has no local change baseline, so what it changed cannot be measured. The baseline is restored from the task record.', 'session.resume');
                     }
-                    if (activeLease?.baselineDiffHash !== baseline.diffHash) {
-                        throw refuse(`The active lease was taken against baseline ${short(activeLease?.baselineDiffHash)} but this task started from ${short(baseline.diffHash)}, so the lease must be taken again against the task's own baseline.`, 'context.prepare_change');
+                    if (!activeLease) {
+                        throw refuse(`There is no active lease (the last one was consumed or expired). Call context.prepare_change for ${baseline.leasePaths.join(', ') || 'the paths this task changes'}; the task baseline stays ${short(baseline.diffHash)}.`, 'context.prepare_change');
                     }
-                    const wholeTreeDelta = manifestDelta(baseline.changedPaths, repository.git.changedPaths);
-                    const leased = new Set(normalizeChangedPaths([...baseline.leasePaths, ...leaseChangedPaths]));
-                    taskChanges = wholeTreeDelta.filter((entry) => leased.has(normalizeChangedPaths([entry.path])[0]));
-                    foreignChangedPaths = wholeTreeDelta
-                        .filter((entry) => !leased.has(normalizeChangedPaths([entry.path])[0]))
+                    if (activeLease.baselineDiffHash !== baseline.diffHash) {
+                        throw refuse(`The active lease was taken against baseline ${short(activeLease.baselineDiffHash)} but this task started from ${short(baseline.diffHash)}, so the lease must be taken again against the task's own baseline.`, 'context.prepare_change');
+                    }
+                    const changeSet = taskChangeSet(baseline, activeLease, repository.git.changedPaths);
+                    taskChanges = changeSet.taskChanges;
+                    foreignChangedPaths = changeSet.wholeTreeDelta
+                        .filter((entry) => !changeSet.leased.has(normalizeChangedPaths([entry.path])[0]))
                         .map((entry) => entry.path)
                         .sort();
                     taskChangedPaths = taskChanges.map((entry) => entry.path).sort();
-                    if (input.changedPaths &&
-                        stableStringify(normalizeChangedPaths(input.changedPaths)) !==
-                            stableStringify(taskChangedPaths)) {
-                        throw refuse(`Reported changed paths do not match the actual Git manifest. ${describePathDisagreement(normalizeChangedPaths(input.changedPaths), taskChangedPaths)} The manifest is the difference between the tree this task started from and the tree now; report exactly what it says. A manifest that looks short means the baseline has moved, and resuming repairs it.`, 'session.resume');
+                    const reported = input.changedPaths
+                        ? normalizeChangedPaths(input.changedPaths)
+                        : taskChangedPaths;
+                    const treePaths = new Set(normalizeChangedPaths(changeSet.wholeTreeDelta.map((entry) => entry.path)));
+                    const outsideLease = [
+                        ...new Set([
+                            ...reported.filter((path) => treePaths.has(path) && !changeSet.leased.has(path)),
+                            ...taskChangedPaths.filter((path) => !pathsContainAll(baseline.leasePaths, [path]) ||
+                                !pathsContainAll(changeSet.leaseChangedPaths, [path])),
+                        ]),
+                    ].sort();
+                    const notChanged = reported.filter((path) => !treePaths.has(path));
+                    const unreported = taskChangedPaths.filter((path) => !reported.includes(path));
+                    const baselineMoved = typeof snapshot?.changeBaselineDiffHash === 'string' &&
+                        snapshot.changeBaselineDiffHash !== baseline.diffHash;
+                    const pathFindings = [
+                        ...(outsideLease.length > 0
+                            ? [
+                                `These changed paths are outside the current lease: ${samplePaths(outsideLease)}. Call context.prepare_change with them; the lease expands and the task baseline stays ${short(baseline.diffHash)}.`,
+                            ]
+                            : []),
+                        ...(notChanged.length > 0
+                            ? [
+                                `These reported paths do not differ from the tree this task started from (baseline ${short(baseline.diffHash)}): ${samplePaths(notChanged)}. ${baselineMoved
+                                    ? 'The baseline has moved from the one the task recorded; resuming repairs it.'
+                                    : 'Report only the paths the manifest lists.'}`,
+                            ]
+                            : []),
+                        ...(unreported.length > 0
+                            ? [
+                                `This task changed these paths but did not report them: ${samplePaths(unreported)}. Report every path the manifest lists.`,
+                            ]
+                            : []),
+                    ];
+                    if (pathFindings.length > 0) {
+                        throw refuse(pathFindings.join(' '), outsideLease.length > 0
+                            ? 'context.prepare_change'
+                            : notChanged.length > 0 && baselineMoved
+                                ? 'session.resume'
+                                : 'task.verify', {
+                            outsideLease,
+                            notChanged,
+                            unreported,
+                            changedPathsOutsideThisTask: foreignChangedPaths,
+                        });
                     }
                     if (taskChangedPaths.length === 0) {
                         throw refuse('The manifest shows this task changed nothing. Either the work is not in the working tree, or the baseline has moved to equal it.', 'session.resume');
                     }
-                    if (!activeLease || !input.leaseId || activeLease.id !== input.leaseId) {
-                        throw refuse(`Verification needs the lease the backend currently holds. It has ${short(activeLease?.id)} and you sent ${short(input.leaseId)}.`, 'context.prepare_change');
+                    if (!input.leaseId || activeLease.id !== input.leaseId) {
+                        throw refuse(`Verification needs the lease the backend currently holds. It has ${short(activeLease.id)} and you sent ${short(input.leaseId)}.`, 'context.prepare_change');
                     }
-                    const unleased = taskChangedPaths.filter((path) => !pathsContainAll(baseline.leasePaths, [path]) ||
-                        !pathsContainAll(leaseChangedPaths, [path]));
-                    if (unleased.length > 0) {
-                        throw refuse(`These changed paths are outside the current lease: ${unleased.slice(0, 5).join(', ')}${unleased.length > 5 ? `, and ${unleased.length - 5} more` : ''}. The lease must cover every path this task changed.`, 'context.prepare_change');
-                    }
-                    assertNewResourceEvidence(taskChanges.flatMap((entry) => newMemoryResourceCandidate(entry, resourceDiscoveryPolicy)), input.newResources ?? []);
                 }
                 assertSafeToPersist(cleanJson(validations));
-                assertValidationEvidence(validations);
+                assertSafeToPersist(cleanJson(waivers));
+                const evidenceFindings = [
+                    ...(taskMode === 'read_only'
+                        ? []
+                        : newResourceEvidenceFindings(taskChanges.flatMap((entry) => newMemoryResourceCandidate(entry, resourceDiscoveryPolicy)), input.newResources ?? [])),
+                    ...validationEvidenceFindings(validations),
+                ];
+                if (evidenceFindings.length > 0) {
+                    throw refuse(evidenceFindings.length === 1
+                        ? evidenceFindings[0]
+                        : `Verification found ${evidenceFindings.length} unmet requirements: ${evidenceFindings
+                            .map((finding, index) => `(${index + 1}) ${finding}`)
+                            .join(' ')}`, 'task.verify', { findings: evidenceFindings });
+                }
+                const validationWaivers = [];
+                if (waivers.length > 0) {
+                    const paths = renderedPaths(taskChangedPaths, resourceDiscoveryPolicy);
+                    const scope = await this.questionnaireScope(repository.repoRoot);
+                    for (const waiver of waivers) {
+                        const questionnaireId = validationWaiverId(input.taskId, waiver.validationId, paths, waiver.reason);
+                        const question = await this.dependencies.questionnaires.get(scope, questionnaireId);
+                        if (question?.answer?.choice !== 'waive') {
+                            throw refuse(`The user has not agreed to skip the ${waiver.validationId} check for ${samplePaths(paths) || 'this change'} with this reason. Call task.verify with the waiver so the tool asks them, or provide the evidence.`, 'task.verify');
+                        }
+                        validationWaivers.push({
+                            validationId: waiver.validationId,
+                            questionnaireId,
+                            reason: waiver.reason,
+                            paths,
+                            answerSource: question.answerSource?.hostTool ?? 'mcp_form',
+                        });
+                    }
+                }
                 const pathChangeManifest = taskMode === 'read_only'
                     ? []
                     : await buildPathChangeManifest(repository.repoRoot, taskChanges);
                 const verifyBody = cleanJson({
-                    source: await this.checkoutSource(repository, pointer.source),
+                    source: await this.checkoutSource(repository, pointer.source, pointer),
                     taskId: input.taskId,
                     sessionId: input.sessionId,
                     expectedTaskVersion: numericTaskVersion(snapshotTask.lockVersion),
@@ -1731,6 +2040,7 @@ export class BridgeService {
                         : {}),
                     ...(taskMode === 'read_only' ? { worktreeHash: repository.git.worktreeHash } : {}),
                     validations,
+                    ...(validationWaivers.length > 0 ? { validationWaivers } : {}),
                     pendingOutboxCount,
                     newResources: input.newResources,
                     introducedStructures: input.introducedStructures,
@@ -1751,6 +2061,8 @@ export class BridgeService {
                     if (!isBackendUnavailableError(error)) {
                         await this.dependencies.activeContexts.clearVerificationIntent(repository.repoFingerprint, input.taskId);
                     }
+                    if (backendRejectsField(error, ['validationWaivers']))
+                        throw refuse('This Engineering Memory server is older than this client and cannot record a validation waiver yet, so the task cannot verify on the waiver the user gave. Provide ui evidence that exercises the changed surface and call task.verify without waivers.', 'task.verify');
                     throw error;
                 }
                 const responseData = objectValue(response.data);
@@ -1774,6 +2086,7 @@ export class BridgeService {
                 else {
                     await this.dependencies.activeContexts.clearVerificationIntent(repository.repoFingerprint, input.taskId);
                 }
+                timer.finish();
                 return asJsonValue({
                     ...objectOrEmpty(response.data),
                     mode: taskMode,
@@ -1785,11 +2098,45 @@ export class BridgeService {
             });
         });
     }
+    async validationWaiverSubject(input) {
+        return await this.execute(async () => {
+            const repository = await this.dependencies.repositories.resolve(input.repoRoot ?? process.cwd());
+            const pointer = await this.requireActivePointer(repository.repoFingerprint, input.taskId, false, 'verify');
+            if (!pointer.changeBaseline) {
+                throw refuse('This task has no local change baseline, so what it changed cannot be measured. The baseline is restored from the task record.', 'session.resume');
+            }
+            const response = await this.dependencies.client.request(endpoints.sessionResume, {
+                method: 'POST',
+                body: {
+                    sessionId: input.sessionId,
+                    repoFingerprint: repository.repoFingerprint,
+                    source: (await this.checkoutSource(repository, pointer.source)) ?? null,
+                    afterSequence: 0,
+                },
+            });
+            const snapshot = objectValue(response.data);
+            const activeLease = objectValue(snapshot?.activeLease);
+            const paths = renderedPaths(taskChangeSet(pointer.changeBaseline, activeLease, repository.git.changedPaths).taskChanges.map((entry) => entry.path), readResourceDiscoveryPolicy(snapshot, activeLease));
+            if (paths.length === 0) {
+                throw refuse(`No path this task changed renders UI, so there is no ${input.validationId} check to waive. Call task.verify without the waiver.`, 'task.verify');
+            }
+            const reason = normalizePersistentInput(input.reason, repository.repoRoot);
+            return asJsonValue({
+                taskId: input.taskId,
+                externalTaskId: pointer.taskSlug,
+                validationId: input.validationId,
+                paths,
+                reason,
+                questionnaireId: validationWaiverId(input.taskId, input.validationId, paths, reason),
+            });
+        });
+    }
     async taskClose(input) {
         return await this.execute(async () => {
             return await this.taskExclusive(input.taskId, async () => {
-                const repository = await this.dependencies.repositories.resolve(input.repoRoot ?? process.cwd());
-                const pointer = await this.requireActivePointer(repository.repoFingerprint, input.taskId, false, 'close');
+                const checkout = await this.dependencies.repositories.resolve(input.repoRoot ?? process.cwd());
+                const pointer = await this.requireActivePointer(checkout.repoFingerprint, input.taskId, false, 'close');
+                const repository = await this.taskRepository(checkout, pointer);
                 if (pointer.closeIntent) {
                     return await this.retryCloseIntent(repository, pointer);
                 }
@@ -1798,7 +2145,7 @@ export class BridgeService {
                     body: {
                         sessionId: pointer.sessionId,
                         repoFingerprint: repository.repoFingerprint,
-                        source: (await this.checkoutSource(repository, pointer.source)) ?? null,
+                        source: (await this.checkoutSource(repository, pointer.source, pointer)) ?? null,
                         afterSequence: 0,
                     },
                 });
@@ -1812,7 +2159,7 @@ export class BridgeService {
                     : [];
                 await this.assertTaskWorktree(repository, task, pointer);
                 const closeBody = {
-                    source: (await this.checkoutSource(repository, pointer.source)) ?? null,
+                    source: (await this.checkoutSource(repository, pointer.source, pointer)) ?? null,
                     taskId: input.taskId,
                     sessionId: pointer.sessionId,
                     expectedTaskVersion: numericTaskVersion(task.lockVersion),
@@ -1833,7 +2180,7 @@ export class BridgeService {
     }
     async worktreeTaskAllocation(input) {
         return this.execute(async () => {
-            const repository = await this.dependencies.repositories.resolve(input.repoRoot);
+            const repository = await this.dependencies.repositories.resolveIdentity(input.repoRoot);
             const allocation = repository.projectId && this.dependencies.worktreePool
                 ? await this.dependencies.worktreePool.find(repository.projectId, input.externalTaskId, repository.repoRoot)
                 : null;
@@ -1842,18 +2189,68 @@ export class BridgeService {
     }
     async projectGitPreferences(input) {
         return this.execute(async () => {
-            const repository = await this.dependencies.repositories.resolve(input.repoRoot ?? process.cwd(), input.projectId);
+            const repository = await this.dependencies.repositories.resolveIdentity(input.repoRoot ?? process.cwd(), input.projectId);
             if (!repository.projectId)
                 throw refuse('Bind a project before reading Git preferences.', 'project.resolve');
             const response = await this.dependencies.client.request(endpoints.projectGitPreferences(repository.projectId));
             return asJsonValue({
                 ...objectOrEmpty(objectValue(response.data)),
                 repoRoot: repository.repoRoot,
-                currentBranch: await this.dependencies.repositories.git.currentBranch(repository.repoRoot),
+                currentBranch: repository.branch,
+                currentCommit: repository.head,
+            });
+        });
+    }
+    async taskBranchPreflight(input) {
+        return this.execute(async () => {
+            const repository = await this.dependencies.repositories.resolve(input.repoRoot);
+            if (!repository.projectId)
+                throw refuse('Resolve the project before choosing its task branch.', 'project.resolve');
+            const existingAllocation = this.dependencies.worktreePool
+                ? await this.dependencies.worktreePool.find(repository.projectId, input.externalTaskId, repository.repoRoot)
+                : null;
+            if (existingAllocation)
+                return asJsonValue({ existingAllocation });
+            if (input.name && !input.keepCurrent) {
+                const unusable = await this.unusableBranchName(repository.repoRoot, input.name);
+                if (unusable)
+                    throw refuse(unusable, 'task.branch');
+            }
+            const [preferences, currentBranch, folder, suggestedName] = await Promise.all([
+                this.dependencies.client.request(endpoints.projectGitPreferences(repository.projectId)),
+                this.dependencies.repositories.git.currentBranch(repository.repoRoot),
+                this.folderState(repository, input.externalTaskId),
+                this.suggestedBranchName(repository.repoRoot, input.externalTaskId),
+            ]);
+            return asJsonValue({
+                existingAllocation: null,
+                preferences: preferences.data,
+                currentBranch,
                 currentCommit: repository.git.head,
+                folder,
+                suggestedName,
             });
         });
     }
+    async suggestedBranchName(repoRoot, externalTaskId) {
+        const candidates = suggestedBranchNames(externalTaskId);
+        for (const candidate of candidates)
+            if (!(await this.unusableBranchName(repoRoot, candidate)))
+                return candidate;
+        return candidates[0];
+    }
+    async unusableBranchName(repoRoot, name) {
+        const git = this.dependencies.repositories.git;
+        try {
+            await git.validateBranch(repoRoot, name);
+        }
+        catch {
+            return `${name} is not a valid Git branch name, so no task branch was created.`;
+        }
+        return (await git.branchExists(repoRoot, name))
+            ? `Branch ${name} already exists, so it cannot be created for a new task; nothing was created.`
+            : null;
+    }
     async setProjectGitPreferences(projectId, body) {
         return this.execute(async () => {
             assertSafeToPersist(body);
@@ -1889,18 +2286,43 @@ export class BridgeService {
     }
     async worktreeOperation(operation, input) {
         return this.execute(async () => {
-            const repository = await this.dependencies.repositories.resolve(input.repoRoot);
+            const timer = startPhaseTimer(`worktree.${operation}`);
+            const repository = await this.dependencies.repositories.resolveIdentity(input.repoRoot);
+            timer.mark('resolve_identity');
             const projectId = repository.projectId;
             const pool = this.dependencies.worktreePool;
             if (!projectId || !pool)
                 throw refuse('Resolve the project with a pool-capable client.', 'project.resolve');
             if (operation === 'list' || operation === 'reconcile') {
                 const managedRoot = await pool.managedRoot();
+                const policy = await this.poolPolicy();
+                timer.mark('policy');
+                const reconciled = await pool.reconcile(projectId, repository.repoRoot, policy);
+                timer.mark('reconcile');
+                const items = reconciled.map((item) => ({
+                    ...item,
+                    ...(item.activity === 'retired'
+                        ? {
+                            nextAction: 'worktree.reconcile with retireLegacy when the user wants the old folder removed; it is never reused.',
+                        }
+                        : item.phase === 'delivery'
+                            ? {
+                                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);
+                timer.finish();
                 return asJsonValue({
-                    items: await pool.reconcile(projectId, repository.repoRoot, await this.poolPolicy()),
-                    selected: await pool.forPath(projectId, repository.repoRoot),
+                    items,
+                    selected,
                     managedRoot,
-                    ...(managedRoot.problem || managedRoot.synced
+                    ...(managedRoot.problem || managedRoot.synced || retired
                         ? {
                             notice: [
                                 ...(managedRoot.problem ? [managedRoot.problem] : []),
@@ -1909,6 +2331,11 @@ export class BridgeService {
                                         `Managed worktrees are created under ${managedRoot.root}, which a cloud sync client watches, so every Git operation there is re-scanned and uploaded. To create new worktrees elsewhere, write {"root": "<absolute directory>"} to ${managedRoot.override}; it takes effect for the next allocation, and existing worktrees keep working where they are.`,
                                     ]
                                     : []),
+                                ...(retired
+                                    ? [
+                                        `Slots outside ${managedRoot.root} are retired: they are never reused and do not count toward the limit.`,
+                                    ]
+                                    : []),
                             ].join(' '),
                         }
                         : {}),
@@ -1936,29 +2363,96 @@ export class BridgeService {
                 await pool.releaseUnowned(projectId, repository.repoRoot, input.generation, input.sourceCommit);
                 return asJsonValue({ operation, complete: true, repoRoot: repository.repoRoot });
             }
+            if (operation === 'retire') {
+                const entry = input.worktreePath ? await pool.forPath(projectId, input.worktreePath) : null;
+                if (!entry ||
+                    entry.generation !== input.generation ||
+                    input.decisionId !== 'worktree-retire-' + sha256(entry.repoRoot + entry.generation))
+                    throw refuse('The retired folder changed after its removal was asked about. List the worktrees again.', 'worktree.list');
+                const decision = await this.questionnaireResume({
+                    repoRoot: repository.repoRoot,
+                    questionnaireId: input.decisionId,
+                });
+                if (decision.status !== 'answered' || decision.answer?.choice !== 'retire')
+                    throw refuse('A retired folder is removed only after the user approves it in the native worktree.reconcile form.', 'worktree.reconcile');
+                await pool.retire(projectId, repository.repoRoot, entry.repoRoot, entry.generation);
+                return asJsonValue({ operation, complete: true, removed: entry.repoRoot });
+            }
             const entry = await pool.forPath(projectId, repository.repoRoot);
             if (!entry ||
                 entry.externalTaskId !== input.externalTaskId ||
                 entry.generation !== input.generation)
                 throw refuse('Use the exact task, repoRoot and ownership generation returned on resume.', 'session.resume');
+            if (operation === 'pause' && input.delivered !== undefined)
+                throw refuse('task.pause keeps a task and its folder and records no delivery. After delivery, or when the user decided not to deliver, call worktree.release with deliveryOutcome delivered or cancelled.', 'worktree.release');
+            const outcome = input.deliveryOutcome ?? (input.delivered === true ? 'delivered' : undefined);
+            if (operation === 'release' && outcome === 'cancelled')
+                throw refuse('A cancelled delivery is settled through the native question that worktree.release with deliveryOutcome cancelled asks.', 'worktree.release');
             const perform = async () => {
-                if (operation === 'heartbeat')
-                    await pool.assertOwnership(projectId, repository.repoRoot, input.generation);
-                if (operation === 'pause') {
-                    await pool.pause(projectId, repository.repoRoot, input.generation);
-                    this.poolAllocations.delete(repository.repoRoot);
+                try {
+                    if (operation === 'heartbeat') {
+                        await pool.assertOwnership(projectId, repository.repoRoot, input.generation);
+                    }
+                    if (operation === 'pause') {
+                        await pool.pause(projectId, repository.repoRoot, input.generation);
+                        this.poolAllocations.delete(repository.repoRoot);
+                    }
+                    if (operation === 'release') {
+                        await this.requireDeliveredTaskWork(entry);
+                        await pool.release(projectId, repository.repoRoot, input.generation, outcome === 'delivered' ? outcome : undefined);
+                        this.poolAllocations.delete(repository.repoRoot);
+                    }
+                    if (operation === 'cancel_delivery') {
+                        if (!entry.pendingDelivery)
+                            throw refuse('This worktree is not waiting for delivery, so there is no delivery to cancel. Release it with worktree.release.', 'worktree.release');
+                        const manifest = await this.dependencies.repositories.git.manifest(repository.repoRoot);
+                        const clean = manifest.changedPaths.length === 0;
+                        if (input.decisionId !== cancelledDeliveryQuestionId(entry, clean))
+                            throw refuse('The folder changed after the question was asked. Call worktree.release with deliveryOutcome cancelled again; it asks about the folder as it is now.', 'worktree.release');
+                        const decision = await this.questionnaireResume({
+                            repoRoot: repository.repoRoot,
+                            questionnaireId: input.decisionId,
+                        });
+                        const choice = decision.answer?.choice ?? '';
+                        const choices = clean || !entry.managed ? ['release', 'keep'] : ['save_and_release', 'keep'];
+                        if (decision.status !== 'answered' || !choices.includes(choice))
+                            throw refuse('Ask the user what happens to the folder in the native worktree.release form.', 'worktree.release');
+                        if (choice !== 'keep')
+                            await this.requireDeliveredTaskWork(entry);
+                        const cancelled = await pool.cancelDelivery(projectId, repository.repoRoot, input.generation, choice);
+                        this.poolAllocations.delete(repository.repoRoot);
+                        return asJsonValue({
+                            operation,
+                            complete: true,
+                            repoRoot: repository.repoRoot,
+                            deliveryOutcome: 'cancelled',
+                            ...cancelled,
+                        });
+                    }
+                    return asJsonValue({ operation, complete: true, repoRoot: repository.repoRoot });
                 }
-                if (operation === 'release') {
-                    if (entry.taskId)
-                        await this.flushOutbox(entry.taskId);
-                    await pool.release(projectId, repository.repoRoot, input.generation, input.delivered === true);
-                    this.poolAllocations.delete(repository.repoRoot);
+                finally {
+                    timer.finish();
                 }
-                return asJsonValue({ operation, complete: true, repoRoot: repository.repoRoot });
             };
             return entry.taskId ? this.taskExclusive(entry.taskId, perform, false) : perform();
         });
     }
+    async requireDeliveredTaskWork(entry) {
+        if (!entry.taskId)
+            return;
+        await this.flushOutbox(entry.taskId);
+        if (!entry.managed)
+            return;
+        const queued = await this.dependencies.outbox.listForTask(entry.taskId);
+        if (queued.length)
+            throw refuse(`Task ${entry.externalTaskId} still has ${queued.length} record(s) in the local outbox that the backend has not accepted: ${queued
+                .map((item) => `${item.id} (${item.operation}${item.lastError ? ', ' + item.lastError : ''})`)
+                .join(', ')}. The folder was left as it is. Inspect each with task.resolve_pending_delivery and retry or discard it, then call worktree.release again.`, 'task.resolve_pending_delivery');
+        const pointer = await this.dependencies.activeContexts.loadForTask(entry.repoFingerprint, entry.taskId);
+        if (pointer?.verificationIntent || pointer?.closeIntent)
+            throw refuse(`Task ${entry.externalTaskId} has an interrupted ${pointer.closeIntent ? 'close' : 'verification'}. The folder was left as it is. Call session.resume in this folder to finish it, then call worktree.release again.`, 'session.resume');
+    }
     async pooledTaskBranch(repository, input) {
         const pool = this.dependencies.worktreePool;
         const projectId = repository.projectId;
@@ -1969,24 +2463,72 @@ export class BridgeService {
         if (existing)
             source = { sourceCommit: existing.baseCommit };
         else {
-            if (!input.decisionId || !input.base)
+            if (!input.decisionId || !input.startId || !input.base)
                 throw refuse('Choose the task base through the native task.branch questionnaire.', 'task.branch');
-            const decision = await this.questionnaireResume({
+            const start = taskStartChoice(await this.questionnaireResume({
                 repoRoot: repository.repoRoot,
-                questionnaireId: input.decisionId,
-            });
-            const signature = sha256(stableStringify({
+                questionnaireId: input.startId,
+            }));
+            const request = {
                 externalTaskId: input.externalTaskId,
                 base: input.base,
                 name: input.name ?? null,
                 keepCurrent: input.keepCurrent === true,
                 ...(input.decisionAttempt ? { decisionAttempt: input.decisionAttempt } : {}),
-            }));
-            if (!['task-branch-confirm-' + signature, 'task-branch-fallback-' + signature].includes(decision.questionnaireId) ||
-                decision.answer?.choice !== 'approve')
-                throw refuse('The task branch decision does not match the approved source and branch.', 'task.branch');
+            };
+            const started = start?.status === 'start' &&
+                start.externalTaskId === request.externalTaskId &&
+                start.decisionAttempt === input.decisionAttempt &&
+                start.name === request.name &&
+                start.keepCurrent === request.keepCurrent &&
+                start.inPlace === (input.inPlace === true)
+                ? start
+                : null;
+            let approved = false;
+            if (started && input.decisionId === input.startId)
+                approved = stableStringify(started.base) === stableStringify(input.base);
+            else if (started &&
+                input.decisionId ===
+                    'task-branch-fallback-' +
+                        sha256(stableStringify({ ...request, inPlace: input.inPlace === true }))) {
+                const fallback = await this.questionnaireResume({
+                    repoRoot: repository.repoRoot,
+                    questionnaireId: input.decisionId,
+                });
+                approved = fallback.status === 'answered' && fallback.answer?.choice === 'approve';
+            }
+            if (!approved)
+                throw refuse('The task branch decision does not match the approved source, branch and location.', 'task.branch');
+            const holder = input.inPlace
+                ? await this.folderHolder(repository, input.externalTaskId)
+                : null;
             source = await resolveTaskBase(git, repository.repoRoot, input.base, preferences);
+            if (holder && input.inPlace) {
+                if (holder.managed || holder.running || !sameHolder(holder, started.holder))
+                    throw refuse(`This folder is held by task ${holder.externalTaskId}. Call task.branch again: its start form asks whether ${holder.externalTaskId} should move out of this folder before the new branch starts here, or opens the new task in a separate worktree.`, 'task.branch');
+                if (repository.git.changedPaths.length > 0)
+                    throw refuse(`This folder has uncommitted changes, so the new branch cannot start here and ${holder.externalTaskId} stays in it. Call task.branch with a new decisionAttempt and open the task in a separate worktree.`, 'task.branch');
+                if (await git.branchExists(repository.repoRoot, input.name))
+                    throw refuse(`Branch ${input.name} already exists, so it cannot start here and ${holder.externalTaskId} stays in this folder. Call task.branch with a new decisionAttempt and choose a new branch name.`, 'task.branch');
+                if (holder.generation) {
+                    await pool.moveOut(projectId, repository.repoRoot, holder.generation, holder.oid ?? undefined);
+                    this.poolAllocations.delete(repository.repoRoot);
+                }
+                else
+                    await git.branchStore(repository.repoRoot).detach({
+                        projectId: holder.projectId,
+                        externalTaskId: holder.externalTaskId,
+                        branch: holder.branch,
+                        ...(holder.taskId ? { taskId: holder.taskId } : {}),
+                    }, holder.oid);
+                const parked = await this.dependencies.activeContexts.loadForSlug(repository.repoFingerprint, holder.externalTaskId);
+                if (parked?.worktreeId === sha256(repository.repoRoot))
+                    await this.parkPointer(parked);
+            }
         }
+        const allocationTimer = startPhaseTimer('task.branch.allocate');
+        const allocationPolicy = await this.poolPolicy(true);
+        allocationTimer.mark('policy');
         const allocation = await pool.allocate({
             projectId,
             projectName: preferences.projectName ?? projectId,
@@ -1996,8 +2538,11 @@ export class BridgeService {
             branch: existing?.branch ?? input.name ?? (await git.currentBranch(repository.repoRoot)),
             baseCommit: source.sourceCommit,
             keepCurrent: input.keepCurrent,
+            inPlace: !existing && input.inPlace,
             resume: Boolean(existing),
-        }, await this.poolPolicy(true));
+        }, allocationPolicy);
+        allocationTimer.mark('pool_allocate');
+        allocationTimer.finish();
         this.poolAllocations.set(allocation.repoRoot, allocation);
         if (existing && allocation.repoRoot === repository.repoRoot) {
             const current = await this.dependencies.activeContexts.loadForSlug(repository.repoFingerprint, input.externalTaskId);
@@ -2020,6 +2565,25 @@ export class BridgeService {
             nextAction: 'Run every file, terminal, lifecycle and delivery operation from this repoRoot. Use task.heartbeat during long work. Pause before handing the task to another client.',
         });
     }
+    adoptOwned(repoRoot, entry) {
+        const cached = this.poolAllocations.get(repoRoot);
+        if (cached)
+            return cached;
+        const pool = this.dependencies.worktreePool;
+        if (!entry || !pool || !pool.owns(entry))
+            return undefined;
+        this.poolAllocations.set(repoRoot, entry);
+        return entry;
+    }
+    async ownedAllocation(projectId, repoRoot) {
+        const cached = this.poolAllocations.get(repoRoot);
+        if (cached)
+            return cached;
+        const pool = this.dependencies.worktreePool;
+        if (!pool)
+            return undefined;
+        return this.adoptOwned(repoRoot, await pool.forPath(projectId, repoRoot));
+    }
     async assertPoolPointer(repository, pointer) {
         const pool = this.dependencies.worktreePool;
         if (!pool)
@@ -2029,7 +2593,7 @@ export class BridgeService {
             return; // existing unmanaged tasks retain their legacy reservation
         if (entry && entry.externalTaskId !== pointer.taskSlug)
             throw refuse(`This directory is allocated to task ${entry.externalTaskId}. Resume this task from its own worktree, or reconcile the pool to release the directory.`, 'worktree.reconcile');
-        const owned = this.poolAllocations.get(repository.repoRoot);
+        const owned = this.adoptOwned(repository.repoRoot, entry);
         if (!entry || !owned || owned.generation !== pointer.worktreeGeneration)
             throw refuse('Resume this task to acquire its worktree before writing or delivering.', 'session.resume');
         await pool.assertOwnership(pointer.projectId, repository.repoRoot, owned.generation);
@@ -2050,8 +2614,9 @@ export class BridgeService {
                 (await this.dependencies.worktreePool.find(repository.projectId, input.externalTaskId, repository.repoRoot)))
                 return this.pooledTaskBranch(repository, input);
             if (Boolean(input.name) === (input.keepCurrent === true) ||
-                (input.worktreePath && !input.name))
-                throw refuse('Choose exactly one branch name or keepCurrent. A separate worktree also needs a branch name.', 'task.branch');
+                (input.worktreePath && !input.name) ||
+                (input.inPlace && input.worktreePath))
+                throw refuse('Choose exactly one branch name or keepCurrent. A separate worktree also needs a branch name, and a new branch in this folder has no worktreePath.', 'task.branch');
             assertSafeToPersist(cleanJson({ externalTaskId: input.externalTaskId, name: input.name }));
             if (this.dependencies.worktreePool)
                 return this.pooledTaskBranch(repository, input);
@@ -2107,7 +2672,24 @@ export class BridgeService {
     async requireBranchDecision(repository, externalTaskId) {
         const git = this.dependencies.repositories.git;
         const store = git.branchStore(repository.repoRoot);
+        const holder = await this.folderHolder(repository, externalTaskId);
+        if (holder) {
+            const held = `This folder is held by task ${holder.externalTaskId} (branch ${holder.branch ?? 'detached HEAD'}, last activity ${holder.lastCheckpointAt ?? 'unknown'})`;
+            throw refuse(holder.managed
+                ? `${held}, which the worktree pool allocated here. Call task.branch for ${externalTaskId} to open it in a separate worktree, then bootstrap in the returned repoRoot.`
+                : holder.running
+                    ? `${held}, which is still running in another client. Pause it there with task.pause, or call task.branch for ${externalTaskId} to open it in a separate worktree; once ${holder.externalTaskId} is paused, its start form also offers this folder. Then bootstrap in the returned repoRoot.`
+                    : holder.pendingDelivery
+                        ? `${held}, which closed but never settled its delivery. Resume ${holder.externalTaskId} here and call worktree.release with deliveryOutcome delivered or cancelled to settle it, or call task.branch for ${externalTaskId} to open it in a separate worktree instead. Then bootstrap in the returned repoRoot.`
+                        : !holder.checkoutClean
+                            ? `${held}, which is not known to be finished. This folder has uncommitted changes, so call task.branch for ${externalTaskId} to open it in a separate worktree, then bootstrap in the returned repoRoot.`
+                            : `${held}, which is not known to be finished. Call task.branch for ${externalTaskId}: its start form offers a new branch in this folder with ${holder.externalTaskId} moved out, or a separate worktree. Then bootstrap in the returned repoRoot.`, 'task.branch');
+        }
         let record = await store.read();
+        if (record &&
+            (record.decision.projectId !== repository.projectId ||
+                record.decision.externalTaskId !== externalTaskId))
+            record = null;
         if (!record) {
             const pointer = await this.dependencies.activeContexts.loadForSlug(repository.repoFingerprint, externalTaskId);
             if (pointer?.worktreeId === sha256(repository.repoRoot) &&
@@ -2123,15 +2705,102 @@ export class BridgeService {
             }
         }
         if (!record)
-            throw refuse(`Ask the branch question through the native questionnaire for task ${externalTaskId}, then call task.branch with that externalTaskId and a name or keepCurrent. The managed pool allocates the separate worktree; use its returned repoRoot.`, 'task.branch');
-        if (record.decision.projectId !== repository.projectId ||
-            record.decision.externalTaskId !== externalTaskId)
-            throw refuse(`This worktree belongs to task ${record.decision.externalTaskId}. Use task.branch to allocate a separate worktree for ${externalTaskId}, then bootstrap in the returned repoRoot.`, 'task.branch');
+            throw refuse(`No branch was chosen for task ${externalTaskId}. Call task.branch with that externalTaskId: its one form asks where the task works, which branch it starts from and the branch name. Use its returned repoRoot.`, 'task.branch');
         const branch = await git.currentBranch(repository.repoRoot);
         if (branch !== record.decision.branch)
             throw refuse(`Task ${externalTaskId} selected ${record.decision.branch ?? 'detached HEAD'}, but this worktree is on ${branch ?? 'detached HEAD'}. Return to the selected branch with task.branch.`, 'task.branch');
         return record.decision;
     }
+    async folderHolder(repository, externalTaskId) {
+        const pool = this.dependencies.worktreePool;
+        const store = this.dependencies.repositories.git.branchStore(repository.repoRoot);
+        const record = await store.read();
+        const found = pool && repository.projectId
+            ? await pool.forPath(repository.projectId, repository.repoRoot)
+            : null;
+        const entry = found && found.phase !== 'released' && found.externalTaskId !== externalTaskId ? found : null;
+        const decision = record &&
+            (record.decision.projectId !== repository.projectId ||
+                record.decision.externalTaskId !== externalTaskId)
+            ? record.decision
+            : null;
+        if (!entry && !decision)
+            return null;
+        const slug = entry?.externalTaskId ?? decision.externalTaskId;
+        const taskId = entry ? entry.taskId : decision.taskId;
+        const running = entry ? await pool.ownedElsewhere(entry) : false;
+        const pointer = await this.dependencies.activeContexts.loadForSlug(repository.repoFingerprint, slug);
+        let status = null;
+        if (taskId && !entry?.managed) {
+            try {
+                status = objectValue((await this.dependencies.client.request(endpoints.taskStatus(taskId))).data);
+            }
+            catch {
+                status = null;
+            }
+        }
+        const pendingDelivery = entry?.pendingDelivery === true;
+        if (taskId &&
+            !entry?.managed &&
+            !running &&
+            !pendingDelivery &&
+            (status?.status === 'closed' || status?.status === 'abandoned')) {
+            if (entry) {
+                await pool.moveOut(entry.projectId, repository.repoRoot, entry.generation);
+                this.poolAllocations.delete(repository.repoRoot);
+            }
+            else
+                await store.release(taskId);
+            if (pointer?.worktreeId === sha256(repository.repoRoot)) {
+                if (status.status === 'abandoned')
+                    await this.dependencies.activeContexts.forget(repository.repoFingerprint, pointer.taskId);
+                else
+                    await this.parkPointer({
+                        ...pointer,
+                        closedAt: pointer.closedAt ?? new Date().toISOString(),
+                    });
+            }
+            return null;
+        }
+        return {
+            projectId: entry?.projectId ?? decision.projectId,
+            externalTaskId: slug,
+            taskId: taskId ?? null,
+            branch: entry ? entry.branch : decision.branch,
+            lastCheckpointAt: typeof status?.updatedAt === 'string' ? status.updatedAt : (pointer?.updatedAt ?? null),
+            checkoutClean: repository.git.changedPaths.length === 0,
+            oid: record && decision?.externalTaskId === slug ? record.oid : null,
+            generation: entry && !entry.managed ? entry.generation : null,
+            managed: entry?.managed === true,
+            running,
+            pendingDelivery,
+        };
+    }
+    async parkPointer(pointer) {
+        const { worktreeId: _worktreeId, worktreeGeneration: _generation, ...parked } = pointer;
+        await this.dependencies.activeContexts.save(parked);
+    }
+    async worktreeFolder(input) {
+        return this.execute(async () => {
+            const repository = await this.dependencies.repositories.resolve(input.repoRoot);
+            if (!repository.projectId)
+                throw refuse('Resolve the project before choosing its task branch.', 'project.resolve');
+            return asJsonValue(await this.folderState(repository, input.externalTaskId));
+        });
+    }
+    async folderState(repository, externalTaskId) {
+        const holder = await this.folderHolder(repository, externalTaskId);
+        const entry = this.dependencies.worktreePool
+            ? await this.dependencies.worktreePool.forPath(repository.projectId, repository.repoRoot)
+            : null;
+        return {
+            managed: entry?.managed === true,
+            heldBy: holder && (holder.managed || holder.running) ? holder.externalTaskId : null,
+            clean: repository.git.changedPaths.length === 0,
+            deliveryPending: entry?.externalTaskId === externalTaskId && entry.pendingDelivery === true,
+            holder: holder && !holder.managed && !holder.running ? holder : null,
+        };
+    }
     async assertTaskWorktree(repository, task, pointer) {
         if (normalizeTaskMode(task.mode) === 'read_only')
             return;
@@ -2156,9 +2825,14 @@ export class BridgeService {
                 if (!abandoned || abandoned.abandoned !== true) {
                     throw refuse('The backend did not record the abandonment, so the task is still open.', 'session.resume');
                 }
-                const allocation = this.poolAllocations.get(repository.repoRoot);
+                const allocation = repository.projectId
+                    ? await this.ownedAllocation(repository.projectId, repository.repoRoot)
+                    : this.poolAllocations.get(repository.repoRoot);
                 if (allocation && this.dependencies.worktreePool) {
-                    await this.dependencies.worktreePool.pause(allocation.projectId, allocation.repoRoot, allocation.generation);
+                    if (allocation.managed)
+                        await this.dependencies.worktreePool.pause(allocation.projectId, allocation.repoRoot, allocation.generation);
+                    else
+                        await this.dependencies.worktreePool.release(allocation.projectId, allocation.repoRoot, allocation.generation);
                     this.poolAllocations.delete(repository.repoRoot);
                 }
                 else
@@ -2592,10 +3266,13 @@ export class BridgeService {
     }
     async sessionEntry(input = {}) {
         return await this.execute(async () => {
+            const timer = startPhaseTimer('session.entry');
             const authentication = await this.dependencies.browserAuth.status();
+            timer.mark('auth_status');
             let repository;
             try {
                 repository = await this.dependencies.repositories.resolve(input.repoRoot ?? process.cwd());
+                timer.mark('resolve_repository');
             }
             catch (error) {
                 const missingTarget = error.code === 'ENOENT';
@@ -2617,32 +3294,44 @@ export class BridgeService {
                 });
             }
             const decision = await this.dependencies.repositoryDecisions.load(repository.repoFingerprint);
+            timer.mark('load_decision');
             const authenticated = authentication.authenticated === true;
             const state = decision?.state === 'disabled' ? 'disabled' : repository.bindingPath ? 'bound' : 'none';
-            const client = await this.clientUpdate(authenticated);
+            const projectId = repository.projectId;
+            const livePointers = authenticated && state === 'bound'
+                ? this.dependencies.activeContexts.list(repository.repoFingerprint)
+                : Promise.resolve([]);
+            const [client, liveTasksRaw, workItems, gitPreferences, worktrees, pendingQuestionnaires] = await Promise.all([
+                this.clientUpdate(authenticated),
+                livePointers,
+                authenticated && state === 'bound' && projectId
+                    ? this.actionableWorkItems(projectId)
+                    : Promise.resolve([]),
+                authenticated && state === 'bound' && projectId && this.dependencies.worktreePool
+                    ? this.projectGitPreferences({ repoRoot: repository.repoRoot, projectId })
+                    : Promise.resolve(null),
+                authenticated && state === 'bound' && projectId && this.dependencies.worktreePool
+                    ? this.worktreeOperation('list', { repoRoot: repository.repoRoot })
+                    : Promise.resolve(null),
+                state !== 'disabled'
+                    ? Promise.all([
+                        livePointers,
+                        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: [] }),
+            ]);
+            timer.mark('independent_lookups');
+            const liveTasks = liveTasksRaw.map(describePointer);
             const shipped = objectValue(objectValue(client)?.shippedKnowledge);
             const incomplete = shipped && (shipped.failure !== null || Number(shipped.live) < Number(shipped.expected));
-            const projectId = repository.projectId;
-            const liveTasks = authenticated && state === 'bound'
-                ? (await this.dependencies.activeContexts.list(repository.repoFingerprint)).map(describePointer)
-                : [];
-            const workItems = authenticated && state === 'bound' && projectId
-                ? await this.actionableWorkItems(projectId)
-                : [];
-            const gitPreferences = authenticated && state === 'bound' && projectId && this.dependencies.worktreePool
-                ? await this.projectGitPreferences({ repoRoot: repository.repoRoot, projectId })
-                : null;
             const preferences = gitPreferences?.ok ? objectValue(gitPreferences.data) : null;
             const unansweredBranches = preferences?.canManage === true
                 ? Object.entries(objectOrEmpty(objectValue(preferences.branches)))
                     .filter(([, value]) => objectValue(value)?.answered === false)
                     .map(([role]) => role)
                 : [];
-            const worktrees = authenticated && state === 'bound' && projectId && this.dependencies.worktreePool
-                ? await this.worktreeOperation('list', { repoRoot: repository.repoRoot })
-                : null;
             const taskSelectionRequired = liveTasks.length > 0 || workItems.length > 0;
-            const pendingQuestionnaires = state !== 'disabled' ? await this.pendingQuestionnaires(repository.repoRoot) : [];
+            timer.finish();
             return asJsonValue({
                 authenticated,
                 repository: publicRepository(repository),
@@ -2657,21 +3346,24 @@ export class BridgeService {
                         gitPreferences: gitPreferences.ok ? gitPreferences.data : gitPreferences.error,
                         unansweredBranchPreferences: unansweredBranches,
                         branchPreferenceAction: unansweredBranches.length
-                            ? 'Ask only these unanswered shared branch preferences using native questionnaires and project.set_git_preferences. Other members choose only their task base.'
+                            ? 'Ask these unanswered shared branch preferences with project.set_git_preferences, which puts them all in one form. Other members choose only their own task base in task.branch.'
                             : 'Existing answers remain valid, including explicit absence. Choose the task base through task.branch when starting development.',
                     }
                     : {}),
-                ...(state !== 'disabled' ? { pendingQuestionnaires } : {}),
+                ...(state !== 'disabled' ? pendingQuestionnairesFields(pendingQuestionnaires) : {}),
+                ...(pendingQuestionnaires.deferred.length > 0
+                    ? { deferredTaskStarts: pendingQuestionnaires.deferred }
+                    : {}),
                 client,
                 ...(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.length > 0
+                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 bootstrap a separate run with the chosen workItemId. Another live task never blocks opening this one.'
+                        ? '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),
             });
         });
@@ -2730,7 +3422,7 @@ export class BridgeService {
     }
     async sessionSetDecision(input) {
         return await this.execute(async () => {
-            const repository = await this.dependencies.repositories.resolve(input.repoRoot ?? process.cwd());
+            const repository = await this.dependencies.repositories.resolveIdentity(input.repoRoot ?? process.cwd());
             if (input.decision === 'none') {
                 await this.dependencies.repositoryDecisions.clear(repository.repoFingerprint);
                 return asJsonValue({
@@ -2873,6 +3565,10 @@ export class BridgeService {
                 }
                 const taskEntries = (await this.dependencies.outbox.list()).filter((entry) => taskIdFromDeliverySafe(entry) === input.taskId);
                 const pointer = await this.resolveCheckpointPointer(input, repoRoot);
+                if (pointer.closedAt && correction)
+                    throw refuse(`Task ${pointer.taskSlug} is closed, so it takes no more corrections. Record the user's correction as a proposal for the rule it concerns with memory.propose_revision, or in the task that next changes this code.`, 'memory.propose_revision');
+                if (pointer.closedAt)
+                    throw refuse(`Task ${pointer.taskSlug} is closed, so it takes no more checkpoints. Further work belongs to a new task.`, 'session.bootstrap');
                 const blockedEntry = taskEntries.find((entry) => entry.lastError && entry.lastError !== 'backend_unavailable');
                 if (blockedEntry && blockedEntry.idempotencyKey !== idempotencyKey) {
                     throw refuse('A blocked task delivery must be explicitly resolved before checkpointing', 'task.resolve_pending_delivery');
@@ -2994,7 +3690,7 @@ export class BridgeService {
                 throw refuse('The receipt does not belong to this task project.', 'session.resume');
             if (pointer.resumeConflicts.length || pointer.verificationIntent || pointer.closeIntent)
                 throw refuse('Resume a clean active task before recording this receipt.', 'session.resume');
-            await this.checkoutSource(repository, pointer.source);
+            await this.checkoutSource(await this.taskRepository(repository, pointer), pointer.source, pointer);
             await this.recoverJournalOutbox(pointer.projectId, pointer.taskSlug);
             const entries = await this.dependencies.outbox.listForTask(taskId);
             if (entries.some((entry) => entry.lastError && entry.lastError !== 'backend_unavailable'))
@@ -3108,19 +3804,16 @@ export class BridgeService {
             });
             const backend = objectValue(response.data);
             const task = objectValue(backend?.task);
-            if (!task ||
-                task.id !== body.taskId ||
-                task.projectId !== entry.projectId ||
-                backend?.requiresContextRefresh === true)
+            if (!task || task.id !== body.taskId || task.projectId !== entry.projectId)
                 throw refuse('Refresh the matching task context before delivering this review.', 'session.resume');
+            if (backend?.requiresContextRefresh === true)
+                throw refuse('Approved memory changed what this task read, so its context must be refreshed before this review is delivered.', 'context.refresh');
             recovered = Boolean(task &&
                 task.id === body.taskId &&
                 task.lockVersion === Number(body.expectedTaskVersion) + 1 &&
                 task.selfReviewDiffHash === body.diffHash &&
-                stableStringify(asJsonValue(task.selfReviewResourceIds)) ===
-                    stableStringify(asJsonValue(body.reviewedResourceIds)) &&
-                stableStringify(asJsonValue(task.selfReviewFindings)) ===
-                    stableStringify(asJsonValue(body.findings)));
+                stableStringify(asJsonValue(task.selfReviewFiles)) ===
+                    stableStringify(asJsonValue(body.files)));
             if (recovered)
                 await this.captureTaskSnapshot(response.data);
         }
@@ -3163,13 +3856,34 @@ export class BridgeService {
         }
         return pending.length;
     }
-    async checkoutSource(repository, expected) {
+    async taskRepository(repository, pointer) {
+        const base = pointer?.source?.sourceCommit;
+        const git = this.dependencies.repositories.git;
+        if (!pointer ||
+            !base ||
+            !repository.git.head ||
+            repository.git.head === base ||
+            normalizeTaskMode(pointer.mode) === 'read_only' ||
+            !pointer.changeBaseline ||
+            typeof pointer.branch !== 'string' ||
+            (await git.currentBranch(repository.repoRoot)) !== pointer.branch ||
+            !(await git.isAncestor(repository.repoRoot, base)) ||
+            !pathsContainAll(pointer.changeBaseline.leasePaths, await git.committedPaths(repository.repoRoot, base)))
+            return repository;
+        return { ...repository, git: await git.manifestAgainst(repository.repoRoot, base) };
+    }
+    async checkoutSource(repository, expected, task) {
         const current = await this.dependencies.repositories.git.sourceIdentity(repository.repoRoot);
         if (expected &&
             (!current ||
                 current.sourceCommit !== expected.sourceCommit ||
                 current.treeHash !== expected.treeHash)) {
-            throw refuse('The checkout no longer matches this task source. Return to its commit or bootstrap a new task for the current committed source.', 'session.bootstrap');
+            if (current &&
+                repository.git.baseCommit === expected.sourceCommit &&
+                repository.git.head === current.sourceCommit)
+                return { ...expected };
+            const branch = await this.dependencies.repositories.git.currentBranch(repository.repoRoot);
+            throw refuse(`The checkout no longer matches this task source. ${task?.taskSlug ? 'Task ' + task.taskSlug : 'This task'} was opened${task?.branch ? ' on ' + task.branch : ''} at commit ${expected.sourceCommit.slice(0, 12)}; this checkout is on ${branch ?? 'detached HEAD'} at ${current?.sourceCommit.slice(0, 12) ?? 'no commit'}, which is not the task's own work committed on top of its source. Ask the user through the native questionnaire which way to go: switch this checkout back to ${task?.branch ?? 'that commit'} and continue the task, or end it with task.abandon.`, 'task.abandon');
         }
         if (current && repository.git.head !== current.sourceCommit) {
             throw refuse('The Git source changed during the request. Retry session.resume with a stable checkout.', 'session.resume');
@@ -3195,14 +3909,17 @@ export class BridgeService {
             body: {
                 sessionId: pointer.sessionId,
                 repoFingerprint: repository.repoFingerprint,
-                source: (await this.checkoutSource(repository, pointer.source)) ?? null,
+                source: (await this.checkoutSource(await this.taskRepository(repository, pointer), pointer.source, pointer)) ?? null,
                 afterSequence: 0,
             },
         });
         const backend = objectValue(response.data);
         const task = objectValue(backend?.task);
-        if (!task || task.id !== taskId || backend?.requiresContextRefresh === true) {
-            throw refuse('Backend task snapshot is stale or does not match the active task', 'session.resume');
+        if (!task || task.id !== taskId) {
+            throw refuse('Backend task snapshot does not match the active task', 'session.resume');
+        }
+        if (backend?.requiresContextRefresh === true) {
+            throw refuse(contextRefreshAction(backend.staleReason, pointer.changeBaseline), 'context.refresh');
         }
         const refreshed = {
             ...pointer,
@@ -3224,8 +3941,11 @@ export class BridgeService {
         });
         const backend = objectValue(response.data);
         const task = objectValue(backend?.task);
-        if (!task || task.id !== taskId || backend?.requiresContextRefresh === true) {
-            throw refuse('Backend task snapshot is stale or does not match the pending delivery', 'session.resume');
+        if (!task || task.id !== taskId) {
+            throw refuse('Backend task snapshot does not match the pending delivery', 'session.resume');
+        }
+        if (backend?.requiresContextRefresh === true) {
+            throw refuse(contextRefreshAction(backend.staleReason, pointer.changeBaseline), 'context.refresh');
         }
         const refreshed = {
             ...pointer,
@@ -3240,6 +3960,13 @@ export class BridgeService {
         const blockingConflicts = pointer?.resumeConflicts.filter((conflict) => !(allowOfflineWarnings && isOfflineDevelopmentWarning(conflict)));
         const lifecycleIntentBlocked = (pointer?.verificationIntent && allowedIntent !== 'verify') ||
             (pointer?.closeIntent && allowedIntent !== 'close');
+        if (pointer &&
+            pointer.taskId === taskId &&
+            !lifecycleIntentBlocked &&
+            blockingConflicts.length > 0 &&
+            blockingConflicts.every((conflict) => contextRefreshConflicts.includes(conflict))) {
+            throw refuse(contextRefreshAction(undefined, pointer.changeBaseline), 'context.refresh');
+        }
         if (!pointer ||
             pointer.taskId !== taskId ||
             (blockingConflicts?.length ?? 0) > 0 ||
@@ -3256,7 +3983,7 @@ export class BridgeService {
         }
     }
     async retryVerificationRecovery(repository, pointer, backend) {
-        await this.checkoutSource(repository, pointer.source);
+        await this.checkoutSource(repository, pointer.source, pointer);
         const intent = pointer.verificationIntent;
         const recovery = objectValue(backend?.verificationRecovery);
         if (!intent) {
@@ -3383,7 +4110,9 @@ export class BridgeService {
         return await this.deliverCloseIntent(repository, body, intent.taskChanges, true);
     }
     async deliverCloseIntent(repository, body, taskChanges, recoveredAfterResponseLoss) {
-        await this.checkoutSource(repository, sourceFromContext(body.source));
+        await this.checkoutSource(repository, sourceFromContext(body.source), {
+            branch: typeof body.branch === 'string' ? body.branch : null,
+        });
         const touchedContract = taskChanges.some((change) => /\.controller\.[tj]s$/.test(change.path));
         const currentBranch = await this.dependencies.repositories.git.currentBranch(repository.repoRoot);
         if (typeof body.branch === 'string' && body.branch !== currentBranch)
@@ -3424,7 +4153,15 @@ export class BridgeService {
             taskChanges,
         });
         await this.dependencies.activeContexts.clearCloseIntent(repository.repoFingerprint, String(body.taskId));
-        const allocation = this.poolAllocations.get(repository.repoRoot);
+        const closedPointer = await this.dependencies.activeContexts.loadForTask(repository.repoFingerprint, String(body.taskId));
+        if (closedPointer)
+            await this.dependencies.activeContexts.save({
+                ...closedPointer,
+                closedAt: new Date().toISOString(),
+            });
+        const allocation = repository.projectId
+            ? await this.ownedAllocation(repository.projectId, repository.repoRoot)
+            : this.poolAllocations.get(repository.repoRoot);
         if (allocation && this.dependencies.worktreePool)
             await this.dependencies.worktreePool.delivery(allocation.projectId, repository.repoRoot, allocation.generation);
         else
@@ -3435,7 +4172,7 @@ export class BridgeService {
             ...closedTask,
             repository: publicRepository(repository),
             recoveredAfterResponseLoss,
-            delivery: deliveryQuestion(touchedContract),
+            delivery: deliveryQuestion(touchedContract, await this.dependencies.repositories.git.pushDestination(repository.repoRoot), objectValue(closedTask.sourcePublication)?.applicable === true),
         });
     }
     async seedResumeSnapshot(pointer, backendPatch) {
@@ -3485,7 +4222,14 @@ export class BridgeService {
                 return await this.requireActivePointer(repository.repoFingerprint, input.taskId, true);
             })()
             : await this.dependencies.activeContexts.findByTaskId(input.taskId, input.projectId, false);
-        if (pointer.resumeConflicts.some((conflict) => !isOfflineDevelopmentWarning(conflict))) {
+        const blockingConflicts = pointer.resumeConflicts.filter((conflict) => !isOfflineDevelopmentWarning(conflict));
+        if (!pointer.verificationIntent &&
+            !pointer.closeIntent &&
+            blockingConflicts.length > 0 &&
+            blockingConflicts.every((conflict) => contextRefreshConflicts.includes(conflict))) {
+            throw refuse(contextRefreshAction(undefined, pointer.changeBaseline), 'context.refresh');
+        }
+        if (blockingConflicts.length > 0) {
             throw refuse('A clean active task snapshot is required for checkpointing', 'session.resume');
         }
         if (pointer.verificationIntent || pointer.closeIntent) {
@@ -3510,7 +4254,7 @@ export class BridgeService {
         try {
             const allocation = await this.dependencies.worktreePool?.forTask(taskId);
             if (allocation) {
-                const owned = this.poolAllocations.get(allocation.repoRoot);
+                const owned = this.adoptOwned(allocation.repoRoot, allocation);
                 if (!owned || owned.generation !== allocation.generation)
                     throw refuse('Resume the task in its owned worktree before this operation.', 'session.resume');
                 await this.dependencies.worktreePool.assertOwnership(allocation.projectId, allocation.repoRoot, owned.generation);
@@ -3566,6 +4310,7 @@ export class BridgeService {
                         code: error.code ?? error.httpStatus,
                         retryable: error.retryable,
                         ...(error.recovery ? { recovery: error.recovery } : {}),
+                        ...(error.envelope?.data ? { details: error.envelope.data } : {}),
                     },
                 };
             }
@@ -3576,6 +4321,9 @@ export class BridgeService {
                     message: error instanceof Error ? error.message : 'Bridge operation failed',
                     retryable: false,
                     ...(error instanceof BridgeRecoveryError ? { recovery: error.recovery } : {}),
+                    ...(error instanceof BridgeRecoveryError && error.details !== undefined
+                        ? { details: error.details }
+                        : {}),
                 },
             };
         }
@@ -3593,6 +4341,59 @@ function normalizeChangedPaths(paths) {
     }
     return [...new Set(normalized)].sort();
 }
+function reviewedFiles(input) {
+    const repoRoot = input.repoRoot ?? process.cwd();
+    const files = input.files.map(({ path, rules }) => ({
+        path: reviewedFilePath(path),
+        rules: rules.map((rule) => normalizePersistentInput(rule, repoRoot)),
+    }));
+    const repeated = files
+        .map(({ path }) => path)
+        .filter((path, index, paths) => paths.indexOf(path) !== index);
+    if (repeated.length > 0)
+        throw refuse(`The self review lists these files more than once: ${[...new Set(repeated)].join(', ')}. Record one entry per changed file with every rule that governs it.`, 'task.self_review');
+    return files;
+}
+function reviewedFilePath(path) {
+    const normalized = path.replace(/\\/g, '/').replace(/^\.\//, '');
+    if (!normalized ||
+        normalized.startsWith('/') ||
+        /^[A-Za-z]:\//.test(normalized) ||
+        normalized.split('/').includes('..'))
+        throw refuse(`Name each reviewed file by its repository-relative path, as Git reports it: ${path}`, 'task.self_review');
+    return normalized;
+}
+function isDeviation(rule) {
+    return rule.outcome === 'user_accepted_deviation';
+}
+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) {
+    const copy = ruleDeviationCopy[language];
+    return {
+        questionnaireId: ruleDeviationQuestionnaireId(taskId, path, rule),
+        message: copy.message(path, rule.resourceKey ?? rule.resourceId, rule.issue ?? ''),
+        language,
+        options: [
+            { id: 'approve', label: copy.approve },
+            { id: 'change', label: copy.change },
+        ],
+    };
+}
+const ruleDeviationCopy = {
+    en: {
+        message: (path, resourceKey, issue) => `${path} does not follow ${resourceKey}: ${issue}`,
+        approve: 'Keep the code as written and record the deviation',
+        change: 'Change the code to follow the rule',
+    },
+    tr: {
+        message: (path, resourceKey, issue) => `${path}, ${resourceKey} kuralına uymuyor: ${issue}`,
+        approve: 'Kodu olduğu gibi bırak ve bu sapmayı kaydet',
+        change: 'Kodu kurala uyacak şekilde değiştir',
+    },
+};
 function pathsContainAll(allowedPaths, actualPaths) {
     const allowed = new Set(normalizeChangedPaths(allowedPaths));
     return normalizeChangedPaths(actualPaths).every((path) => allowed.has(path));
@@ -3673,6 +4474,12 @@ async function buildPathChangeManifest(repoRoot, changes) {
         });
     }));
 }
+function pendingQuestionnairesFields(value) {
+    return {
+        pendingQuestionnaires: value.mine,
+        ...(value.other.length > 0 ? { otherTasksPendingQuestionnaires: value.other } : {}),
+    };
+}
 function describePointer(pointer) {
     return asJsonValue({
         taskSlug: pointer.taskSlug,
@@ -3719,26 +4526,42 @@ function entryNextAction(authenticated, decision) {
         return 'Ask the user to sign in before answering anything about this project, and start the browser flow when they agree.';
     }
     if (decision === 'bound') {
-        return 'Continue into the lifecycle with session.bootstrap or session.resume.';
+        return 'Continue into the lifecycle. For a task already running here, call session.resume. For new write work, call task.branch first: one form asks where the branch starts, its name and which folder it uses. Then call session.bootstrap in the repoRoot it returns. Read-only work goes straight to session.bootstrap.';
     }
     return 'Ask which organization and then which project, whatever the user asked for, listing what they already have with the option to create a new one last. Switching Engineering Memory off in this repository is the other answer, and it is remembered.';
 }
-function deliveryQuestion(touchedContract = false) {
+function deliveryQuestion(touchedContract, destination, publishApplicable) {
+    const { branch, remote, pushUrl, remoteDefaultBranch, headCommit } = destination;
+    const onto = branch ? `branch ${branch}` : 'a detached HEAD, which is on no branch';
+    const target = branch && remote ? `${remote} (${pushUrl ?? 'no push URL'}) branch ${branch}` : null;
+    const head = headCommit ? `, on top of ${headCommit.slice(0, 12)}` : '';
+    const pushed = target ? `, and a push goes to ${target}` : '';
+    const to = target ? ` to ${target}` : '';
+    const blocked = target
+        ? ''
+        : !branch
+            ? ' (not possible until the work is on a branch)'
+            : ` (not possible: this clone has no remote that a push of ${branch} would go to)`;
+    const base = 'base branch the pull request targets' +
+        (remote && remoteDefaultBranch
+            ? `; the default branch of ${remote} is ${remoteDefaultBranch}`
+            : '');
     return asJsonValue({
         required: true,
-        question: 'The task is closed and nothing has been committed. Ask the user which of these to do, and do only what they choose.',
+        question: `The task is closed and nothing has been committed. The commit goes on ${onto}${head}${pushed}. If the user already said in their own message which of these they want, that is the answer; do not ask it again. Otherwise ask, and do only what they choose.`,
+        destination,
         options: [
-            { id: 'commit', label: 'Commit' },
-            { id: 'commit_push', label: 'Commit and push' },
+            { id: 'commit', label: `Commit on ${onto}` },
+            { id: 'commit_push', label: `Commit and push${to}${blocked}` },
             {
                 id: 'commit_push_draft_pr',
-                label: 'Commit, push and open a draft pull request',
-                input: 'base branch the pull request targets',
+                label: `Commit, push${to} and open a draft pull request${blocked}`,
+                input: base,
             },
             {
                 id: 'commit_push_pr',
-                label: 'Commit, push and open a pull request',
-                input: 'base branch the pull request targets',
+                label: `Commit, push${to} and open a pull request${blocked}`,
+                input: base,
             },
         ],
         ...(touchedContract
@@ -3747,6 +4570,9 @@ function deliveryQuestion(touchedContract = false) {
             }
             : {}),
         afterPullRequest: 'Do not end the turn once a pull request exists. Check whether it merges cleanly, report the conflicting files if it does not, and ask whether to resolve them before touching anything.',
+        afterCommit: publishApplicable
+            ? 'Call memory.publish_task with this closed task id and repoRoot after the authorized commit is created.'
+            : 'This task has nothing to publish (see sourcePublication on the close response); do not call memory.publish_task.',
     });
 }
 function cleanJson(value) {
@@ -3769,6 +4595,73 @@ function objectValue(value) {
 function objectOrEmpty(value) {
     return objectValue(value ?? undefined) ?? {};
 }
+function journalSummary(journal) {
+    return {
+        directory: journal.directory,
+        appliedEventCount: journal.projection?.appliedEventIds.length ?? 0,
+        pendingDeliveryCount: journal.pendingDeliveryCount,
+    };
+}
+function outboxSummary(outbox) {
+    const value = objectOrEmpty(outbox);
+    return {
+        synchronizedCount: Array.isArray(value.synchronized) ? value.synchronized.length : 0,
+        blocked: Array.isArray(value.blocked) ? value.blocked : [],
+        pending: typeof value.pending === 'number' ? value.pending : 0,
+    };
+}
+function documentViews(documents) {
+    return (Array.isArray(documents) ? documents : []).flatMap((document) => {
+        const value = objectValue(document);
+        return value && typeof value.content === 'string' && value.content.trim()
+            ? [{ documentType: value.documentType ?? null, content: value.content }]
+            : [];
+    });
+}
+function checkpointView(checkpoint) {
+    if (!checkpoint)
+        return null;
+    const event = objectValue(checkpoint.event);
+    return {
+        event: event
+            ? {
+                id: event.id ?? null,
+                sequence: event.sequence ?? null,
+                checkpointType: event.checkpointType ?? null,
+                createdAt: event.createdAt ?? null,
+            }
+            : null,
+        documents: documentViews(checkpoint.documents),
+    };
+}
+function resumeBackendView(backend, includeDocuments) {
+    const rest = Object.fromEntries(Object.entries(backend).filter(([key]) => key !== 'requirements'));
+    const task = objectValue(backend.task);
+    const selfReviewFiles = Array.isArray(task?.selfReviewFiles) ? task.selfReviewFiles : [];
+    return {
+        ...rest,
+        ...(task
+            ? {
+                task: {
+                    ...Object.fromEntries(Object.entries(task).filter(([key]) => key !== 'selfReviewFiles')),
+                    selfReviewFileCount: selfReviewFiles.length,
+                },
+            }
+            : {}),
+        events: (Array.isArray(backend.events) ? backend.events : []).map((event) => {
+            const value = objectOrEmpty(event);
+            const payload = objectOrEmpty(value.payload ?? null);
+            return {
+                sequence: value.sequence ?? null,
+                eventType: value.eventType ?? null,
+                checkpointType: value.checkpointType ?? null,
+                createdAt: value.createdAt ?? null,
+                ...(typeof payload.summary === 'string' ? { summary: payload.summary } : {}),
+            };
+        }),
+        documents: includeDocuments ? documentViews(backend.documents) : [],
+    };
+}
 function archivedProjectGuidance(project) {
     const projectId = typeof project?.id === 'string' ? project.id : null;
     const expectedVersion = typeof project?.lockVersion === 'number' ? project.lockVersion : null;
@@ -3816,6 +4709,11 @@ function classifyError(error) {
     }
     return 'bridge_delivery_error';
 }
+function backendRejectsField(error, fields) {
+    return (error instanceof ApiResponseError &&
+        error.httpStatus === 400 &&
+        fields.some((field) => error.message.includes(`property ${field} should not exist`)));
+}
 function isDefinitiveAuthenticationFailure(error) {
     return (error instanceof ApiResponseError &&
         (error.httpStatus === 400 || error.httpStatus === 401 || error.httpStatus === 403));
@@ -3893,24 +4791,49 @@ function isOfflineLeaseUsable(lease, sessionId, changedPaths, baselineDiffHash)
         return false;
     }
 }
-function refuse(message, recovery) {
-    return new BridgeRecoveryError(message, recovery);
+export function cancelledDeliveryQuestionId(entry, clean) {
+    return ('worktree-delivery-cancel-' +
+        sha256(entry.generation + ':' + (clean ? 'clean' : entry.managed ? 'modified' : 'own-folder')));
+}
+function refuse(message, recovery, details) {
+    return new BridgeRecoveryError(message, recovery, details);
 }
 function short(value) {
     return typeof value === 'string' && value.length > 0 ? value.slice(0, 12) : 'none';
 }
-function describePathDisagreement(reported, manifest) {
-    const inManifest = new Set(manifest);
-    const inReport = new Set(reported);
-    const missing = manifest.filter((path) => !inReport.has(path));
-    const extra = reported.filter((path) => !inManifest.has(path));
-    const sample = (paths) => paths.slice(0, 5).join(', ') + (paths.length > 5 ? `, and ${paths.length - 5} more` : '');
-    const parts = [`You reported ${reported.length}; the manifest has ${manifest.length}.`];
-    if (missing.length > 0)
-        parts.push(`Missing from your report: ${sample(missing)}.`);
-    if (extra.length > 0)
-        parts.push(`Reported but not in the manifest: ${sample(extra)}.`);
-    return parts.join(' ');
+function samplePaths(paths) {
+    return paths.slice(0, 5).join(', ') + (paths.length > 5 ? `, and ${paths.length - 5} more` : '');
+}
+const contextRefreshConflicts = [
+    'context_refresh_required',
+    'approved_memory_revision_requires_refresh',
+];
+function contextRefreshAction(staleReason, baseline) {
+    const reason = objectValue(staleReason);
+    const cause = reason && typeof reason.resourceKey === 'string'
+        ? `Approved revision ${String(reason.revisionNumber)} of ${reason.resourceKey}${typeof reason.taskExternalId === 'string' ? ` (from ${reason.taskExternalId})` : ''} changed memory this task read.`
+        : 'Approved memory changed what this task read.';
+    return `${cause} Call context.refresh, then context.prepare_change with ${baseline?.leasePaths.length ? baseline.leasePaths.join(', ') : 'the paths this task changes'}.${baseline ? ` The task baseline stays ${short(baseline.diffHash)}.` : ''}`;
+}
+function taskChangeSet(baseline, activeLease, current) {
+    const leaseChangedPaths = Array.isArray(activeLease?.changedPaths)
+        ? activeLease.changedPaths.filter((path) => typeof path === 'string')
+        : [];
+    const wholeTreeDelta = manifestDelta(baseline.changedPaths, current);
+    const leased = new Set(normalizeChangedPaths([...baseline.leasePaths, ...leaseChangedPaths]));
+    const taskChanges = wholeTreeDelta.filter((entry) => leased.has(normalizeChangedPaths([entry.path])[0]));
+    return { leaseChangedPaths, wholeTreeDelta, leased, taskChanges };
+}
+function renderedPaths(paths, policy) {
+    if (!policy)
+        return [];
+    return paths
+        .filter((path) => policy.units.some((unit) => (unit.kind === 'screen_logic' || unit.kind === 'component_mapping') &&
+        unit.patterns.some((pattern) => globMatches(path, pattern))))
+        .sort();
+}
+function validationWaiverId(taskId, validationId, paths, reason) {
+    return `validation-waiver-${validationId}-${sha256(stableStringify({ taskId, validationId, paths, reason })).slice(0, 32)}`;
 }
 function repairChangeBaseline(local, recordedDiffHash, head) {
     if (!recordedDiffHash || local?.diffHash === recordedDiffHash)
@@ -4101,7 +5024,7 @@ function globMatches(path, pattern) {
     }
     return minimatch(path.replace(/\\/g, '/'), normalizedPattern, { dot: true });
 }
-function assertNewResourceEvidence(candidates, evidence) {
+function newResourceEvidenceFindings(candidates, evidence) {
     const normalizedEvidence = evidence.map((entry) => ({
         ...entry,
         path: normalizeChangedPaths([entry.path])[0],
@@ -4112,47 +5035,56 @@ function assertNewResourceEvidence(candidates, evidence) {
     if (new Set(normalizedEvidence.map((entry) => entry.path)).size !== normalizedEvidence.length) {
         throw refuse('New resource evidence contains duplicate paths', 'task.verify');
     }
-    const expected = [...candidates].sort((left, right) => left.path.localeCompare(right.path));
-    const actual = normalizedEvidence
-        .map(({ path, kind }) => ({ path, kind }))
-        .sort((left, right) => left.path.localeCompare(right.path));
-    if (stableStringify(expected) !== stableStringify(actual)) {
-        const expectedPaths = new Set(expected.map((entry) => entry.path));
-        const actualPaths = new Set(actual.map((entry) => entry.path));
-        const missing = expected
-            .filter((entry) => !actualPaths.has(entry.path))
-            .map((entry) => `${entry.path} (${entry.kind})`);
-        const extra = actual
-            .filter((entry) => !expectedPaths.has(entry.path))
-            .map((entry) => `${entry.path} (${entry.kind})`);
-        const details = [
-            missing.length ? `missing evidence for ${missing.join(', ')}` : '',
-            extra.length ? `evidence for paths the policy does not classify: ${extra.join(', ')}` : '',
-        ].filter(Boolean);
-        throw refuse(`New screen or shared component paths require exact memory reconciliation. ${details.length ? details.join('; ') : 'The kinds do not match the project discovery policy.'}`, 'task.verify');
-    }
+    const sent = new Map(normalizedEvidence.map((entry) => [entry.path, entry.kind]));
+    const expected = new Map(candidates.map((entry) => [entry.path, entry.kind]));
+    const missing = candidates
+        .filter((entry) => !sent.has(entry.path))
+        .map((entry) => `${entry.path} (${entry.kind})`)
+        .sort();
+    const extra = normalizedEvidence
+        .filter((entry) => !expected.has(entry.path))
+        .map((entry) => `${entry.path} (${entry.kind})`)
+        .sort();
+    const mismatched = normalizedEvidence
+        .filter((entry) => expected.has(entry.path) && expected.get(entry.path) !== entry.kind)
+        .map((entry) => `${entry.path} (sent ${entry.kind}, policy ${expected.get(entry.path)})`)
+        .sort();
+    const details = [
+        missing.length ? `missing evidence for ${missing.join(', ')}` : '',
+        extra.length ? `evidence for paths the policy does not classify: ${extra.join(', ')}` : '',
+        mismatched.length
+            ? `kinds that do not match the project discovery policy: ${mismatched.join(', ')}`
+            : '',
+    ].filter(Boolean);
+    return details.length > 0
+        ? [
+            `New screen or shared component paths require exact memory reconciliation. ${details.join('; ')}.`,
+        ]
+        : [];
 }
-function assertValidationEvidence(validations) {
+function validationEvidenceFindings(validations) {
     if (validations.length === 0) {
-        throw refuse('Validation evidence is required', 'task.verify');
+        return ['Validation evidence is required'];
     }
     const allowed = new Set(validationIds);
     const seen = new Set();
+    const findings = [];
     for (const validation of validations) {
         if (!allowed.has(validation.validationId)) {
-            throw refuse(`Unknown validation evidence: ${validation.validationId}`, 'task.verify');
+            findings.push(`Unknown validation evidence: ${validation.validationId}`);
         }
-        if (seen.has(validation.validationId)) {
-            throw refuse(`Duplicate validation evidence: ${validation.validationId}`, 'task.verify');
+        else if (seen.has(validation.validationId)) {
+            findings.push(`Duplicate validation evidence: ${validation.validationId}`);
         }
         if (!validation.command.trim()) {
-            throw refuse(`Validation command is required: ${validation.validationId}`, 'task.verify');
+            findings.push(`Validation command is required: ${validation.validationId}`);
         }
         if (!/^[0-9a-f]{64}$/.test(validation.outputHash)) {
-            throw refuse(`Validation output hash is invalid: ${validation.validationId}`, 'task.verify');
+            findings.push(`Validation output hash is invalid: ${validation.validationId}`);
         }
         seen.add(validation.validationId);
     }
+    return findings;
 }
 function sourceFromContext(value) {
     const context = objectValue(value);