engineering-memory 1.11.22 → 1.11.24

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

@@ -1,6 +1,7 @@
+import { liveQuestionKind } from './live-signals.js';
 import { ignoredRuntimeFiles, localRelativePath } from './worktree-preparation.js';
 import { decisionModeSchema } from './decision-mode-store.js';
-import { delegatedReasonSchema } from './questionnaire-store.js';
+import { answerSourceName, delegatedReasonSchema } from './questionnaire-store.js';
 import { unreadableWorktree, } from './worktree-pool.js';
 import { validWorktreePolicy } from './worktree-policy.js';
 import { resolveTaskBase } from './branch-preferences.js';
@@ -56,6 +57,9 @@ export class BridgeService {
     managesWorktrees() {
         return Boolean(this.dependencies.worktreePool);
     }
+    get live() {
+        return this.dependencies.live;
+    }
     async language(told) {
         const accessToken = await this.dependencies.credentials.get('access-token');
         const principalHash = accessToken ? principalFingerprint(accessToken) : sha256('anonymous');
@@ -219,7 +223,7 @@ export class BridgeService {
                 alternativesConsidered: input.alternativesConsidered,
                 userInterestReview: input.userInterestReview,
             });
-            const resolved = await this.dependencies.questionnaires.accept(scope, record.questionnaireId, record.requestKey, answer, {
+            const resolved = await this.acceptWithScope(scope, record.questionnaireId, record.requestKey, answer, {
                 kind: 'delegated_agent',
                 externalTaskId,
                 mode: policy.state.mode,
@@ -242,7 +246,17 @@ export class BridgeService {
             : 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()) };
+        return await this.liveQuestion({
+            ...record,
+            language: record.language ?? (await this.language()),
+        });
+    }
+    async liveQuestion(record) {
+        if (record.status === 'pending')
+            await this.live.questionOpened(liveQuestionKind(record));
+        else
+            await this.live.questionClosed();
+        return record;
     }
     async checkoutTask(repoFingerprint, repoRoot) {
         const worktreeId = sha256(await canonicalPath(repoRoot));
@@ -259,11 +273,14 @@ export class BridgeService {
         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()) };
+        return await this.liveQuestion({
+            ...record,
+            language: record.language ?? (await this.language()),
+        });
     }
     async questionnaireWithdraw(input) {
         const scope = await this.questionnaireScope(input.repoRoot, input.preparation);
-        return this.dependencies.questionnaires.withdraw(scope, input.questionnaireId);
+        return await this.liveQuestion(await this.dependencies.questionnaires.withdraw(scope, input.questionnaireId));
     }
     async questionnaireAccept(input) {
         const scope = await this.questionnaireScope(input.repoRoot, input.preparation);
@@ -273,7 +290,9 @@ export class BridgeService {
         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);
+        const resolved = await this.dependencies.questionnaires.accept(scope, questionnaireId, requestKey, answer, answerSource);
+        await this.liveQuestion(resolved.record);
+        return resolved;
     }
     questionnaireRetry(record, repoRoot, attemptOffset = 0) {
         if (!record.owner || record.owner.tool === 'questionnaire.ask')
@@ -574,6 +593,7 @@ export class BridgeService {
             };
             await this.dependencies.activeContexts.save(pointer);
             this.workedTasks.set(sha256(repository.repoRoot), input.externalTaskId);
+            await this.live.taskStarted(task.id);
             await this.dependencies.journal.apply({
                 eventId: checkpointId,
                 taskId: task.id,
@@ -964,6 +984,7 @@ export class BridgeService {
                         ? { closedAt: pointer?.closedAt ?? new Date().toISOString() }
                         : {}),
                 });
+                await this.live.taskStarted(backendTask.id);
             }
             const backendFresh = responseSource !== 'stale_cache';
             return asJsonValue({
@@ -1023,16 +1044,19 @@ export class BridgeService {
     }
     async contextPrepareChange(input) {
         const pointer = await this.dependencies.activeContexts.findBySessionId(input.sessionId);
-        if (!pointer)
-            return this.contextPrepareChangeUnlocked(input);
-        try {
-            return await this.taskExclusive(pointer.taskId, () => this.contextPrepareChangeUnlocked(input));
-        }
-        catch (error) {
-            return this.execute(async () => {
+        const result = pointer
+            ? await this.taskExclusive(pointer.taskId, () => this.contextPrepareChangeUnlocked(input)).catch((error) => this.execute(async () => {
                 throw error;
-            });
-        }
+            }))
+            : await this.contextPrepareChangeUnlocked(input);
+        return this.liveTaskCall(result);
+    }
+    liveTaskCall(result) {
+        if (result.ok)
+            this.live.settled();
+        else if (result.error?.recovery)
+            this.live.refused(result.error.recovery);
+        return result;
     }
     async contextPrepareChangeUnlocked(input) {
         return await this.execute(async () => {
@@ -1689,10 +1713,31 @@ export class BridgeService {
             catch (error) {
                 throw refuse(error instanceof Error ? error.message : 'The resulting commit must be inspected.', 'memory.sync_start');
             }
+            if (!proof)
+                throw refuse('This task has nothing to publish: its project had no inspected source snapshot when the task was verified.', 'memory.sync_start');
             const response = await this.dependencies.client.request('/memory/sources/publish-task', { method: 'POST', body: proof });
             return response.data;
         });
     }
+    async publishDelivered(repoRoot, taskId) {
+        try {
+            const proof = await this.dependencies.gate.publicationProof(repoRoot, taskId);
+            if (!proof)
+                return null;
+            const response = await this.dependencies.client.request('/memory/sources/publish-task', { method: 'POST', body: proof });
+            const answer = objectValue(response.data);
+            return answer?.published === false
+                ? { published: false, reason: String(answer.reason) }
+                : { published: true };
+        }
+        catch (error) {
+            return {
+                published: false,
+                reason: error instanceof Error ? error.message : String(error),
+                nextAction: 'The delivery is recorded; only the source memory of this task was not published. The member who opened the task can call memory.publish_task in this folder before another task reuses it; otherwise memory.sync_start inspects the result.',
+            };
+        }
+    }
     async onboardingRequest(operation, body) {
         return this.execute(async () => {
             if (operation === 'next' || operation === 'submit') {
@@ -1778,7 +1823,7 @@ export class BridgeService {
         });
     }
     async taskCheckpoint(input) {
-        return await this.writeTaskEvent(input, false);
+        return this.liveTaskCall(await this.writeTaskEvent(input, false));
     }
     async taskRecordCorrection(input) {
         const reference = input.correctionRef ?? input.summary;
@@ -1864,7 +1909,7 @@ export class BridgeService {
         }));
     }
     async taskSelfReview(input) {
-        return await this.execute(async () => {
+        const reviewed = await this.execute(async () => {
             const files = await this.approvedDeviations(input);
             assertSafeToPersist(cleanJson({ files }));
             const checkout = await this.dependencies.repositories.resolve(input.repoRoot ?? process.cwd());
@@ -1896,6 +1941,7 @@ export class BridgeService {
                 },
             });
         });
+        return this.liveTaskCall(reviewed);
     }
     async approvedDeviations(input) {
         const files = reviewedFiles(input);
@@ -1934,7 +1980,7 @@ export class BridgeService {
         })));
     }
     async taskReconcile(input) {
-        return await this.execute(async () => {
+        const reconciled = await this.execute(async () => {
             const repoRoot = input.repoRoot ?? process.cwd();
             const entries = (input.entries ?? [
                 {
@@ -1965,6 +2011,7 @@ export class BridgeService {
             });
             return asJsonValue({ reconciliations: response.data });
         });
+        return this.liveTaskCall(reconciled);
     }
     async taskResolvePendingDelivery(input) {
         return await this.execute(async () => {
@@ -2075,7 +2122,7 @@ export class BridgeService {
         }, true);
     }
     async taskVerify(input) {
-        return await this.execute(async () => {
+        const verified = await this.execute(async () => {
             const timer = startPhaseTimer('task.verify');
             return await this.taskExclusive(input.taskId, async () => {
                 await this.recoverJournalOutbox();
@@ -2268,11 +2315,7 @@ export class BridgeService {
                             questionnaireId,
                             reason: waiver.reason,
                             paths,
-                            answerSource: question.answerSource?.kind === 'delegated_agent'
-                                ? 'delegated_agent'
-                                : question.answerSource?.kind === 'host_native_relay'
-                                    ? question.answerSource.hostTool
-                                    : 'mcp_form',
+                            answerSource: answerSourceName(question.answerSource),
                             ...(delegatedEvidence(question)
                                 ? { delegatedDecision: delegatedEvidence(question) }
                                 : {}),
@@ -2365,6 +2408,7 @@ export class BridgeService {
                 });
             });
         });
+        return this.liveTaskCall(verified);
     }
     async validationWaiverSubject(input) {
         return await this.execute(async () => {
@@ -2407,7 +2451,7 @@ export class BridgeService {
         });
     }
     async taskClose(input) {
-        return await this.execute(async () => {
+        const closed = await this.execute(async () => {
             return await this.taskExclusive(input.taskId, async () => {
                 const checkout = await this.dependencies.repositories.resolve(input.repoRoot ?? process.cwd());
                 const pointer = await this.requireActivePointer(checkout.repoFingerprint, input.taskId, false, 'close');
@@ -2452,6 +2496,7 @@ export class BridgeService {
                 return await this.deliverCloseIntent(repository, closeBody, taskChanges, false);
             });
         });
+        return this.liveTaskCall(closed);
     }
     async worktreeTaskAllocation(input) {
         return this.execute(async () => {
@@ -2545,9 +2590,44 @@ export class BridgeService {
                 currentCommit: repository.git.head,
                 folder,
                 suggestedName,
+                ...(input.workItemId
+                    ? await this.workItemBranches(repository.repoRoot, repository.projectId, input.workItemProjectId ?? repository.projectId, input.workItemId, preferences.data)
+                    : { planBranch: null, continueBranches: [] }),
             });
         });
     }
+    async workItemBranches(repoRoot, projectId, itemProjectId, workItemId, preferences) {
+        const git = this.dependencies.repositories.git;
+        const [plan, runs, reserved, openDeliveries] = await Promise.all([
+            this.dependencies.client.request(endpoints.workItemPlan(itemProjectId, workItemId)),
+            this.dependencies.client.request(`${endpoints.workItemRuns(itemProjectId, workItemId)}?offset=0&limit=50`),
+            git.protectedBranchNames(repoRoot),
+            this.dependencies.client
+                .request(`${endpoints.projectDeliveries(projectId)}?state=open&limit=100`)
+                .then((response) => response.data?.items ?? [], () => []),
+        ]);
+        for (const preference of Object.values(preferences.branches))
+            if (preference.branch)
+                reserved.add(preference.branch);
+        const used = [
+            ...new Set((runs.data?.items ?? [])
+                .filter((run) => run.projectId === projectId && run.mode !== 'read_only')
+                .map((run) => run.branch)
+                .filter((branch) => !!branch && !reserved.has(branch))),
+        ];
+        const planBranch = plan.data?.confirmed ? plan.data.branch : null;
+        const continueBranches = !planBranch
+            ? used.slice(0, 2)
+            : used.includes(planBranch) || (await git.branchExists(repoRoot, planBranch))
+                ? [planBranch]
+                : [];
+        const open = new Set(openDeliveries.map((delivery) => delivery.taskId));
+        return {
+            planBranch,
+            continueBranches,
+            openDeliveryBranches: continueBranches.filter((branch) => (runs.data?.items ?? []).some((run) => run.branch === branch && open.has(run.id))),
+        };
+    }
     async suggestedBranchName(repoRoot, externalTaskId) {
         const candidates = suggestedBranchNames(externalTaskId);
         for (const candidate of candidates)
@@ -2770,11 +2850,22 @@ export class BridgeService {
                     if (operation === 'pause') {
                         await pool.pause(projectId, repository.repoRoot, input.generation);
                         this.poolAllocations.delete(repository.repoRoot);
+                        await this.live.taskPaused(entry.taskId);
                     }
                     if (operation === 'release') {
                         await this.requireDeliveredTaskWork(entry);
+                        const sourcePublication = outcome === 'delivered' && entry.taskId && entry.pendingDelivery
+                            ? await this.publishDelivered(repository.repoRoot, entry.taskId)
+                            : null;
                         await pool.release(projectId, repository.repoRoot, input.generation, outcome === 'delivered' ? outcome : undefined);
                         this.poolAllocations.delete(repository.repoRoot);
+                        await this.live.taskPaused(entry.taskId);
+                        return asJsonValue({
+                            operation,
+                            complete: true,
+                            repoRoot: repository.repoRoot,
+                            ...(sourcePublication ? { sourcePublication } : {}),
+                        });
                     }
                     if (operation === 'cancel_delivery') {
                         if (!entry.pendingDelivery)
@@ -2795,6 +2886,7 @@ export class BridgeService {
                             await this.requireDeliveredTaskWork(entry);
                         const cancelled = await pool.cancelDelivery(projectId, repository.repoRoot, input.generation, choice);
                         this.poolAllocations.delete(repository.repoRoot);
+                        await this.live.taskPaused(entry.taskId);
                         return asJsonValue({
                             operation,
                             complete: true,
@@ -2882,7 +2974,8 @@ export class BridgeService {
                     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))
+                if (input.base.kind !== 'existing' &&
+                    (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);
@@ -2914,6 +3007,7 @@ export class BridgeService {
             keepCurrent: input.keepCurrent,
             inPlace: !existing && input.inPlace,
             resume: Boolean(existing),
+            continued: !existing && input.base?.kind === 'existing',
         }, allocationPolicy));
         allocationTimer.mark('pool_allocate');
         allocationTimer.finish();
@@ -3215,6 +3309,7 @@ export class BridgeService {
                         .release(input.taskId);
                 const forgotten = await this.dependencies.activeContexts.forget(repository.repoFingerprint, input.taskId);
                 await this.dependencies.gate.invalidateTask(input.taskId);
+                this.live.taskEnded(input.taskId);
                 return asJsonValue({
                     ...abandoned,
                     localPointerRemoved: forgotten,
@@ -3725,6 +3820,22 @@ export class BridgeService {
             return asJsonValue(response.data);
         });
     }
+    async workItemComment(input) {
+        return this.execute(async () => {
+            const response = await this.dependencies.client.request(endpoints.workItemComments(input.projectId, input.workItemId), { method: 'POST', body: cleanJson(input.data) });
+            return asJsonValue(response.data);
+        });
+    }
+    async workItemComments(input) {
+        return this.execute(async () => {
+            const query = new URLSearchParams({
+                offset: String(input.offset ?? 0),
+                limit: String(input.limit ?? 50),
+            });
+            const response = await this.dependencies.client.request(`${endpoints.workItemComments(input.projectId, input.workItemId)}?${query}`);
+            return asJsonValue(response.data);
+        });
+    }
     async workItemPlan(input) {
         return this.execute(async () => {
             const response = await this.dependencies.client.request(endpoints.workItemPlan(input.projectId, input.workItemId));
@@ -4023,7 +4134,7 @@ export class BridgeService {
             const livePointers = authenticated && state === 'bound'
                 ? this.dependencies.activeContexts.list(repository.repoFingerprint)
                 : Promise.resolve([]);
-            const [client, liveTasksRaw, workItems, gitPreferences, worktrees, pendingQuestionnaires, moved,] = await Promise.all([
+            const [client, liveTasksRaw, workItems, gitPreferences, worktrees, pendingQuestionnaires, moved, deliveries,] = await Promise.all([
                 this.clientUpdate(authenticated),
                 livePointers,
                 authenticated && state === 'bound' && projectId
@@ -4044,6 +4155,9 @@ export class BridgeService {
                 authenticated && state === 'bound' && projectId
                     ? this.movedAway(repository, projectId)
                     : Promise.resolve({}),
+                authenticated && state === 'bound' && projectId
+                    ? this.openDeliveries(projectId)
+                    : Promise.resolve(null),
             ]);
             timer.mark('independent_lookups');
             const liveTasks = liveTasksRaw.map(describePointer);
@@ -4056,9 +4170,11 @@ export class BridgeService {
                     .map(([role]) => role)
                 : [];
             const taskSelectionRequired = liveTasks.length > 0 || workItems.length > 0;
-            const whatsNew = authenticated && state === 'bound' && !moved.nextAction
+            const open = authenticated && state === 'bound' && !moved.nextAction;
+            const whatsNew = open
                 ? await this.dependencies.releaseNotes?.prepare(this.dependencies.clientVersion, language)
                 : null;
+            const liveStatusNotice = open && projectId ? await this.liveStatusNotice(projectId, language) : null;
             timer.finish();
             return asJsonValue({
                 authenticated,
@@ -4069,6 +4185,12 @@ export class BridgeService {
                 workItems,
                 taskSelectionRequired,
                 ...(whatsNew ? { whatsNew } : {}),
+                ...(liveStatusNotice
+                    ? {
+                        liveStatusNotice,
+                        liveStatusNoticeAction: 'Show this text to the user once as a short paragraph in their language, then silently call live_status.notice_presented with this exact noticeVersion. It asks nothing, needs no answer and never blocks their work.',
+                    }
+                    : {}),
                 ...(worktrees ? { worktrees: worktrees.ok ? worktrees.data : worktrees.error } : {}),
                 ...(gitPreferences
                     ? {
@@ -4083,6 +4205,7 @@ export class BridgeService {
                 ...(pendingQuestionnaires.deferred.length > 0
                     ? { deferredTaskStarts: pendingQuestionnaires.deferred }
                     : {}),
+                ...(deliveries ? { openDeliveries: deliveries } : {}),
                 client,
                 ...moved,
                 ...(incomplete && state === 'bound'
@@ -4113,6 +4236,58 @@ export class BridgeService {
             recorded: (await this.dependencies.releaseNotes?.presented(input.reportId, input.claimId)) ?? false,
         }));
     }
+    async liveStatusNotice(projectId, language) {
+        const response = await this.dependencies.client
+            .request(endpoints.liveStatusNotice(projectId), {
+            networkTimeoutMs: 2000,
+            retryRefresh: false,
+        })
+            .catch(() => null);
+        const notice = liveStatusNoticeSchema.safeParse(response?.data);
+        if (!notice.success || notice.data.presented)
+            return null;
+        const { copy } = copies(liveStatusNoticeWording, 'liveStatusNotice', language)[0];
+        return {
+            projectId: notice.data.projectId,
+            organizationId: notice.data.organizationId,
+            noticeVersion: notice.data.noticeVersion,
+            sharing: notice.data.sharing,
+            text: copy[notice.data.sharing],
+        };
+    }
+    async liveStatusList(input) {
+        return await this.execute(async () => {
+            const scope = input.organizationId
+                ? new URLSearchParams({ organizationId: input.organizationId })
+                : new URLSearchParams({
+                    projectId: input.projectId ?? (await this.boundProject(input.repoRoot)),
+                });
+            const response = await this.dependencies.client.request(`${endpoints.liveStatusList}?${scope}`);
+            return asJsonValue(response.data);
+        });
+    }
+    async liveStatusNoticePresented(input) {
+        return await this.execute(async () => {
+            const projectId = input.projectId ?? (await this.boundProject(input.repoRoot));
+            const response = await this.dependencies.client.request(endpoints.liveStatusNoticePresented(projectId), { method: 'POST', body: { noticeVersion: input.noticeVersion } });
+            return asJsonValue(response.data);
+        });
+    }
+    async liveStatusSetSharing(input) {
+        return await this.execute(async () => {
+            const response = await this.dependencies.client.request(endpoints.liveStatusSharing(input.organizationId), {
+                method: 'PUT',
+                body: { sharing: input.sharing, expectedSharing: input.expectedSharing },
+            });
+            return asJsonValue(response.data);
+        });
+    }
+    async boundProject(repoRoot) {
+        const repository = await this.dependencies.repositories.resolveIdentity(repoRoot ?? process.cwd());
+        if (!repository.projectId)
+            throw refuse('This repository has no selected project, so there is no default scope for live status. Name a projectId or an organizationId.', 'session.entry');
+        return repository.projectId;
+    }
     async movedAway(repository, projectId) {
         try {
             const response = await this.dependencies.client.request(endpoints.projectResolve, {
@@ -4126,6 +4301,30 @@ export class BridgeService {
             return {};
         }
     }
+    async openDeliveries(projectId) {
+        try {
+            const response = await this.dependencies.client.request(`${endpoints.projectDeliveries(projectId)}?state=open&limit=5`);
+            const page = objectValue(response.data);
+            const items = Array.isArray(page?.items) ? page.items : [];
+            if (!items.length)
+                return null;
+            const pool = this.dependencies.worktreePool;
+            return {
+                total: page.total ?? items.length,
+                items: await Promise.all(items.map(async (item) => {
+                    const folder = await pool?.forTask(String(objectValue(item)?.taskId));
+                    return {
+                        ...objectOrEmpty(item),
+                        folderHere: folder?.pendingDelivery ? folder.repoRoot : null,
+                    };
+                })),
+                nextAction: 'These closed tasks have no concluded delivery. Mention them to the user in one line. For one whose folderHere is set, task.close with its taskId in that folder asks and performs the Git delivery there. Any other can be answered or concluded with task.delivery when the user asks.',
+            };
+        }
+        catch {
+            return null;
+        }
+    }
     async actionableWorkItems(projectId) {
         try {
             const response = await this.dependencies.client.request(`${endpoints.workItemList(projectId)}?limit=100&actionable=true`);
@@ -4431,6 +4630,44 @@ export class BridgeService {
             return asJsonValue({ queued: true, outboxId: queued.id, idempotencyKey });
         }
     }
+    async taskDeliveryAnswer(input) {
+        return this.execute(() => this.mutateWithOutbox('task.delivery', endpoints.taskDeliveryAnswer(input.projectId, input.taskId), cleanJson({
+            expectedVersion: input.expectedVersion,
+            choice: input.choice,
+            baseBranch: input.baseBranch,
+            answerSource: input.answerSource,
+        })));
+    }
+    async taskDeliveryCancel(input) {
+        return this.execute(() => this.mutateWithOutbox('task.delivery', endpoints.taskDeliveryCancel(input.projectId, input.taskId), { reason: input.reason }));
+    }
+    async taskDeliveryRecord(input) {
+        return this.execute(async () => {
+            const response = await this.dependencies.client.request(endpoints.taskDelivery(input.projectId, input.taskId));
+            const folder = await this.dependencies.worktreePool?.forTask(input.taskId);
+            return asJsonValue({
+                record: response.data,
+                folder: folder?.pendingDelivery ? folder.repoRoot : null,
+            });
+        });
+    }
+    async reportDeliveryOutcome(report) {
+        const path = report.outcome === 'delivered'
+            ? endpoints.taskDeliveryDeliver(report.projectId, report.taskId)
+            : endpoints.taskDeliveryCancel(report.projectId, report.taskId);
+        const body = report.outcome === 'delivered'
+            ? { commit: report.commit, pushed: report.pushed }
+            : { reason: report.reason };
+        await this.dependencies.outbox.enqueue({
+            operation: 'task.delivery',
+            method: 'POST',
+            path,
+            body,
+            projectId: report.projectId,
+            idempotencyKey: sha256(stableStringify({ path, body })),
+        });
+        this.deliverInBackground();
+    }
     async enqueueTaskReceipt(operation, path, taskId, repoRoot, content) {
         const repository = await this.dependencies.repositories.resolve(repoRoot);
         return this.taskExclusive(taskId, async () => {
@@ -4479,7 +4716,11 @@ export class BridgeService {
         for (const entry of entries) {
             const owner = taskIdFromDeliverySafe(entry);
             const body = objectOrEmpty(entry.body);
-            const key = owner ? 'task:' + owner : 'project:' + String(body.projectId ?? 'unscoped');
+            const key = owner
+                ? 'task:' + owner
+                : entry.operation === 'task.delivery'
+                    ? 'delivery:' + entry.path.slice(0, entry.path.lastIndexOf('/'))
+                    : 'project:' + String(body.projectId ?? 'unscoped');
             const group = groups.get(key) ?? [];
             group.push(entry);
             groups.set(key, group);
@@ -4505,6 +4746,12 @@ export class BridgeService {
                             synchronized.push(entry.id);
                         }
                         catch (error) {
+                            if (entry.operation === 'task.delivery' &&
+                                error instanceof ApiResponseError &&
+                                (error.httpStatus === 404 || error.httpStatus === 409)) {
+                                await this.dependencies.outbox.acknowledge(entry.id);
+                                continue;
+                            }
                             const errorKind = classifyError(error);
                             await this.dependencies.outbox.markAttempt(entry.id, errorKind);
                             if (entry.journalRef)
@@ -4874,6 +5121,9 @@ export class BridgeService {
             response = await this.dependencies.client.request(endpoints.taskClose, {
                 method: 'POST',
                 body,
+                ...(this.dependencies.clientVersion
+                    ? { headers: { 'x-client-version': this.dependencies.clientVersion } }
+                    : {}),
             });
         }
         catch (error) {
@@ -5139,6 +5389,17 @@ const modeWording = z.strictObject({
     autonomous: option,
     ask: option,
 });
+const liveStatusNoticeWording = z.strictObject({
+    managers: text,
+    off: text,
+});
+const liveStatusNoticeSchema = z.object({
+    projectId: z.uuid(),
+    organizationId: z.uuid(),
+    sharing: z.enum(['managers', 'off']),
+    noticeVersion: z.string().regex(/^[0-9a-f]{64}$/),
+    presented: z.boolean(),
+});
 const ruleDeviationWording = z.strictObject({
     ask: text,
     rule: text,
@@ -5371,7 +5632,7 @@ function deliveryQuestion(touchedContract, destination, publishApplicable) {
             : {}),
         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.'
+            ? "After the authorized delivery, call worktree.release in this folder with deliveryOutcome delivered: it publishes this task's source memory and then records the delivery for the project. Its sourcePublication says whether publication happened; call memory.publish_task only when it names a reason you can fix. A task without a worktree to release calls memory.publish_task after the commit instead."
             : 'This task has nothing to publish (see sourcePublication on the close response); do not call memory.publish_task.',
     });
 }

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

@@ -1,3 +1,4 @@
+import { LiveSignals } from './live-signals.js';
 import { ReleaseNotes } from './release-notes.js';
 import { WorktreePool } from './worktree-pool.js';
 import { WorktreePolicyCache } from './worktree-policy.js';
@@ -42,13 +43,16 @@ export function createBridgeService(options = {}) {
         credentials,
         cache,
         refreshPath: endpoints.authRefresh,
+        liveHeader: (path) => live.header(path),
     });
+    const live = new LiveSignals(client);
     const git = new GitInspector();
     const outbox = new OfflineOutbox(stateRoot);
     const activeContexts = new ActiveContextStore(stateRoot);
     const repositoryDecisions = new RepositoryDecisionStore(stateRoot);
     const updateChoices = new UpdateChoiceStore(stateRoot);
     const shadowNotices = new ShadowNoticeStore(stateRoot);
+    let service;
     const worktreePool = new WorktreePool(stateRoot, {
         ...(options.ownerId ? { ownerId: options.ownerId } : {}),
         pendingWork: async (entry) => {
@@ -59,11 +63,13 @@ export function createBridgeService(options = {}) {
                 pointer?.closeIntent ||
                 (await outbox.listForTask(entry.taskId)).length);
         },
+        onDeliveryOutcome: async (report) => service?.reportDeliveryOutcome(report),
     });
     const gate = new VerificationGate(stateRoot, git, outbox, undefined, worktreePool);
     const principalState = new PrincipalStateGuard(stateRoot, credentials, cache, outbox, activeContexts, gate);
     const languages = new LanguageStore(stateRoot);
-    return new BridgeService({
+    return (service = new BridgeService({
+        live,
         releaseNotes: new ReleaseNotes(stateRoot, client, credentials),
         worktreePool,
         worktreePolicy: new WorktreePolicyCache(stateRoot),
@@ -83,6 +89,6 @@ export function createBridgeService(options = {}) {
         onboarding: new OnboardingStore(stateRoot),
         clientVersion: options.clientVersion === undefined ? config.clientVersion : options.clientVersion,
         principalState,
-    });
+    }));
 }
 //# sourceMappingURL=create-bridge-service.js.map