engineering-memory 1.11.5 → 1.11.7

package/dispatcher/sections.mjs

@@ -19,7 +19,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, use \`task.branch\` for native base selection and automatic worktree allocation. 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. Ask only unanswered shared branch preferences when \`session.entry\` says the user can manage them; otherwise choose a task-specific base.
+Before a new write/scaffold task, inspect \`worktree.list\` first, then use \`task.branch\` for native base selection and pool allocation. A separate worktree does not necessarily mean a new directory: reuse a safely available slot before creating another. Never invent the next numbered 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. Ask only unanswered shared branch preferences when \`session.entry\` says the user can manage them; otherwise choose a task-specific base.
 
 Do not edit until the skill lifecycle has completed discovery, its checkpoint, and \`context.prepare_change\`. Do not claim completion until \`task.verify\` succeeds.
 
@@ -27,6 +27,8 @@ Do not block independent task work on \`memory.propose_revision\` drafting, subm
 
 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. 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.
+
 When the repository is unbound, use the native questionnaire required by the skill. Do not silently create or bind a project. Do not open a survey web page.
 
 For project creation or adoption, read the skill's project-onboarding reference. Use read-only maturity evidence, then native selection of greenfield, exhaustive adoption or phased rework. A missing folder or Git repository uses preparation:true questionnaires before project.initialize. Recognize later memory-refresh intent semantically and confirm its scope natively; never trigger it from a fixed word list. Adoption and refresh cover architecture, state, services, network, data, screens and cross-module flows, not just page logic.`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engineering-memory",
-  "version": "1.11.5",
+  "version": "1.11.7",
   "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/dist/src/git/verification-gate.js

