engineering-memory 1.11.19 → 1.11.21

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

@@ -1,4 +1,6 @@
+import * as z from 'zod/v4';
 import { sha256, stableStringify } from '../utilities/hash.js';
+import { copies, format } from './texts.js';
 const startCopy = {
     en: {
         start: (task) => `${task}: how should this task start?`,
@@ -39,6 +41,34 @@ const startCopy = {
         typedName: 'Adı aşağıya yaz. Zaten var olan bir ad kabul edilmez, form yeniden sorulur.',
     },
 };
+const text = z.string().min(1);
+const option = z.strictObject({ label: text, description: text });
+const startWording = z.strictObject({
+    message: text,
+    keepContext: text,
+    newBranch: text,
+    example: text,
+    stay: text,
+    base: z.strictObject({
+        message: text,
+        local: text,
+        localDetail: text,
+        other: text,
+        otherDetail: text,
+        fetchDetail: text,
+        field: text,
+    }),
+    location: z.strictObject({
+        message: text,
+        holder: text,
+        busy: text,
+        dirty: text,
+        worktree: option,
+        here: option,
+        keep: option,
+        defer: option,
+    }),
+});
 export function suggestedBranchNames(externalTaskId) {
     const slug = externalTaskId
         .replace(/[^A-Za-z0-9._-]+/g, '-')
@@ -73,14 +103,15 @@ export function configuredBase(preferences, role) {
         : null;
 }
 export function taskStartDefinition(facts) {
-    const { previous, ...legacy } = legacyTaskStartDefinition(facts);
-    const tr = facts.language === 'tr';
+    const { language, copy } = copies(startWording, 'taskStart', facts.language)[0];
+    const { previous, ...legacy } = legacyTaskStartDefinition({ ...facts, language });
     const binding = { ...legacy.binding };
     const keepOnly = facts.keepCurrent === true || !facts.currentCommit;
     if (!keepOnly) {
         binding.name = facts.name ?? facts.suggestedName;
         delete binding.suggestedName;
     }
+    const branch = facts.currentBranch ?? 'HEAD';
     const seen = new Set();
     const questions = legacy
         .questions.filter((question) => question.id !== 'name')
@@ -88,7 +119,7 @@ export function taskStartDefinition(facts) {
         if (question.id === 'base')
             return {
                 ...question,
-                message: tr ? 'Hangi daldan başlayalım?' : 'Which starting branch?',
+                message: copy.base.message,
                 options: question.options
                     .filter((option) => {
                     const base = binding.bases?.[option.id];
@@ -105,92 +136,57 @@ export function taskStartDefinition(facts) {
                         label: base?.kind === 'remote'
                             ? sourceLabel(base, facts.currentBranch)
                             : option.id === 'current'
-                                ? (tr ? 'Yerel: ' : 'Local: ') + (facts.currentBranch ?? 'HEAD')
-                                : tr
-                                    ? 'origin üzerinde başka dal'
-                                    : 'Another branch on origin',
+                                ? format(copy.base.local, language, { branch })
+                                : copy.base.other,
                         description: option.id === 'current'
-                            ? tr
-                                ? 'Çekmeden, mevcut commit’ten.'
-                                : 'Current commit; no fetch.'
+                            ? copy.base.localDetail
                             : option.id === 'other'
-                                ? tr
-                                    ? 'Alttaki alana yaz.'
-                                    : 'Enter it below.'
-                                : tr
-                                    ? 'Güncel hali çekilir.'
-                                    : 'Fetch the latest commit.',
+                                ? copy.base.otherDetail
+                                : copy.base.fetchDetail,
                     };
                 }),
-                textField: {
-                    ...question.textField,
-                    title: tr
-                        ? 'origin dalı (yalnızca başka dal için)'
-                        : 'Branch on origin (only for another branch)',
-                },
+                textField: { ...question.textField, title: copy.base.field },
             };
         const holder = binding.holder?.externalTaskId;
+        const withheld = withheldReason(facts.folder, keepOnly);
         return {
             ...question,
-            message: tr ? 'Nerede çalışalım?' : 'Where should we work?',
+            message: copy.location.message,
             ...(holder
-                ? {
-                    context: tr
-                        ? `Bu klasördeki ${holder} görevi burada başlarsan ayrı worktree’ye geçer; işi korunur.`
-                        : `Starting here moves ${holder} to a separate worktree; its work is kept.`,
-                }
-                : {}),
-            options: question.options.map((option) => ({
-                ...option,
-                label: option.id === 'worktree'
-                    ? tr
-                        ? 'Ayrı worktree'
-                        : 'Separate worktree'
+                ? { context: format(copy.location.holder, language, { task: holder }) }
+                : withheld
+                    ? {
+                        context: format(copy.location[withheld], language, {
+                            task: facts.folder.heldBy ?? '',
+                        }),
+                    }
+                    : {}),
+            options: question.options.map((option) => {
+                const shown = option.id === 'worktree'
+                    ? copy.location.worktree
                     : option.id === 'here'
-                        ? tr
-                            ? 'Bu klasörde yeni dal'
-                            : 'New branch in this folder'
+                        ? copy.location.here
                         : option.id === 'keep_current'
-                            ? tr
-                                ? 'Mevcut dalda kal'
-                                : 'Stay on the current branch'
-                            : tr
-                                ? 'Şimdilik başlatma'
-                                : 'Not now',
-                description: option.id === 'worktree'
-                    ? tr
-                        ? 'Bu klasör değişmez.'
-                        : 'Leave this folder unchanged.'
-                    : option.id === 'here'
-                        ? tr
-                            ? 'Klasör yeni dala geçer.'
-                            : 'Switch this folder to the new branch.'
-                        : option.id === 'keep_current'
-                            ? tr
-                                ? `${facts.currentBranch ?? 'HEAD'} üzerinde devam et.`
-                                : `Continue on ${facts.currentBranch ?? 'HEAD'}.`
-                            : tr
-                                ? 'Hiçbir şey oluşturulmaz.'
-                                : 'Create nothing.',
-            })),
+                            ? copy.location.keep
+                            : copy.location.defer;
+                return {
+                    ...option,
+                    label: shown.label,
+                    description: format(shown.description, language, { branch }),
+                };
+            }),
         };
     });
     questions.sort((left, right) => Number(right.id === 'base') - Number(left.id === 'base'));
+    const current = sourceLabel({ kind: 'current', ...(facts.currentCommit ? { commit: facts.currentCommit } : {}) }, facts.currentBranch);
     return {
         ...legacy,
-        message: tr ? 'Göreve başla' : 'Start task',
+        message: copy.message,
         context: keepOnly
-            ? tr
-                ? 'Mevcut dalda devam edilecek.'
-                : 'Continue on the current branch.'
-            : (tr ? 'Yeni dal: ' : 'New branch: ') +
-                binding.name +
+            ? copy.keepContext
+            : format(copy.newBranch, language, { name: binding.name }) +
                 (binding.base ? ' · ' + sourceLabel(binding.base, facts.currentBranch) : ''),
-        example: keepOnly
-            ? legacy.example
-            : tr
-                ? 'Ayrı worktree, işi ayrı klasörde tutar.'
-                : 'A worktree keeps this task in its own folder.',
+        example: keepOnly ? format(copy.stay, language, { source: current }) : copy.example,
         questions,
         binding: JSON.parse(JSON.stringify(binding)),
         previous: [previous, legacy],
@@ -470,10 +466,16 @@ function readableTime(value, tr) {
         return null;
     return (tr ? date.split('-').reverse().join('.') : date) + ' ' + time + ' UTC';
 }
-function withheld(folder, keepOnly, tr) {
+function withheldReason(folder, keepOnly) {
     if (keepOnly || folder.managed || (!folder.heldBy && folder.clean))
         return null;
-    if (folder.heldBy)
+    return folder.heldBy ? 'busy' : 'dirty';
+}
+function withheld(folder, keepOnly, tr) {
+    const reason = withheldReason(folder, keepOnly);
+    if (!reason)
+        return null;
+    if (reason === 'busy')
         return tr
             ? folder.heldBy +
                 ' 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.'

package/runtime/dist/src/runtime/texts.js

@@ -0,0 +1,135 @@
+import * as z from 'zod/v4';
+import { endpoints } from '../config.js';
+import { bundledDirections, bundledTexts } from '../localization/catalogue.generated.js';
+const fetched = {};
+const runtimeTexts = z.object({
+    language: z.string(),
+    direction: z.enum(['ltr', 'rtl']),
+    texts: z.array(z.object({ key: z.string(), text: z.string() })),
+});
+const savedTexts = z.object({ current: runtimeTexts, previous: runtimeTexts.optional() });
+export async function fetchLanguage(client, store, language) {
+    const stored = savedTexts.safeParse(await store.fetchedTexts(language));
+    let saved = stored.success ? stored.data : undefined;
+    const response = await client
+        .request(`${endpoints.runtimeTexts}?${new URLSearchParams({ language })}`, {
+        authenticated: false,
+        networkTimeoutMs: 2000,
+    })
+        .catch(() => null);
+    const fresh = runtimeTexts.safeParse(response?.data);
+    if (fresh.success && JSON.stringify(fresh.data) !== JSON.stringify(saved?.current)) {
+        saved = { current: fresh.data, previous: saved?.current };
+        await store.rememberFetchedTexts(language, saved);
+    }
+    if (!saved?.current.texts.length)
+        return;
+    fetched[saved.current.language] = {
+        direction: saved.current.direction,
+        versions: [saved.current, ...(saved.previous ? [saved.previous] : [])].map((version) => Object.fromEntries(version.texts
+            .filter(({ key }) => bundledTexts.en[key] !== undefined)
+            .map(({ key, text }) => [key, text]))),
+    };
+}
+export function texts(prefix, language, version = 0) {
+    const own = (code) => bundledTexts[code] ?? fetched[code]?.versions[version];
+    const catalogue = { ...own(language.split('-')[0]), ...own(language) };
+    const copy = {};
+    for (const [key, text] of Object.entries(catalogue)) {
+        if (!key.startsWith(prefix + '.'))
+            continue;
+        const path = key.slice(prefix.length + 1).split('.');
+        let node = copy;
+        for (const part of path.slice(0, -1))
+            node = (node[part] ??= {});
+        node[path.at(-1)] = text;
+    }
+    return copy;
+}
+export function format(template, language, values) {
+    let text = '';
+    for (let index = 0; index < template.length; index++) {
+        if (template[index] !== '{') {
+            text += template[index];
+            continue;
+        }
+        const end = closing(template, index);
+        const inner = template.slice(index + 1, end);
+        const comma = inner.indexOf(',');
+        const name = (comma < 0 ? inner : inner.slice(0, comma)).trim();
+        if (values[name] === undefined)
+            throw new Error(`No value for {${name}} in ${template}`);
+        if (comma < 0)
+            text += String(values[name]);
+        else {
+            const kind = inner.indexOf(',', comma + 1);
+            if (inner.slice(comma + 1, kind).trim() !== 'plural')
+                throw new Error(`Only plural formats are supported: ${template}`);
+            const count = Number(values[name]);
+            const chosen = pluralCase(inner.slice(kind + 1), language, count);
+            text += format(chosen.replaceAll('#', String(values[name])), language, values);
+        }
+        index = end;
+    }
+    return text;
+}
+function pluralCase(cases, language, count) {
+    const found = new Map();
+    for (let index = 0; index < cases.length;) {
+        const open = cases.indexOf('{', index);
+        if (open < 0)
+            break;
+        const end = closing(cases, open);
+        found.set(cases.slice(index, open).trim(), cases.slice(open + 1, end));
+        index = end + 1;
+    }
+    const chosen = found.get('=' + count) ??
+        found.get(new Intl.PluralRules(language).select(count)) ??
+        found.get('other');
+    if (chosen === undefined)
+        throw new Error(`A plural format needs an other case: ${cases}`);
+    return chosen;
+}
+function closing(text, open) {
+    let depth = 0;
+    for (let index = open; index < text.length; index++) {
+        if (text[index] === '{')
+            depth++;
+        if (text[index] === '}' && --depth === 0)
+            return index;
+    }
+    throw new Error(`Unbalanced braces in ${text}`);
+}
+export function catalogueLanguages() {
+    return [...Object.keys(bundledTexts), ...Object.keys(fetched)];
+}
+export function escapeHtml(value) {
+    return value.replace(/[&<>"']/g, (character) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[character]);
+}
+export function textDirection(language) {
+    const primary = language.split('-')[0];
+    return (bundledDirections[language] ??
+        fetched[language]?.direction ??
+        bundledDirections[primary] ??
+        fetched[primary]?.direction ??
+        'ltr');
+}
+export function copies(wording, prefix, language = 'en') {
+    const complete = (code, version = 0) => {
+        const copy = wording.safeParse(texts(prefix, code, version));
+        return copy.success ? [{ language: code, copy: copy.data }] : [];
+    };
+    const known = catalogueLanguages().find((code) => code.toLowerCase() === language.toLowerCase()) ??
+        language.split('-')[0];
+    const shown = complete(known)[0] ?? complete('en')[0];
+    if (!shown)
+        throw new Error(`The English ${prefix} texts do not match the wording the code reads.`);
+    return [
+        shown,
+        ...catalogueLanguages()
+            .filter((code) => code !== shown.language)
+            .flatMap((code) => complete(code)),
+        ...Object.entries(fetched).flatMap(([code, { versions }]) => versions.slice(1).flatMap((_, index) => complete(code, index + 1))),
+    ];
+}
+//# sourceMappingURL=texts.js.map

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

@@ -7,7 +7,7 @@ import { GitInspector } from '../git/git-inspector.js';
 import { atomicWrite, assertManagedPath, canonicalPath, ensureManagedDirectory, pathExists, readJson, removeFile, safeSegment, } from '../utilities/files.js';
 import { sha256 } from '../utilities/hash.js';
 import { localMutex } from '../utilities/local-mutex.js';
-import { NativeCommandRunner } from '../utilities/process.js';
+import { NativeCommandRunner, windowsSystemTool } from '../utilities/process.js';
 import { BridgeRecoveryError } from './recovery-error.js';
 import { planWorktreeFiles, ignoredRuntimeFiles, createWorktreeStage, stageWorktreeFiles, publishWorktreeFiles, discardStagedWorktreeFiles, } from './worktree-preparation.js';
 import { WorktreeFileIssue, WorktreeFileStatus, } from './worktree-readiness-types.js';
@@ -43,6 +43,8 @@ const allocationSchema = z.object({
     root: z.string().optional(),
     layout: z.union([z.literal(1), z.literal(2)]).optional(),
     deliveryOutcome: z.enum(['delivered', 'cancelled']).optional(),
+    deliveredCommit: z.string().optional(),
+    deliveredRef: z.string().optional(),
     cancelledAt: z.string().optional(),
     preservedRef: z.string().optional(),
     sourceRepoRoot: z.string().optional(),
@@ -251,6 +253,7 @@ export class WorktreePool {
                 await this.save(registry);
                 return structuredClone(entry);
             }
+            await this.settleDelivered(registry, project.entries);
             let reusable;
             const activeRoot = key(await this.documentsDirectory());
             const legacyRoot = await this.legacyDocumentsDirectory();
@@ -463,8 +466,10 @@ export class WorktreePool {
     }
     async list(projectId, policy) {
         return this.transaction(async (registry) => {
+            const entries = registry.projects[projectId]?.entries ?? [];
+            await this.settleDelivered(registry, entries);
             const result = [];
-            for (const entry of registry.projects[projectId]?.entries ?? [])
+            for (const entry of entries)
                 result.push(await this.view(entry, policy));
             return result;
         });
@@ -945,6 +950,26 @@ export class WorktreePool {
         };
         return entry;
     }
+    async settleDelivered(registry, entries) {
+        for (const entry of entries) {
+            if (!entry.managed ||
+                !entry.pendingDelivery ||
+                ['creating', 'quarantined', 'released'].includes(entry.phase) ||
+                (entry.owner && !this.owns(entry) && (await this.ownerAlive(entry.owner))) ||
+                (await this.fileProtection(entry)).length)
+                continue;
+            const head = (await this.git.sourceIdentity(entry.repoRoot))?.sourceCommit;
+            if (!head || head === entry.baseCommit)
+                continue;
+            const ref = await this.git.remoteRefContaining(entry.repoRoot, head);
+            if (!ref)
+                continue;
+            entry.deliveryOutcome = 'delivered';
+            entry.deliveredCommit = head;
+            entry.deliveredRef = ref;
+            await this.releaseEntry(registry, entry);
+        }
+    }
     async releaseEntry(registry, entry) {
         await this.releaseReservation(entry);
         if (entry.managed) {
@@ -1220,7 +1245,7 @@ export class WorktreePool {
         const found = new Map();
         try {
             if (process.platform === 'win32') {
-                const result = await this.runner.run('powershell.exe', [
+                const result = await this.runner.run(windowsSystemTool('WindowsPowerShell', 'v1.0', 'powershell.exe'), [
                     '-NoProfile',
                     '-NonInteractive',
                     '-Command',
@@ -1262,7 +1287,7 @@ export class WorktreePool {
                 return stat.slice(stat.lastIndexOf(')') + 2).split(' ')[19] ?? null;
             }
             const result = process.platform === 'win32'
-                ? await this.runner.run('powershell.exe', [
+                ? await this.runner.run(windowsSystemTool('WindowsPowerShell', 'v1.0', 'powershell.exe'), [
                     '-NoProfile',
                     '-NonInteractive',
                     '-Command',
@@ -1359,7 +1384,7 @@ export class WorktreePool {
         if (this.legacyDocuments)
             return resolve(this.legacyDocuments);
         if (process.platform === 'win32') {
-            const result = await this.runner.run('powershell.exe', [
+            const result = await this.runner.run(windowsSystemTool('WindowsPowerShell', 'v1.0', 'powershell.exe'), [
                 '-NoProfile',
                 '-NonInteractive',
                 '-Command',

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

@@ -7,6 +7,7 @@ import { assertManagedPath, ensureManagedDirectory } from '../utilities/files.js
 import { WorktreeFileIssue, WorktreeFileStatus, } from './worktree-readiness-types.js';
 import { parseGradleSigning } from './worktree-gradle.js';
 import { sha256, stableStringify } from '../utilities/hash.js';
+import { windowsSystemTool } from '../utilities/process.js';
 export async function ignoredRuntimeFiles(sourceRoot, mainRoot, repoRoot) {
     const sources = [];
     for (const root of [...new Set([sourceRoot, mainRoot])]) {
@@ -824,7 +825,7 @@ async function assertStage(stage, missing = false) {
 export async function stageWorktreeFiles(stage) {
     const directory = (await assertStage(stage));
     if (process.platform === 'win32') {
-        const account = await execute('whoami.exe', ['/user', '/fo', 'csv', '/nh'], {
+        const account = await execute(windowsSystemTool('whoami.exe'), ['/user', '/fo', 'csv', '/nh'], {
             timeout: 10000,
             windowsHide: true,
             maxBuffer: 8192,
@@ -832,7 +833,7 @@ export async function stageWorktreeFiles(stage) {
         const sid = /S-1-5-\d+(?:-\d+)+/.exec(account.stdout)?.[0];
         if (!sid)
             throw new Error('Local file access could not be restricted');
-        await execute('icacls.exe', [directory, '/inheritance:r', '/grant:r', '*' + sid + ':(OI)(CI)F'], {
+        await execute(windowsSystemTool('icacls.exe'), [directory, '/inheritance:r', '/grant:r', '*' + sid + ':(OI)(CI)F'], {
             timeout: 10000,
             windowsHide: true,
             maxBuffer: 8192,

package/runtime/dist/src/utilities/process.js

@@ -1,4 +1,11 @@
 import { spawn } from 'node:child_process';
+import { win32 } from 'node:path';
+export function windowsSystemTool(...path) {
+    const windowsDirectory = process.env.SystemRoot ?? process.env.WINDIR;
+    if (!windowsDirectory || !win32.isAbsolute(windowsDirectory))
+        throw new Error('A trusted absolute Windows system directory is required');
+    return win32.join(windowsDirectory, 'System32', ...path);
+}
 export class NativeCommandRunner {
     async run(command, args, options = {}) {
         return await new Promise((resolvePromise, reject) => {

package/skill/references/lifecycle.md

@@ -371,9 +371,10 @@ identity. Autonomous must still provide reasoned questionnaire.decide responses;
 settings are critical in Approve for me. A changed snapshot requires rereading and reviewing, never
 substituting new versions. Honor explicit deferral and reconsider only when authorized.
 
-For a language other than Turkish or English, supply every copy field in the conversation language.
+Copy comes from the product texts when they cover the conversation language. When the tool refuses
+for missing copy, supply every copy field in the conversation language.
 Do not open custom parallel questions or force a separate Other option. Use the optional description
-flow below separately from role setup. Counted work remapping remains a later unit.
+flow below separately from role setup. Moving existing work to other stages is its own flow below.
 
 ## Optional stage descriptions
 
@@ -386,4 +387,21 @@ The existing editable question can collect explicit text; supplied longer author
 reviewed in full through pages. Only the final review saves the chosen field. Clear requires the
 same review, while keep/skip and unchanged text write nothing. Do not substitute fresh versions,
 reuse a different task's approval or silently proceed after deferral. Mode-governed native or
-reasoned delegated receipts still apply. Complete copy is required outside Turkish/English.
+reasoned delegated receipts still apply. Complete copy is required when the product texts lack the
+conversation language.
+
+## Moving work between stages
+
+When the user retires or merges stages and wants their work to continue elsewhere, read every
+work_item.workflow page at one snapshot. Each row carries `activeItems` and `archivedItems`, the
+open and archived work in that stage. Ask the user where each stage's work goes; never pick a
+target from a stage name. Then call work_item.remap_statuses with the resumed task, that exact
+snapshot, the from/to pairs they chose, a short reason and the conversation language.
+
+A source may be an archived stage; a target must be active; a stage cannot be both. The tool shows
+every group with its counts and the roles still aimed at a source stage, and moves all of a
+source's work, open and archived, in one operation. Stage definitions, order, archive state and
+roles stay as they are; change an aimed role separately with work_item.setup_workflow. Approval is
+bound to the counts it showed: when they change, the question is asked again, and a change at the
+moment of writing moves nothing. It is critical under the task mode. An empty source needs no
+question. Keep the same requestKey to resume and honor deferral as in the flows above.

package/skill/references/project-onboarding.md

@@ -218,8 +218,11 @@ A deferred individual field or final profile saves no onboarding choice. Retryin
 ## Inspection confirmation language
 
 For memory.sync_start, pass language: tr in a Turkish conversation and language: en in an English
-conversation. Use the conversation language, never the computer locale. Legacy calls without language
-use English. The form shows a short source reference, scope, the treatment of uncommitted changes and
+conversation. Use the conversation language, never the computer locale. A call without language uses
+the language remembered from an earlier call, and English when none is known. The bridge's own forms
+carry Turkish and English, fetch any other language the product texts have, and open in English when
+that language lacks a form's text. The form shows a short source reference, scope, the treatment of
+uncommitted changes and
 the separate approval needed for permanent memory. Full commit and request hashes stay in the durable
 approval binding, not in the visible question. Generic questionnaire.ask messages and option labels
 are written by the agent in the same language; pass language for the native help and field labels.

package/skill/references/questionnaires.md

@@ -22,6 +22,8 @@ When the task mode calls for a user answer, use the host's native questionnaire
 
 ## Required decisions stay pending
 
+The owned task-mode selector presents the question, its task-local scope and the consequences beside each option. Keep this routine choice short; complex decisions still need their context and example. Standard MCP exposes feedback as a separate optional field, and some Codex versions render that field and the choice on separate pages. This is one durable question, not two decisions. Do not claim an inline choice/free-input layout is supported by that renderer. Prefer the host's combined native control only where the host permits it; do not substitute asynchronous input for a required answer or bypass a tool's mode restrictions. Retain free feedback without adding a duplicate Other option or treating a comment as consent.
+
 Use `questionnaire.ask` for a required decision. It records the question before opening a native MCP form. Use a stable question identifier belonging to the current task and decision, so a retry returns to the same question instead of creating another one. A new decision needs its own identifier; an answer to an earlier proposal, branch or delivery does not approve a later one.
 
 Pass `repoRoot`, `questionnaireId`, `message` and two to twelve `options`, each with an `id` and `label`. Identifiers use letters, digits, underscores or hyphens.
@@ -353,7 +355,9 @@ Saving a profile does not authorize filesystem initialization.
 For memory.sync_start, pass language: tr in a Turkish conversation and language: en in an English
 conversation. Use the conversation language, never the computer locale. A call without language uses
 the language remembered from an earlier call, and English when none is known. The bridge's own forms
-have Turkish and English text; any other language opens them in English. The form shows a short source reference, scope, the treatment of uncommitted changes and
+carry Turkish and English, fetch any other language the product texts have, and open in English when
+that language lacks a form's text. The form shows a short source reference, scope, the treatment of
+uncommitted changes and
 the separate approval needed for permanent memory. Full commit and request hashes stay in the durable
 approval binding, not in the visible question. Generic questionnaire.ask messages and option labels
 are written by the agent in the same language; pass language for the native help and field labels.