engineering-memory 1.11.17 → 1.11.19

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

@@ -1,3 +1,6 @@
+import { ignoredRuntimeFiles, localRelativePath } from './worktree-preparation.js';
+import { decisionModeSchema } from './decision-mode-store.js';
+import { delegatedReasonSchema } from './questionnaire-store.js';
 import { unreadableWorktree, } from './worktree-pool.js';
 import { validWorktreePolicy } from './worktree-policy.js';
 import { resolveTaskBase } from './branch-preferences.js';
@@ -57,6 +60,202 @@ export class BridgeService {
             await this.dependencies.languages.remember(principalHash, told);
         return told ?? (await this.dependencies.languages.read(principalHash));
     }
+    async decisionModeStatus(input) {
+        const scope = await this.questionnaireScope(input.repoRoot);
+        return this.dependencies.questionnaires.decisions.read(scope, this.dependencies.client.namespace, input.externalTaskId);
+    }
+    async decisionModeQuestion(input) {
+        const scope = await this.questionnaireScope(input.repoRoot);
+        if (!scope.projectId || !(await this.dependencies.credentials.get('access-token')))
+            throw refuse('Select a signed-in project before choosing a task decision mode.', 'session.entry');
+        const namespace = this.dependencies.client.namespace;
+        const id = 'decision-mode-' +
+            sha256(stableStringify({
+                scope,
+                namespace,
+                task: input.externalTaskId,
+                version: input.expectedVersion,
+                ...(input.decisionAttempt ? { decisionAttempt: input.decisionAttempt } : {}),
+            }));
+        const current = await this.decisionModeStatus(input);
+        if (current.version !== input.expectedVersion &&
+            !(current.version === input.expectedVersion + 1 && current.questionnaireId === id))
+            throw refuse('The mode changed. Read decision.mode_status before opening another mode question.', 'decision.mode_status');
+        const language = await this.language(input.language);
+        const existing = await this.dependencies.questionnaires.get(scope, id);
+        if (existing) {
+            if (existing.owner?.tool !== 'decision.mode' ||
+                existing.owner.externalTaskId !== input.externalTaskId)
+                throw refuse('This mode question has a different owner. Start a new decisionAttempt.', 'decision.mode');
+            if (existing.status === 'withdrawn')
+                throw refuse('The mode question was withdrawn. When the user resumes this choice, increment decisionAttempt without changing expectedVersion.', 'decision.mode');
+            return {
+                questionnaireId: id,
+                message: existing.message,
+                context: existing.context,
+                example: existing.example,
+                language: existing.language,
+                options: existing.options,
+                binding: existing.binding,
+            };
+        }
+        const tr = language?.startsWith('tr');
+        const definition = {
+            questionnaireId: id,
+            message: tr
+                ? input.expectedVersion
+                    ? 'Hangi moda geçelim?'
+                    : 'Bu taskta nasıl ilerleyelim?'
+                : input.expectedVersion
+                    ? 'Which mode should we switch to?'
+                    : 'How should we work on this task?',
+            context: tr
+                ? 'Seçim bu task için geçerli; istediğinde değiştirebilirsin.'
+                : 'This choice applies to this task; you can change it anytime.',
+            example: tr
+                ? 'Örneğin canlıya alma kararını ajana bırakabilir veya kendin onaylayabilirsin.'
+                : 'For example, you can delegate a release decision or approve it yourself.',
+            language: tr ? 'tr' : 'en',
+            options: tr
+                ? [
+                    {
+                        id: 'approve_for_me',
+                        label: 'Benim için onayla',
+                        description: 'Sıradan kararları ben veririm; çok kritik olanları sana sorarım.',
+                    },
+                    {
+                        id: 'autonomous',
+                        label: 'Otonom',
+                        description: 'Seçenekleri senin hedeflerine göre değerlendirip kararları gerekçesiyle veririm.',
+                    },
+                    {
+                        id: 'ask',
+                        label: 'Onay iste',
+                        description: 'Karar gereken her durumda sana sorarım.',
+                    },
+                ]
+                : [
+                    {
+                        id: 'approve_for_me',
+                        label: 'Approve for me',
+                        description: 'I decide routine matters and ask you about critical ones.',
+                    },
+                    {
+                        id: 'autonomous',
+                        label: 'Autonomous',
+                        description: 'I weigh the choices against your goals and record my reasoning.',
+                    },
+                    {
+                        id: 'ask',
+                        label: 'Ask for approval',
+                        description: 'I ask you whenever a decision is needed.',
+                    },
+                ],
+            binding: {
+                namespace,
+                externalTaskId: input.externalTaskId,
+                expectedVersion: input.expectedVersion,
+            },
+        };
+        return definition;
+    }
+    async decisionModeSelect(input) {
+        const record = await this.questionnaireResume(input);
+        const namespace = this.dependencies.client.namespace;
+        if (record.owner?.tool !== 'decision.mode' ||
+            record.owner.externalTaskId !== input.externalTaskId ||
+            record.binding?.namespace !== namespace ||
+            record.binding?.externalTaskId !== input.externalTaskId ||
+            record.binding?.expectedVersion !== input.expectedVersion ||
+            record.status !== 'answered' ||
+            !record.answerAvailable ||
+            record.answerSource?.kind === 'delegated_agent')
+            throw refuse('A mode can only be selected through its native task mode question.', 'decision.mode');
+        const mode = decisionModeSchema.parse(record.answer?.choice);
+        return this.dependencies.questionnaires.decisions.select(record.scope, namespace, input.externalTaskId, input.expectedVersion, mode, record.questionnaireId);
+    }
+    async questionnaireDecisionPolicy(record, answer) {
+        const externalTaskId = record.owner?.externalTaskId;
+        const state = externalTaskId
+            ? await this.dependencies.questionnaires.decisions.read(record.scope, this.dependencies.client.namespace, externalTaskId)
+            : null;
+        let impact = record.owner?.tool === 'questionnaire.ask' ? (record.impact ?? 'critical') : 'critical';
+        if (record.owner?.tool === 'task.branch' && record.binding) {
+            if (!answer)
+                impact = 'routine';
+            else {
+                const selected = taskStartChoice({
+                    ...record,
+                    status: 'answered',
+                    answerAvailable: true,
+                    ...(record.questions
+                        ? { answers: answer }
+                        : { answer: answer }),
+                });
+                if (selected?.status === 'deferred' ||
+                    (selected?.status === 'start' && !selected.inPlace && !selected.keepCurrent))
+                    impact = 'routine';
+            }
+        }
+        if (record.questionnaireId.startsWith('rule-deviation-') ||
+            record.questionnaireId.startsWith('validation-waiver-'))
+            impact = 'critical';
+        const userOnly = record.owner?.tool === 'decision.mode' || !record.scope.projectId || !externalTaskId;
+        const delegated = !userOnly &&
+            !!state?.configured &&
+            (state.mode === 'autonomous' || (state.mode === 'approve_for_me' && impact === 'routine'));
+        return { delegated, impact, state, userOnly };
+    }
+    async assertDecisionCurrent(record) {
+        const source = record.answerSource;
+        if (source?.kind !== 'delegated_agent')
+            return;
+        const policy = await this.questionnaireDecisionPolicy(record, record.questions ? record.answers : record.answer);
+        if (!policy.delegated ||
+            policy.state?.version !== source.modeVersion ||
+            policy.state.mode !== source.mode ||
+            record.owner?.externalTaskId !== source.externalTaskId ||
+            source.namespace !== this.dependencies.client.namespace)
+            throw refuse('The mode changed after this delegated answer. Re-evaluate using a new questionnaireId, or increment the owning operation decisionAttempt. Do not execute this answer.', 'questionnaire.resume');
+    }
+    async questionnaireDecide(input) {
+        const scope = await this.questionnaireScope(input.repoRoot);
+        const record = await this.dependencies.questionnaires.get(scope, input.questionnaireId);
+        if (!record ||
+            record.requestKey !== input.requestKey ||
+            record.contentHash !== input.contentHash)
+            throw refuse('Read the exact pending questionnaire before deciding.', 'questionnaire.resume');
+        const externalTaskId = record.owner?.externalTaskId;
+        if (!externalTaskId)
+            throw refuse('This question has no task delegation scope.', 'questionnaire.resume');
+        return this.dependencies.questionnaires.decisions.locked(scope, this.dependencies.client.namespace, externalTaskId, async () => {
+            const answer = input.answer ?? input.answers;
+            if (!answer || Boolean(input.answer) === Boolean(input.answers))
+                throw refuse('Exactly one of answer or answers is required. Resume the original question.', 'questionnaire.resume');
+            const policy = await this.questionnaireDecisionPolicy(record, answer);
+            if (!policy.delegated || !policy.state || policy.state.version !== input.modeVersion)
+                throw refuse('The current mode requires a native answer for this decision, or its version changed. Resume the question.', 'questionnaire.resume');
+            await this.assertDecisionCurrent(record);
+            const reasoning = delegatedReasonSchema.parse({
+                reason: input.reason,
+                alternativesConsidered: input.alternativesConsidered,
+                userInterestReview: input.userInterestReview,
+            });
+            const resolved = await this.dependencies.questionnaires.accept(scope, record.questionnaireId, record.requestKey, answer, {
+                kind: 'delegated_agent',
+                externalTaskId,
+                mode: policy.state.mode,
+                modeVersion: policy.state.version,
+                namespace: this.dependencies.client.namespace,
+                impact: policy.impact,
+                ...reasoning,
+            });
+            return {
+                ...resolved,
+                retry: this.questionnaireRetry(resolved.record, input.repoRoot ?? process.cwd()),
+            };
+        });
+    }
     async questionnaireAsk(input, previousDefinitions = [], owner) {
         const scope = await this.questionnaireScope(input.repoRoot, input.preparation);
         const { repoRoot: _repoRoot, preparation: _preparation, presentation: _presentation, ...definition } = input;
@@ -64,6 +263,7 @@ export class BridgeService {
             ? null
             : await this.checkoutTask(scope.repoFingerprint, await this.dependencies.repositories.git.findRoot(input.repoRoot ?? process.cwd()));
         const record = await this.dependencies.questionnaires.ask(scope, definition, previousDefinitions, owner ?? (askingTask ? { tool: 'questionnaire.ask', externalTaskId: askingTask } : undefined));
+        await this.assertDecisionCurrent(record);
         return { ...record, language: record.language ?? (await this.language()) };
     }
     async checkoutTask(repoFingerprint, repoRoot) {
@@ -80,6 +280,7 @@ export class BridgeService {
         const record = await this.dependencies.questionnaires.get(scope, input.questionnaireId);
         if (!record)
             throw refuse('No questionnaire exists for this account and repository binding.', 'session.entry');
+        await this.assertDecisionCurrent(record);
         return { ...record, language: record.language ?? (await this.language()) };
     }
     async questionnaireWithdraw(input) {
@@ -96,7 +297,7 @@ export class BridgeService {
     async acceptWithScope(scope, questionnaireId, requestKey, answer, answerSource) {
         return this.dependencies.questionnaires.accept(scope, questionnaireId, requestKey, answer, answerSource);
     }
-    retryHint(record, repoRoot, attemptOffset = 0) {
+    questionnaireRetry(record, repoRoot, attemptOffset = 0) {
         if (!record.owner || record.owner.tool === 'questionnaire.ask')
             return undefined;
         const attempt = (record.owner.decisionAttempt ?? 0) + attemptOffset;
@@ -121,7 +322,7 @@ export class BridgeService {
         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()),
+            retry: this.questionnaireRetry(resolved.record, input.repoRoot ?? process.cwd()),
         };
     }
     async questionnaireScope(repoRoot, preparation = false) {
@@ -227,7 +428,7 @@ export class BridgeService {
             .map(([externalTaskId, record]) => asJsonValue({
             externalTaskId,
             deferredAt: record.answeredAt ?? record.createdAt,
-            reconsider: this.retryHint(record, repoRoot, 1),
+            reconsider: this.questionnaireRetry(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 };
@@ -415,6 +616,10 @@ export class BridgeService {
             await this.seedResumeSnapshot(pointer, data);
             return asJsonValue({
                 ...data,
+                decisionMode: await this.decisionModeStatus({
+                    repoRoot: repository.repoRoot,
+                    externalTaskId: input.externalTaskId,
+                }),
                 checkpoint: checkpointView(checkpoint),
                 repository: publicRepository(repository),
                 localJournal: journalSummary(await this.dependencies.journal.load(projectId, input.externalTaskId)),
@@ -774,6 +979,10 @@ export class BridgeService {
             return asJsonValue({
                 backend: resumeBackendView(backend, backendFresh || !localJournal.projection),
                 requirements: backend.requirements ?? null,
+                decisionMode: await this.decisionModeStatus({
+                    repoRoot: repository.repoRoot,
+                    externalTaskId: taskSlug,
+                }),
                 ...(contextRefreshRequired
                     ? {
                         staleReason: backend.staleReason ?? null,
@@ -1250,6 +1459,8 @@ export class BridgeService {
                 const question = input.questionnaireId
                     ? await this.dependencies.questionnaires.get(scope, input.questionnaireId)
                     : null;
+                if (question)
+                    await this.assertDecisionCurrent(question);
                 const digest = sha256(stableStringify(input.choice));
                 if (question?.answer?.choice !== 'approve' ||
                     (question.binding?.choiceDigest !== digest &&
@@ -1341,6 +1552,8 @@ export class BridgeService {
             const digest = sha256(stableStringify(confirmedInput));
             const scope = await this.questionnaireScope(input.repoRoot);
             const question = await this.dependencies.questionnaires.get(scope, questionnaireId);
+            if (question)
+                await this.assertDecisionCurrent(question);
             if (questionnaireId !== 'sync-start-' + digest ||
                 question?.answer?.choice !== 'approve' ||
                 input.ref !== snapshot.commit)
@@ -1706,6 +1919,8 @@ export class BridgeService {
                     return rule;
                 const questionnaireId = ruleDeviationQuestionnaireId(input.taskId, path, rule);
                 const question = await this.dependencies.questionnaires.get(scope, questionnaireId);
+                if (question)
+                    await this.assertDecisionCurrent(question);
                 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');
@@ -1717,7 +1932,12 @@ export class BridgeService {
                     deviationApproval: {
                         questionnaireId,
                         answeredAt: question.answeredAt,
-                        hostTool: question.answerSource?.hostTool ?? null,
+                        hostTool: question.answerSource?.kind === 'host_native_relay'
+                            ? question.answerSource.hostTool
+                            : null,
+                        ...(delegatedEvidence(question)
+                            ? { delegatedDecision: delegatedEvidence(question) }
+                            : {}),
                     },
                 };
             })),
@@ -1934,6 +2154,11 @@ export class BridgeService {
                 if (recoveredVerification) {
                     return asJsonValue({
                         ...recoveredVerification,
+                        ...(recoveredVerification.verified === true
+                            ? {
+                                nextAction: 'Call task.close now for this verified task. It opens the mode-governed Git delivery selector. Memory publication approval is separate; do not stop after publishing memory.',
+                            }
+                            : {}),
                         repository: publicRepository(repository),
                     });
                 }
@@ -2043,6 +2268,8 @@ export class BridgeService {
                     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)
+                            await this.assertDecisionCurrent(question);
                         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');
                         }
@@ -2051,7 +2278,14 @@ export class BridgeService {
                             questionnaireId,
                             reason: waiver.reason,
                             paths,
-                            answerSource: question.answerSource?.hostTool ?? 'mcp_form',
+                            answerSource: question.answerSource?.kind === 'delegated_agent'
+                                ? 'delegated_agent'
+                                : question.answerSource?.kind === 'host_native_relay'
+                                    ? question.answerSource.hostTool
+                                    : 'mcp_form',
+                            ...(delegatedEvidence(question)
+                                ? { delegatedDecision: delegatedEvidence(question) }
+                                : {}),
                         });
                     }
                 }
@@ -2129,6 +2363,11 @@ export class BridgeService {
                 return asJsonValue({
                     ...objectOrEmpty(response.data),
                     mode: taskMode,
+                    ...(responseData?.verified === true
+                        ? {
+                            nextAction: 'Call task.close now for this verified task. It opens the mode-governed Git delivery selector. Memory publication approval is separate; do not stop after publishing memory.',
+                        }
+                        : {}),
                     ...(foreignChangedPaths.length > 0
                         ? { changedPathsOutsideThisTask: foreignChangedPaths }
                         : {}),
@@ -2170,6 +2409,13 @@ export class BridgeService {
             });
         });
     }
+    async taskDeliveryBase(input) {
+        return this.execute(async () => {
+            const repository = await this.dependencies.repositories.resolve(input.repoRoot ?? process.cwd());
+            await this.dependencies.repositories.git.validateBranch(repository.repoRoot, input.branch);
+            return { branch: input.branch };
+        });
+    }
     async taskClose(input) {
         return await this.execute(async () => {
             return await this.taskExclusive(input.taskId, async () => {
@@ -2226,6 +2472,47 @@ export class BridgeService {
             return asJsonValue({ allocation });
         });
     }
+    async worktreePrepareFiles(input) {
+        return this.execute(async () => {
+            const repository = await this.dependencies.repositories.resolve(input.repoRoot);
+            const pool = this.dependencies.worktreePool;
+            if (!repository.projectId || !pool)
+                throw refuse('Resume a bound managed worktree before preparing files.', 'session.resume');
+            const allocation = await pool.assertOwnership(repository.projectId, repository.repoRoot, input.generation);
+            if (!allocation.managed ||
+                allocation.phase !== 'working' ||
+                allocation.externalTaskId !== input.externalTaskId)
+                throw refuse('Resume this task with its current worktree generation.', 'session.resume');
+            const source = allocation.sourceRepoRoot;
+            if (!source)
+                throw refuse('Resume worktree preparation before inspecting runtime files.', 'session.resume');
+            const inventory = await ignoredRuntimeFiles(source, allocation.sourceMainRoot ?? source, allocation.repoRoot);
+            let prepared = allocation;
+            if (input.paths !== undefined) {
+                if (input.expectedInventory !== inventory.inventory || input.paths.length > 100)
+                    throw refuse('Inspect the current ignored-file inventory before selecting required files.', 'worktree.prepare_files');
+                const paths = input.paths.map(localRelativePath);
+                if (new Set(paths).size !== paths.length)
+                    throw refuse('Choose each required runtime path once.', 'worktree.prepare_files');
+                prepared = await pool.prepare(allocation, { inventory: inventory.inventory, paths });
+                this.poolAllocations.set(repository.repoRoot, prepared);
+            }
+            const offset = input.offset ?? 0, limit = input.limit ?? 100;
+            return asJsonValue({
+                repoRoot: prepared.repoRoot,
+                generation: prepared.generation,
+                inventory: inventory.inventory,
+                candidates: inventory.paths.slice(offset, offset + limit),
+                total: inventory.paths.length,
+                offset,
+                limit,
+                nextOffset: offset + limit < inventory.paths.length ? offset + limit : null,
+                selectedPaths: prepared.runtimeFiles?.paths ?? [],
+                readiness: prepared.readiness,
+                nextAction: 'Inspect every candidate page and tracked imports, build/configuration references and explicit user requirements. Select only necessary local runtime files with paths and expectedInventory; use an empty paths array when none are needed. A selection supplements recognized automatic files and acknowledges the reviewed inventory. Keep generated caches/artifacts excluded; paths inside them may be selected only on explicit runtime evidence. Contents remain local and must never be logged, uploaded or committed. Resolve missing/conflicting/unsafe files without overwriting them; a runtimeReview.required result is not a ready worktree.',
+            });
+        });
+    }
     async projectGitPreferences(input) {
         return this.execute(async () => {
             const repository = await this.dependencies.repositories.resolveIdentity(input.repoRoot ?? process.cwd(), input.projectId);
@@ -2648,7 +2935,7 @@ export class BridgeService {
         return asJsonValue({
             ...allocation,
             kept: !allocation.managed,
-            nextAction: 'Run every file, terminal, lifecycle and delivery operation from this repoRoot. Inspect readiness separately: a file problem does not cancel the task, and an editor request does not prove its window is visible. Resolve reported local file issues without overwriting existing files, then retry task.branch or session.resume. Use task.heartbeat during long work and pause before handoff.',
+            nextAction: 'Run every file, terminal, lifecycle and delivery operation from this repoRoot. Inspect readiness separately: a file problem does not cancel the task, and an editor request does not prove its window is visible. If files.runtimeReview.required, call worktree.prepare_files in this repoRoot with externalTaskId and generation, inspect all candidate pages against tracked imports/build configuration and user requirements, and select the necessary relative paths before claiming runtime readiness. Resolve reported local file issues without overwriting existing files, then retry task.branch or session.resume. Use task.heartbeat during long work and pause before handoff.',
         });
     }
     adoptOwned(repoRoot, entry) {
@@ -3090,6 +3377,218 @@ export class BridgeService {
             return asJsonValue(response.data);
         });
     }
+    async workItemSetupScope(input) {
+        const scope = await this.questionnaireScope(input.repoRoot);
+        const root = await this.dependencies.repositories.git.findRoot(input.repoRoot);
+        const task = await this.checkoutTask(scope.repoFingerprint, root);
+        const pointer = await this.dependencies.activeContexts.loadForSlug(scope.repoFingerprint, input.externalTaskId);
+        if (scope.projectId !== input.projectId ||
+            task !== input.externalTaskId ||
+            !pointer ||
+            pointer.closedAt ||
+            pointer.mode === 'read_only')
+            throw refuse('Resume the active write task in its bound project before configuring its workflow.', 'session.resume');
+        return scope;
+    }
+    async workItemSetupContext(input) {
+        return this.execute(async () => {
+            await this.workItemSetupScope(input);
+            return {
+                projectId: input.projectId,
+                externalTaskId: input.externalTaskId,
+                namespace: this.dependencies.client.namespace,
+            };
+        });
+    }
+    async workItemApplyWorkflowSetup(input) {
+        return this.execute(async () => {
+            const scope = await this.workItemSetupScope(input);
+            return this.dependencies.questionnaires.decisions.locked(scope, this.dependencies.client.namespace, input.externalTaskId, async () => {
+                const final = await this.questionnaireResume({
+                    repoRoot: input.repoRoot,
+                    questionnaireId: input.questionnaireId,
+                });
+                const proposal = {
+                    projectId: input.projectId,
+                    expectedSnapshot: input.expectedSnapshot,
+                    rules: input.rules,
+                };
+                if (final.owner?.tool !== 'work_item.setup_workflow' ||
+                    final.owner.externalTaskId !== input.externalTaskId ||
+                    final.status !== 'answered' ||
+                    !final.answerAvailable ||
+                    final.answer?.choice !== 'approve' ||
+                    final.binding?.namespace !== this.dependencies.client.namespace ||
+                    final.binding?.proposalDigest !== sha256(stableStringify(proposal)) ||
+                    stableStringify(final.binding?.selectionQuestionnaireIds) !==
+                        stableStringify(input.selectionQuestionnaireIds) ||
+                    input.selectionQuestionnaireIds.length !== 5 ||
+                    input.rules.length !== 5 ||
+                    new Set(input.rules.map((rule) => rule.event)).size !== 5 ||
+                    input.rules.some((rule) => rule.event === 'draft_pr_opened'))
+                    throw refuse('Review the exact five choices through work_item.setup_workflow before saving.', 'work_item.setup_workflow');
+                for (let index = 0; index < input.rules.length; index++) {
+                    const rule = input.rules[index];
+                    const record = await this.questionnaireResume({
+                        repoRoot: input.repoRoot,
+                        questionnaireId: input.selectionQuestionnaireIds[index],
+                    });
+                    if (record.owner?.tool !== 'work_item.setup_workflow' ||
+                        record.owner.externalTaskId !== input.externalTaskId ||
+                        record.status !== 'answered' ||
+                        !record.answerAvailable ||
+                        record.answer?.choice !== rule.toStatusId ||
+                        record.binding?.setupId !== final.binding?.setupId ||
+                        record.binding?.projectId !== input.projectId ||
+                        record.binding?.expectedSnapshot !== input.expectedSnapshot ||
+                        record.binding?.event !== rule.event ||
+                        record.binding?.mode !== rule.mode)
+                        throw refuse('A role choice no longer matches the exact workflow review. Resume its original decision.', 'work_item.setup_workflow');
+                }
+                if (stableStringify(await this.workItemSetupScope(input)) !== stableStringify(scope))
+                    throw refuse('The task account or repository binding changed before saving.', 'session.resume');
+                const response = await this.dependencies.client.request(endpoints.workItemList(input.projectId) + '/workflow', {
+                    method: 'PUT',
+                    body: cleanJson({ expectedSnapshot: input.expectedSnapshot, rules: input.rules }),
+                });
+                return asJsonValue(response.data);
+            });
+        });
+    }
+    async workItemApplyStatusDescription(input) {
+        return this.execute(async () => {
+            const scope = await this.workItemSetupScope(input);
+            return this.dependencies.questionnaires.decisions.locked(scope, this.dependencies.client.namespace, input.externalTaskId, async () => {
+                if (input.reviewQuestionnaireIds.length < 1 ||
+                    input.reviewQuestionnaireIds.length > 10 ||
+                    new Set(input.reviewQuestionnaireIds).size !== input.reviewQuestionnaireIds.length)
+                    throw refuse('Review the complete status description before saving.', 'work_item.describe_status');
+                const final = await this.questionnaireResume({
+                    repoRoot: input.repoRoot,
+                    questionnaireId: input.reviewQuestionnaireIds.at(-1),
+                });
+                const proposal = {
+                    projectId: input.projectId,
+                    statusId: input.statusId,
+                    expectedVersion: input.expectedVersion,
+                    field: input.field,
+                    value: input.value,
+                };
+                const proposalDigest = sha256(stableStringify(proposal));
+                if (final.owner?.tool !== 'work_item.describe_status' ||
+                    final.owner.externalTaskId !== input.externalTaskId ||
+                    final.binding?.namespace !== this.dependencies.client.namespace ||
+                    final.binding?.proposalDigest !== proposalDigest ||
+                    final.binding?.inputQuestionnaireId !== input.inputQuestionnaireId ||
+                    stableStringify(final.binding?.reviewQuestionnaireIds) !==
+                        stableStringify(input.reviewQuestionnaireIds))
+                    throw refuse('This approval does not match the exact description change.', 'work_item.describe_status');
+                for (let index = 0; index < input.reviewQuestionnaireIds.length; index++) {
+                    const record = await this.questionnaireResume({
+                        repoRoot: input.repoRoot,
+                        questionnaireId: input.reviewQuestionnaireIds[index],
+                    });
+                    if (record.owner?.tool !== 'work_item.describe_status' ||
+                        record.owner.externalTaskId !== input.externalTaskId ||
+                        record.status !== 'answered' ||
+                        !record.answerAvailable ||
+                        record.answer?.choice !==
+                            (index === input.reviewQuestionnaireIds.length - 1 ? 'save' : 'continue') ||
+                        record.binding?.setupId !== final.binding?.setupId ||
+                        record.binding?.namespace !== this.dependencies.client.namespace ||
+                        record.binding?.proposalDigest !== proposalDigest ||
+                        record.binding?.index !== index ||
+                        record.binding?.inputQuestionnaireId !== input.inputQuestionnaireId ||
+                        stableStringify(record.binding?.reviewQuestionnaireIds) !==
+                            stableStringify(input.reviewQuestionnaireIds))
+                        throw refuse('A review page is missing or no longer matches this description.', 'work_item.describe_status');
+                }
+                if (input.inputQuestionnaireId) {
+                    const draft = await this.questionnaireResume({
+                        repoRoot: input.repoRoot,
+                        questionnaireId: input.inputQuestionnaireId,
+                    });
+                    if (draft.owner?.tool !== 'work_item.describe_status' ||
+                        draft.owner.externalTaskId !== input.externalTaskId ||
+                        draft.status !== 'answered' ||
+                        !draft.answerAvailable ||
+                        draft.binding?.setupId !== final.binding?.setupId ||
+                        draft.binding?.namespace !== this.dependencies.client.namespace ||
+                        draft.binding?.projectId !== input.projectId ||
+                        draft.binding?.statusId !== input.statusId ||
+                        draft.binding?.expectedVersion !== input.expectedVersion ||
+                        draft.binding?.field !== input.field ||
+                        !((draft.answer?.choice === 'clear' && input.value === '') ||
+                            (draft.answer?.choice === 'write' && draft.answer.text === input.value)))
+                        throw refuse('The saved draft does not match this exact editable answer.', 'work_item.describe_status');
+                }
+                else if (final.owner.retryArguments?.draft !== input.value) {
+                    throw refuse('The supplied draft changed after review.', 'work_item.describe_status');
+                }
+                if (stableStringify(await this.workItemSetupScope(input)) !== stableStringify(scope))
+                    throw refuse('The task account or binding changed before saving.', 'session.resume');
+                const response = await this.dependencies.client.request(endpoints.workItemStatuses(input.projectId) + '/' + encodeURIComponent(input.statusId), {
+                    method: 'PATCH',
+                    body: { expectedVersion: input.expectedVersion, [input.field]: input.value },
+                });
+                return asJsonValue(response.data);
+            });
+        });
+    }
+    async workItemWorkflow(input) {
+        return this.execute(async () => {
+            const query = new URLSearchParams({
+                offset: String(input.offset ?? 0),
+                limit: String(input.limit ?? 50),
+            });
+            if (input.includeArchived !== undefined)
+                query.set('includeArchived', String(input.includeArchived));
+            if (input.snapshot !== undefined)
+                query.set('snapshot', input.snapshot);
+            const response = await this.dependencies.client.request(endpoints.workItemList(input.projectId) + '/workflow?' + query.toString());
+            return asJsonValue(response.data);
+        });
+    }
+    async workItemConfigureWorkflow(input) {
+        return this.execute(async () => {
+            const { projectId, ...body } = input;
+            const response = await this.dependencies.client.request(endpoints.workItemList(projectId) + '/workflow', { method: 'PUT', body: cleanJson(body) });
+            return asJsonValue(response.data);
+        });
+    }
+    async workItemCreateStatus(input) {
+        return this.execute(async () => {
+            const { projectId, ...body } = input;
+            const response = await this.dependencies.client.request(endpoints.workItemStatuses(projectId), { method: 'POST', body: cleanJson(body) });
+            return asJsonValue(response.data);
+        });
+    }
+    async workItemSetStatusArchived(input) {
+        return this.execute(async () => {
+            const response = await this.dependencies.client.request(endpoints.workItemStatuses(input.projectId) +
+                '/' +
+                encodeURIComponent(input.statusId) +
+                (input.archived ? '' : '/restore'), {
+                method: input.archived ? 'DELETE' : 'POST',
+                body: { expectedVersion: input.expectedVersion },
+            });
+            return asJsonValue(response.data);
+        });
+    }
+    async workItemSetInitialStatus(input) {
+        return this.execute(async () => {
+            const { projectId, statusId, ...body } = input;
+            const response = await this.dependencies.client.request(endpoints.workItemStatuses(projectId) + '/' + encodeURIComponent(statusId) + '/initial', { method: 'PUT', body: cleanJson(body) });
+            return asJsonValue(response.data);
+        });
+    }
+    async workItemUpdateStatus(input) {
+        return this.execute(async () => {
+            const { projectId, statusId, ...body } = input;
+            const response = await this.dependencies.client.request(endpoints.workItemStatuses(projectId) + '/' + encodeURIComponent(statusId), { method: 'PATCH', body: cleanJson(body) });
+            return asJsonValue(response.data);
+        });
+    }
     async workItemList(input) {
         return await this.execute(async () => {
             const query = new URLSearchParams();
@@ -3446,7 +3945,7 @@ export class BridgeService {
     async sessionEntry(input = {}) {
         return await this.execute(async () => {
             const timer = startPhaseTimer('session.entry');
-            await this.language(input.language);
+            const language = await this.language(input.language);
             const authentication = await this.dependencies.browserAuth.status();
             timer.mark('auth_status');
             let repository;
@@ -3514,6 +4013,9 @@ export class BridgeService {
                     .map(([role]) => role)
                 : [];
             const taskSelectionRequired = liveTasks.length > 0 || workItems.length > 0;
+            const whatsNew = authenticated && state === 'bound' && !moved.nextAction
+                ? await this.dependencies.releaseNotes?.prepare(this.dependencies.clientVersion, language)
+                : null;
             timer.finish();
             return asJsonValue({
                 authenticated,
@@ -3523,6 +4025,7 @@ export class BridgeService {
                 liveTasks,
                 workItems,
                 taskSelectionRequired,
+                ...(whatsNew ? { whatsNew } : {}),
                 ...(worktrees ? { worktrees: worktrees.ok ? worktrees.data : worktrees.error } : {}),
                 ...(gitPreferences
                     ? {
@@ -3554,6 +4057,19 @@ export class BridgeService {
             });
         });
     }
+    async releaseNotesShow(input) {
+        return await this.execute(async () => {
+            await this.questionnaireScope(input.repoRoot);
+            const language = await this.language(input.language);
+            const report = await this.dependencies.releaseNotes?.show(this.dependencies.clientVersion, language);
+            return asJsonValue({ report: report ?? null });
+        });
+    }
+    async releaseNotesPresented(input) {
+        return await this.execute(async () => ({
+            recorded: (await this.dependencies.releaseNotes?.presented(input.reportId, input.claimId)) ?? false,
+        }));
+    }
     async movedAway(repository, projectId) {
         try {
             const response = await this.dependencies.client.request(endpoints.projectResolve, {
@@ -4365,6 +4881,12 @@ export class BridgeService {
             ...closedTask,
             repository: publicRepository(repository),
             recoveredAfterResponseLoss,
+            deliveryContext: {
+                externalTaskId: closedPointer?.taskSlug ?? null,
+                namespace: this.dependencies.client.namespace,
+                diffHash: String(body.diffHash),
+                mode: normalizeTaskMode(closedPointer?.mode),
+            },
             delivery: deliveryQuestion(touchedContract, await this.dependencies.repositories.git.pushDestination(repository.repoRoot), objectValue(closedTask.sourcePublication)?.applicable === true),
         });
     }
@@ -5420,4 +5942,16 @@ function publicMembership(value) {
     }
     return result;
 }
+function delegatedEvidence(question) {
+    const source = question.answerSource;
+    if (source?.kind !== 'delegated_agent')
+        return undefined;
+    return {
+        mode: source.mode,
+        modeVersion: source.modeVersion,
+        reason: source.reason,
+        alternativesConsidered: source.alternativesConsidered,
+        userInterestReview: source.userInterestReview,
+    };
+}
 //# sourceMappingURL=bridge-service.js.map