engineering-memory 1.11.14 → 1.11.16

package/dispatcher/sections.mjs

@@ -20,7 +20,7 @@ Never answer a question about a bound repository from the working tree alone. Wh
 
 After compaction, a new chat, interruption, or handoff, call \`session.resume\` before continuing.
 
-Before a new write/scaffold task, call \`task.branch\` directly: do not ask the user where, from which branch or under which name first, and do not call \`worktree.list\` for it. Its one native form asks where the task works, which branch it starts from and the branch name, and nothing is created until the user answers. The pool reuses a safely available worktree slot before creating another; never pass or invent a worktree path. Reconcile protected legacy entries through the native recovery flow; clean files alone do not establish that the old agent and delivery have finished. Run all commands from its returned \`repoRoot\`. Renew \`task.heartbeat\` during actual work, use \`task.pause\` on handoff, and resume before writing again. Inactivity never permits force checkout or cleanup. Keep closed worktrees until authorized delivery completes. When \`session.entry\` says the user can manage them, unanswered shared branch preferences are asked together in one native form via \`project.set_git_preferences\`; other members choose only their own task base in \`task.branch\`. Answering "Not now" returns \`deferred\` with nothing allocated and a \`reconsider\` call; say so in one line, keep working on anything that does not depend on it, and make that \`reconsider\` call only when the user actually asks to start that task.
+Before a new write/scaffold task, call \`task.branch\` directly: do not ask the user where, from which branch or under which name first, and do not call \`worktree.list\` for it. Its short native form asks only the starting branch and where to work. It generates the new branch name automatically; do not ask the user to name it unless they request a specific name. Nothing is created until the user answers. The pool reuses a safely available worktree slot before creating another; never pass or invent a worktree path. Reconcile protected legacy entries through the native recovery flow; clean files alone do not establish that the old agent and delivery have finished. Run all commands from its returned \`repoRoot\`. Renew \`task.heartbeat\` during actual work, use \`task.pause\` on handoff, and resume before writing again. Inactivity never permits force checkout or cleanup. Keep closed worktrees until authorized delivery completes. When \`session.entry\` says the user can manage them, unanswered shared branch preferences are asked together in one native form via \`project.set_git_preferences\`; other members choose only their own task base in \`task.branch\`. Answering "Not now" returns \`deferred\` with nothing allocated and a \`reconsider\` call; say so in one line, keep working on anything that does not depend on it, and make that \`reconsider\` call only when the user actually asks to start that task.
 
 Do not edit until the skill lifecycle has completed discovery, its checkpoint, and \`context.prepare_change\`. Do not claim completion until \`task.verify\` succeeds.
 
@@ -28,7 +28,7 @@ Do not block independent task work on \`memory.propose_revision\` drafting, subm
 
 A check whose answer decides the next action — delivery preconditions such as the commit hook, the remote and the branch; whether verification or close can pass; what a waiver allows — is run by the agent that takes that action, in its own turn. Hand work to another agent only when you have other real work to do while it runs, and never take the action a delegated check gates before its answer is back. Work another agent checked is neither the user's approval nor task verification. Size delegation to the task — a one- or two-file change needs no multi-agent workflow — and once work is delegated, wait for its real completion signal, never a sleep loop polling its output.
 
-Use the host's native questionnaire for every question to the user, including implementation choices, names, clarification, branch/worktree decisions and delivery. For a required decision, use \`questionnaire.ask\` to open a durable native MCP form and \`questionnaire.resume\` to return to the same unanswered question. Read the skill's questionnaires reference first. Write every question in the user's language, say in \`context\` why it is asked, give in \`example\` one concrete thing the decision changes, and give every option a \`description\` of what happens next. Show a record by its title, never by an id or a hash. When the user says they did not understand, that is not an answer: explain in chat and show the same question again. Never use request_user_input_async for a required decision: it does not wait for an answer. When the durable form is unavailable, use a blocking native control only where the host permits it: request_user_input in Codex or AskUserQuestion in Claude. Never replace the questionnaire with a chat instruction such as 'type this', 'reply yes', or 'write X if you want Y'. Do not open a survey web page. If the required native control is unavailable or prohibited for that kind of question, follow the host's tool restrictions, explain the limitation, and continue only work already authorized; do not fabricate a survey or silently choose an answer. A timeout, dismissed form, empty response or ended turn is not an answer. Keep the decision pending and resume it; do not start dependent work or report it as resolved. Existing answers remain valid through retries and handoffs.
+Choose question detail to suit the decision: task start is short, while complex decisions retain context and examples. Put a deliberate recommended choice first and preserve the host's free-input path without requiring an option or adding a duplicate Other choice; feedback is not consent. Use the host's native questionnaire for every question to the user, including implementation choices, names, clarification, branch/worktree decisions and delivery. For a required decision, use \`questionnaire.ask\` to open a durable native MCP form and \`questionnaire.resume\` to return to the same unanswered question. Read the skill's questionnaires reference first. Write every question in the user's language, say in \`context\` why it is asked, give in \`example\` one concrete thing the decision changes, and give every option a \`description\` of what happens next. Show a record by its title, never by an id or a hash. When the user says they did not understand, that is not an answer: explain in chat and show the same question again. Never use request_user_input_async for a required decision: it does not wait for an answer. When the durable form is unavailable, use a blocking native control only where the host permits it: request_user_input in Codex or AskUserQuestion in Claude. Never replace the questionnaire with a chat instruction such as 'type this', 'reply yes', or 'write X if you want Y'. Do not open a survey web page. If the required native control is unavailable or prohibited for that kind of question, follow the host's tool restrictions, explain the limitation, and continue only work already authorized; do not fabricate a survey or silently choose an answer. A timeout, dismissed form, empty response or ended turn is not an answer. Keep the decision pending and resume it; do not start dependent work or report it as resolved. Existing answers remain valid through retries and handoffs.
 
 When a durable MCP form cannot be displayed, read its \`hostFallback\` or call \`questionnaire.resume\` with \`presentation: host_native\` to get the original question without reopening the MCP form. Display the same question, all choices and notices through a blocking native control only if the host permits that control for this decision. After an actual native answer, call \`questionnaire.answer_from_host\` with the unchanged questionnaireId, requestKey and contentHash, the hostTool name and the returned choice/text. This is an agent-reported relay, not MCP transport attestation. Then retry the owning operation; its authority, content and version checks still apply. Never relay prose consent, a default, an asynchronous response or a cancelled/declined/missing answer. Decline alone is not proof that the host cannot display forms. Keep the decision pending if no permitted native control can represent it.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engineering-memory",
-  "version": "1.11.14",
+  "version": "1.11.16",
   "description": "Installs the Engineering Memory skill and its local MCP bridge. Sign in after installing; your organization and project are resolved from your account.",
   "license": "UNLICENSED",
   "type": "module",

package/runtime/build.json

@@ -1,3 +1,3 @@
 {
-  "gitHead": "df9e70a543ee3b3f57a102e251df657ef6a62618"
+  "gitHead": "9623849ae66a8cc72716533cb131790a4c517ac7"
 }

package/runtime/dist/src/mcp/questionnaire-tools.js

@@ -42,12 +42,21 @@ export async function resumeQuestionnaire(server, service, input, context) {
 }
 export async function answerQuestionnaireFromHost(service, input) {
     try {
-        if (input.answer?.choice === explain) {
+        if (input.answer?.choice === explain ||
+            input.answer?.choice === '__other__' ||
+            Object.values(input.answers ?? {}).some((answer) => answer.choice === '__other__')) {
             const record = await service.questionnaireResume(input);
             if (record.status === 'pending' &&
                 record.requestKey === input.requestKey &&
-                record.contentHash === input.contentHash)
-                return pending(record, 'needs_explanation');
+                record.contentHash === input.contentHash) {
+                if (input.answer?.choice === explain)
+                    return pending(record, 'needs_explanation');
+                if (record.questions || !record.allowFreeText) {
+                    const feedback = input.answer ??
+                        Object.values(input.answers ?? {}).find((answer) => answer.choice === '__other__');
+                    return feedbackResult(record, feedback?.text);
+                }
+            }
         }
         const resolved = await service.questionnaireAnswerFromHost(input);
         return answered(resolved.record, resolved.answer, resolved.replayed, resolved.retry);
@@ -77,11 +86,33 @@ async function present(server, service, record, repoRoot, context, preparation,
     const response = inputResponse(responses, record.requestKey);
     if (response.kind === 'elicit' && response.action === 'accept') {
         const content = acceptedContent(responses, record.requestKey);
-        if (content?.choice === explain || content?.[explain] === true) {
+        if (content?.choice === explain ||
+            content?.[explain] === true ||
+            record.questions?.some((question) => content?.[question.id] === explain)) {
             consumedResponses(context).add(record.requestKey);
             return pending(record, 'needs_explanation');
         }
-        const parsed = questionnaireAnswerSchema(record).safeParse(record.questions && content ? formAnswers(record, content) : content);
+        if (content?.__feedback__ !== undefined &&
+            !(typeof content.__feedback__ === 'string' && !content.__feedback__.trim())) {
+            consumedResponses(context).add(record.requestKey);
+            return feedbackResult(record, content.__feedback__);
+        }
+        if (!record.questions &&
+            !record.allowFreeText &&
+            !content?.choice &&
+            typeof content?.text === 'string' &&
+            content.text.trim()) {
+            consumedResponses(context).add(record.requestKey);
+            return feedbackResult(record, content.text);
+        }
+        const { __feedback__: _feedback, ...answerContent } = content ?? {};
+        if (!record.questions &&
+            record.allowFreeText &&
+            !answerContent.choice &&
+            typeof answerContent.text === 'string' &&
+            answerContent.text.trim())
+            answerContent.choice = '__other__';
+        const parsed = questionnaireAnswerSchema(record).safeParse(record.questions ? formAnswers(record, answerContent) : answerContent);
         const answer = parsed.success ? parsed.data : undefined;
         if (!answer)
             return pending(record, 'invalid_response');
@@ -109,15 +140,22 @@ async function present(server, service, record, repoRoot, context, preparation,
         return pending(record, 'native_form_unavailable');
     const copy = copyFor(record);
     if (record.questions) {
+        const compact = record.questionnaireId.startsWith('task-start-') && !!record.binding;
         const properties = {};
         for (const sub of record.questions) {
+            const options = compact && sub.otherAsText
+                ? sub.options.filter((option) => option.id !== 'other')
+                : sub.options;
             properties[sub.id] = {
                 type: 'string',
                 title: sub.message,
-                enum: sub.options.map((option) => option.id),
-                enumNames: sub.options.map((option) => option.label),
+                description: [sub.context, sub.example && `${copy.example}: ${sub.example}`]
+                    .filter(Boolean)
+                    .join('\n'),
+                enum: options.map((option) => option.id),
+                enumNames: optionLabels(options, copy),
             };
-            if (sub.textField)
+            if (sub.textField && !(compact && sub.otherAsText))
                 properties[`${sub.id}_text`] = {
                     type: 'string',
                     title: sub.textField.title,
@@ -125,12 +163,12 @@ async function present(server, service, record, repoRoot, context, preparation,
                     maxLength: sub.textField.maxLength,
                 };
         }
-        properties[explain] = { type: 'boolean', title: copy.explain };
+        properties.__feedback__ = { type: 'string', title: copy.feedback, maxLength: 2000 };
         return inputRequired({
             inputRequests: {
                 [record.requestKey]: inputRequired.elicit({
                     mode: 'form',
-                    message: presentationMessage(record),
+                    message: presentationMessage(record, compact),
                     requestedSchema: { type: 'object', properties },
                 }),
             },
@@ -147,23 +185,14 @@ async function present(server, service, record, repoRoot, context, preparation,
                         choice: {
                             type: 'string',
                             title: copy.answer,
-                            enum: [
-                                ...record.options.map((option) => option.id),
-                                ...(record.allowFreeText ? ['__other__'] : []),
-                                explain,
-                            ],
-                            enumNames: [
-                                ...record.options.map((option) => option.label),
-                                ...(record.allowFreeText ? [copy.other] : []),
-                                copy.explain,
-                            ],
+                            enum: record.options.map((option) => option.id),
+                            enumNames: optionLabels(record.options, copy),
                         },
                         ...(record.allowFreeText
                             ? {
                                 text: {
                                     type: 'string',
-                                    title: copy.otherAnswer,
-                                    minLength: 1,
+                                    title: copy.freeAnswer,
                                     maxLength: 2000,
                                 },
                             }
@@ -178,8 +207,10 @@ async function present(server, service, record, repoRoot, context, preparation,
                                 },
                             }
                             : {}),
+                        ...(!record.allowFreeText
+                            ? { __feedback__: { type: 'string', title: copy.feedback, maxLength: 2000 } }
+                            : {}),
                     },
-                    required: ['choice'],
                 },
             }),
         },
@@ -195,25 +226,25 @@ function consumedResponses(context) {
 const questionnaireCopy = {
     en: {
         pending: 'Choose an answer to resolve this decision. Closing or cancelling the form leaves it pending.',
-        freeText: ' For another answer choose Other and fill in text. Free text is not stored and cannot be replayed.',
+        freeText: ' You can type a different answer without choosing an option. Free text is not stored and cannot be replayed.',
         storedText: ' The bounded text field is stored as part of this exact decision and is replayed after restart.',
-        everyQuestion: ' Answer every question before submitting, unless you pick an option that ends the form.',
+        everyQuestion: ' To record a decision, answer each question or choose an option that ends the form. You can send a comment without selecting any option.',
         example: 'Example',
-        explain: 'I did not understand; explain in more detail first',
         answer: 'Answer',
-        other: 'Other',
-        otherAnswer: 'Other answer',
+        freeAnswer: 'Write another answer (optional)',
+        recommended: 'Recommended',
+        feedback: 'Write an answer or comment (optional)',
     },
     tr: {
         pending: 'Kararını kaydetmek için bir seçenek seç. Formu kapatmak veya iptal etmek onay sayılmaz; soru beklemede kalır.',
-        freeText: ' Farklı bir yanıt için Diğer seçeneğini seçip metin alanını doldur. Serbest yanıt saklanmaz ve daha sonra geri getirilemez.',
+        freeText: ' Bir seçenek seçmeden farklı yanıtını yazabilirsin. Serbest yanıt saklanmaz ve daha sonra geri getirilemez.',
         storedText: ' Bu metin alanındaki yanıt kararınla birlikte saklanır; yeniden başlattığında korunur.',
-        everyQuestion: ' Göndermeden önce her soruyu cevapla; formu bitiren bir seçenek seçtiysen gerekmez.',
+        everyQuestion: ' Karar vermek için soruları cevapla veya formu bitiren bir seçenek seç. Hiçbir seçenek seçmeden yorum da gönderebilirsin.',
         example: 'Örnek',
-        explain: 'Anlamadım; önce daha ayrıntılı anlat',
         answer: 'Yanıt',
-        other: 'Diğer',
-        otherAnswer: 'Diğer yanıt',
+        freeAnswer: 'Farklı yanıtını yaz (isteğe bağlı)',
+        recommended: 'Önerilen',
+        feedback: 'Yanıtını veya yorumunu yaz (isteğe bağlı)',
     },
 };
 function formAnswers(record, content) {
@@ -231,23 +262,26 @@ function formAnswers(record, content) {
     }
     return answers;
 }
-function presentationMessage(record) {
+function presentationMessage(record, compact = false) {
     const copy = copyFor(record);
+    if (compact)
+        return [
+            record.message,
+            record.context,
+            record.example,
+            record.language?.startsWith('tr')
+                ? 'İptal edersen başlamaz.'
+                : 'Cancelling does not start the task.',
+        ]
+            .filter(Boolean)
+            .join('\n');
     const explained = (item) => [
         item.context,
         item.example && `${copy.example}: ${item.example}`,
-        (item.options ?? [])
-            .filter((option) => option.description)
-            .map((option) => `${option.label}: ${option.description}`)
-            .join('\n'),
     ];
     return [
         record.message,
         ...explained(record),
-        ...(record.questions ?? []).flatMap((sub) => {
-            const details = explained(sub).filter(Boolean);
-            return details.length ? [sub.message, ...details] : [];
-        }),
         `${copy.pending}${record.questions ? copy.everyQuestion : ''}${record.allowFreeText ? copy.freeText : ''}${record.textField ? copy.storedText : ''}`,
     ]
         .filter(Boolean)
@@ -256,19 +290,38 @@ function presentationMessage(record) {
 function copyFor(record) {
     return questionnaireCopy[record.language?.startsWith('tr') ? 'tr' : 'en'];
 }
-function pending(record, reason) {
+function optionLabels(options, copy) {
+    const recommended = options.find((option) => option.label.includes(`(${copy.recommended})`))?.id ?? options[0].id;
+    return options.map((option) => {
+        const label = option.id === recommended && !option.label.includes(`(${copy.recommended})`)
+            ? `${option.label} (${copy.recommended})`
+            : option.label;
+        return option.description ? `${label} — ${option.description}` : label;
+    });
+}
+function feedbackResult(record, text) {
+    if (typeof text !== 'string' || !text.trim() || text.length > 2000)
+        return pending(record, 'invalid_response');
+    return pending(record, 'feedback', { text: text.trim() });
+}
+function pending(record, reason, feedback) {
     return result({
         questionnaireId: record.questionnaireId,
         status: 'pending',
         reason,
+        ...(feedback ? { feedback } : {}),
         answerAvailable: false,
         hostFallback: {
             operation: 'questionnaire.answer_from_host',
             questionnaireId: record.questionnaireId,
             requestKey: record.requestKey,
             contentHash: record.contentHash,
-            message: presentationMessage(record),
+            message: presentationMessage(record, record.questionnaireId.startsWith('task-start-') && !!record.binding),
             language: record.language ?? 'en',
+            freeTextFeedback: {
+                relayChoice: '__other__',
+                recordsDecision: !record.questions && record.allowFreeText,
+            },
             ...(record.questions
                 ? {
                     questions: record.questions,
@@ -281,15 +334,17 @@ function pending(record, reason) {
                 }),
             instructions: `${record.questions
                 ? 'Only if the host permits a blocking native control for this decision, display every question, its options and notices in AskUserQuestion or request_user_input, one call at a time if needed. Relay every answer together in one questionnaire.answer_from_host call as `answers`, keyed by question id. Closing, declining, timeout, prose consent and missing answers are not native answers for any question. Do not reopen a dismissed question in a loop or label decline as proof of host incompatibility. The relay records agent-reported provenance, not MCP transport attestation. Retry the owning operation after acceptance; its authority and version checks still apply.'
-                : 'Only if the host permits a blocking native control for this decision, display this exact question, all options and notices in AskUserQuestion or request_user_input. Relay only the actual returned answer with these unchanged bindings. Closing, declining, timeout, prose consent and missing answers are not native answers. Do not reopen a dismissed question in a loop or label decline as proof of host incompatibility. The relay records agent-reported provenance, not MCP transport attestation. Retry the owning operation after acceptance; its authority and version checks still apply.'} Show each option's description under its label. If the person says they did not understand, including through the control's free-text answer, that is not an answer: call questionnaire.answer_from_host with answer {choice: "${explain}"} and the same bindings, and the decision stays pending.${(record.options?.length ?? 0) > 4
+                : 'Only if the host permits a blocking native control for this decision, display this exact question, all options and notices in AskUserQuestion or request_user_input. Relay only the actual returned answer with these unchanged bindings. Closing, declining, timeout, prose consent and missing answers are not native answers. Do not reopen a dismissed question in a loop or label decline as proof of host incompatibility. The relay records agent-reported provenance, not MCP transport attestation. Retry the owning operation after acceptance; its authority and version checks still apply.'} Keep the question proportional to the decision: short for task start, detailed when needed; do not omit context, examples or consequences. Mark the explicitly recommended option, otherwise the first option, as recommended without treating it as an answer. Use the host control's existing free-text input so the person can write without picking an option. Do not add a duplicate Other choice or a second feedback question. Relay that actual native text through the internal __other__ choice with text and preserve all bindings. This internal relay identifier is not a visible option. Show each option's description under its label. If the person says they did not understand, including through the control's free-text answer, that is not an answer: call questionnaire.answer_from_host with answer {choice: "${explain}"} and the same bindings, and the decision stays pending.${(record.options?.length ?? 0) > 4
                 ? ' The host control shows fewer options than this question has: show them three at a time with one more option that reveals the rest, and relay only the final pick.'
                 : ''}`,
         },
-        nextAction: reason === 'needs_explanation'
-            ? 'The person asked for more detail and the decision is still pending. Explain in chat, in their language, why this is asked, what each option does next and one concrete example. Then show the same question once more with questionnaire.resume. Do not infer an answer.'
-            : reason === 'native_form_unavailable'
-                ? 'This host does not advertise native MCP forms. The decision remains pending. Explain the limitation and continue only independently authorized work. Use hostFallback only with a permitted blocking native control; otherwise keep pending. Never substitute an asynchronous question.'
-                : 'The decision remains pending without expiry. Call questionnaire.resume with this questionnaireId to show the same question again. Do not infer an answer or continue dependent work.',
+        nextAction: reason === 'feedback'
+            ? 'The person provided feedback, not consent. Address it in their language. The original decision is still pending and no choice has been saved. Resume it after explaining, or compose a new bound question if the requested choices change. Do not persist arbitrary feedback text.'
+            : reason === 'needs_explanation'
+                ? 'The person asked for more detail and the decision is still pending. Explain in chat, in their language, why this is asked, what each option does next and one concrete example. Then show the same question once more with questionnaire.resume. Do not infer an answer.'
+                : reason === 'native_form_unavailable'
+                    ? 'This host does not advertise native MCP forms. The decision remains pending. Explain the limitation and continue only independently authorized work. Use hostFallback only with a permitted blocking native control; otherwise keep pending. Never substitute an asynchronous question.'
+                    : 'The decision remains pending without expiry. Call questionnaire.resume with this questionnaireId to show the same question again. Do not infer an answer or continue dependent work.',
     });
 }
 function answered(record, answer, replayed, retry) {

package/runtime/dist/src/mcp/worktree-tools.js

@@ -358,7 +358,7 @@ export function registerWorktreeTools(server, service) {
         inputSchema: z.strictObject(policy),
     }, async (input) => output(await service.worktreePolicy(json(input))));
     server.registerTool('task.branch', {
-        description: 'Start a write task with ONE durable native form: where the branch starts (unless base is given), the new branch name with a suggested default (unless name is given), and the folder: a separate managed worktree, this folder as a new branch when it is clean (moving out an unfinished task that holds it, named in the option), this folder on its current branch, or not now. Nothing is created until the user answers; the next call with the same arguments allocates. A remote base is fetched and its exact commit pinned. Retry/resume preserves the allocation. Not now returns status deferred with the exact reconsider call; retries keep the same decisionAttempt. Use the returned repoRoot for ALL commands. A read-only task allocates only when transitioning to write.',
+        description: 'Start a write task with ONE durable native form: two short questions for the starting branch (unless base is given) and the folder. A unique branch name is generated automatically unless name is supplied. Folder options: a separate managed worktree, this folder as a new branch when it is clean (moving out an unfinished task that holds it, named in the option), this folder on its current branch, or not now. Nothing is created until the user answers; the next call with the same arguments allocates. A remote base is fetched and its exact commit pinned. Retry/resume preserves the allocation. Not now returns status deferred with the exact reconsider call; retries keep the same decisionAttempt. Use the returned repoRoot for ALL commands. A read-only task allocates only when transitioning to write.',
         inputSchema: z.strictObject({
             repoRoot: repo,
             externalTaskId: z.string().min(2).max(160),
@@ -401,14 +401,15 @@ export function registerWorktreeTools(server, service) {
                 keepCurrent: input.keepCurrent,
             }),
         };
-        const form = await askQuestionnaire(server, service, { ...definition, repoRoot: input.repoRoot, presentation: input.presentation }, context, [previous], owner);
+        const form = await askQuestionnaire(server, service, { ...definition, repoRoot: input.repoRoot, presentation: input.presentation }, context, previous, owner);
         const record = await service
             .questionnaireResume({
             repoRoot: input.repoRoot,
             questionnaireId: definition.questionnaireId,
         })
             .catch(() => undefined);
-        const choice = record?.binding && stableStringify(record.binding) === stableStringify(definition.binding)
+        const choice = record?.binding &&
+            [definition, ...previous].some((offered) => stableStringify(record.binding) === stableStringify(offered.binding))
             ? taskStartChoice(record)
             : null;
         if (!choice)

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

@@ -544,7 +544,7 @@ export class BridgeService {
                 if ((!sourceCommit && !(previous && previous.baseCommit === null && !previous.managed)) ||
                     branch === undefined)
                     throw refuse('The task branch and base must be restored before resuming its worktree.', 'worktree.reconcile');
-                const allocation = await pool.allocate({
+                const allocation = await pool.prepare(await pool.allocate({
                     projectId,
                     projectName: projectId,
                     repoFingerprint: repository.repoFingerprint,
@@ -554,7 +554,7 @@ export class BridgeService {
                     baseCommit: sourceCommit ?? null,
                     keepCurrent: previous ? !previous.managed : false,
                     resume: true,
-                }, await this.poolPolicy());
+                }, await this.poolPolicy()));
                 await pool.bind(projectId, allocation.repoRoot, allocation.generation, pointer.taskId);
                 allocation.taskId = pointer.taskId;
                 this.poolAllocations.set(allocation.repoRoot, allocation);
@@ -2276,7 +2276,13 @@ export class BridgeService {
         for (const candidate of candidates)
             if (!(await this.unusableBranchName(repoRoot, candidate)))
                 return candidate;
-        return candidates[0];
+        const git = this.dependencies.repositories.git;
+        let suffix = candidates.length + 1;
+        while (await git.branchExists(repoRoot, candidates[0] + '-' + suffix))
+            suffix++;
+        const name = candidates[0] + '-' + suffix;
+        await git.validateBranch(repoRoot, name);
+        return name;
     }
     async unusableBranchName(repoRoot, name) {
         const git = this.dependencies.repositories.git;
@@ -2609,7 +2615,7 @@ export class BridgeService {
         const allocationTimer = startPhaseTimer('task.branch.allocate');
         const allocationPolicy = await this.poolPolicy(true);
         allocationTimer.mark('policy');
-        const allocation = await pool.allocate({
+        const allocation = await pool.prepare(await pool.allocate({
             projectId,
             projectName: preferences.projectName ?? projectId,
             repoFingerprint: repository.repoFingerprint,
@@ -2620,7 +2626,7 @@ export class BridgeService {
             keepCurrent: input.keepCurrent,
             inPlace: !existing && input.inPlace,
             resume: Boolean(existing),
-        }, allocationPolicy);
+        }, allocationPolicy));
         allocationTimer.mark('pool_allocate');
         allocationTimer.finish();
         this.poolAllocations.set(allocation.repoRoot, allocation);
@@ -2642,7 +2648,7 @@ export class BridgeService {
         return asJsonValue({
             ...allocation,
             kept: !allocation.managed,
-            nextAction: 'Run every file, terminal, lifecycle and delivery operation from this repoRoot. Use task.heartbeat during long work. Pause before handing the task to another client.',
+            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.',
         });
     }
     adoptOwned(repoRoot, entry) {

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

@@ -73,6 +73,130 @@ export function configuredBase(preferences, role) {
         : null;
 }
 export function taskStartDefinition(facts) {
+    const { previous, ...legacy } = legacyTaskStartDefinition(facts);
+    const tr = facts.language === 'tr';
+    const binding = { ...legacy.binding };
+    const keepOnly = facts.keepCurrent === true || !facts.currentCommit;
+    if (!keepOnly) {
+        binding.name = facts.name ?? facts.suggestedName;
+        delete binding.suggestedName;
+    }
+    const seen = new Set();
+    const questions = legacy
+        .questions.filter((question) => question.id !== 'name')
+        .map((question) => {
+        if (question.id === 'base')
+            return {
+                ...question,
+                message: tr ? 'Hangi daldan başlayalım?' : 'Which starting branch?',
+                options: question.options
+                    .filter((option) => {
+                    const base = binding.bases?.[option.id];
+                    const identity = base ? stableStringify(base) : option.id;
+                    if (seen.has(identity))
+                        return false;
+                    seen.add(identity);
+                    return true;
+                })
+                    .map((option) => {
+                    const base = binding.bases?.[option.id];
+                    return {
+                        ...option,
+                        label: base?.kind === 'remote'
+                            ? sourceLabel(base, facts.currentBranch)
+                            : option.id === 'current'
+                                ? (tr ? 'Yerel: ' : 'Local: ') + (facts.currentBranch ?? 'HEAD')
+                                : tr
+                                    ? 'origin üzerinde başka dal'
+                                    : 'Another branch on origin',
+                        description: option.id === 'current'
+                            ? tr
+                                ? 'Çekmeden, mevcut commit’ten.'
+                                : 'Current commit; no fetch.'
+                            : option.id === 'other'
+                                ? tr
+                                    ? 'Alttaki alana yaz.'
+                                    : 'Enter it below.'
+                                : tr
+                                    ? 'Güncel hali çekilir.'
+                                    : 'Fetch the latest commit.',
+                    };
+                }),
+                textField: {
+                    ...question.textField,
+                    title: tr
+                        ? 'origin dalı (yalnızca başka dal için)'
+                        : 'Branch on origin (only for another branch)',
+                },
+            };
+        const holder = binding.holder?.externalTaskId;
+        return {
+            ...question,
+            message: tr ? 'Nerede çalışalım?' : 'Where should we work?',
+            ...(holder
+                ? {
+                    context: tr
+                        ? `Bu klasördeki ${holder} görevi burada başlarsan ayrı worktree’ye geçer; işi korunur.`
+                        : `Starting here moves ${holder} to a separate worktree; its work is kept.`,
+                }
+                : {}),
+            options: question.options.map((option) => ({
+                ...option,
+                label: option.id === 'worktree'
+                    ? tr
+                        ? 'Ayrı worktree'
+                        : 'Separate worktree'
+                    : option.id === 'here'
+                        ? tr
+                            ? 'Bu klasörde yeni dal'
+                            : 'New branch in this folder'
+                        : option.id === 'keep_current'
+                            ? tr
+                                ? 'Mevcut dalda kal'
+                                : 'Stay on the current branch'
+                            : tr
+                                ? 'Şimdilik başlatma'
+                                : 'Not now',
+                description: option.id === 'worktree'
+                    ? tr
+                        ? 'Bu klasör değişmez.'
+                        : 'Leave this folder unchanged.'
+                    : option.id === 'here'
+                        ? tr
+                            ? 'Klasör yeni dala geçer.'
+                            : 'Switch this folder to the new branch.'
+                        : option.id === 'keep_current'
+                            ? tr
+                                ? `${facts.currentBranch ?? 'HEAD'} üzerinde devam et.`
+                                : `Continue on ${facts.currentBranch ?? 'HEAD'}.`
+                            : tr
+                                ? 'Hiçbir şey oluşturulmaz.'
+                                : 'Create nothing.',
+            })),
+        };
+    });
+    questions.sort((left, right) => Number(right.id === 'base') - Number(left.id === 'base'));
+    return {
+        ...legacy,
+        message: tr ? 'Göreve başla' : 'Start task',
+        context: keepOnly
+            ? tr
+                ? 'Mevcut dalda devam edilecek.'
+                : 'Continue on the current branch.'
+            : (tr ? 'Yeni dal: ' : 'New branch: ') +
+                binding.name +
+                (binding.base ? ' · ' + sourceLabel(binding.base, facts.currentBranch) : ''),
+        example: keepOnly
+            ? legacy.example
+            : tr
+                ? 'Ayrı worktree, işi ayrı klasörde tutar.'
+                : 'A worktree keeps this task in its own folder.',
+        questions,
+        binding: JSON.parse(JSON.stringify(binding)),
+        previous: [previous, legacy],
+    };
+}
+function legacyTaskStartDefinition(facts) {
     const tr = facts.language === 'tr';
     const copy = startCopy[tr ? 'tr' : 'en'];
     const folder = facts.folder;