engineering-memory 1.11.20 → 1.11.22

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/local-mutex.js

@@ -3,7 +3,10 @@ import { performance } from 'node:perf_hooks';
 import { sha256 } from './hash.js';
 import { BridgeRecoveryError } from '../runtime/recovery-error.js';
 export async function localMutex(identity, work, timeoutMs = 60000) {
-    const port = 20000 + (parseInt(sha256(identity).slice(0, 8), 16) % 30000);
+    const hash = sha256(identity);
+    const address = process.platform === 'win32'
+        ? { path: String.raw `\\.\pipe\engineering-memory-` + hash }
+        : { host: '127.0.0.1', port: 20000 + (parseInt(hash.slice(0, 8), 16) % 30000) };
     const deadline = performance.now() + timeoutMs;
     let server;
     for (;;) {
@@ -11,7 +14,7 @@ export async function localMutex(identity, work, timeoutMs = 60000) {
         try {
             await new Promise((resolve, reject) => {
                 server.once('error', reject);
-                server.listen({ host: '127.0.0.1', port, exclusive: true }, () => {
+                server.listen({ ...address, exclusive: true }, () => {
                     server.removeListener('error', reject);
                     resolve();
                 });

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

@@ -40,7 +40,7 @@ Renew `task.heartbeat` using the exact returned task, path and ownership generat
 
 Use `task.pause` when work stops or is handed to another client. It preserves task state and files, invalidates the old owner, and allows safe clean directories to be reused. It is not `task.abandon`. Resume reacquires the original directory when possible or uses the retained task branch in another safe directory. `worktree.reconcile` recovers interrupted allocation and validated local ownership records against Git. Never edit the registry, force checkout, stash/reset/clean, remove branches, kill a client or delete a worktree to bypass a refusal.
 
-`task.close` retains a managed checkout while changes or delivery remain pending. After delivery, release with `deliveryOutcome:'delivered'` and the current generation. When the user decides not to deliver, call `worktree.release` with `deliveryOutcome:'cancelled'`; the product asks what happens to the folder and saves any changes to a ref. Never run `git restore` or `git clean` yourself to free a worktree, and never report a delivery that did not happen. Dirty/staged/untracked files, pending outbox/intents and unfinished Git operations prevent release. An old release cannot affect a reused directory. User-owned existing directories are never added to automatic cleanup. When the user wants to work in the main folder, they answer that in `task.branch`'s start form; when an open task holds the folder, that option names the task that would move out. A closed or abandoned task stops holding the folder by itself; a task still running in another client keeps it until it is paused there. Never edit or delete the reservation ref by hand.
+`task.close` retains a managed checkout while changes or delivery remain pending. After delivery, release with `deliveryOutcome:'delivered'` and the current generation. Once the task's commits are on a remote branch the pool settles the folder by itself; `worktree.release` then answers `alreadyReleased`, `session.resume` of the closed task answers `folderReleased`, and nothing further is needed. When the user decides not to deliver, call `worktree.release` with `deliveryOutcome:'cancelled'`; the product asks what happens to the folder and saves any changes to a ref. Never run `git restore` or `git clean` yourself to free a worktree, and never report a delivery that did not happen. Dirty/staged/untracked files, pending outbox/intents and unfinished Git operations prevent release. An old release cannot affect a reused directory. User-owned existing directories are never added to automatic cleanup. When the user wants to work in the main folder, they answer that in `task.branch`'s start form; when an open task holds the folder, that option names the task that would move out. A closed or abandoned task stops holding the folder by itself; a task still running in another client keeps it until it is paused there. Never edit or delete the reservation ref by hand.
 
 Read-only tasks allocate no worktree. If the user authorizes writing, settle `task.branch` for that same externalTaskId, use the allocated repoRoot, then call `context.prepare_change` with `transitionToWrite`. Its pinned source must still match; choosing a different source requires a new task, never rewriting the original task's source identity. Existing lease, discipline, source-memory, verify and commit gates remain mandatory.
 
@@ -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

@@ -355,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.