engineering-memory 1.11.9 → 1.11.11

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

@@ -4,6 +4,7 @@ import { isAbsolute, relative, resolve, sep } from 'node:path';
 import { assertManagedPath, canonicalPath } from '../utilities/files.js';
 import { sha256, stableStringify } from '../utilities/hash.js';
 import { NativeCommandRunner } from '../utilities/process.js';
+import { restrictedValueKind } from '../runtime/privacy-detector.js';
 import { TaskBranchStore } from '../runtime/task-branch-store.js';
 export const temporaryScaffoldingMarker = 'ENGINEERING-MEMORY-TEMPORARY';
 export const temporaryScaffoldingPattern = `${temporaryScaffoldingMarker}:`;
@@ -35,6 +36,18 @@ export class GitInspector {
         }
         return sha256(identity);
     }
+    async remoteIdentity(repoRoot) {
+        const remote = await this.gitValue(repoRoot, ['config', '--get', 'remote.origin.url']);
+        if (!remote)
+            return null;
+        const identity = canonicalRemoteIdentity(remote);
+        return !identity.startsWith('local/') &&
+            identity.length <= 500 &&
+            /^[a-z0-9][a-z0-9.-]*(:\d{1,5})?\/[^\s@\\]+$/.test(identity) &&
+            !restrictedValueKind(identity, 'remoteIdentity')
+            ? identity
+            : null;
+    }
     branchStore(repoRoot) {
         return new TaskBranchStore(repoRoot, this.runner);
     }
@@ -72,11 +85,13 @@ export class GitInspector {
             throw new Error('The worktree directory already belongs to another repository or branch. Choose a different directory');
         }
         const exists = await this.branchExists(repoRoot, name);
+        const lost = (await this.lostRegistration(repoRoot, path, name)) ? ['-f'] : [];
         const args = exists
-            ? ['worktree', 'add', '--', path, name]
+            ? ['worktree', 'add', ...lost, '--', path, name]
             : [
                 'worktree',
                 'add',
+                ...lost,
                 '--no-track',
                 '-b',
                 name,
@@ -89,6 +104,22 @@ export class GitInspector {
             throw new Error(`Git could not create the worktree: ${result.stderr.trim()}`);
         return await this.findRoot(path);
     }
+    async lostRegistration(repoRoot, path, name) {
+        const listed = await this.runner.run('git', ['worktree', 'list', '--porcelain'], {
+            cwd: repoRoot,
+        });
+        if (listed.exitCode !== 0)
+            return false;
+        const registered = listed.stdout.split(/\r?\n\r?\n/).map((block) => ({
+            path: /^worktree (.+)$/m.exec(block)?.[1] ?? '',
+            branch: /^branch refs\/heads\/(.+)$/m.exec(block)?.[1] ?? null,
+        }));
+        const same = (left, right) => process.platform === 'win32'
+            ? resolve(left).toLowerCase() === resolve(right).toLowerCase()
+            : resolve(left) === resolve(right);
+        return (registered.some((entry) => entry.path && same(entry.path, path)) &&
+            !registered.some((entry) => entry.branch === name && !same(entry.path, path)));
+    }
     async fetchBranchCommit(repoRoot, remote, branch) {
         await this.validateBranch(repoRoot, branch);
         if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/.test(remote))
@@ -242,6 +273,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 +350,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 +373,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 +453,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 +795,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 };
@@ -133,7 +133,114 @@ const onboardingInput = z.strictObject({
     projectId: uuid.optional(),
     reworkBehavior: z.enum(['preserve', 'redesign']).optional(),
 });
