engineering-memory 1.11.9 → 1.11.10

package/runtime/dist/src/git/git-inspector.js

@@ -242,6 +242,39 @@ export class GitInspector {
         ]);
         return ref ? ref.replace(/^origin\//, '') : null;
     }
+    async pushDestination(repoRoot) {
+        const branch = await this.currentBranch(repoRoot);
+        const upstream = branch
+            ? await this.gitValue(repoRoot, ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'])
+            : null;
+        const listed = await this.runner.run('git', ['remote'], { cwd: repoRoot });
+        const remotes = listed.exitCode === 0 ? listed.stdout.split(/\r?\n/).filter(Boolean) : [];
+        const configured = (branch &&
+            (await this.gitValue(repoRoot, ['config', '--get', `branch.${branch}.pushRemote`]))) ||
+            (await this.gitValue(repoRoot, ['config', '--get', 'remote.pushDefault'])) ||
+            (branch && (await this.gitValue(repoRoot, ['config', '--get', `branch.${branch}.remote`]))) ||
+            'origin';
+        const remote = remotes.includes(configured) ? configured : null;
+        const pushUrl = remote
+            ? await this.gitValue(repoRoot, ['remote', 'get-url', '--push', remote])
+            : null;
+        const remoteHead = remote
+            ? await this.gitValue(repoRoot, [
+                'symbolic-ref',
+                '--short',
+                '-q',
+                `refs/remotes/${remote}/HEAD`,
+            ])
+            : null;
+        return {
+            branch,
+            upstream,
+            remote,
+            pushUrl: pushUrl ? withoutCredentials(pushUrl) : null,
+            remoteDefaultBranch: remoteHead ? remoteHead.slice(`${remote}/`.length) : null,
+            headCommit: await this.gitValue(repoRoot, ['rev-parse', '--verify', '-q', 'HEAD']),
+        };
+    }
     async protectedBranchNames(repoRoot) {
         const names = new Set(['main', 'master', 'develop', 'prod']);
         const fallback = await this.defaultBranch(repoRoot);
@@ -286,6 +319,14 @@ export class GitInspector {
         }
         return await canonicalPath(resolve(commonDirectory, '..'));
     }
+    async identity(repoRoot) {
+        const root = await this.findRoot(repoRoot);
+        const [head, branch] = await Promise.all([
+            this.gitValue(root, ['rev-parse', 'HEAD']),
+            this.currentBranch(root),
+        ]);
+        return { repoRoot: root, head, branch };
+    }
     async manifest(repoRoot) {
         const root = await this.findRoot(repoRoot);
         const head = await this.gitValue(root, ['rev-parse', 'HEAD']);
@@ -301,6 +342,30 @@ export class GitInspector {
             diffHash: sha256(`${head ?? '<unborn>'}\n${stableStringify(hashManifest)}\n`),
         };
     }
+    async manifestAgainst(repoRoot, baseCommit) {
+        const root = await this.findRoot(repoRoot);
+        const head = await this.gitValue(root, ['rev-parse', 'HEAD']);
+        const changedPaths = await this.changedPathsAgainstHead(root, baseCommit);
+        const hashManifest = canonicalHashManifest(changedPaths);
+        return {
+            repoRoot: root,
+            head,
+            baseCommit,
+            changedPaths,
+            worktreeHash: sha256(`${stableStringify(hashManifest)}\n`),
+            diffHash: sha256(`${baseCommit}\n${head ?? '<unborn>'}\n${stableStringify(hashManifest)}\n`),
+        };
+    }
+    async isAncestor(repoRoot, ancestor, descendant = 'HEAD') {
+        const result = await this.runner.run('git', ['merge-base', '--is-ancestor', ancestor, descendant], { cwd: repoRoot });
+        return result.exitCode === 0;
+    }
+    async committedPaths(repoRoot, baseCommit) {
+        const result = await this.runner.run('git', ['diff', '--name-only', '-z', '--find-renames', baseCommit, 'HEAD', '--'], { cwd: repoRoot });
+        if (result.exitCode !== 0)
+            throw new Error(`Git committed diff failed: ${result.stderr.trim()}`);
+        return result.stdout.split('\0').filter(Boolean).map(normalizeGitPath).sort();
+    }
     async stagedManifest(repoRoot) {
         const root = await this.findRoot(repoRoot);
         let result = await this.runner.run('git', ['diff', '--cached', '--name-status', '-z', '--find-renames', '--find-copies', 'HEAD', '--'], { cwd: root });
@@ -357,10 +422,10 @@ export class GitInspector {
         }
         return result.sort((left, right) => left.path.localeCompare(right.path));
     }
-    async changedPathsAgainstHead(repoRoot) {
+    async changedPathsAgainstHead(repoRoot, ref = 'HEAD') {
         const [tracked, raw, untracked] = await Promise.all([
-            this.runner.run('git', ['diff', 'HEAD', '--name-status', '-z', '--find-renames', '--find-copies', '--'], { cwd: repoRoot }),
-            this.runner.run('git', ['diff', 'HEAD', '--raw', '-z', '--no-abbrev', '--'], {
+            this.runner.run('git', ['diff', ref, '--name-status', '-z', '--find-renames', '--find-copies', '--'], { cwd: repoRoot }),
+            this.runner.run('git', ['diff', ref, '--raw', '-z', '--no-abbrev', '--'], {
                 cwd: repoRoot,
             }),
             this.runner.run('git', ['ls-files', '--others', '--exclude-standard', '-z'], {
@@ -699,6 +764,20 @@ function canonicalRemoteIdentity(remote) {
         return `local/${normalizeRemotePath(trimmed.replace(/[?#].*$/, ''))}`;
     }
 }
+function withoutCredentials(remote) {
+    if (!/^[A-Za-z][A-Za-z0-9+.-]*:\/\//.test(remote))
+        return remote;
+    try {
+        const url = new URL(remote);
+        if (url.protocol === 'http:' || url.protocol === 'https:')
+            url.username = ''; // a pasted token sits here
+        url.password = '';
+        return url.toString();
+    }
+    catch {
+        return remote.replace(/\/\/[^/@]*@/, '//');
+    }
+}
 function normalizeRemotePath(path) {
     const normalized = path
         .replace(/\\/g, '/')

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

@@ -151,23 +151,34 @@ export class VerificationGate {
             };
         }
         const actualSource = receipt.source ? await this.git.sourceIdentity(repoRoot) : null;
+        const ahead = receipt.branch &&
+            receipt.source &&
+            actualSource &&
+            actualSource.sourceCommit !== receipt.source.sourceCommit &&
+            (await this.git.isAncestor(repository.repoRoot, receipt.source.sourceCommit)) &&
+            (await this.git.committedPaths(repository.repoRoot, receipt.source.sourceCommit)).every((path) => receipt.taskChanges.some((change) => change.path === path))
+            ? await this.git.manifestAgainst(repository.repoRoot, receipt.source.sourceCommit)
+            : null;
+        const committedAhead = ahead?.diffHash === receipt.diffHash;
+        const current = ahead && committedAhead ? ahead : manifest;
         if (receipt.source &&
+            !committedAhead &&
             (!actualSource ||
                 actualSource.sourceCommit !== receipt.source.sourceCommit ||
                 actualSource.treeHash !== receipt.source.treeHash)) {
             return {
                 allowed: false,
                 reason: 'source_commit_mismatch',
-                diffHash: manifest.diffHash,
+                diffHash: current.diffHash,
                 taskId: receipt.taskId,
                 details: ['Return to the task source commit or start a task for the current source.'],
             };
         }
-        if (receipt.diffHash !== manifest.diffHash) {
+        if (receipt.diffHash !== current.diffHash) {
             return {
                 allowed: false,
                 reason: 'git_diff_changed_after_verify',
-                diffHash: manifest.diffHash,
+                diffHash: current.diffHash,
                 taskId: receipt.taskId,
             };
         }
@@ -175,7 +186,7 @@ export class VerificationGate {
             return {
                 allowed: false,
                 reason: 'no_task_changes_staged',
-                diffHash: manifest.diffHash,
+                diffHash: current.diffHash,
                 taskId: receipt.taskId,
             };
         }
@@ -183,7 +194,7 @@ export class VerificationGate {
             return {
                 allowed: false,
                 reason: 'staged_change_outside_task',
-                diffHash: manifest.diffHash,
+                diffHash: current.diffHash,
                 taskId: receipt.taskId,
             };
         }
@@ -191,22 +202,24 @@ export class VerificationGate {
             return {
                 allowed: false,
                 reason: 'online_commit_gate_unavailable',
-                diffHash: manifest.diffHash,
+                diffHash: current.diffHash,
                 taskId: receipt.taskId,
             };
         }
         try {
             const attestation = await this.commitGateAttestor({
-                source: actualSource
-                    ? {
-                        ...actualSource,
-                        ...(receipt.source?.linked ? { linked: receipt.source.linked } : {}),
-                    }
-                    : undefined,
+                source: committedAhead
+                    ? receipt.source
+                    : actualSource
+                        ? {
+                            ...actualSource,
+                            ...(receipt.source?.linked ? { linked: receipt.source.linked } : {}),
+                        }
+                        : undefined,
                 taskId: receipt.taskId,
                 projectId: receipt.projectId,
                 repoFingerprint: receipt.repoFingerprint,
-                diffHash: manifest.diffHash,
+                diffHash: current.diffHash,
                 expectedTaskVersion: receipt.taskVersion,
                 branch: branch ?? undefined,
             });
@@ -214,11 +227,11 @@ export class VerificationGate {
             if (result?.allowed !== true ||
                 result.taskId !== receipt.taskId ||
                 result.taskVersion !== receipt.taskVersion ||
-                result.diffHash !== manifest.diffHash) {
+                result.diffHash !== current.diffHash) {
                 return {
                     allowed: false,
                     reason: 'online_commit_gate_mismatch',
-                    diffHash: manifest.diffHash,
+                    diffHash: current.diffHash,
                     taskId: receipt.taskId,
                 };
             }
@@ -227,7 +240,7 @@ export class VerificationGate {
             return {
                 allowed: false,
                 reason: 'online_commit_gate_rejected',
-                diffHash: manifest.diffHash,
+                diffHash: current.diffHash,
                 taskId: receipt.taskId,
                 details: [error instanceof Error ? error.message : String(error)],
             };
@@ -235,7 +248,7 @@ export class VerificationGate {
         return {
             allowed: true,
             reason: 'verified',
-            diffHash: manifest.diffHash,
+            diffHash: current.diffHash,
             taskId: receipt.taskId,
         };
     }

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

@@ -1,6 +1,6 @@
 import * as z from 'zod/v4';
 import { sha256, stableStringify } from '../utilities/hash.js';
-import { askQuestionnaire } from './questionnaire-tools.js';
+import { answerChoice, answerData, askQuestionnaire } from './questionnaire-tools.js';
 const uuid = z.string().uuid();
 const hash = z.string().regex(/^[a-f0-9]{64}$/);
 const project = { projectId: uuid };
@@ -468,7 +468,7 @@ export function registerOnboardingTools(server, service) {
         inputSchema: z.object(run),
     }, async (input) => output(await service.onboardingRequest('verify', body(input))));
     server.registerTool('memory.catalog', {
-        description: 'Page accessible memory resource headers by id. Read all pages using the last id when a page is full. includeArchived exposes retired identities for refresh and rename preservation.',
+        description: 'Page accessible memory resource headers by id: each entry names its current revision and its size in characters instead of carrying its content. Pass the response nextAfterId as afterId to read the next page; nextAfterId is null once nothing more remains. includeArchived exposes retired identities for refresh and rename preservation.',
         inputSchema: z.object({
             ...project,
             ...page,
@@ -479,7 +479,7 @@ export function registerOnboardingTools(server, service) {
         }),
     }, async (input) => output(await service.onboardingRequest('catalog', body(input))));
     server.registerTool('memory.read_revisions', {
-        description: 'Read selected immutable revisions in an authorized context session and record receipts. Bounds keep large project learning independent of normal task context limits.',
+        description: 'Read selected immutable revisions in an authorized context session and record receipts. One response carries what fits its size budget, in the order requested, as items; the revisions it did not carry are listed in remainingRevisionIds, to pass to the next call. Bounds keep large project learning independent of normal task context limits.',
         inputSchema: z.object({
             ...project,
             sessionId: uuid,
@@ -533,19 +533,6 @@ export function registerOnboardingTools(server, service) {
         })));
     });
 }
-function answerChoice(result) {
-    return answerData(result)?.choice;
-}
-function answerData(result) {
-    const response = result;
-    const text = response.content?.find((item) => item.type === 'text')?.text;
-    if (!text)
-        return undefined;
-    const value = JSON.parse(text);
-    return value.ok && value.data?.status === 'answered' && value.data.answerAvailable
-        ? value.data.answer
-        : undefined;
-}
 async function approveOnboarding(server, service, input, context, initialize) {
     const preparation = !input.projectId;
     const scope = { repoRoot: input.repoRoot, preparation };

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

@@ -1,13 +1,26 @@
 import { acceptedContent, CLIENT_CAPABILITIES_META_KEY, inputRequired, inputResponse, } from '@modelcontextprotocol/server';
 import { questionnaireAnswerSchema, } from '../runtime/questionnaire-store.js';
-export async function askQuestionnaire(server, service, input, context, previousDefinitions = []) {
+export async function askQuestionnaire(server, service, input, context, previousDefinitions = [], owner) {
     try {
-        return await present(server, service, await service.questionnaireAsk(input, previousDefinitions), input.repoRoot, context, input.preparation);
+        return await present(server, service, await service.questionnaireAsk(input, previousDefinitions, owner), input.repoRoot, context, input.preparation, input.presentation);
     }
     catch (error) {
         return failure(error);
     }
 }
+export function answerChoice(result) {
+    return answerData(result)?.choice;
+}
+export function answerData(result) {
+    const response = result;
+    const text = response.content?.find((item) => item.type === 'text')?.text;
+    if (!text)
+        return undefined;
+    const value = JSON.parse(text);
+    return value.ok && value.data?.status === 'answered' && value.data.answerAvailable
+        ? value.data.answer
+        : undefined;
+}
 export async function resumeQuestionnaire(server, service, input, context) {
     try {
         return await present(server, service, await service.questionnaireResume(input), input.repoRoot, context, input.preparation, input.presentation);
@@ -19,7 +32,7 @@ export async function resumeQuestionnaire(server, service, input, context) {
 export async function answerQuestionnaireFromHost(service, input) {
     try {
         const resolved = await service.questionnaireAnswerFromHost(input);
-        return answered(resolved.record, resolved.answer, resolved.replayed);
+        return answered(resolved.record, resolved.answer, resolved.replayed, resolved.retry);
     }
     catch (error) {
         return failure(error);
@@ -33,8 +46,11 @@ async function present(server, service, record, repoRoot, context, preparation,
             answerAvailable: false,
             nextAction: 'This decision was explicitly withdrawn. Do not continue dependent work. Use a new questionnaireId or onboarding requestKey only if the user resumes that work.',
         });
-    if (record.status === 'answered')
-        return answered(record, record.answer, true);
+    if (record.status === 'answered') {
+        if (inputResponse(context.mcpReq.inputResponses, record.requestKey).kind !== 'missing')
+            consumedResponses(context).add(record.requestKey);
+        return answered(record, record.questions ? record.answers : record.answer, true);
+    }
     if (context.mcpReq.signal.aborted)
         return pending(record, 'interrupted');
     if (presentation === 'host_native')
@@ -42,22 +58,27 @@ async function present(server, service, record, repoRoot, context, preparation,
     const responses = context.mcpReq.inputResponses;
     const response = inputResponse(responses, record.requestKey);
     if (response.kind === 'elicit' && response.action === 'accept') {
-        const answer = acceptedContent(responses, record.requestKey, questionnaireAnswerSchema(record));
+        const content = acceptedContent(responses, record.requestKey);
+        const parsed = questionnaireAnswerSchema(record).safeParse(record.questions && content ? formAnswers(record, content) : content);
+        const answer = parsed.success ? parsed.data : undefined;
         if (!answer)
             return pending(record, 'invalid_response');
+        consumedResponses(context).add(record.requestKey);
         const resolved = await service.questionnaireAccept({
             repoRoot,
             preparation,
             questionnaireId: record.questionnaireId,
             requestKey: record.requestKey,
             scope: record.scope,
-            answer,
+            answer: answer,
         });
         return answered(resolved.record, resolved.answer, resolved.replayed);
     }
     if (response.kind === 'elicit')
         return pending(record, response.action);
-    if (responses !== undefined || context.mcpReq.droppedInputResponseKeys?.length)
+    if (response.kind !== 'missing' ||
+        context.mcpReq.droppedInputResponseKeys?.length ||
+        Object.keys(responses ?? {}).some((key) => !consumedResponses(context).has(key)))
         return pending(record, 'missing_or_stale_response');
     const envelope = context.mcpReq.envelope;
     const capabilities = envelope?.[CLIENT_CAPABILITIES_META_KEY] ?? server.server.getClientCapabilities();
@@ -65,6 +86,35 @@ async function present(server, service, record, repoRoot, context, preparation,
     if (!elicitation || (!elicitation.form && elicitation.url !== undefined))
         return pending(record, 'native_form_unavailable');
     const copy = questionnaireCopy[record.language ?? 'en'];
+    if (record.questions) {
+        const properties = {};
+        const required = [];
+        for (const sub of record.questions) {
+            properties[sub.id] = {
+                type: 'string',
+                title: sub.message,
+                enum: sub.options.map((option) => option.id),
+                enumNames: sub.options.map((option) => option.label),
+            };
+            required.push(sub.id);
+            if (sub.textField)
+                properties[`${sub.id}_text`] = {
+                    type: 'string',
+                    title: sub.textField.title,
+                    minLength: 1,
+                    maxLength: sub.textField.maxLength,
+                };
+        }
+        return inputRequired({
+            inputRequests: {
+                [record.requestKey]: inputRequired.elicit({
+                    mode: 'form',
+                    message: presentationMessage(record),
+                    requestedSchema: { type: 'object', properties, required },
+                }),
+            },
+        });
+    }
     return inputRequired({
         inputRequests: {
             [record.requestKey]: inputRequired.elicit({
@@ -112,11 +162,18 @@ async function present(server, service, record, repoRoot, context, preparation,
         },
     });
 }
+const consumed = new WeakMap();
+function consumedResponses(context) {
+    const keys = consumed.get(context.mcpReq) ?? new Set();
+    consumed.set(context.mcpReq, keys);
+    return keys;
+}
 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.',
         storedText: ' The bounded text field is stored as part of this exact decision and is replayed after restart.',
+        multi: ' AskUserQuestion takes up to 4 questions per call. Show every question in as few calls as needed, then relay all answers in one questionnaire.answer_from_host.',
         answer: 'Answer',
         other: 'Other',
         otherAnswer: 'Other answer',
@@ -125,17 +182,33 @@ const questionnaireCopy = {
         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.',
         storedText: ' Bu metin alanındaki yanıt kararınla birlikte saklanır; yeniden başlattığında korunur.',
+        multi: ' AskUserQuestion tek çağrıda en fazla 4 soru alır. Her soruyu en az çağrıyla göster, sonra tüm yanıtları tek bir questionnaire.answer_from_host çağrısında ilet.',
         answer: 'Yanıt',
         other: 'Diğer',
         otherAnswer: 'Diğer yanıt',
     },
 };
+function formAnswers(record, content) {
+    const answers = {};
+    for (const sub of record.questions ?? []) {
+        if (content[sub.id] === undefined)
+            continue;
+        const text = content[`${sub.id}_text`];
+        answers[sub.id] = {
+            choice: content[sub.id],
+            ...(text !== undefined && sub.textField?.requiredForChoice === content[sub.id]
+                ? { text }
+                : {}),
+        };
+    }
+    return answers;
+}
 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 : ''}`;
+    return `${record.message}${notice ? `\n\n${notice}` : ''}\n\n${copy.pending}${record.allowFreeText ? copy.freeText : ''}${record.textField ? copy.storedText : ''}${record.questions ? copy.multi : ''}`;
 }
 function pending(record, reason) {
     return result({
@@ -149,25 +222,36 @@ function pending(record, reason) {
             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.',
+            ...(record.questions
+                ? {
+                    questions: record.questions,
+                    ...(record.terminalChoices ? { terminalChoices: record.terminalChoices } : {}),
+                }
+                : {
+                    options: record.options,
+                    allowFreeText: record.allowFreeText,
+                    ...(record.textField ? { textField: record.textField } : {}),
+                }),
+            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.',
         },
         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 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) {
+function answered(record, answer, replayed, retry) {
+    const key = record.questions ? 'answers' : 'answer';
     return result({
         questionnaireId: record.questionnaireId,
         status: 'answered',
         answerAvailable: answer !== undefined,
-        ...(answer ? { answer } : {}),
+        ...(answer ? { [key]: answer } : {}),
         replayed,
         ...(record.answerSource ? { answerSource: record.answerSource } : {}),
+        ...(retry ? { retry } : {}),
         ...(!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-annotations.js

@@ -0,0 +1,111 @@
+const read = { readOnlyHint: true, openWorldHint: false }; // receipts and registry upkeep still read
+const write = {
+    readOnlyHint: false,
+    destructiveHint: false,
+    openWorldHint: false,
+};
+const repeatableWrite = { ...write, idempotentHint: true };
+const destructive = {
+    readOnlyHint: false,
+    destructiveHint: true,
+    openWorldHint: false,
+};
+const outward = {
+    readOnlyHint: false,
+    destructiveHint: false,
+    openWorldHint: true,
+};
+export const toolAnnotations = {
+    'project.git_preferences': read,
+    'project.set_git_preferences': write,
+    'worktree.policy': read,
+    'worktree.set_policy': write,
+    'worktree.list': read,
+    'worktree.reconcile': destructive, // releaseUnowned hands a recovered checkout back
+    'task.heartbeat': repeatableWrite,
+    'task.pause': write,
+    'worktree.release': destructive,
+    'audit.list': read,
+    'questionnaire.ask': repeatableWrite,
+    'questionnaire.resume': repeatableWrite, // records an accepted answer
+    'questionnaire.answer_from_host': repeatableWrite,
+    'questionnaire.withdraw': destructive,
+    'session.entry': read,
+    'session.set_decision': repeatableWrite,
+    'session.decline_update': repeatableWrite,
+    'session.answer_shadow_notice': repeatableWrite,
+    'session.bootstrap': write,
+    'session.resume': write,
+    'context.prepare_change': write,
+    'context.refresh': write,
+    'project.inspect': read,
+    'project.onboard': write,
+    'project.onboarding_status': read,
+    'project.rework_plan': write,
+    'project.initialize': write,
+    'memory.source': read,
+    'memory.sync_start': repeatableWrite,
+    'memory.sync_status': read,
+    'memory.sync_inventory': write,
+    'memory.sync_plan': write,
+    'memory.sync_next': write,
+    'memory.sync_submit': write,
+    'memory.sync_reopen': write,
+    'memory.sync_delta': read,
+    'memory.sync_verify': repeatableWrite,
+    'memory.catalog': read,
+    'memory.sources': read,
+    'memory.source_targets': read,
+    'memory.publish_task': write,
+    'memory.read_revisions': read,
+    'memory.review_batch': write,
+    'memory.query': read,
+    'memory.history': read,
+    'memory.propose_revision': write,
+    'memory.list_proposals': read,
+    'memory.review_proposal': write,
+    'task.checkpoint': write,
+    'task.record_correction': write,
+    'task.self_review': write,
+    'task.reconcile': write,
+    'task.resolve_pending_delivery': destructive, // discards a pending delivery
+    'task.verify': write,
+    'task.close': write,
+    'task.abandon': destructive,
+    'task.branch': outward, // fetches the chosen base from the Git remote
+    'architecture.plan': read,
+    'architecture.module': read,
+    'architecture.record_application': write,
+    'organization.list': read,
+    'organization.create': write,
+    'organization.update': write,
+    'organization.member_list': read,
+    'organization.member_upsert': write,
+    'project.setup': write,
+    'project.list': read,
+    'project.resolve': repeatableWrite, // binds an explicitly selected project
+    'project.archive': destructive,
+    'project.restore': write,
+    'project.member_add': write,
+    'project.member_list': read,
+    'work_item.create': write,
+    'work_item.update': write,
+    'work_item.archive': destructive,
+    'work_item.restore': write,
+    'work_item.runs': read,
+    'work_item.record_test': write,
+    'work_item.test_results': read,
+    'work_item.plan': read,
+    'work_item.confirm_plan': write,
+    'project.update': write,
+    'work_item.list': read,
+    'work_item.get': read,
+    'project.clone': outward,
+    'project.link': write,
+    'project.unlink': destructive,
+    'project.links': read,
+    'auth.status': read,
+    'auth.signin_browser': outward,
+    'auth.logout': destructive,
+};
+//# sourceMappingURL=tool-annotations.js.map