@@ -50,9 +50,9 @@ export class VerificationGate {
         }, this.root);
     }
     async rebindWorktreeOwnership(repoRoot, taskId, previous, generation) {
-        const fingerprint = await this.git.fingerprint(repoRoot);
-        const identity = worktreeIdentity(await this.git.findRoot(repoRoot));
-        const path = this.pathFor(fingerprint, identity, taskId);
+        const repository = await this.repositories.resolve(repoRoot);
+        const identity = worktreeIdentity(repository.repoRoot);
+        const path = this.pathFor(repository.repoFingerprint, identity, taskId);
         const receipt = await readJson(path, this.root);
         if (!receipt || receipt.taskId !== taskId || receipt.worktreeGeneration !== previous)
             return;

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

@@ -10,13 +10,22 @@ export async function askQuestionnaire(server, service, input, context, previous
 }
 export async function resumeQuestionnaire(server, service, input, context) {
     try {
-        return await present(server, service, await service.questionnaireResume(input), input.repoRoot, context, input.preparation);
+        return await present(server, service, await service.questionnaireResume(input), input.repoRoot, context, input.preparation, input.presentation);
     }
     catch (error) {
         return failure(error);
     }
 }
-async function present(server, service, record, repoRoot, context, preparation) {
+export async function answerQuestionnaireFromHost(service, input) {
+    try {
+        const resolved = await service.questionnaireAnswerFromHost(input);
+        return answered(resolved.record, resolved.answer, resolved.replayed);
+    }
+    catch (error) {
+        return failure(error);
+    }
+}
+async function present(server, service, record, repoRoot, context, preparation, presentation) {
     if (record.status === 'withdrawn')
         return result({
             questionnaireId: record.questionnaireId,
@@ -28,6 +37,8 @@ async function present(server, service, record, repoRoot, context, preparation)
         return answered(record, record.answer, true);
     if (context.mcpReq.signal.aborted)
         return pending(record, 'interrupted');
+    if (presentation === 'host_native')
+        return pending(record, 'host_native_requested');
     const responses = context.mcpReq.inputResponses;
     const response = inputResponse(responses, record.requestKey);
     if (response.kind === 'elicit' && response.action === 'accept') {
@@ -53,15 +64,12 @@ async function present(server, service, record, repoRoot, context, preparation)
     const elicitation = capabilities?.elicitation;
     if (!elicitation || (!elicitation.form && elicitation.url !== undefined))
         return pending(record, 'native_form_unavailable');
-    const presentationNotice = /^memory-batch-[a-f0-9]{64}-[0-9]+$/.test(record.questionnaireId)
-        ? 'For an unversioned project proposal, approval updates legacy memory only. Source-aware tasks cannot read it until an inspection explicitly retains it. Check each sourceApplicabilityNotice in memory.list_proposals before approving.'
-        : undefined;
     const copy = questionnaireCopy[record.language ?? 'en'];
     return inputRequired({
         inputRequests: {
             [record.requestKey]: inputRequired.elicit({
                 mode: 'form',
-                message: `${record.message}${presentationNotice ? `\n\n${presentationNotice}` : ''}\n\n${copy.pending}${record.allowFreeText ? copy.freeText : ''}${record.textField ? copy.storedText : ''}`,
+                message: presentationMessage(record),
                 requestedSchema: {
                     type: 'object',
                     properties: {
@@ -122,14 +130,33 @@ const questionnaireCopy = {
         otherAnswer: 'Diğer yanıt',
     },
 };
+function presentationMessage(record) {
+    const notice = /^memory-batch-[a-f0-9]{64}-[0-9]+$/.test(record.questionnaireId)
+        ? 'For an unversioned project proposal, approval updates legacy memory only. Source-aware tasks cannot read it until an inspection explicitly retains it. Check each sourceApplicabilityNotice in memory.list_proposals before approving.'
+        : undefined;
+    const copy = questionnaireCopy[record.language ?? 'en'];
+    return `${record.message}${notice ? `\n\n${notice}` : ''}\n\n${copy.pending}${record.allowFreeText ? copy.freeText : ''}${record.textField ? copy.storedText : ''}`;
+}
 function pending(record, reason) {
     return result({
         questionnaireId: record.questionnaireId,
         status: 'pending',
         reason,
         answerAvailable: false,
+        hostFallback: {
+            operation: 'questionnaire.answer_from_host',
+            questionnaireId: record.questionnaireId,
+            requestKey: record.requestKey,
+            contentHash: record.contentHash,
+            message: presentationMessage(record),
+            options: record.options,
+            language: record.language ?? 'en',
+            allowFreeText: record.allowFreeText,
+            ...(record.textField ? { textField: record.textField } : {}),
+            instructions: '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.',
+        },
         nextAction: 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 a supported native host and questionnaire.resume to answer; do not silently substitute an asynchronous question.'
+            ? '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.',
     });
 }
@@ -140,6 +167,7 @@ function answered(record, answer, replayed) {
         answerAvailable: answer !== undefined,
         ...(answer ? { answer } : {}),
         replayed,
+        ...(record.answerSource ? { answerSource: record.answerSource } : {}),
         ...(!answer
             ? {
                 nextAction: 'The free-text answer was accepted earlier but was not stored for privacy. It cannot be recovered or inferred. Use the original answer if still present in this conversation; otherwise collect it again through a new questionnaire or supported native input before dependent work.',

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

@@ -1,7 +1,7 @@
 import * as z from 'zod/v4';
 import { validationIds } from '../runtime/bridge-service.js';
-import { questionnaireDefinitionSchema } from '../runtime/questionnaire-store.js';
-import { askQuestionnaire, resumeQuestionnaire } from './questionnaire-tools.js';
+import { hostAnswerSchema, questionnaireDefinitionSchema } from '../runtime/questionnaire-store.js';
+import { answerQuestionnaireFromHost, askQuestionnaire, resumeQuestionnaire, } from './questionnaire-tools.js';
 const optionalRepoRoot = z.string().min(1).optional();
 const stringList = z.array(z.string().min(1));
 const jsonValue = z.lazy(() => z.union([
@@ -58,6 +58,7 @@ export const engineeringMemoryToolNames = [
     'audit.list',
     'questionnaire.ask',
     'questionnaire.resume',
+    'questionnaire.answer_from_host',
     'questionnaire.withdraw',
     'session.entry',
     'session.set_decision',
@@ -152,6 +153,13 @@ const reconciliationEntry = z.object({
     reason: z.string().optional(),
 });
 export function registerQuestionnaireTools(server, service) {
+    server.registerTool('questionnaire.answer_from_host', {
+        description: 'Relay an actual answer from a host-permitted blocking native AskUserQuestion or request_user_input control to the exact durable question. First read hostFallback from the pending operation or questionnaire.resume with presentation host_native, display its unchanged question/options/notices and await the real native result. Never infer answers, use chat consent, asynchronous controls, defaults or a declined/dismissed form. The hostTool field is agent-reported provenance, not transport-verified attestation. Bind requestKey and contentHash exactly; changed scope, withdrawn questions, invalid or conflicting answers are refused. This only saves the answer; retry the owning operation for current authority and version checks.',
+        inputSchema: hostAnswerSchema.extend({
+            repoRoot: optionalRepoRoot,
+            preparation: z.boolean().optional(),
+        }),
+    }, async (input) => answerQuestionnaireFromHost(service, input));
     server.registerTool('questionnaire.withdraw', {
         description: 'Withdraw a pending decision only when the user explicitly cancels that decision or its owning workflow. This is not approval. An answered decision is immutable. Interruption, timeout and dismissal alone never authorize withdrawal.',
         inputSchema: z.strictObject({
@@ -183,18 +191,19 @@ export function registerQuestionnaireTools(server, service) {
         }
     });
     server.registerTool('questionnaire.ask', {
-        description: 'Persist a required decision before displaying a native questionnaire. Write the message and labels in the conversation language and set language (tr or en) for the native form help. Use a questionnaireId unique to this decision occurrence or task, and reuse it only for identical retries. A later decision or changed wording/options requires a new id. Only a schema-validated native acceptance answers it. Dismissal, timeout and missing replies remain pending without expiry. Never supply answers in tool arguments. Do not put personal information or secrets in the question or options. Free text is returned once and never stored; use explicit options for replayable decisions.',
+        description: 'Persist a required decision before displaying a native questionnaire. Write the message and labels in the conversation language and set language (tr or en) for the native form help. Use a questionnaireId unique to this decision occurrence or task, and reuse it only for identical retries. A later decision or changed wording/options requires a new id. Only a schema-validated native acceptance answers it. Dismissal, timeout and missing replies remain pending without expiry. Never supply answers in questionnaire.ask arguments; use questionnaire.answer_from_host only after an actual permitted blocking native answer. Do not put personal information or secrets in the question or options. Free text is returned once and never stored; use explicit options for replayable decisions.',
         inputSchema: questionnaireDefinitionSchema.extend({
             repoRoot: optionalRepoRoot,
             preparation: z.boolean().optional(),
         }),
     }, async (input, context) => await askQuestionnaire(server, service, input, context));
     server.registerTool('questionnaire.resume', {
-        description: 'Display the original durable questionnaire after interruption or return its saved accepted choice. No timeout or dismissal resolves a pending question. A saved free-text receipt cannot replay the text and must never be treated as a recovered answer.',
+        description: 'Display the original durable questionnaire after interruption or return its saved accepted choice. No timeout or dismissal resolves a pending question. A saved free-text receipt cannot replay the text and must never be treated as a recovered answer. presentation host_native returns the original question and bindings for a permitted blocking host control without reopening the MCP form.',
         inputSchema: z.strictObject({
             repoRoot: optionalRepoRoot,
             questionnaireId: z.string().regex(/^[A-Za-z0-9_-]{1,100}$/),
             preparation: z.boolean().optional(),
+            presentation: z.literal('host_native').optional(),
         }),
     }, async (input, context) => await resumeQuestionnaire(server, service, input, context));
 }

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

@@ -338,13 +338,76 @@ export function registerWorktreeTools(server, service) {
         delivered: z.boolean().optional(),
     });
     server.registerTool('worktree.list', {
-        description: 'List task checkouts, activity and reasons each directory is protected.',
+        description: 'Discover existing managed Git checkouts and list activity and protection reasons before allocating another folder. Unregistered legacy checkouts remain protected until explicitly reconciled.',
         inputSchema: locationSchema,
     }, async (input) => output(await service.worktreeOperation('list', input)));
     server.registerTool('worktree.reconcile', {
-        description: 'Reconcile Git with the local registry and recover interrupted allocations or a validated backup, without deleting files or resetting branches.',
-        inputSchema: locationSchema,
-    }, async (input) => output(await service.worktreeOperation('reconcile', input)));
+        description: 'Reconcile Git with the local registry, including unregistered legacy checkouts. Use releaseUnowned only on a selected unreserved recovered checkout after prior work has finished; a native source-bound confirmation and fresh safety checks precede reuse. Never delete files or reset branches.',
+        inputSchema: z.strictObject({
+            repoRoot: repo,
+            releaseUnowned: z.boolean().optional(),
+            decisionAttempt: z.number().int().min(0).default(0),
+            language: z.enum(['tr', 'en']).default('en'),
+        }),
+    }, async (input, context) => {
+        const inspection = await service.worktreeOperation('reconcile', input);
+        if (!inspection.ok || !input.releaseUnowned)
+            return output(inspection);
+        const data = inspection.data;
+        const entry = data.selected;
+        if (!entry?.recoveredWithoutReservation || !entry.baseCommit)
+            return output({
+                ok: false,
+                error: {
+                    kind: 'bridge_error',
+                    retryable: false,
+                    recovery: 'worktree.reconcile',
+                    message: 'Select an unregistered, unreserved checkout from worktree.list. Existing task ownership cannot be released by this recovery.',
+                },
+            });
+        const digest = sha256(stableStringify({
+            projectId: entry.projectId,
+            repoRoot: entry.repoRoot,
+            generation: entry.generation,
+            sourceCommit: entry.baseCommit,
+            decisionAttempt: input.decisionAttempt,
+        }));
+        const questionnaireId = 'worktree-release-unowned-' + digest;
+        const form = await askQuestionnaire(server, service, {
+            repoRoot: input.repoRoot,
+            questionnaireId,
+            language: input.language,
+            allowFreeText: false,
+            message: input.language === 'tr'
+                ? 'Bu eski çalışma klasörünün önceki sahiplik kaydı yok. Önceki ajan burada artık çalışmıyor ve teslim tamamlandıysa, temiz klasörü yeniden kullanılabilir yapalım mı? Dosyalar ve branch silinmeyecek.'
+                : 'This legacy checkout has no prior ownership record. If the previous agent has stopped and delivery is complete, make the clean checkout reusable? No files or branches will be deleted.',
+            options: [
+                {
+                    id: 'release_unowned',
+                    label: input.language === 'tr'
+                        ? 'Önceki iş bitti; güvenli kontrollerden sonra kullanılabilir yap'
+                        : 'Prior work finished; release after safety checks',
+                },
+                {
+                    id: 'preserve',
+                    label: input.language === 'tr' ? 'Korumaya devam et' : 'Keep protected',
+                },
+            ],
+        }, context);
+        const decision = await service.questionnaireResume({
+            repoRoot: input.repoRoot,
+            questionnaireId,
+        });
+        if (decision.status !== 'answered' || decision.answer?.choice !== 'release_unowned')
+            return form;
+        return output(await service.worktreeOperation('release_unowned', {
+            repoRoot: input.repoRoot,
+            generation: entry.generation,
+            sourceCommit: entry.baseCommit,
+            decisionAttempt: input.decisionAttempt,
+            decisionId: questionnaireId,
+        }));
+    });
     server.registerTool('task.heartbeat', {
         description: 'Renew this exact task ownership during real activity. Never run an idle timer to keep an abandoned task active.',
         inputSchema: ownershipSchema,

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

@@ -66,7 +66,18 @@ export class BridgeService {
         if (stableStringify(scope) !== stableStringify(input.scope)) {
             throw refuse('The account or repository binding changed while the questionnaire was open.', 'session.entry');
         }
-        return await this.dependencies.questionnaires.accept(scope, input.questionnaireId, input.requestKey, input.answer);
+        return await this.dependencies.questionnaires.accept(scope, input.questionnaireId, input.requestKey, input.answer, input.answerSource);
+    }
+    async questionnaireAnswerFromHost(input) {
+        const record = await this.questionnaireResume(input);
+        if (record.requestKey !== input.requestKey || record.contentHash !== input.contentHash) {
+            throw refuse('The host answer belongs to a different question or content. Read the original with questionnaire.resume; do not reuse this answer for a changed decision.', 'questionnaire.resume');
+        }
+        return this.questionnaireAccept({
+            ...input,
+            scope: record.scope,
+            answerSource: { kind: 'host_native_relay', hostTool: input.hostTool },
+        });
     }
     async questionnaireScope(repoRoot, preparation = false) {
         await this.dependencies.principalState?.ensure();
@@ -643,7 +654,10 @@ export class BridgeService {
                     localPendingDeliveryCount: localJournal.pendingDeliveryCount,
                     conflicts,
                     requiresAttention: conflicts.length > 0,
-                    editLeaseAllowed: conflicts.length === 0 || offlineDevelopmentAllowed,
+                    editLeaseAllowed: backendTask.status !== 'closed' &&
+                        backendTask.status !== 'abandoned' &&
+                        backendSession.status !== 'closed' &&
+                        (conflicts.length === 0 || offlineDevelopmentAllowed),
                     offlineDevelopmentOnly: offlineDevelopmentAllowed,
                     recoveredVerification,
                 },
@@ -1870,12 +1884,33 @@ export class BridgeService {
             const pool = this.dependencies.worktreePool;
             if (!projectId || !pool)
                 throw refuse('Resolve the project with a pool-capable client.', 'project.resolve');
-            if (operation === 'list')
-                return asJsonValue({ items: await pool.list(projectId, await this.poolPolicy()) });
-            if (operation === 'reconcile')
+            if (operation === 'list' || operation === 'reconcile')
                 return asJsonValue({
                     items: await pool.reconcile(projectId, repository.repoRoot, await this.poolPolicy()),
+                    selected: await pool.forPath(projectId, repository.repoRoot),
+                });
+            if (operation === 'release_unowned') {
+                const entry = await pool.forPath(projectId, repository.repoRoot);
+                if (!entry || !input.sourceCommit || !input.generation || !input.decisionId)
+                    throw refuse('Inspect the recovered checkout with worktree.reconcile before confirming its release.', 'worktree.reconcile');
+                const digest = sha256(stableStringify({
+                    projectId,
+                    repoRoot: entry.repoRoot,
+                    generation: input.generation,
+                    sourceCommit: input.sourceCommit,
+                    decisionAttempt: input.decisionAttempt ?? 0,
+                }));
+                if (input.decisionId !== 'worktree-release-unowned-' + digest)
+                    throw refuse('The availability decision does not match this checkout and source. Repeat worktree.reconcile.', 'worktree.reconcile');
+                const decision = await this.questionnaireResume({
+                    repoRoot: repository.repoRoot,
+                    questionnaireId: input.decisionId,
                 });
+                if (decision.status !== 'answered' || decision.answer?.choice !== 'release_unowned')
+                    throw refuse('Confirm that prior work and delivery have finished in the native worktree.reconcile form.', 'worktree.reconcile');
+                await pool.releaseUnowned(projectId, repository.repoRoot, input.generation, input.sourceCommit);
+                return asJsonValue({ operation, complete: true, repoRoot: repository.repoRoot });
+            }
             const entry = await pool.forPath(projectId, repository.repoRoot);
             if (!entry ||
                 entry.externalTaskId !== input.externalTaskId ||

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

@@ -49,11 +49,26 @@ const storedQuestionSchema = questionnaireDefinitionSchema.extend({
     requestKey: z.string().regex(/^questionnaire_[0-9a-f]{64}$/),
     createdAt: z.string().datetime(),
 });
+export const hostAnswerSchema = z.strictObject({
+    questionnaireId: identifier,
+    requestKey: z.string().regex(/^questionnaire_[0-9a-f]{64}$/),
+    contentHash: z.string().regex(/^[0-9a-f]{64}$/),
+    hostTool: z.enum(['AskUserQuestion', 'request_user_input']),
+    answer: z.strictObject({
+        choice: z.string().min(1).max(80),
+        text: z.string().max(2000).optional(),
+    }),
+});
+const answerSourceSchema = z.strictObject({
+    kind: z.literal('host_native_relay'),
+    hostTool: z.enum(['AskUserQuestion', 'request_user_input']),
+});
 const storedAnswerSchema = z.strictObject({
     requestKey: z.string().regex(/^questionnaire_[0-9a-f]{64}$/),
     answeredAt: z.string().datetime(),
     answerAvailable: z.boolean(),
     withdrawn: z.literal(true).optional(),
+    answerSource: answerSourceSchema.optional(),
     answer: z.strictObject({ choice: z.string(), text: z.string().optional() }).optional(),
 });
 export function questionnaireAnswerSchema(record) {
@@ -194,7 +209,9 @@ export class QuestionnaireStore {
         }
         return records.sort((left, right) => left.createdAt.localeCompare(right.createdAt));
     }
-    async accept(scope, questionnaireId, requestKey, input) {
+    async accept(scope, questionnaireId, requestKey, input, answerSource) {
+        if (answerSource)
+            answerSourceSchema.parse(answerSource);
         const record = await this.get(scope, questionnaireId);
         if (!record || record.requestKey !== requestKey)
             throw new Error('Questionnaire response is stale or belongs to a different scope.');
@@ -209,6 +226,7 @@ export class QuestionnaireStore {
         }
         const receipt = {
             requestKey,
+            ...(answerSource ? { answerSource } : {}),
             answeredAt: new Date().toISOString(),
             answerAvailable: answer.choice !== '__other__',
             ...(answer.choice !== '__other__'

package/runtime/dist/src/runtime/worktree-pool.js

@@ -35,6 +35,7 @@ const allocationSchema = z.object({
     lastActivityAt: z.number().finite(),
     phase: z.enum(['creating', 'working', 'paused', 'delivery', 'released', 'quarantined']),
     pendingDelivery: z.boolean(),
+    recoveredWithoutReservation: z.boolean().optional(),
     reason: z.string().optional(),
 });
 const registrySchema = z.object({
@@ -74,6 +75,7 @@ export class WorktreePool {
                 throw new BridgeRecoveryError('Choose a valid literal Git branch name of at most 255 characters. Retry task.branch with the corrected name; no allocation was recorded.', 'task.branch');
             }
         }
+        await this.reconcile(input.projectId, input.repoRoot, policy, true);
         const commonDir = await this.commonDirectory(input.repoRoot);
         return this.transaction(async (registry) => {
             if (!registry.projects[input.projectId]) {
@@ -292,33 +294,83 @@ export class WorktreePool {
             await this.save(registry);
         });
     }
-    async reconcile(projectId, repoRoot, policy) {
+    async releaseUnowned(projectId, repoRoot, generation, sourceCommit) {
+        await this.transaction(async (registry) => {
+            const entry = registry.projects[projectId]?.entries.find((e) => key(e.repoRoot) === key(repoRoot));
+            if (!entry ||
+                entry.generation !== generation ||
+                !entry.recoveredWithoutReservation ||
+                entry.phase !== 'quarantined' ||
+                entry.owner ||
+                entry.taskId ||
+                (await this.git.branchStore(repoRoot).read()))
+                throw refuse('This is not the same unowned recovered checkout. List and reconcile its current ownership before release.');
+            if ((await this.git.sourceIdentity(repoRoot))?.sourceCommit !== sourceCommit ||
+                entry.baseCommit !== sourceCommit)
+                throw refuse('The recovered checkout source changed. Inspect it again before confirming availability.');
+            const reasons = await this.fileProtection(entry);
+            if (reasons.length)
+                throw refuse('The recovered checkout is protected: ' + reasons.join(', '));
+            entry.phase = 'released';
+            entry.pendingDelivery = false;
+            entry.recoveredWithoutReservation = false;
+            entry.generation = randomUUID();
+            delete entry.reason;
+            await this.save(registry);
+        });
+    }
+    async reconcile(projectId, repoRoot, policy, discoverOnly = false) {
         await this.restoreRegistry();
         const commonDir = await this.commonDirectory(repoRoot);
         await this.transaction(async (registry) => {
             let project = registry.projects[projectId];
-            if (!project) {
-                const locations = await this.gitPaths(repoRoot);
-                for (const location of locations) {
-                    if (!(await pathExists(location.path)))
-                        continue;
-                    const reservation = await this.git.branchStore(location.path).read();
-                    if (reservation?.decision.projectId !== projectId)
-                        continue;
-                    const folder = dirname(dirname(location.path)).split(/[\\/]/).pop();
-                    const expected = join(await this.documentsDirectory(), 'engineeringmemory', folder, 'worktrees');
-                    if (key(dirname(location.path)) !== key(expected))
+            const locations = await this.gitPaths(repoRoot);
+            const candidates = [];
+            const managedRoot = join(await this.documentsDirectory(), 'engineeringmemory');
+            for (const location of locations) {
+                if (project?.entries.some((entry) => key(entry.repoRoot) === key(location.path)))
+                    continue;
+                if (!(await pathExists(location.path)))
+                    continue;
+                const parent = dirname(location.path);
+                const folder = dirname(parent).split(/[\\/]/).pop();
+                const name = location.path.split(/[\\/]/).pop();
+                if (key(parent) !== key(join(managedRoot, folder, 'worktrees')))
+                    continue;
+                const prefix = folder + '-worktree';
+                const slot = Number(name.slice(prefix.length));
+                if (!name.startsWith(prefix) ||
+                    !Number.isSafeInteger(slot) ||
+                    slot < 1 ||
+                    name !== prefix + slot)
+                    continue;
+                try {
+                    await assertManagedPath(managedRoot, location.path, false);
+                    if ((await this.commonDirectory(location.path)) !== commonDir)
                         continue;
-                    registry.projects[projectId] = { folder, entries: [] };
-                    break;
                 }
+                catch {
+                    continue;
+                }
+                const reservation = await this.git.branchStore(location.path).read();
+                if (reservation && reservation.decision.projectId !== projectId)
+                    continue;
+                if (Object.entries(registry.projects).some(([id, value]) => id !== projectId && key(value.folder) === key(folder)))
+                    continue;
+                candidates.push({ path: location.path, folder, slot });
+            }
+            if (!project) {
+                const folders = [...new Set(candidates.map((candidate) => candidate.folder))];
+                if (folders.length > 1)
+                    throw refuse('Several managed folders belong to this clone. Restore the project index to identify its original folder before allocating a directory.');
+                if (folders.length === 1)
+                    registry.projects[projectId] = { folder: folders[0], entries: [] };
             }
             const recoveredProject = registry.projects[projectId];
             if (!recoveredProject)
                 return;
             project = recoveredProject;
-            const locations = await this.gitPaths(repoRoot);
-            for (const entry of project.entries.filter((e) => e.commonDir === commonDir)) {
+            for (const entry of project.entries.filter((e) => !discoverOnly && e.commonDir === commonDir)) {
                 if (entry.owner && entry.owner.id !== this.ownerId && (await this.ownerAlive(entry.owner)))
                     continue;
                 if (await pathExists(entry.repoRoot))
@@ -337,48 +389,54 @@ export class WorktreePool {
                     }
                 }
             }
-            for (const location of locations) {
+            for (const location of candidates.filter((candidate) => key(candidate.folder) === key(project.folder))) {
                 if (project.entries.some((e) => key(e.repoRoot) === key(location.path)))
                     continue;
-                const parent = dirname(location.path);
-                if (dirname(parent)
-                    .split(/[\\\\/]/)
-                    .pop() !== project.folder ||
-                    parent.split(/[\\\\/]/).pop() !== 'worktrees')
-                    continue;
                 const reservation = await this.git.branchStore(location.path).read();
-                if (reservation?.decision.projectId !== projectId)
+                if (reservation && reservation.decision.projectId !== projectId)
                     continue;
                 const source = await this.git.sourceIdentity(location.path);
-                const slotText = location.path
-                    .split(/[\\\\/]/)
-                    .pop()
-                    ?.match(/-worktree([0-9]+)$/)?.[1];
-                if (!source || !slotText)
+                if (!source)
                     continue;
                 project.entries.push({
                     projectId,
                     repoFingerprint: await this.git.fingerprint(repoRoot),
                     commonDir,
                     repoRoot: await canonicalPath(location.path),
-                    slot: Number(slotText),
+                    slot: location.slot,
                     managed: true,
-                    externalTaskId: reservation.decision.externalTaskId,
-                    taskId: reservation.decision.taskId,
-                    branch: reservation.decision.branch,
+                    externalTaskId: reservation?.decision.externalTaskId ??
+                        'unregistered-' + sha256(key(location.path)).slice(0, 20),
+                    taskId: reservation?.decision.taskId,
+                    branch: reservation?.decision.branch ?? (await this.git.currentBranch(location.path)),
+                    recoveredWithoutReservation: !reservation,
                     baseCommit: source.sourceCommit,
                     owner: null,
                     generation: randomUUID(),
                     lastActivityAt: 0,
                     phase: 'quarantined',
                     pendingDelivery: true,
-                    reason: 'Recovered a Git reservation missing from the registry. Restore its original task source and delivery state before reuse.',
+                    reason: reservation
+                        ? 'Recovered a Git reservation missing from the registry. Restore its original task source and delivery state before reuse.'
+                        : 'Unregistered checkout: prior ownership and delivery are unknown. After prior work has finished, use worktree.reconcile with releaseUnowned through its native confirmation.',
                 });
             }
-            for (const entry of project.entries.filter((e) => e.commonDir === commonDir)) {
+            for (const entry of project.entries.filter((e) => !discoverOnly && e.commonDir === commonDir)) {
                 if (entry.owner && (await this.ownerAlive(entry.owner)) && entry.owner.id !== this.ownerId)
                     continue;
                 try {
+                    if (entry.recoveredWithoutReservation &&
+                        !entry.owner &&
+                        !entry.taskId &&
+                        !(await this.git.branchStore(entry.repoRoot).read())) {
+                        const source = await this.git.sourceIdentity(entry.repoRoot);
+                        const branch = await this.git.currentBranch(entry.repoRoot);
+                        if (source && (source.sourceCommit !== entry.baseCommit || branch !== entry.branch)) {
+                            entry.baseCommit = source.sourceCommit;
+                            entry.branch = branch;
+                            entry.generation = randomUUID();
+                        }
+                    }
                     await this.repairCreating(entry);
                     if (await pathExists(entry.repoRoot))
                         await this.assertIdentity(entry);
@@ -391,7 +449,7 @@ export class WorktreePool {
             }
             await this.save(registry);
         });
-        return this.list(projectId, policy);
+        return discoverOnly ? [] : this.list(projectId, policy);
     }
     async entry(input, commonDir, repoRoot, slot, managed) {
         const generation = randomUUID();

package/skill/SKILL.md

@@ -13,6 +13,8 @@ Mandatory behavior:
 
 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, read [questionnaires.md](references/questionnaires.md), then use `questionnaire.ask` to open a durable native MCP form and `questionnaire.resume` to return to the same unanswered question. 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.
+
 Do not block independent task work on `memory.propose_revision` drafting, submission or approval. Follow [memory-updates.md](references/memory-updates.md): use background agents or concurrent tools when the host permits them and continue useful work; without concurrency, checkpoint the pending draft and defer submission until needed. Wait only at the operation that depends on the proposal or revision. This scheduling rule applies to every project and AI host, while native approval and required task verification remain in force. Apply the same dependency rule to reconciliation, self-review, scaffold receipts, inventory upload, completed-unit evidence and test-result reporting. A bridge result with deliveryStatus pending means durable local recording, so continue independent work without polling or resending. Keep claim acquisition, required approval, edit leases and final verification as real dependencies.
 
 1. Discover the repository binding through `session.entry`. Bindings live in the user-level Engineering Memory state directory, outside the repository and installed runtime. No project settings file is required. For a bound repository, the project's knowledge is in the backend, so answer nothing about it before bootstrapping; the absence of local design files or records says nothing about its stored knowledge.

package/skill/references/lifecycle.md

@@ -254,3 +254,43 @@ version is not automatically raised; projects opt in by starting a source-bound
 ## Offline source context
 
 An unexpired cached context pack may be used for implementation. The bridge records checkpoints in its outbox. Permanent proposal review, strict verification, task close, and Git commit require the backend and synchronization of the relevant task deliveries. An unrelated task or repository queue does not block this task; account switching and logout still require all deliveries to be resolved. Commit receipts are retained per task and worktree and still require an online attestation for the selected closed task and exact staged content.
+
+## Reuse before allocating another directory
+
+Before starting a write task, call `worktree.list` with the bound repository. It reconciles managed
+Git checkouts with local records. Then let `task.branch` choose the smallest safe slot; do not guess
+a new worktree number or create a directory yourself. Allocation also performs discovery when the
+caller omitted the listing. Old unregistered managed checkouts count toward the limit and remain
+protected because their previous ownership and delivery are unknown. A clean checkout alone is
+insufficient proof of availability.
+
+When prior work has finished, call `worktree.reconcile` on that checkout with `releaseUnowned:true`
+and the conversation language. Its native question binds the decision to the checkout, source and
+ownership generation. Cancellation leaves it protected. Git reservation, dirty files, unfinished
+Git operations and pending work are checked again before release. A changed source requires a new
+inspection and answer. This recovery never deletes files or branches or interrupts another agent.
+
+If the running client predates the pool tools, inspect `git worktree list` and the existing task
+reservations before any explicit allocation. Do not treat an unavailable tool or an empty registry
+as an empty filesystem. Preserve uncertain checkouts and report the client limitation.
+
+## Network and generation evidence
+
+`network` means tests of the changed network/contract behavior, not a connection to a live provider.
+Use local contract tests and controlled responses for the applicable success, errors, timeout,
+retry and cancellation behavior. Report the real runner command, for example
+`mvn -B -Dtest=CardDepositServiceTest test` or `./gradlew test --tests CardDepositServiceTest`;
+the class name need not contain a special keyword. Report `network` only when that suite actually
+covers the changed contract. A command match cannot establish behavioral coverage by itself.
+Source searches, static analyzers, `echo` and a successful `curl` request do not replace these tests.
+Never rename a command or invent a passing result to satisfy a category.
+
+Handwritten files under `service`/`services` do not automatically require a separate network category,
+and handwritten `model`/`models` files do not automatically require code generation. Explicit
+network paths and generated `.g.dart`/`.freezed.dart` files retain their gates. On code tasks,
+additional applicable `network` and `codegen` evidence is accepted; all submitted evidence must pass.
+Read-only validation requirements are unchanged. Test commands that explicitly skip tests cannot
+serve as test or network evidence. A live environment is a separate check when the task requires it.
+
+If the user later reconsiders a preserved legacy checkout, repeat `worktree.reconcile` with a new
+`decisionAttempt`; never reinterpret the previous preserve answer as approval.

package/skill/references/questionnaires.md

@@ -20,6 +20,30 @@ The host owns the visible form and may impose a transport deadline or close it w
 
 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. Questions and saved answers must not contain credentials, personal data or production payloads. Authentication secrets belong in the existing browser authentication flow. Use an appropriate permitted native control for information that cannot be persisted; do not put it into a durable question's title, options or stored answer.
 
+## Host-native answer relay
+
+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.
+
+For branch preferences, each role remains a separate decision bound to the exact preference
+value and expectedVersion. A combined "yes to all branches" from a different question cannot
+be relayed into three independent forms. Finish each original role question, then retry
+project.set_git_preferences with its original arguments. The backend applies the group only
+when every supplied role is approved and the version and authority still match. A concurrent
+edit requires reading current preferences and fresh decisions for the new version.
+
+Map the native result to the original option id only when the selected label identifies it
+unambiguously; never substitute or omit choices to fit a host limit. If all choices and required
+text cannot be represented by a permitted blocking control, leave the original question pending.
+Do not use this relay to evade host approval restrictions or a user declining the owning action.
+With a saved explicit defer, use a new decisionAttempt only after the user chooses to reconsider.
+
+The relay stores host-native provenance beside the atomic answer. It does not store transcripts,
+personal identities or host tool-call logs. Bounded decision text follows the existing privacy
+checks; unrestricted Other text is returned once and cannot be recovered after restart. Installed
+clients must restart after an upgrade to read the new relay receipt field; old receipts remain
+readable by the new client. No server or SDK can independently prove an agent's claim that a
+host-native form was shown; agents must use only the actual native result they observed.
+
 ## Authentication
 
 When no Engineering Memory session exists, ask whether to sign in, create an account, or skip Engineering Memory for this task. Explain that skip is permitted only for an unbound repository. After sign in or sign up is selected, let the bridge open the browser authentication flow. Never ask for a password in the native questionnaire or chat. If a browser link is expired, rejected, already used, or otherwise unusable, call `auth.signin_browser` with `restart: true` and present only the newly returned URL.
@@ -262,3 +286,16 @@ withdrawing it. Language changes never broaden the approved source, mode or prev
 Shared preferences use separate native decisions for development, production and test. Explicitly absent production/test values are answers. Members without canManage receive a task-specific branch choice, never an administrator question they cannot apply. The same task's accepted decision stays valid across Codex/Claude handoff after pause; return to session.resume and the recorded repoRoot.
 
 For task.branch and project.set_git_preferences, retries keep the same decisionAttempt (omit it on the first attempt). When the user explicitly reconsiders an answered deferral, use a new positive decisionAttempt to open a fresh native decision. Never reinterpret the old deferral as consent.
+
+## Legacy worktree availability
+
+Use `worktree.list` before deciding another directory is needed. An unregistered legacy checkout
+has unknown prior ownership and delivery, even if Git reports clean. `worktree.reconcile` with
+`releaseUnowned:true` and `language` opens the native availability question for that exact checkout,
+source commit and generation. The user confirms prior work and delivery have finished; current Git
+safety checks still decide whether reuse is possible. Cancellation or choosing to preserve does not
+release it. Resume the same form via the same operation. A changed source/generation needs a fresh
+decision, and an old answer cannot release a newly owned task.
+
+If the user later reconsiders a preserved legacy checkout, repeat `worktree.reconcile` with a new
+`decisionAttempt`; never reinterpret the previous preserve answer as approval.