engineering-memory 1.8.0 → 1.10.0

package/dispatcher/sections.mjs

@@ -1,6 +1,6 @@
 const shared = `This section is managed by the Engineering Memory installer.
 
-Search from the working directory toward the repository root for \`.engineering-memory/project.json\` before doing anything with this repository, including answering a question about it.
+Repository bindings live in the user-level Engineering Memory state directory, not in the working tree. Do not require or create a repository settings file. Always discover the binding with \`session.entry\`; the absence of \`.engineering-memory/project.json\` does not mean the repository is unbound.
 
 Call \`session.entry\` before you answer anything in a repository, whatever the user asked for. It reports whether they are signed in, whether this repository is bound, what they decided about it last time, and the one thing to do now. Act on that before the message itself:
 
@@ -13,7 +13,7 @@ Call \`session.entry\` before you answer anything in a repository, whatever the
 
 The user may say at any point that they want a different organization, a different project, Engineering Memory switched off, or switched back on. Recognise what they mean rather than matching words — the request arrives in whatever language and phrasing they happen to use — and act on it. Changing the organization always asks for the project again.
 
-When the marker exists, load the personal \`engineering-memory\` skill and use the \`engineering-memory\` MCP server before you answer. Call \`session.bootstrap\` after the entry check — not only before planning or editing, but before telling the user anything about this project: its design source, its screens, its rules, its history, what it does or does not have.
+When session.entry reports a bound repository, load the personal \`engineering-memory\` skill and use the \`engineering-memory\` MCP server before you answer. Call \`session.bootstrap\` after the entry check — not only before planning or editing, but before telling the user anything about this project: its design source, its screens, its rules, its history, what it does or does not have.
 
 Never answer a question about a bound repository from the working tree alone. What the repository holds is not what the project knows: the design file, the screen records, the engineering rules and the history of every earlier task live in Engineering Memory, and a file search will report them missing. If you are about to say that something is not recorded anywhere, that is the moment you have not asked yet.
 
@@ -21,6 +21,8 @@ After compaction, a new chat, interruption, or handoff, call \`session.resume\`
 
 Do not edit until the skill lifecycle has completed discovery, its checkpoint, and \`context.prepare_change\`. Do not claim completion until \`task.verify\` succeeds.
 
+Use the host's native questionnaire for every question to the user, including implementation choices, names, clarification, branch/worktree decisions and delivery. In Codex use request_user_input when available; in Claude use AskUserQuestion. Never replace the questionnaire with a chat instruction such as 'type this', 'reply yes', or 'write X if you want Y'. Do not open a survey web page. If the required native control is unavailable or prohibited for that kind of question, follow the host's tool restrictions, explain the limitation, and continue only work already authorized; do not fabricate a survey or silently choose an answer. Existing answers remain valid through retries and handoffs.
+
 When the repository is unbound, use the native questionnaire required by the skill. Do not silently create or bind a project. Do not open a survey web page.`;
 
 export const dispatcherSections = Object.freeze({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engineering-memory",
-  "version": "1.8.0",
+  "version": "1.10.0",
   "description": "Installs the Engineering Memory skill and its local MCP bridge. Sign in after installing; your organization and project are resolved from your account.",
   "license": "UNLICENSED",
   "type": "module",

package/runtime/dist/src/config.js

@@ -50,6 +50,7 @@ export const endpoints = {
     taskScaffoldApplication: '/tasks/scaffold-application',
     organizationList: '/organizations',
     organizationCreate: '/organizations',
+    organizationUpdate: (organizationId) => `/organizations/${organizationId}`,
     organizationMemberList: (organizationId) => `/organizations/${organizationId}/members`,
     organizationMemberUpsert: (organizationId) => `/organizations/${organizationId}/members`,
     taskVerify: '/runtime/task/verify',
@@ -60,6 +61,11 @@ export const endpoints = {
     projectList: '/projects',
     projectResolve: '/projects/resolve',
     projectBind: (projectId) => `/projects/${projectId}/bind`,
+    projectUpdate: (projectId) => `/projects/${projectId}`,
+    workItemRuns: (projectId, workItemId) => `/projects/${projectId}/work-items/${workItemId}/runs`,
+    workItemRestore: (projectId, workItemId) => `/projects/${projectId}/work-items/${workItemId}/restore`,
+    workItemTests: (projectId, workItemId) => `/projects/${projectId}/work-items/${workItemId}/tests`,
+    workItemPlan: (projectId, workItemId) => `/projects/${projectId}/work-items/${workItemId}/plan`,
     projectArchive: (projectId) => `/projects/${projectId}`,
     projectRestore: (projectId) => `/projects/${projectId}/restore`,
     projectMemberAdd: (projectId) => `/projects/${projectId}/members`,

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

@@ -3,6 +3,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 { TaskBranchStore } from '../runtime/task-branch-store.js';
 export const temporaryScaffoldingMarker = 'ENGINEERING-MEMORY-TEMPORARY';
 export const temporaryScaffoldingPattern = `${temporaryScaffoldingMarker}:`;
 export class GitInspector {
@@ -33,6 +34,96 @@ export class GitInspector {
         }
         return sha256(identity);
     }
+    branchStore(repoRoot) {
+        return new TaskBranchStore(repoRoot, this.runner);
+    }
+    async validateBranch(repoRoot, name) {
+        const result = await this.runner.run('git', ['check-ref-format', '--branch', name], {
+            cwd: repoRoot,
+        });
+        if (name.length > 255 || result.exitCode !== 0 || result.stdout.trim() !== name)
+            throw new Error('Choose a valid literal Git branch name of at most 255 characters');
+    }
+    async createWorktree(repoRoot, name, target) {
+        await this.validateBranch(repoRoot, name);
+        const path = resolve(repoRoot, target);
+        const present = await lstat(path).then(() => true, (error) => {
+            if (error.code === 'ENOENT')
+                return false;
+            throw error;
+        });
+        if (present) {
+            const root = await this.findRoot(path);
+            const common = await this.gitValue(root, [
+                'rev-parse',
+                '--path-format=absolute',
+                '--git-common-dir',
+            ]);
+            const sourceCommon = await this.gitValue(repoRoot, [
+                'rev-parse',
+                '--path-format=absolute',
+                '--git-common-dir',
+            ]);
+            if (root === (await canonicalPath(path)) &&
+                common === sourceCommon &&
+                (await this.currentBranch(root)) === name)
+                return root;
+            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 args = exists
+            ? ['worktree', 'add', '--', path, name]
+            : ['worktree', 'add', '-b', name, '--', path];
+        const result = await this.runner.run('git', args, { cwd: repoRoot });
+        if (result.exitCode !== 0)
+            throw new Error(`Git could not create the worktree: ${result.stderr.trim()}`);
+        return await this.findRoot(path);
+    }
+    async currentBranch(repoRoot) {
+        return await this.gitValue(repoRoot, ['symbolic-ref', '--short', '-q', 'HEAD']);
+    }
+    async defaultBranch(repoRoot) {
+        const ref = await this.gitValue(repoRoot, [
+            'symbolic-ref',
+            '--short',
+            '-q',
+            'refs/remotes/origin/HEAD',
+        ]);
+        return ref ? ref.replace(/^origin\//, '') : null;
+    }
+    async protectedBranchNames(repoRoot) {
+        const names = new Set(['main', 'master', 'develop', 'prod']);
+        const fallback = await this.defaultBranch(repoRoot);
+        if (fallback)
+            names.add(fallback);
+        return names;
+    }
+    async createBranch(repoRoot, name) {
+        await this.validateBranch(repoRoot, name);
+        const result = await this.runner.run('git', ['switch', '-c', name], { cwd: repoRoot });
+        if (result.exitCode !== 0) {
+            throw new Error(`Git could not create the branch ${name}: ${result.stderr.trim() || 'unknown error'}`);
+        }
+        const branch = await this.currentBranch(repoRoot);
+        if (branch !== name) {
+            throw new Error(`Git created ${name} but HEAD is on ${branch ?? 'no branch'}`);
+        }
+        return branch;
+    }
+    async branchExists(repoRoot, name) {
+        const result = await this.runner.run('git', ['rev-parse', '--verify', '--quiet', `refs/heads/${name}`], {
+            cwd: repoRoot,
+        });
+        return result.exitCode === 0;
+    }
+    async switchBranch(repoRoot, name) {
+        await this.validateBranch(repoRoot, name);
+        const result = await this.runner.run('git', ['switch', '--', name], { cwd: repoRoot });
+        if (result.exitCode !== 0) {
+            throw new Error(`Git could not switch to the branch ${name}: ${result.stderr.trim() || 'unknown error'}`);
+        }
+        return name;
+    }
     async mainWorktree(repoRoot) {
         const commonDirectory = await this.gitValue(repoRoot, [
             'rev-parse',

package/runtime/dist/src/git/pre-commit.js

@@ -35,8 +35,24 @@ async function run() {
     })).data);
     const result = await gate.verify(repoRoot);
     process.stderr.write(`${JSON.stringify(result)}\n`);
+    const advice = describe(result);
+    if (advice)
+        process.stderr.write(`${advice}\n`);
     process.exitCode = result.allowed ? 0 : 1;
 }
+function describe(result) {
+    const [expected, actual] = result.details ?? [];
+    switch (result.reason) {
+        case 'branch_mismatch':
+            return `The task selected ${expected} but HEAD is on ${actual}. Run: git switch ${expected}`;
+        case 'branch_detached':
+            return `The task selected ${expected} but HEAD is detached. Run: git switch ${expected}`;
+        case 'online_commit_gate_rejected':
+            return `The backend refused the commit: ${expected ?? 'no reason given'}`;
+        default:
+            return null;
+    }
+}
 void run().catch(() => {
     process.stderr.write('Engineering Memory Git gate failed\n');
     process.exitCode = 1;

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

@@ -1,16 +1,19 @@
 import { readdir } from 'node:fs/promises';
 import { join } from 'node:path';
+import { RepositoryResolver } from '../project/repository.js';
 import { ensureManagedDirectory, readJson, removeFile, safeSegment, writeJson, } from '../utilities/files.js';
 export class VerificationGate {
     git;
     outbox;
     commitGateAttestor;
     root;
+    repositories;
     constructor(stateRoot, git, outbox, commitGateAttestor) {
         this.git = git;
         this.outbox = outbox;
         this.commitGateAttestor = commitGateAttestor;
         this.root = join(stateRoot, 'verification-gates');
+        this.repositories = new RepositoryResolver(git, 2, stateRoot);
     }
     async record(input) {
         if (input.taskClosed &&
@@ -32,16 +35,17 @@ export class VerificationGate {
             taskClosed: input.taskClosed ?? false,
             taskVersion: input.taskVersion ?? null,
             taskChanges,
+            branch: input.branch ?? null,
         }, this.root);
     }
     async verify(repoRoot) {
-        const [fingerprint, manifest, stagedChanges, pending, scaffolding] = await Promise.all([
-            this.git.fingerprint(repoRoot),
-            this.git.manifest(repoRoot),
+        const [repository, stagedChanges, pending, scaffolding] = await Promise.all([
+            this.repositories.resolve(repoRoot),
             this.git.stagedManifest(repoRoot),
             this.outbox.list(),
             this.git.temporaryScaffolding(repoRoot),
         ]);
+        const { repoFingerprint: fingerprint, git: manifest } = repository;
         if (pending.length > 0) {
             return { allowed: false, reason: 'offline_outbox_pending', diffHash: manifest.diffHash };
         }
@@ -79,6 +83,16 @@ export class VerificationGate {
                 taskId: receipt.taskId,
             };
         }
+        const branch = await this.git.currentBranch(repoRoot);
+        if (receipt.branch && branch !== receipt.branch) {
+            return {
+                allowed: false,
+                reason: branch ? 'branch_mismatch' : 'branch_detached',
+                diffHash: manifest.diffHash,
+                taskId: receipt.taskId,
+                details: [receipt.branch, branch ?? 'HEAD'],
+            };
+        }
         if (receipt.diffHash !== manifest.diffHash) {
             return {
                 allowed: false,
@@ -118,6 +132,7 @@ export class VerificationGate {
                 repoFingerprint: receipt.repoFingerprint,
                 diffHash: manifest.diffHash,
                 expectedTaskVersion: receipt.taskVersion,
+                branch: branch ?? undefined,
             });
             const result = asObject(attestation);
             if (result?.allowed !== true ||
@@ -132,12 +147,13 @@ export class VerificationGate {
                 };
             }
         }
-        catch {
+        catch (error) {
             return {
                 allowed: false,
                 reason: 'online_commit_gate_rejected',
                 diffHash: manifest.diffHash,
                 taskId: receipt.taskId,
+                details: [error instanceof Error ? error.message : String(error)],
             };
         }
         return {

package/runtime/dist/src/index.js

@@ -51,7 +51,7 @@ export function createBridgeService() {
         client,
         credentials,
         browserAuth: new BrowserAuthCoordinator(client, credentials),
-        repositories: new RepositoryResolver(git, config.markerSchemaVersion),
+        repositories: new RepositoryResolver(git, config.markerSchemaVersion, stateRoot),
         journal: new JournalStore(stateRoot),
         outbox,
         gate,

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

@@ -66,11 +66,13 @@ export const engineeringMemoryToolNames = [
     'task.verify',
     'task.close',
     'task.abandon',
+    'task.branch',
     'architecture.plan',
     'architecture.module',
     'architecture.record_application',
     'organization.list',
     'organization.create',
+    'organization.update',
     'organization.member_list',
     'organization.member_upsert',
     'project.setup',
@@ -80,6 +82,16 @@ export const engineeringMemoryToolNames = [
     'project.restore',
     'project.member_add',
     'project.member_list',
+    'work_item.create',
+    'work_item.update',
+    'work_item.archive',
+    'work_item.restore',
+    'work_item.runs',
+    'work_item.record_test',
+    'work_item.test_results',
+    'work_item.plan',
+    'work_item.confirm_plan',
+    'project.update',
     'work_item.list',
     'work_item.get',
     'project.clone',
@@ -428,6 +440,16 @@ export function registerEngineeringMemoryTools(server, service) {
             reason: z.string().min(1).max(2000),
         }),
     }, async (input) => toolResult(await service.taskAbandon(input)));
+    server.registerTool('task.branch', {
+        description: 'Record the native questionnaire answer for the exact externalTaskId before any new write/scaffold task or read-only-to-write transition. Choose name or keepCurrent. For another task in a busy checkout supply worktreePath and name; use the returned repoRoot for all subsequent commands. Existing branches may be selected without resetting them. Decisions persist across retries and restarts.',
+        inputSchema: z.object({
+            repoRoot: optionalRepoRoot,
+            externalTaskId: z.string().min(2).max(160),
+            worktreePath: z.string().min(1).optional(),
+            name: z.string().min(1).max(255).optional(),
+            keepCurrent: z.boolean().optional(),
+        }),
+    }, async (input) => toolResult(await service.taskBranch(input)));
     server.registerTool('organization.create', {
         description: 'Create an organization the user named, with the short identifier they typed. Offer this underneath the organizations they already belong to; never invent the identifier from the name.',
         inputSchema: z.object({
@@ -445,11 +467,20 @@ export function registerEngineeringMemoryTools(server, service) {
             organizationId: z.string().uuid(),
             email: z.string().email(),
             role: z.enum(['owner', 'member']),
-            discipline: z.enum(['backend', 'frontend', 'fullstack']),
+            discipline: z.enum([
+                'backend',
+                'frontend',
+                'fullstack',
+                'web',
+                'mobile',
+                'designer',
+                'product_manager',
+                'tester',
+            ]),
         }),
     }, async (input) => toolResult(await service.organizationMemberUpsert(input)));
     server.registerTool('project.setup', {
-        description: 'Create a policy-ready backend project from the native questionnaire and local repository audit, then write its secret-free marker.',
+        description: 'Create a policy-ready backend project from the native questionnaire and local repository audit, then store its binding in user-local state.',
         inputSchema: z.object({
             repoRoot: optionalRepoRoot,
             organizationId: z.string().uuid(),
@@ -507,6 +538,14 @@ export function registerEngineeringMemoryTools(server, service) {
                 .min(1),
         }),
     }, async (input) => toolResult(await service.architectureRecordApplication(input)));
+    server.registerTool('organization.update', {
+        description: 'Rename an organization as its administrator, using the last name read to avoid overwriting another rename. This does not change the organization identity or grant a global role.',
+        inputSchema: z.object({
+            organizationId: z.string().uuid(),
+            name: z.string().trim().min(2).max(120),
+            expectedName: z.string().min(2).max(120),
+        }),
+    }, async (input) => toolResult(await service.organizationUpdate(input)));
     server.registerTool('organization.list', {
         description: 'List the organizations the authenticated user belongs to so project setup can inherit an existing engineering core instead of silently creating an empty organization.',
         inputSchema: z.object({}),
@@ -516,7 +555,7 @@ export function registerEngineeringMemoryTools(server, service) {
         inputSchema: z.object({ includeArchived: z.boolean().optional() }),
     }, async (input) => toolResult(await service.projectList(input)));
     server.registerTool('project.resolve', {
-        description: 'Resolve the current repository fingerprint or bind an explicitly selected project, then write the secret-free marker only after backend authorization succeeds.',
+        description: 'Resolve the current repository fingerprint or bind an explicitly selected project, then store the user-local binding only after backend authorization succeeds.',
         inputSchema: z.object({
             repoRoot: optionalRepoRoot,
             bind: z.boolean().optional(),
@@ -543,13 +582,133 @@ export function registerEngineeringMemoryTools(server, service) {
             projectId: z.string().min(1),
             email: z.string().email(),
             role: z.enum(['owner', 'maintainer', 'member', 'reader']),
-            discipline: z.enum(['backend', 'frontend', 'fullstack']).nullable().optional(),
+            discipline: z
+                .enum([
+                'backend',
+                'frontend',
+                'fullstack',
+                'web',
+                'mobile',
+                'designer',
+                'product_manager',
+                'tester',
+            ])
+                .nullable()
+                .optional(),
         }),
     }, async (input) => toolResult(await service.projectMemberAdd(input)));
     server.registerTool('project.member_list', {
         description: 'List the members and roles of a project, including an archived project, so an action that requires an owner can be coordinated with the right person.',
         inputSchema: z.object({ projectId: z.string().uuid() }),
     }, async (input) => toolResult(await service.projectMemberList(input)));
+    const workItemLocator = { projectId: z.string().uuid(), workItemId: z.string().uuid() };
+    const workItemFields = {
+        title: z.string().trim().min(2).max(240).optional(),
+        description: z.string().max(20000).nullable().optional(),
+        priority: z.enum(['lowest', 'low', 'medium', 'high', 'highest']).optional(),
+        assigneeUserId: z.string().uuid().nullable().optional(),
+        acceptanceCriteria: z.array(z.string().trim().min(2).max(500)).max(50).optional(),
+        figmaUrl: z.string().url().nullable().optional(),
+        dueAt: z.string().datetime().nullable().optional(),
+        position: z.number().int().min(0).optional(),
+        dependencyIds: z.array(z.string().uuid()).max(50).optional(),
+    };
+    server.registerTool('work_item.create', {
+        description: 'Create a requirement in an authorized project. Organization administrators and assigned product managers manage work. Testers may report an unassigned bug with kind bug; no implementation permission is granted.',
+        inputSchema: z.object({
+            projectId: z.string().uuid(),
+            data: z.object({
+                ...workItemFields,
+                title: z.string().trim().min(2).max(240),
+                kind: z.enum(['task', 'bug']).optional(),
+            }),
+        }),
+    }, async (input) => toolResult(await service.workItemCreate(input)));
+    server.registerTool('work_item.update', {
+        description: 'Edit or assign a work item at its current version. Assignees must already be active project members; this does not grant project access.',
+        inputSchema: z.object({
+            ...workItemLocator,
+            data: z.object({
+                ...workItemFields,
+                expectedVersion: z.number().int().min(1),
+                status: z
+                    .enum(['backlog', 'ready', 'in_progress', 'in_review', 'done', 'cancelled'])
+                    .optional(),
+            }),
+        }),
+    }, async (input) => toolResult(await service.workItemUpdate(input)));
+    server.registerTool('work_item.archive', {
+        description: 'Reversibly remove a work item from the active backlog at its current version, preserving history.',
+        inputSchema: z.object({ ...workItemLocator, expectedVersion: z.number().int().min(1) }),
+    }, async (input) => toolResult(await service.workItemArchive(input)));
+    server.registerTool('work_item.restore', {
+        description: 'Restore an archived work item at its current version.',
+        inputSchema: z.object({ ...workItemLocator, expectedVersion: z.number().int().min(1) }),
+    }, async (input) => toolResult(await service.workItemRestore(input)));
+    server.registerTool('work_item.runs', {
+        description: 'List execution runs for this requirement in the current and authorized directly linked projects. A closed run in one repository does not prove another repository finished.',
+        inputSchema: z.object({
+            ...workItemLocator,
+            offset: z.number().int().min(0).optional(),
+            limit: z.number().int().min(1).max(100).optional(),
+        }),
+    }, async (input) => toolResult(await service.workItemRuns(input)));
+    server.registerTool('work_item.record_test', {
+        description: 'Record immutable, privacy-safe QA evidence for the exact work-item version. Passed does not auto-complete the work item. Reuse the same idempotency key only for an identical retry.',
+        inputSchema: z.object({
+            ...workItemLocator,
+            data: z.object({
+                expectedVersion: z.number().int().min(1),
+                idempotencyKey: z.string().uuid(),
+                outcome: z.enum(['passed', 'failed', 'blocked']),
+                summary: z.string().trim().min(2).max(4000),
+                testedRevision: z.string().min(1).max(160).optional(),
+            }),
+        }),
+    }, async (input) => toolResult(await service.workItemRecordTest(input)));
+    server.registerTool('work_item.test_results', {
+        description: 'Read the versioned QA evidence for an authorized work item. Older evidence remains attached to the requirement version it tested.',
+        inputSchema: z.object({
+            ...workItemLocator,
+            offset: z.number().int().min(0).optional(),
+            limit: z.number().int().min(1).max(100).optional(),
+        }),
+    }, async (input) => toolResult(await service.workItemTestResults(input)));
+    server.registerTool('work_item.plan', {
+        description: 'Inspect authorized current and linked project targets, repository URLs, implementation capabilities and the persisted shared branch before opening work. Check contracts to identify backend/web/mobile impact; capability is not user consent.',
+        inputSchema: z.object(workItemLocator),
+    }, async (input) => toolResult(await service.workItemPlan(input)));
+    server.registerTool('work_item.confirm_plan', {
+        description: 'Persist only the project scope and shared branch the user approved, through the native questionnaire or explicit existing instruction. Explain additional backend/frontend work and ask before expanding scope. Existing answers survive retries and handoffs; never fabricate confirmation.',
+        inputSchema: z.object({
+            ...workItemLocator,
+            data: z.object({
+                expectedVersion: z.number().int().min(1),
+                projectIds: z.array(z.string().uuid()).min(1).max(12),
+                branch: z
+                    .string()
+                    .regex(/^(?=.{1,255}$)[a-zA-Z0-9][a-zA-Z0-9_-]*(?:\/[a-zA-Z0-9][a-zA-Z0-9_-]*)*$/),
+                reason: z.string().trim().min(2).max(2000),
+                userConfirmed: z.literal(true),
+            }),
+        }),
+    }, async (input) => toolResult(await service.workItemConfirmPlan(input)));
+    server.registerTool('project.update', {
+        description: 'Update project details or its GitHub/GitLab HTTPS repository URL at the current version. Organization administrators can manage their organization projects without an implementation assignment.',
+        inputSchema: z.object({
+            projectId: z.string().uuid(),
+            data: z.object({
+                expectedVersion: z.number().int().min(1),
+                name: z.string().min(2).max(160).optional(),
+                framework: z.string().min(2).max(80).nullable().optional(),
+                repositoryUrl: z.string().url().nullable().optional(),
+                workItemPrefix: z
+                    .string()
+                    .regex(/^[A-Z][A-Z0-9]{1,11}$/)
+                    .optional(),
+            }),
+        }),
+    }, async (input) => toolResult(await service.projectUpdate(input)));
     server.registerTool('work_item.list', {
         description: 'List selectable work items for a project before opening an engineering run in this chat.',
         inputSchema: z.object({

package/runtime/dist/src/project/repository.js

@@ -1,74 +1,111 @@
-import { dirname, join, parse, resolve } from 'node:path';
+import { dirname, join, parse } from 'node:path';
 import { canonicalPath, pathExists, readJson, writeJson } from '../utilities/files.js';
+import { sha256 } from '../utilities/hash.js';
 export class RepositoryResolver {
     git;
     markerSchemaVersion;
-    constructor(git, markerSchemaVersion) {
+    stateRoot;
+    constructor(git, markerSchemaVersion, stateRoot) {
         this.git = git;
         this.markerSchemaVersion = markerSchemaVersion;
+        this.stateRoot = stateRoot;
     }
     async resolve(startPath, explicitProjectId) {
         const repoRoot = await this.git.findRoot(startPath);
-        const markerPath = await this.findMarker(startPath, repoRoot);
-        const marker = markerPath ? await this.readMarker(markerPath, repoRoot) : null;
-        if (explicitProjectId) {
-            assertProjectId(explicitProjectId);
+        const repositoryKey = await this.keyFor(repoRoot);
+        const bindingPath = this.pathFor(repositoryKey);
+        let binding = await readJson(bindingPath, this.stateRoot);
+        let markerPath = null;
+        if (binding) {
+            this.assertMarker(binding);
+            if (binding.repositoryKey !== repositoryKey ||
+                !/^[0-9a-f]{64}$/.test(binding.repoFingerprint)) {
+                throw new Error('Engineering Memory local project binding is invalid');
+            }
+        }
+        else {
+            markerPath = await this.findMarker(startPath, repoRoot);
+            if (!markerPath) {
+                const mainRoot = await this.git.mainWorktree(repoRoot);
+                if (mainRoot !== repoRoot)
+                    markerPath = await this.findMarker(mainRoot, mainRoot);
+            }
+            if (markerPath) {
+                const markerRoot = await this.git.findRoot(dirname(dirname(markerPath)));
+                const marker = await readJson(markerPath, markerRoot);
+                this.assertMarker(marker);
+                binding = {
+                    projectId: marker.projectId,
+                    schemaVersion: marker.schemaVersion,
+                    repositoryKey,
+                    repoFingerprint: await this.git.fingerprint(repoRoot, marker.schemaVersion),
+                };
+                await writeJson(bindingPath, binding, this.stateRoot);
+            }
         }
-        if (explicitProjectId && marker && explicitProjectId !== marker.projectId) {
-            throw new Error('Explicit project does not match the repository marker');
+        if (explicitProjectId)
+            assertProjectId(explicitProjectId);
+        if (explicitProjectId && binding && explicitProjectId !== binding.projectId) {
+            throw new Error('Explicit project does not match the local repository binding');
         }
         const [repoFingerprint, git] = await Promise.all([
-            this.git.fingerprint(repoRoot, marker?.schemaVersion ?? this.markerSchemaVersion),
+            binding?.repoFingerprint ?? this.git.fingerprint(repoRoot, this.markerSchemaVersion),
             this.git.manifest(repoRoot),
         ]);
         return {
             repoRoot,
             markerPath,
-            projectId: explicitProjectId ?? marker?.projectId ?? null,
-            schemaVersion: marker?.schemaVersion ?? null,
+            bindingPath: binding ? bindingPath : null,
+            projectId: explicitProjectId ?? binding?.projectId ?? null,
+            schemaVersion: binding?.schemaVersion ?? null,
             repoFingerprint,
             git,
         };
     }
-    async writeMarker(repoRoot, projectId) {
+    async writeBinding(repoRoot, projectId) {
         assertProjectId(projectId);
-        const canonicalRoot = await canonicalPath(repoRoot);
-        const markerPath = join(canonicalRoot, '.engineering-memory', 'project.json');
-        await writeJson(markerPath, {
+        const repository = await this.resolve(repoRoot, projectId);
+        const repositoryKey = await this.keyFor(repository.repoRoot);
+        const bindingPath = this.pathFor(repositoryKey);
+        await writeJson(bindingPath, {
             projectId,
-            schemaVersion: this.markerSchemaVersion,
-        }, canonicalRoot);
-        return markerPath;
+            schemaVersion: repository.schemaVersion ?? this.markerSchemaVersion,
+            repositoryKey,
+            repoFingerprint: repository.repoFingerprint,
+        }, this.stateRoot);
+        return bindingPath;
+    }
+    async keyFor(repoRoot) {
+        const mainRoot = await this.git.mainWorktree(repoRoot);
+        const path = process.platform === 'win32' ? mainRoot.toLowerCase() : mainRoot;
+        return sha256(`${path}\n${await this.git.fingerprint(repoRoot, 2)}`);
+    }
+    pathFor(repositoryKey) {
+        return join(this.stateRoot, 'project-bindings', `${repositoryKey}.json`);
     }
     async findMarker(startPath, repoRoot) {
         let current = await canonicalPath(startPath);
         const root = await canonicalPath(repoRoot);
         while (true) {
             const candidate = join(current, '.engineering-memory', 'project.json');
-            if (await pathExists(candidate, root)) {
+            if (await pathExists(candidate, root))
                 return candidate;
-            }
-            if (current === root || current === parse(current).root) {
+            if (current === root || current === parse(current).root)
                 return null;
-            }
             current = dirname(current);
         }
     }
-    async readMarker(path, repoRoot) {
-        const marker = await readJson(path, repoRoot);
-        const schemaVersion = marker?.schemaVersion;
+    assertMarker(marker) {
         if (!marker ||
             typeof marker.projectId !== 'string' ||
-            typeof schemaVersion !== 'number' ||
-            !Number.isInteger(schemaVersion) ||
-            schemaVersion < 1) {
-            throw new Error(`Invalid Engineering Memory project marker: ${resolve(path)}`);
+            !Number.isInteger(marker.schemaVersion) ||
+            marker.schemaVersion < 1) {
+            throw new Error('Invalid Engineering Memory project binding');
         }
-        if (schemaVersion > this.markerSchemaVersion) {
-            throw new Error(`Unsupported project marker schema: ${schemaVersion}`);
+        if (marker.schemaVersion > this.markerSchemaVersion) {
+            throw new Error(`Unsupported project binding schema: ${marker.schemaVersion}`);
         }
         assertProjectId(marker.projectId);
-        return marker;
     }
 }
 function assertProjectId(value) {