engineering-memory 1.11.21 → 1.11.23

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

@@ -1,6 +1,6 @@
 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';
@@ -689,6 +689,18 @@ export class BridgeService {
                 (repository.projectId && repository.projectId !== projectId)) {
                 throw refuse('The live task belongs to a different project than the one this repository is bound to.', 'project.resolve');
             }
+            if (pointer?.closedAt &&
+                pointer.worktreeGeneration &&
+                this.dependencies.worktreePool &&
+                !(await this.dependencies.worktreePool.find(projectId, taskSlug, repository.repoRoot)))
+                return asJsonValue({
+                    taskClosed: true,
+                    folderReleased: true,
+                    branch: pointer.branch ?? null,
+                    ...pendingQuestionnairesFields(pendingQuestionnaires),
+                    repository: publicRepository(repository),
+                    nextAction: 'This task is closed and its folder has been released, so there is nothing to resume or release. Its branch keeps the committed work; start new work with task.branch.',
+                });
             const adoptable = pointer &&
                 !pointer.worktreeGeneration &&
                 normalizeTaskMode(pointer.mode) !== 'read_only' &&
@@ -1677,10 +1689,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') {
@@ -2256,11 +2289,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) }
                                 : {}),
@@ -2533,9 +2562,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)
@@ -2730,6 +2794,17 @@ export class BridgeService {
                 return asJsonValue({ operation, complete: true, removed: entry.repoRoot });
             }
             const entry = await pool.forPath(projectId, repository.repoRoot);
+            if ((operation === 'release' || operation === 'cancel_delivery') &&
+                !(await pool.find(projectId, input.externalTaskId, repository.repoRoot)) &&
+                ((entry?.phase === 'released' && entry.externalTaskId === input.externalTaskId) ||
+                    (await this.dependencies.activeContexts.loadForSlug(repository.repoFingerprint, input.externalTaskId))?.worktreeGeneration === input.generation))
+                return asJsonValue({
+                    operation,
+                    complete: true,
+                    repoRoot: repository.repoRoot,
+                    alreadyReleased: true,
+                    nextAction: "This task's folder was already released; there is nothing left to release.",
+                });
             if (!entry ||
                 entry.externalTaskId !== input.externalTaskId ||
                 entry.generation !== input.generation)
@@ -2750,8 +2825,17 @@ export class BridgeService {
                     }
                     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);
