engineering-memory 1.11.21 → 1.11.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engineering-memory",
-  "version": "1.11.21",
+  "version": "1.11.23",
   "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": "9df251d4cf095e0f9ed2e7da4e480bbf60142c81"
+  "gitHead": "c1f7c36543eddba364aa3e853bd8ffe0a80bcb43"
 }

package/runtime/dist/src/config.js

@@ -65,6 +65,11 @@ export const endpoints = {
     taskAbandon: '/runtime/task/abandon',
     taskStatus: (taskId) => `/runtime/task/${taskId}/status`,
     taskCommitGate: '/runtime/task/commit-gate',
+    projectDeliveries: (projectId) => `/projects/${projectId}/deliveries`,
+    taskDelivery: (projectId, taskId) => `/projects/${projectId}/tasks/${taskId}/delivery`,
+    taskDeliveryAnswer: (projectId, taskId) => `/projects/${projectId}/tasks/${taskId}/delivery/answer`,
+    taskDeliveryDeliver: (projectId, taskId) => `/projects/${projectId}/tasks/${taskId}/delivery/deliver`,
+    taskDeliveryCancel: (projectId, taskId) => `/projects/${projectId}/tasks/${taskId}/delivery/cancel`,
     projectSetup: '/projects/setup',
     projectList: '/projects',
     projectResolve: '/projects/resolve',
@@ -74,6 +79,7 @@ export const endpoints = {
     workItemRuns: (projectId, workItemId) => `/projects/${projectId}/work-items/${workItemId}/runs`,
     workItemRestore: (projectId, workItemId) => `/projects/${projectId}/work-items/${workItemId}/restore`,
     workItemTests: (projectId, workItemId) => `/projects/${projectId}/work-items/${workItemId}/tests`,
+    workItemComments: (projectId, workItemId) => `/projects/${projectId}/work-items/${workItemId}/comments`,
     workItemPlan: (projectId, workItemId) => `/projects/${projectId}/work-items/${workItemId}/plan`,
     projectArchive: (projectId) => `/projects/${projectId}`,
     projectRestore: (projectId) => `/projects/${projectId}/restore`,

package/runtime/dist/src/git/verification-gate.js

@@ -257,6 +257,8 @@ export class VerificationGate {
         const receipts = await this.receiptsFor(repository.repoFingerprint, worktreeIdentity(repository.repoRoot));
         const receipt = receipts.find((candidate) => candidate.taskId === taskId &&
             candidate.worktreeId === worktreeIdentity(repository.repoRoot));
+        if (receipt?.taskClosed && !receipt.source)
+            return null;
         if (!receipt?.source ||
             !receipt.taskClosed ||
             !receipt.projectId ||

package/runtime/dist/src/localization/catalogue.generated.js

@@ -41,6 +41,7 @@ export const bundledTexts = {
         'delivery.destination': 'Branch / remote repository',
         'delivery.example': 'Commit keeps work on the local branch. PR/MR pushes that branch and opens it for team review.',
         'delivery.message': 'How should we deliver these changes?',
+        'delivery.recorded': 'Already answered in Engineering Memory',
         'forgetWorktree.context': 'A checkout that cannot be read is still counted against the worktree limit although nothing can use it; forgetting it frees that slot. No file in the folder is touched or deleted, and the branch stays.',
         'forgetWorktree.example': 'After this, {task} no longer appears in the worktree list and the {folder} folder stays on disk exactly as it is.',
         'forgetWorktree.forget': 'Stop tracking it; leave the files alone',
@@ -316,6 +317,14 @@ export const bundledTexts = {
         'statusRemap.roles.test_failed': 'Failed test',
         'statusRemap.roles.work_started': 'Starting development',
         'statusRemap.rolesStay': 'These roles keep pointing at stages being emptied; change them separately through role setup:',
+        'taskDelivery.abandon.description': 'Nothing is delivered, for example because the files are no longer reachable. The delivery is closed for everyone.',
+        'taskDelivery.abandon.label': 'Conclude without delivery',
+        'taskDelivery.context': "Nobody has concluded this delivery yet. Your answer is recorded in Engineering Memory for the whole project. The Git action itself happens on the computer that holds the task's files, when task.close runs there.",
+        'taskDelivery.example': 'Choosing Commit and push records that choice; the member with the files is asked there before anything is pushed.',
+        'taskDelivery.message': '{task} is closed. How should it be delivered?',
+        'taskStart.base.continue': 'Continue {branch}',
+        'taskStart.base.continueDetail': 'No new branch; fetched from origin when this clone lacks it.',
+        'taskStart.base.continueOpenDetail': 'No new branch. The previous round’s delivery is still open, so its last commits may not be on origin yet.',
         'taskStart.base.fetchDetail': 'Fetch the latest commit.',
         'taskStart.base.field': 'Branch on origin (only for another branch)',
         'taskStart.base.local': 'Local: {branch}',
@@ -323,6 +332,7 @@ export const bundledTexts = {
         'taskStart.base.message': 'Which starting branch?',
         'taskStart.base.other': 'Another branch on origin',
         'taskStart.base.otherDetail': 'Enter it below.',
+        'taskStart.continuePlan': "Continue {branch}, the branch of this work item's confirmed plan",
         'taskStart.example': 'A worktree keeps this task in its own folder.',
         'taskStart.keepContext': 'Continue on the current branch.',
         'taskStart.location.busy': 'Task {task} is still running in another client in this folder, so the new branch cannot start here. Once it is paused there, this folder can be chosen too.',
@@ -339,6 +349,7 @@ export const bundledTexts = {
         'taskStart.location.worktree.label': 'Separate worktree',
         'taskStart.message': 'Start task',
         'taskStart.newBranch': 'New branch: {name}',
+        'taskStart.newBranchOrContinue': 'New branch: {name}, unless you continue an existing one',
         'taskStart.stay': 'Nothing new is created. The work continues on {source} in this folder, so every commit lands on that branch.',
         'uiWaiver.ask': '{task}: skip the UI check (widget, golden or screenshot test) for this task?',
         'uiWaiver.context': 'The UI check is what proves the screens this task changed still render. Skipping it means nothing in this task opens them, and the skip is stored in the task audit trail with the reason above.',
@@ -432,6 +443,7 @@ export const bundledTexts = {
         'delivery.destination': 'Dal / uzak depo',
         'delivery.example': 'Commit yerel dalda kalır. PR/MR seçersen değişiklikler uzak dala gönderilir ve ekip incelemesine açılır.',
         'delivery.message': 'Değişiklikleri nasıl teslim edelim?',
+        'delivery.recorded': 'Engineering Memory’de verilmiş cevap',
         'forgetWorktree.context': 'Okunamayan bir çalışma kopyası hiçbir işe yaramadığı hâlde worktree sınırına sayılmaya devam eder; takipten çıkarılırsa o yer boşalır. Klasördeki hiçbir dosyaya dokunulmaz, hiçbiri silinmez; dal da kalır.',
         'forgetWorktree.example': 'Bundan sonra {task} worktree listesinde görünmez, {folder} klasörü ise diskte olduğu gibi kalır.',
         'forgetWorktree.forget': 'Takip etmeyi bırak; dosyalara dokunma',
@@ -707,6 +719,14 @@ export const bundledTexts = {
         'statusRemap.roles.test_failed': 'Başarısız test',
         'statusRemap.roles.work_started': 'Geliştirmeye başlama',
         'statusRemap.rolesStay': 'Bu roller taşınan kolonları hedeflemeye devam eder; değiştirmek için rol kurulumu ayrıca yapılır:',
+        'taskDelivery.abandon.description': 'Hiçbir şey teslim edilmez; örneğin dosyalara artık ulaşılamıyorsa. Teslim herkes için kapanır.',
+        'taskDelivery.abandon.label': 'Teslim etmeden kapat',
+        'taskDelivery.context': 'Bu teslim henüz kimse tarafından sonuçlandırılmadı. Cevabın Engineering Memory’de tüm proje için kaydedilir. Git işlemi ise görevin dosyalarının olduğu bilgisayarda, orada task.close çalıştığında yapılır.',
+        'taskDelivery.example': 'Commit ve push seçersen bu seçim kaydedilir; dosyaların olduğu bilgisayardaki üyeye bir şey gönderilmeden önce orada sorulur.',
+        'taskDelivery.message': '{task} kapandı. Nasıl teslim edilsin?',
+        'taskStart.base.continue': '{branch} dalını sürdür',
+        'taskStart.base.continueDetail': 'Yeni dal açılmaz; bu klonda yoksa origin’den çekilir.',
+        'taskStart.base.continueOpenDetail': 'Yeni dal açılmaz. Önceki turun teslimi henüz açık; son commit’leri origin’de olmayabilir.',
         'taskStart.base.fetchDetail': 'Güncel hali çekilir.',
         'taskStart.base.field': 'origin dalı (yalnızca başka dal için)',
         'taskStart.base.local': 'Yerel: {branch}',
@@ -714,6 +734,7 @@ export const bundledTexts = {
         'taskStart.base.message': 'Hangi daldan başlayalım?',
         'taskStart.base.other': 'origin üzerinde başka dal',
         'taskStart.base.otherDetail': 'Alttaki alana yaz.',
+        'taskStart.continuePlan': '{branch} dalında devam: bu iş kaleminin onaylı planındaki dal',
         'taskStart.example': 'Ayrı worktree, işi ayrı klasörde tutar.',
         'taskStart.keepContext': 'Mevcut dalda devam edilecek.',
         'taskStart.location.busy': '{task} bu klasörde başka bir oturumda hâlâ çalışıyor; yeni branch burada açılamaz. O oturumda duraklatılırsa bu klasör de seçilebilir.',
@@ -730,6 +751,7 @@ export const bundledTexts = {
         'taskStart.location.worktree.label': 'Ayrı worktree',
         'taskStart.message': 'Göreve başla',
         'taskStart.newBranch': 'Yeni dal: {name}',
+        'taskStart.newBranchOrContinue': 'Yeni dal: {name} (var olan bir dalı sürdürmezsen)',
         'taskStart.stay': 'Yeni bir şey oluşturulmaz. İş bu klasörde {source} üzerinde sürer; her commit o dala gider.',
         'uiWaiver.ask': '{task}: bu görev için UI kontrolünü (widget, golden veya ekran görüntüsü testi) atlayalım mı?',
         'uiWaiver.context': 'UI kontrolü, bu görevde değişen ekranların hâlâ doğru çizildiğini gösteren testtir. Atlarsan bu görevde o ekranları açan hiçbir test kalmaz ve atlama kararı yukarıdaki gerekçesiyle görevin denetim kaydına yazılır.',

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

@@ -1,6 +1,6 @@
 import * as z from 'zod/v4';
-import { languageTag } from '../runtime/questionnaire-store.js';
-import { texts } from '../runtime/texts.js';
+import { answerSourceName, languageTag, } from '../runtime/questionnaire-store.js';
+import { format, texts } from '../runtime/texts.js';
 import { sha256, stableStringify } from '../utilities/hash.js';
 import { answerChoice, answerData, askQuestionnaire } from './questionnaire-tools.js';
 const option = z.strictObject({
@@ -21,6 +21,7 @@ const copySchema = z.strictObject({
     baseContext: z.string().trim().min(1).max(500),
     baseTitle: z.string().trim().min(1).max(100),
     baseWrite: option,
+    recorded: z.string().trim().min(1).max(100).optional(),
 });
 const closedSchema = z.object({
     closed: z.literal(true),
@@ -39,8 +40,31 @@ const closedSchema = z.object({
             headCommit: z.string().nullable(),
         }),
     }),
+    deliveryRecord: z
+        .object({
+        projectId: z.string(),
+        taskId: z.string(),
+        lockVersion: z.number().int(),
+        choice: z.enum(['commit', 'commit_push', 'commit_push_draft_pr', 'commit_push_pr']).nullish(),
+    })
+        .nullish(),
+});
+const recordWording = z.strictObject({
+    message: z.string().trim().min(1).max(240),
+    context: z.string().trim().min(1).max(500),
+    example: z.string().trim().min(1).max(400),
+    abandon: option,
+});
+const recordSchema = z.object({
+    projectId: z.string(),
+    taskId: z.string(),
+    externalTaskId: z.string(),
+    branch: z.string().nullable(),
+    state: z.enum(['unanswered', 'answered', 'delivered', 'cancelled']),
+    lockVersion: z.number().int(),
 });
 export function registerDeliveryTools(server, service) {
+    registerTaskDelivery(server, service);
     server.registerTool('task.close', {
         description: 'Close the verified task, then open its durable mode-governed Git delivery selector in the same call. Memory publication is separate. Cancellation/feedback leave delivery pending; retry identical input to resume. PR/MR is one review-request concept, not an instruction to merge. No Git action is performed by this tool. Read-only tasks need no delivery. Supply complete copy when the product text catalogue lacks the conversation language. If the user already explicitly chose Git delivery in their own message, deliveryInstruction preserves that choice with its exact relevant excerpt; it is an agent-reported instruction, never a native answer or a substitute for missing user consent. Do not use it for agent decisions or memory-publication approval.',
         inputSchema: z.object({
@@ -128,6 +152,7 @@ export function registerDeliveryTools(server, service) {
             ? ['commit', 'commit_push', 'commit_push_draft_pr', 'commit_push_pr', 'defer']
             : ['commit', 'defer'];
         const instruction = input.deliveryInstruction;
+        const recorded = data.deliveryRecord?.choice;
         if (instruction && !ids.some((id) => id === instruction.choice))
             return output({
                 ok: false,
@@ -152,7 +177,10 @@ export function registerDeliveryTools(server, service) {
                     copy.destination +
                     ': ' +
                     destination.branch +
-                    (canPush ? ' → ' + destination.remote + ' (' + destination.pushUrl + ')' : ''),
+                    (canPush ? ' → ' + destination.remote + ' (' + destination.pushUrl + ')' : '') +
+                    (recorded && copy.recorded
+                        ? '\n' + copy.recorded + ': ' + copy[recorded].label
+                        : ''),
                 example: copy.example,
                 options: ids.map((id) => ({
                     id,
@@ -188,23 +216,8 @@ export function registerDeliveryTools(server, service) {
             : undefined;
         let baseQuestionnaireId;
         if ((choice === 'commit_push_draft_pr' || choice === 'commit_push_pr') && !baseBranch) {
-            baseQuestionnaireId = questionnaireId + '-base-' + choice;
-            const base = await askQuestionnaire(server, service, {
-                repoRoot: input.repoRoot,
-                presentation: input.presentation,
-                questionnaireId: baseQuestionnaireId,
-                language,
-                impact: 'critical',
-                message: copy.baseMessage,
-                context: copy.baseContext,
-                example: copy.example,
-                options: [
-                    { id: 'write', label: copy.baseWrite.label, description: copy.baseWrite.description },
-                    { id: 'defer', label: copy.defer.label, description: copy.defer.description },
-                ],
-                textField: { title: copy.baseTitle, maxLength: 240, requiredForChoice: 'write' },
-                binding: { ...binding, choice },
-            }, context, [], owner);
+            baseQuestionnaireId = 'task-delivery-base-' + sha256(questionnaireId + choice);
+            const base = await askPullRequestBase(server, service, context, { ...input, questionnaireId: baseQuestionnaireId, binding: { ...binding, choice } }, language, copy, owner);
             if (!answerChoice(base))
                 return base;
             if (answerChoice(base) === 'defer')
@@ -270,17 +283,41 @@ export function registerDeliveryTools(server, service) {
                     retryable: false,
                 },
             });
-        if (!instruction)
-            await service.questionnaireResume({ repoRoot: input.repoRoot, questionnaireId });
+        const question = instruction
+            ? null
+            : await service.questionnaireResume({ repoRoot: input.repoRoot, questionnaireId });
         if (baseQuestionnaireId)
             await service.questionnaireResume({
                 repoRoot: input.repoRoot,
                 questionnaireId: baseQuestionnaireId,
             });
+        const record = current.data.deliveryRecord;
+        const answer = record
+            ? await service.taskDeliveryAnswer({
+                projectId: record.projectId,
+                taskId: record.taskId,
+                expectedVersion: record.lockVersion,
+                choice,
+                ...(baseBranch ? { baseBranch } : {}),
+                answerSource: question ? answerSourceName(question.answerSource) : 'user_instruction',
+            })
+            : null;
+        const answered = answer?.ok ? answer.data : null;
+        const refused = answer && !answer.ok ? answer.error : null;
+        const other = refused?.details?.delivery;
         return output({
             ok: true,
             data: {
                 ...fresh.data,
+                ...(answered?.data ? { deliveryRecord: answered.data } : {}),
+                ...(answered?.queued
+                    ? {
+                        deliveryRecordNotice: 'Engineering Memory is unreachable, so this answer is queued. It is recorded when Engineering Memory is reachable again, unless another answer was recorded first.',
+                    }
+                    : {}),
+                ...(refused
+                    ? { ...(other ? { deliveryRecord: other } : {}), deliveryRecordNotice: refused.message }
+                    : {}),
                 deliveryStatus: 'selected',
                 selectedDelivery: {
                     choice,
@@ -301,6 +338,173 @@ export function registerDeliveryTools(server, service) {
         });
     });
 }
+function registerTaskDelivery(server, service) {
+    server.registerTool('task.delivery', {
+        description: 'Answer how a closed task is delivered, or conclude its delivery without delivering, from any chat — for example a delivery session.entry lists as open. The answer is recorded in Engineering Memory for the whole project; the Git action itself happens only where the task files are, through task.close. When the task folder is on this computer it points to task.close there instead of asking. Defer records nothing.',
+        inputSchema: z.strictObject({
+            repoRoot: z.string().min(1).optional(),
+            projectId: z.string().uuid(),
+            taskId: z.string().uuid(),
+            language: languageTag.optional(),
+            decisionAttempt: z.number().int().min(1).max(10000).optional(),
+            presentation: z.literal('host_native').optional(),
+        }),
+    }, async (input, context) => {
+        const language = await service.language(input.language);
+        const copy = language ? copySchema.safeParse(texts('delivery', language)).data : undefined;
+        const wording = language
+            ? recordWording.safeParse(texts('taskDelivery', language)).data
+            : undefined;
+        if (!language || !copy || !wording)
+            return output({
+                ok: false,
+                error: {
+                    kind: 'delivery',
+                    message: 'The delivery question has no text in the conversation language. Ask again in a language Engineering Memory offers.',
+                    recovery: 'task.delivery',
+                    retryable: false,
+                },
+            });
+        const found = await service.taskDeliveryRecord(input);
+        if (!found.ok)
+            return output(found);
+        const { record: raw, folder } = found.data;
+        const record = recordSchema.parse(raw);
+        if (folder)
+            return output({
+                ok: true,
+                data: {
+                    deliveryRecord: raw,
+                    repoRoot: folder,
+                    nextAction: `The files of ${record.externalTaskId} are on this computer in ${folder}. Call task.close there with taskId ${record.taskId}; it asks how to deliver and performs the Git action there.`,
+                },
+            });
+        if (record.state === 'delivered' || record.state === 'cancelled')
+            return output({
+                ok: true,
+                data: {
+                    deliveryRecord: raw,
+                    nextAction: 'This delivery is already concluded. Tell the user what was recorded.',
+                },
+            });
+        const binding = { taskId: record.taskId, lockVersion: record.lockVersion };
+        const questionnaireId = 'task-delivery-record-' +
+            sha256(stableStringify({ ...binding, decisionAttempt: input.decisionAttempt ?? 0 }));
+        const owner = {
+            tool: 'task.delivery',
+            externalTaskId: record.externalTaskId,
+            decisionAttempt: input.decisionAttempt,
+            retryArguments: {
+                projectId: input.projectId,
+                taskId: input.taskId,
+                language: input.language,
+            },
+        };
+        const ids = [
+            'commit',
+            'commit_push',
+            'commit_push_draft_pr',
+            'commit_push_pr',
+            'abandon',
+            'defer',
+        ];
+        const form = await askQuestionnaire(server, service, {
+            repoRoot: input.repoRoot,
+            presentation: input.presentation,
+            questionnaireId,
+            language,
+            impact: 'critical',
+            message: format(wording.message, language, { task: record.externalTaskId }),
+            context: wording.context + (record.branch ? '\n' + copy.destination + ': ' + record.branch : ''),
+            example: wording.example,
+            options: ids.map((id) => ({
+                id,
+                label: id === 'abandon' ? wording.abandon.label : copy[id].label,
+                description: id === 'abandon' ? wording.abandon.description : copy[id].description,
+            })),
+            binding,
+        }, context, [], owner);
+        const choice = answerChoice(form);
+        if (!choice)
+            return form;
+        if (choice === 'defer')
+            return output({
+                ok: true,
+                data: {
+                    deliveryRecord: raw,
+                    deliveryStatus: 'deferred',
+                    nextAction: 'Nothing was recorded; the delivery stays open.',
+                },
+            });
+        if (choice === 'abandon')
+            return output(await service.taskDeliveryCancel({
+                projectId: input.projectId,
+                taskId: input.taskId,
+                reason: 'abandoned',
+            }));
+        let baseBranch;
+        if (choice === 'commit_push_draft_pr' || choice === 'commit_push_pr') {
+            const base = await askPullRequestBase(server, service, context, {
+                ...input,
+                questionnaireId: 'task-delivery-base-' + sha256(questionnaireId + choice),
+                binding: { ...binding, choice },
+            }, language, copy, owner);
+            if (!answerChoice(base))
+                return base;
+            if (answerChoice(base) === 'defer')
+                return output({
+                    ok: true,
+                    data: {
+                        deliveryRecord: raw,
+                        deliveryStatus: 'deferred',
+                        nextAction: 'Nothing was recorded; the delivery stays open.',
+                    },
+                });
+            baseBranch = answerData(base)?.text;
+            if (!baseBranch)
+                return base;
+        }
+        const question = await service.questionnaireResume({
+            repoRoot: input.repoRoot,
+            questionnaireId,
+        });
+        const answer = await service.taskDeliveryAnswer({
+            projectId: input.projectId,
+            taskId: input.taskId,
+            expectedVersion: record.lockVersion,
+            choice,
+            ...(baseBranch ? { baseBranch } : {}),
+            answerSource: answerSourceName(question.answerSource),
+        });
+        if (!answer.ok)
+            return output(answer);
+        return output({
+            ok: true,
+            data: {
+                ...answer.data,
+                nextAction: `The answer is recorded for the whole project. The Git action happens where the files of ${record.externalTaskId} are, when task.close runs there.`,
+            },
+        });
+    });
+}
+function askPullRequestBase(server, service, context, input, language, copy, owner) {
+    return askQuestionnaire(server, service, {
+        repoRoot: input.repoRoot,
+        presentation: input.presentation,
+        questionnaireId: input.questionnaireId,
+        language,
+        impact: 'critical',
+        message: copy.baseMessage,
+        context: copy.baseContext,
+        example: copy.example,
+        options: [
+            { id: 'write', label: copy.baseWrite.label, description: copy.baseWrite.description },
+            { id: 'defer', label: copy.defer.label, description: copy.defer.description },
+        ],
+        textField: { title: copy.baseTitle, maxLength: 240, requiredForChoice: 'write' },
+        binding: input.binding,
+    }, context, [], owner);
+}
 function output(result) {
     return {
         content: [{ type: 'text', text: JSON.stringify(result) }],

package/runtime/dist/src/mcp/tool-annotations.js

@@ -77,6 +77,7 @@ export const toolAnnotations = {
     'task.resolve_pending_delivery': destructive, // discards a pending delivery
     'task.verify': write,
     'task.close': write,
+    'task.delivery': write,
     'task.abandon': destructive,
     'task.branch': outward, // fetches the chosen base from the Git remote
     'architecture.plan': read,
@@ -102,6 +103,8 @@ export const toolAnnotations = {
     'work_item.runs': read,
     'work_item.record_test': write,
     'work_item.test_results': read,
+    'work_item.comment': write,
+    'work_item.comments': read,
     'work_item.plan': read,
     'work_item.confirm_plan': write,
     'project.update': write,

package/runtime/dist/src/mcp/tool-definitions.js

@@ -115,6 +115,7 @@ export const engineeringMemoryToolNames = [
     'task.resolve_pending_delivery',
     'task.verify',
     'task.close',
+    'task.delivery',
     'task.abandon',
     'task.branch',
     'architecture.plan',
@@ -140,6 +141,8 @@ export const engineeringMemoryToolNames = [
     'work_item.runs',
     'work_item.record_test',
     'work_item.test_results',
+    'work_item.comment',
+    'work_item.comments',
     'work_item.plan',
     'work_item.confirm_plan',
     'project.update',
@@ -969,7 +972,7 @@ export function registerEngineeringMemoryTools(server, service) {
             ...workItemLocator,
             data: z.object({
                 expectedVersion: z.number().int().min(1),
-                idempotencyKey: z.string().uuid(),
+                idempotencyKey: z.uuidv4(),
                 outcome: z.enum(['passed', 'failed', 'blocked']),
                 summary: z.string().trim().min(2).max(4000),
                 testedRevision: z.string().min(1).max(160).optional(),
@@ -984,6 +987,24 @@ export function registerEngineeringMemoryTools(server, service) {
             limit: z.number().int().min(1).max(100).optional(),
         }),
     }, async (input) => toolResult(await service.workItemTestResults(input)));
+    server.registerTool('work_item.comment', {
+        description: 'Write a comment on an authorized work item, such as the reason a tester sent it back to Rework. Comments are permanent: correct one with a new comment. Reuse the same idempotency key only for an identical retry.',
+        inputSchema: z.object({
+            ...workItemLocator,
+            data: z.object({
+                idempotencyKey: z.uuidv4(),
+                body: z.string().trim().min(1).max(4000),
+            }),
+        }),
+    }, async (input) => toolResult(await service.workItemComment(input)));
+    server.registerTool('work_item.comments', {
+        description: 'Read the comments of an authorized work item, newest first. Read them before starting a round on work that came back from testing.',
+        inputSchema: z.object({
+            ...workItemLocator,
+            offset: z.number().int().min(0).optional(),
+            limit: z.number().int().min(1).max(100).optional(),
+        }),
+    }, async (input) => toolResult(await service.workItemComments(input)));
     server.registerTool('work_item.plan', {
         description: 'Inspect authorized current and linked project targets, repository URLs, implementation capabilities and the persisted shared branch before opening work. Check contracts to identify backend/web/mobile impact; capability is not user consent.',
         inputSchema: z.object(workItemLocator),

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

@@ -30,6 +30,8 @@ function deferredStart(input, questionnaireId) {
                     name: input.name,
                     base: input.base,
                     keepCurrent: input.keepCurrent,
+                    workItemId: input.workItemId,
+                    workItemProjectId: input.workItemProjectId,
                 },
             },
             nextAction: `Nothing was created, reserved or saved. Tell the user in one line that starting ${input.externalTaskId} is on hold. Continue only read-only work. When the user wants to start, call reconsider exactly as given; it asks the start form again.`,
@@ -285,7 +287,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 by selecting its decision mode in one short native form, then resolve 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 a valid native or mode-delegated start answer is recorded; 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 by selecting its decision mode in one short native form, then resolve 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. Pass workItemId (and workItemProjectId when the item lives in a linked project) for work on a work item: the branch question then also offers continuing the branch of its plan or of its earlier rounds, fetched from origin when this clone lacks it, and a planned item that has no branch yet gets its plan branch as the new name. 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 a valid native or mode-delegated start answer is recorded; 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),
@@ -293,6 +295,8 @@ export function registerWorktreeTools(server, service) {
             name: branch.optional(),
             base: baseSchema.optional(),
             keepCurrent: z.boolean().optional(),
+            workItemId: z.string().uuid().optional(),
+            workItemProjectId: z.string().uuid().optional(),
             language: languageTag.optional(),
             presentation,
         }),
@@ -319,9 +323,14 @@ export function registerWorktreeTools(server, service) {
                     recovery: 'task.branch',
                 },
             });
+        const plan = flight.planBranch;
         const { previous, ...definition } = taskStartDefinition({
             ...input,
             ...flight,
+            ...(plan ? { name: plan } : {}),
+            ...(plan && flight.continueBranches.includes(plan)
+                ? { base: { kind: 'existing', branch: plan } }
+                : {}),
             language: told ?? 'en',
         });
         const owner = {
@@ -333,6 +342,8 @@ export function registerWorktreeTools(server, service) {
                 name: input.name,
                 base: input.base,
                 keepCurrent: input.keepCurrent,
+                workItemId: input.workItemId,
+                workItemProjectId: input.workItemProjectId,
             }),
         };
         const form = await askQuestionnaire(server, service, { ...definition, repoRoot: input.repoRoot, presentation: input.presentation }, context, previous, owner);
@@ -359,7 +370,10 @@ export function registerWorktreeTools(server, service) {
                 recovery: 'task.branch',
             },
         });
-        if (choice.name && choice.name !== input.name && choice.name !== flight.suggestedName) {
+        if (choice.name &&
+            choice.base.kind !== 'existing' &&
+            choice.name !== input.name &&
+            choice.name !== flight.suggestedName) {
             const unusable = await service.unusableBranchName(input.repoRoot, choice.name);
             if (unusable)
                 return reconsider(unusable);

package/runtime/dist/src/runtime/api-client.js

@@ -23,6 +23,8 @@ export const backendRecoveryOperationNames = [
     'work_item.statuses',
     'work_item.workflow',
     'work_item.get',
+    'work_item.comment',
+    'work_item.comments',
     'session.bootstrap',
     'session.resume',
     'context.refresh',
@@ -47,6 +49,7 @@ export const backendRecoveryOperationNames = [
     'task.abandon',
     'task.branch',
     'task.resolve_pending_delivery',
+    'task.delivery',
 ];
 const backendRecoveryOperations = new Set(backendRecoveryOperationNames);
 const browserSigninRecovery = 'auth.signin_browser';

package/runtime/dist/src/runtime/branch-preferences.js

@@ -1,5 +1,20 @@
 import { BridgeRecoveryError } from './recovery-error.js';
 export async function resolveTaskBase(git, repoRoot, base, preferences) {
+    if (base.kind === 'existing') {
+        const local = await git.sourceIdentity(repoRoot, 'refs/heads/' + base.branch);
+        const fetched = await git.fetchBranchCommit(repoRoot, 'origin', base.branch).catch(() => null);
+        const tip = !fetched ||
+            (local && (await git.isAncestor(repoRoot, fetched.sourceCommit, local.sourceCommit)))
+            ? local
+            : !local || (await git.isAncestor(repoRoot, local.sourceCommit, fetched.sourceCommit))
+                ? fetched
+                : null;
+        if (!tip)
+            throw new BridgeRecoveryError(local
+                ? `Branch ${base.branch} here and on origin went separate ways, so it cannot simply be continued. Bring the two together with Git, or call task.branch with a new decisionAttempt and start a new branch.`
+                : `Branch ${base.branch} is neither in this clone nor on origin, so it cannot be continued. Call task.branch with a new decisionAttempt and start a new branch.`, 'task.branch');
+        return { ...tip, base };
+    }
     if (base.kind === 'current' || base.kind === 'local') {
         const source = await git.sourceIdentity(repoRoot, base.kind === 'current' ? (base.commit ?? 'HEAD') : base.ref);
         if (!source && base.kind === 'current' && !base.commit)