+const moveCopy = {
+    tr: {
+        ask: (name) => `"${name}" projesini bu depoya taşıyalım mı?`,
+        from: 'Projenin şu anki deposu',
+        to: 'Bu klasörün deposu',
+        unknown: 'adresi kayıtlı değil',
+        keeps: (tasks, records, items) => `Proje olduğu gibi devam eder: ${tasks} görev, ${records} hafıza kaydı ve ${items} iş kalemi projede kalır, hiçbir şey silinmez ve yeniden öğrenilmez.`,
+        after: 'Eski depo projenin geçmişinde saklanır. Hâlâ eski depoda çalışan ekip arkadaşları açık görevlerini bitirebilir, yeni görevi yeni depodan açar. Proje ileride yeniden taşınabilir.',
+        approve: 'Projeyi bu depoya taşı',
+        decline: 'Taşıma',
+    },
+    en: {
+        ask: (name) => `Move the project "${name}" to this repository?`,
+        from: 'The project lives in',
+        to: 'This folder points at',
+        unknown: 'address not recorded',
+        keeps: (tasks, records, items) => `The project continues as it is: ${tasks} tasks, ${records} memory records and ${items} work items stay with it; nothing is deleted or learned again.`,
+        after: 'The old repository is kept in the project history. Teammates still working in it can finish their open tasks and start new ones from the new repository. The project can be moved again later.',
+        approve: 'Move the project here',
+        decline: 'Do not move',
+    },
+};
 export function registerOnboardingTools(server, service) {
+    server.registerTool('project.move_repository', {
+        description: 'Move an existing project to the repository this checkout points at, after its code moved (another host, a new remote, a history restart). Project owners only. Opens ONE durable native form naming the old and the new repository; on approval the project keeps every task, memory record, work item and open session, the old repository is kept in its history, and this checkout is bound. Use it when project.resolve with bind refuses with recovery project.move_repository; never create a second project for moved code. Reconsider a declined move with a new decisionAttempt; retries keep the same attempt.',
+        inputSchema: z.strictObject({
+            repoRoot,
+            projectId: uuid,
+            decisionAttempt: z.number().int().min(1).max(10000).optional(),
+            language: z.enum(['tr', 'en']).default('en'),
+            presentation: z.enum(['host_native']).optional(),
+        }),
+    }, async (input, context) => {
+        const preflight = await service.projectRepositoryMovePreflight(input);
+        if (!preflight.ok)
+            return output(preflight);
+        const flight = preflight.data;
+        if (flight.authentication)
+            return output(preflight);
+        if (flight.alreadyHere || !flight.history.current)
+            return output(await service.projectResolve({
+                repoRoot: input.repoRoot,
+                bind: true,
+                projectId: input.projectId,
+            }));
+        if (flight.history.role !== 'owner')
+            return output({
+                ok: false,
+                error: {
+                    kind: 'bridge_error',
+                    message: 'Only a project owner can move a project to another repository. List the members with project.member_list and ask an owner to run project.move_repository from a checkout of the new repository. Nothing was changed.',
+                    retryable: false,
+                    recovery: 'project.member_list',
+                },
+            });
+        const copy = moveCopy[input.language];
+        const questionnaireId = 'project-move-' +
+            sha256(stableStringify({
+                projectId: input.projectId,
+                from: flight.history.current.repoFingerprint,
+                to: flight.checkout.repoFingerprint,
+                version: flight.history.lockVersion,
+                ...(input.decisionAttempt ? { decisionAttempt: input.decisionAttempt } : {}),
+            }));
+        const form = await askQuestionnaire(server, service, {
+            repoRoot: input.repoRoot,
+            questionnaireId,
+            presentation: input.presentation,
+            language: input.language,
+            message: [
+                copy.ask(flight.history.name),
+                `${copy.from}: ${flight.history.current.remoteIdentity ?? copy.unknown}`,
+                `${copy.to}: ${flight.checkout.remoteIdentity ?? copy.unknown}`,
+                copy.keeps(flight.history.records.tasks, flight.history.records.memoryRecords, flight.history.records.workItems),
+                copy.after,
+            ].join('\n'),
+            options: [
+                { id: 'approve', label: copy.approve },
+                { id: 'decline', label: copy.decline },
+            ],
+        }, context, [], {
+            tool: 'project.move_repository',
+            ...(input.decisionAttempt ? { decisionAttempt: input.decisionAttempt } : {}),
+            retryArguments: { projectId: input.projectId, language: input.language },
+        });
+        const record = await service.questionnaireResume({
+            repoRoot: input.repoRoot,
+            questionnaireId,
+        });
+        if (record.status !== 'answered')
+            return form;
+        if (record.answer?.choice !== 'approve')
+            return output({
+                ok: true,
+                data: {
+                    moved: false,
+                    status: 'declined',
+                    nextAction: 'The project was not moved and nothing changed. Tell the user in one line. If they later want the move, call project.move_repository with decisionAttempt ' +
+                        ((input.decisionAttempt ?? 0) + 1) +
+                        '.',
+                },
+            });
+        return output(await service.projectMoveRepository({
+            repoRoot: input.repoRoot,
+            projectId: input.projectId,
+            expectedVersion: flight.history.lockVersion,
+        }));
+    });
     server.registerTool('memory.source_targets', {
         description: 'Read bounded Git ref candidates without assuming environment roles from their names. Confirm only the chosen committed sources with native memory.sync_start questionnaires; an explicit ref can select a source outside this preview.',
         inputSchema: z.object({ repoRoot: z.string().optional() }),
@@ -468,7 +575,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 +586,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 +640,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 };