+                        return asJsonValue({
+                            operation,
+                            complete: true,
+                            repoRoot: repository.repoRoot,
+                            ...(sourcePublication ? { sourcePublication } : {}),
+                        });
                     }
                     if (operation === 'cancel_delivery') {
                         if (!entry.pendingDelivery)
@@ -2859,7 +2943,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);
@@ -2891,6 +2976,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();
@@ -3702,6 +3788,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));
@@ -4000,7 +4102,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
@@ -4021,6 +4123,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);
@@ -4060,6 +4165,7 @@ export class BridgeService {
                 ...(pendingQuestionnaires.deferred.length > 0
                     ? { deferredTaskStarts: pendingQuestionnaires.deferred }
                     : {}),
+                ...(deliveries ? { openDeliveries: deliveries } : {}),
                 client,
                 ...moved,
                 ...(incomplete && state === 'bound'
@@ -4103,6 +4209,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`);
@@ -4408,6 +4538,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 () => {
@@ -4456,7 +4624,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);
@@ -4482,6 +4654,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)
@@ -4851,6 +5029,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) {
@@ -5348,7 +5529,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

@@ -49,6 +49,7 @@ export function createBridgeService(options = {}) {
     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 +60,12 @@ 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({
         releaseNotes: new ReleaseNotes(stateRoot, client, credentials),
         worktreePool,
         worktreePolicy: new WorktreePolicyCache(stateRoot),
@@ -83,6 +85,6 @@ export function createBridgeService(options = {}) {
         onboarding: new OnboardingStore(stateRoot),
         clientVersion: options.clientVersion === undefined ? config.clientVersion : options.clientVersion,
         principalState,
-    });
+    }));
 }
 //# sourceMappingURL=create-bridge-service.js.map

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

@@ -170,6 +170,13 @@ const answerSourceSchema = z.union([
         impact: z.enum(['routine', 'critical']),
     }),
 ]);
+export function answerSourceName(source) {
+    return source?.kind === 'delegated_agent'
+        ? 'delegated_agent'
+        : source?.kind === 'host_native_relay'
+            ? source.hostTool
+            : 'mcp_form';
+}
 const storedAnswerSchema = z.strictObject({
     requestKey: z.string().regex(/^questionnaire_[0-9a-f]{64}$/),
     answeredAt: z.string().datetime(),

package/runtime/dist/src/runtime/task-start.js

@@ -18,6 +18,7 @@ const startCopy = {
         fetched: (role, source) => `The project's ${role} branch ${source} is fetched from the remote and the new branch starts from that exact commit.`,
         pinned: (source) => `The new branch starts where this folder is right now, ${source}. Nothing is fetched.`,
         typedBranch: 'Write a branch name on origin below. It is fetched and the new branch starts from it.',
+        continued: (branch) => `No new branch is created. The work continues from the newest commit of ${branch}, fetched from origin when this clone lacks it.`,
         suggested: 'The branch is created with this name.',
         typedName: 'Write the name below. A name that already exists is refused and the form is asked again.',
     },
@@ -37,6 +38,7 @@ const startCopy = {
         fetched: (role, source) => `Projenin ${role} dalı ${source} uzak sunucudan çekilir ve yeni dal tam o commit’ten başlar.`,
         pinned: (source) => `Yeni dal, bu klasörün şu an üzerinde olduğu ${source} noktasından başlar. Hiçbir şey çekilmez.`,
         typedBranch: 'origin üzerindeki dal adını aşağıya yaz. O dal çekilir ve yeni dal ondan başlar.',
+        continued: (branch) => `Yeni dal açılmaz. İş ${branch} dalının en yeni commit’inden sürer; bu klonda yoksa origin’den çekilir.`,
         suggested: 'Dal bu adla açılır.',
         typedName: 'Adı aşağıya yaz. Zaten var olan bir ad kabul edilmez, form yeniden sorulur.',
     },
@@ -47,6 +49,8 @@ const startWording = z.strictObject({
     message: text,
     keepContext: text,
     newBranch: text,
+    newBranchOrContinue: text,
+    continuePlan: text,
     example: text,
     stay: text,
     base: z.strictObject({
@@ -56,6 +60,9 @@ const startWording = z.strictObject({
         other: text,
         otherDetail: text,
         fetchDetail: text,
+        continue: text,
+        continueDetail: text,
+        continueOpenDetail: text,
         field: text,
     }),
     location: z.strictObject({
@@ -92,6 +99,8 @@ export function sourceLabel(base, currentBranch) {
         return base.remote + '/' + base.branch;
     if (base.kind === 'local')
         return base.ref;
+    if (base.kind === 'existing')
+        return base.branch;
     if (base.kind === 'current')
         return (currentBranch ?? 'HEAD') + (base.commit ? ' (' + base.commit.slice(0, 7) + ')' : '');
     return base.kind;
@@ -135,14 +144,20 @@ export function taskStartDefinition(facts) {
                         ...option,
                         label: base?.kind === 'remote'
                             ? sourceLabel(base, facts.currentBranch)
+                            : base?.kind === 'existing'
+                                ? format(copy.base.continue, language, { branch: base.branch })
+                                : option.id === 'current'
+                                    ? format(copy.base.local, language, { branch })
+                                    : copy.base.other,
+                        description: base?.kind === 'existing'
+                            ? facts.openDeliveryBranches?.includes(base.branch)
+                                ? copy.base.continueOpenDetail
+                                : copy.base.continueDetail
                             : option.id === 'current'
-                                ? format(copy.base.local, language, { branch })
-                                : copy.base.other,
-                        description: option.id === 'current'
-                            ? copy.base.localDetail
-                            : option.id === 'other'
-                                ? copy.base.otherDetail
-                                : copy.base.fetchDetail,
+                                ? copy.base.localDetail
+                                : option.id === 'other'
+                                    ? copy.base.otherDetail
+                                    : copy.base.fetchDetail,
                     };
                 }),
                 textField: { ...question.textField, title: copy.base.field },
@@ -184,8 +199,11 @@ export function taskStartDefinition(facts) {
         message: copy.message,
         context: keepOnly
             ? copy.keepContext
-            : format(copy.newBranch, language, { name: binding.name }) +
-                (binding.base ? ' · ' + sourceLabel(binding.base, facts.currentBranch) : ''),
+            : binding.base?.kind === 'existing'
+                ? format(copy.continuePlan, language, { branch: binding.base.branch })
+                : format(Object.values(binding.bases ?? {}).some((base) => base.kind === 'existing')
+                    ? copy.newBranchOrContinue
+                    : copy.newBranch, language, { name: binding.name }) + (binding.base ? ' · ' + sourceLabel(binding.base, facts.currentBranch) : ''),
         example: keepOnly ? format(copy.stay, language, { source: current }) : copy.example,
         questions,
         binding: JSON.parse(JSON.stringify(binding)),
@@ -269,17 +287,27 @@ function legacyTaskStartDefinition(facts) {
             label: base.remote + '/' + base.branch + ' (' + role + ')',
             description: copy.fetched(copy.roles[role], base.remote + '/' + base.branch),
         });
+        const continued = facts.continueBranches ?? [];
         binding.bases = {
             current: {
                 kind: 'current',
                 ...(facts.currentCommit ? { commit: facts.currentCommit } : {}),
             },
             ...Object.fromEntries(roles.map(({ role, base }) => [role, base])),
+            ...Object.fromEntries(continued.map((branch, index) => [
+                'continue_' + (index + 1),
+                { kind: 'existing', branch },
+            ])),
         };
         questions.push({
             id: 'base',
             message: tr ? 'Hangi daldan başlasın?' : 'Which branch should it start from?',
             options: [
+                ...continued.map((branch, index) => ({
+                    id: 'continue_' + (index + 1),
+                    label: (tr ? 'Var olan dalı sürdür: ' : 'Continue the existing branch ') + branch,
+                    description: copy.continued(branch),
+                })),
                 ...roles.slice(0, 1).map(roleOption),
                 {
                     id: 'current',
@@ -422,12 +450,14 @@ export function taskStartChoice(record) {
                 ? binding.bases?.[baseAnswer.choice]
                 : undefined);
     const nameAnswer = record.answers.name;
-    const name = binding.name ??
-        (nameAnswer?.choice === 'custom'
-            ? nameAnswer.text
-            : nameAnswer?.choice === 'suggested'
-                ? binding.suggestedName
-                : undefined);
+    const name = base?.kind === 'existing'
+        ? base.branch
+        : (binding.name ??
+            (nameAnswer?.choice === 'custom'
+                ? nameAnswer.text
+                : nameAnswer?.choice === 'suggested'
+                    ? binding.suggestedName
+                    : undefined));
     if (!base || !name)
         return null;
     return {