engineering-memory 1.9.0 → 1.10.0

package/bin/entry-point.test.mjs

@@ -0,0 +1,29 @@
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import test from 'node:test';
+
+const entryPoint = new URL('./engineering-memory.mjs', import.meta.url);
+const manifest = new URL('../package.json', import.meta.url);
+
+test('the published entry point tells the installer which version it is', async () => {
+  const source = await readFile(entryPoint, 'utf8');
+
+  assert.match(
+    source,
+    /'--client-version',\s*await publishedVersion\(\)/,
+    'The installer is never told the version, so every install reports itself as unknown and no update is ever offered',
+  );
+});
+
+test('the published entry point tells the installer which backend it was built for', async () => {
+  const source = await readFile(entryPoint, 'utf8');
+
+  assert.match(source, /'--api-url',\s*await publishedApiUrl\(\)/);
+});
+
+test('the manifest carries a version the entry point can stamp', async () => {
+  const declared = JSON.parse(await readFile(manifest, 'utf8'));
+
+  assert.match(String(declared.version), /^\d+\.\d+\.\d+$/);
+  assert.equal(declared.name, 'engineering-memory');
+});

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.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engineering-memory",
-  "version": "1.9.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/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 &&
@@ -36,13 +39,13 @@ export class VerificationGate {
         }, 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 };
         }

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

@@ -72,6 +72,7 @@ export const engineeringMemoryToolNames = [
     'architecture.record_application',
     'organization.list',
     'organization.create',
+    'organization.update',
     'organization.member_list',
     'organization.member_upsert',
     'project.setup',
@@ -81,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',
@@ -456,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(),
@@ -518,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({}),
@@ -527,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(),
@@ -554,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) {

package/runtime/dist/src/runtime/bridge-service.js

@@ -3,7 +3,6 @@ import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { minimatch } from 'minimatch';
 import { endpoints } from '../config.js';
-import { RepositoryResolver } from '../project/repository.js';
 import { sha256, stableStringify } from '../utilities/hash.js';
 import { ApiResponseError, BackendUnavailableError, } from './api-client.js';
 import { assertSafeToPersist, normalizeRepositoryPaths } from './offline-outbox.js';
@@ -68,7 +67,7 @@ export class BridgeService {
             const recoveredDeliveries = await this.recoverJournalOutbox();
             const outbox = await this.flushOutbox();
             let projectId = repository.projectId;
-            if (!repository.markerPath) {
+            if (!repository.bindingPath) {
                 const resolved = await this.dependencies.client.request(endpoints.projectResolve, {
                     method: 'POST',
                     body: { repoFingerprint: repository.repoFingerprint },
@@ -89,7 +88,7 @@ export class BridgeService {
                 });
             }
             if (!projectId) {
-                throw refuse('This repository has a marker that names no project, so there is nothing to bootstrap against.', 'project.resolve');
+                throw refuse('This repository has no selected project. Select its project before bootstrapping.', 'project.resolve');
             }
             const bootstrapMode = persistedBootstrap.mode ?? 'write';
             const decision = bootstrapMode === 'read_only'
@@ -1248,10 +1247,8 @@ export class BridgeService {
                     target = await this.dependencies.repositories.resolve(targetRoot);
                     if (target.projectId && target.projectId !== repository.projectId)
                         throw refuse('The target worktree belongs to a different Engineering Memory project. Choose another worktreePath.', 'task.branch');
-                    if (!target.markerPath) {
-                        await new RepositoryResolver(git, repository.schemaVersion ?? 2).writeMarker(targetRoot, repository.projectId);
-                        target = await this.dependencies.repositories.resolve(targetRoot);
-                    }
+                    if (!target.bindingPath || target.repoFingerprint !== repository.repoFingerprint)
+                        throw refuse('The worktree did not inherit the selected local project binding.', 'project.resolve');
                 }
                 const branch = input.name ?? (await git.currentBranch(target.repoRoot));
                 const store = git.branchStore(target.repoRoot);
@@ -1391,8 +1388,8 @@ export class BridgeService {
                 readDiscoveryUnits(policy).length === 0) {
                 throw refuse('Project setup response is not policy-ready', 'project.setup');
             }
-            const markerPath = await this.dependencies.repositories.writeMarker(repository.repoRoot, project.id);
-            return asJsonValue({ ...data, markerPath });
+            const bindingPath = await this.dependencies.repositories.writeBinding(repository.repoRoot, project.id);
+            return asJsonValue({ ...data, marker: null, markerPath: null, bindingPath });
         });
     }
     async projectMemberAdd(input) {
@@ -1493,6 +1490,77 @@ export class BridgeService {
             return asJsonValue({ workItem: response.data });
         });
     }
+    async workItemCreate(input) {
+        return this.execute(async () => {
+            const response = await this.dependencies.client.request(endpoints.workItemList(input.projectId), { method: 'POST', body: cleanJson(input.data) });
+            return asJsonValue(response.data);
+        });
+    }
+    async workItemUpdate(input) {
+        return this.execute(async () => {
+            const response = await this.dependencies.client.request(endpoints.workItemGet(input.projectId, input.workItemId), { method: 'PATCH', body: cleanJson(input.data) });
+            return asJsonValue(response.data);
+        });
+    }
+    async workItemArchive(input) {
+        return this.execute(async () => {
+            const response = await this.dependencies.client.request(endpoints.workItemGet(input.projectId, input.workItemId), { method: 'DELETE', body: cleanJson({ expectedVersion: input.expectedVersion }) });
+            return asJsonValue(response.data);
+        });
+    }
+    async workItemRestore(input) {
+        return this.execute(async () => {
+            const response = await this.dependencies.client.request(endpoints.workItemRestore(input.projectId, input.workItemId), { method: 'POST', body: cleanJson({ expectedVersion: input.expectedVersion }) });
+            return asJsonValue(response.data);
+        });
+    }
+    async workItemRecordTest(input) {
+        return this.execute(async () => {
+            const response = await this.dependencies.client.request(endpoints.workItemTests(input.projectId, input.workItemId), { method: 'POST', body: cleanJson(input.data) });
+            return asJsonValue(response.data);
+        });
+    }
+    async workItemConfirmPlan(input) {
+        return this.execute(async () => {
+            const response = await this.dependencies.client.request(endpoints.workItemPlan(input.projectId, input.workItemId), { method: 'PUT', body: cleanJson(input.data) });
+            return asJsonValue(response.data);
+        });
+    }
+    async projectUpdate(input) {
+        return this.execute(async () => {
+            const response = await this.dependencies.client.request(endpoints.projectUpdate(input.projectId), { method: 'PATCH', body: cleanJson(input.data) });
+            return asJsonValue(response.data);
+        });
+    }
+    async workItemRuns(input) {
+        return this.execute(async () => {
+            const query = new URLSearchParams({
+                offset: String(input.offset ?? 0),
+                limit: String(input.limit ?? 50),
+            });
+            const response = await this.dependencies.client.request(`${endpoints.workItemRuns(input.projectId, input.workItemId)}?${query}`);
+            return asJsonValue(response.data);
+        });
+    }
+    async workItemTestResults(input) {
+        return this.execute(async () => {
+            const query = new URLSearchParams({
+                offset: String(input.offset ?? 0),
+                limit: String(input.limit ?? 50),
+            });
+            const response = await this.dependencies.client.request(`${endpoints.workItemTests(input.projectId, input.workItemId)}?${query}`);
+            return asJsonValue(response.data);
+        });
+    }
+    async workItemPlan(input) {
+        return this.execute(async () => {
+            const response = await this.dependencies.client.request(endpoints.workItemPlan(input.projectId, input.workItemId));
+            return asJsonValue({
+                ...objectOrEmpty(response.data),
+                nextAction: 'Read the current and authorized linked project contracts. Decide whether web, mobile, backend or multiple projects need changes. If additional scope is needed, explain why and obtain the native questionnaire answer before work_item.confirm_plan. Reuse an already confirmed scope and shared branch; each repository has its own worktree and task lifecycle.',
+            });
+        });
+    }
     async architecturePlan(input) {
         return await this.execute(async () => {
             const body = cleanJson(input);
@@ -1541,6 +1609,15 @@ export class BridgeService {
             return asJsonValue({ application: response.data });
         });
     }
+    async organizationUpdate(input) {
+        return this.execute(async () => {
+            const response = await this.dependencies.client.request(endpoints.organizationUpdate(input.organizationId), {
+                method: 'PATCH',
+                body: cleanJson({ name: input.name, expectedName: input.expectedName }),
+            });
+            return asJsonValue(response.data);
+        });
+    }
     async organizationCreate(input) {
         return await this.execute(async () => {
             const response = await this.dependencies.client.request(endpoints.organizationCreate, { method: 'POST', body: cleanJson(input) });
@@ -1614,17 +1691,14 @@ export class BridgeService {
                 if (!project || project.id !== input.projectId) {
                     throw refuse('Project bind response does not match the selected project', 'project.resolve');
                 }
-                const markerPath = await this.dependencies.repositories.writeMarker(repository.repoRoot, input.projectId);
+                const bindingPath = await this.dependencies.repositories.writeBinding(repository.repoRoot, input.projectId);
                 return asJsonValue({
                     resolved: true,
                     bound: true,
                     project,
-                    markerPath,
-                    repository: publicRepository({
-                        ...repository,
-                        markerPath,
-                        projectId: input.projectId,
-                    }),
+                    markerPath: null,
+                    bindingPath,
+                    repository: publicRepository(await this.dependencies.repositories.resolve(repository.repoRoot)),
                     selectionRequired: false,
                 });
             }
@@ -1669,11 +1743,11 @@ export class BridgeService {
             }
             const decision = await this.dependencies.repositoryDecisions.load(repository.repoFingerprint);
             const authenticated = authentication.authenticated === true;
-            const state = decision?.state ?? (repository.projectId ? 'bound' : 'none');
+            const state = decision?.state === 'disabled' ? 'disabled' : repository.bindingPath ? 'bound' : 'none';
             const client = await this.clientUpdate(authenticated);
             const shipped = objectValue(objectValue(client)?.shippedKnowledge);
             const incomplete = shipped && (shipped.failure !== null || Number(shipped.live) < Number(shipped.expected));
-            const projectId = repository.projectId ?? decision?.projectId ?? null;
+            const projectId = repository.projectId;
             const liveTasks = authenticated && state === 'bound'
                 ? (await this.dependencies.activeContexts.list(repository.repoFingerprint)).map(describePointer)
                 : [];
@@ -2543,6 +2617,7 @@ function publicRepository(repository) {
     return asJsonValue({
         repoRoot: repository.repoRoot,
         markerPath: repository.markerPath,
+        bindingPath: repository.bindingPath,
         projectId: repository.projectId,
         schemaVersion: repository.schemaVersion,
         repoFingerprint: repository.repoFingerprint,

package/skill/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: engineering-memory
-description: Enforces the Engineering Memory lifecycle for Codex and Claude in repositories bound by .engineering-memory/project.json. Use before answering anything about a bound repository, including a question about what it has or where its design lives, and for every planning, implementation, review, diagnosis, rework, Figma, component, screen, service, model, navigation, localization, storage, validation, or Git task in one.
+description: Enforces the Engineering Memory lifecycle for Codex and Claude in repositories bound in user-local Engineering Memory state. Use before answering anything about a bound repository, including a question about what it has or where its design lives, and for every planning, implementation, review, diagnosis, rework, Figma, component, screen, service, model, navigation, localization, storage, validation, or Git task in one.
 ---
 
 # Engineering Memory
@@ -13,7 +13,7 @@ Mandatory behavior:
 
 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.
 
-1. Locate `.engineering-memory/project.json` from the working directory toward the repository root. When it exists, the project's knowledge is in the backend and not in the working tree, so answer nothing about the project before bootstrapping — a file search that finds no design link, no screen record and no rule is reporting what the repository lacks, not what the project knows.
+1. Discover the repository binding through `session.entry`. Bindings live in the user-level Engineering Memory state directory, outside the repository and installed runtime. No project settings file is required. For a bound repository, the project's knowledge is in the backend, so answer nothing about it before bootstrapping; the absence of local design files or records says nothing about its stored knowledge.
 2. Call `session.entry` before answering anything in a repository, and act on what it reports before the message itself: sign in when it says so, ask for organization and project when nothing has been decided, and stay completely silent about Engineering Memory in a repository where the user switched it off. Record every one of those answers with `session.set_decision`, and only ever from something the user actually said.
 3. Before planning or editing, call `session.bootstrap`. After compaction, a new chat, interruption, or handoff, call `session.resume` first.
 4. Open the task in `read_only` mode for review, diagnosis, planning, or reporting that does not authorize writes; use `scaffold` mode only to apply organization architecture templates to a new project; otherwise use `write` mode. Do read-only discovery, then record the discovery checkpoint.
@@ -27,6 +27,6 @@ Use the host's native questionnaire for every question to the user, including im
 12. Never commit, push, publish, deploy, approve a permanent memory revision, or overwrite an existing Git hook without explicit user authorization.
 13. Never store tokens, passwords, client secrets, raw headers, raw payloads, customer data, or PII in tool inputs, journals, memory, logs, or generated documentation.
 
-If the repository is unbound, do not silently create or attach a project. Use the native questionnaire workflow. If the user selects task-only skip, do not create a marker or memory records.
+If the repository is unbound, do not silently create or attach a project. Use the native questionnaire workflow. If the user selects task-only skip, do not create a binding or memory records.
 
 If the backend is unavailable, use only an unexpired bridge-provided cached context. Checkpoints may enter the local outbox, but verification, task close, and commit remain blocked until synchronization succeeds.

package/skill/references/lifecycle.md

@@ -4,7 +4,7 @@
 
 Sign-in decides nothing beyond who the user is. The organization and the project are chosen after it, through the questionnaires in `questionnaires.md`, and both listings end with an option to create a new one. Ask for both whenever this session has not already confirmed them, and ask again the moment the user says they want to change either — changing the organization always means choosing the project again.
 
-Treat `.engineering-memory/project.json` as the binding authority. The marker contains only `projectId` and `schemaVersion`. Never infer a binding from a directory name or Git remote when a marker exists. Schema 1 markers retain the legacy commit-aware repository identity so existing bindings keep working. Schema 2 markers use the canonical remote or main-worktree identity, which stays unchanged when an unborn repository receives its first commit. Never rewrite or upgrade a marker by hand.
+Use the binding returned by `session.entry` as the authority. The bridge stores the selected project and repository identity under `~/.engineering-memory/origins/<api-hash>/project-bindings/`, outside the installed runtime and working tree. It imports a legacy `.engineering-memory/project.json` once, preserving its schema and exact backend fingerprint for existing tasks and receipts. It leaves that file unchanged; after migration the file is optional and may be removed through the repository's normal Git workflow. New bindings never create it. Never infer a selection from a directory or remote, and never edit binding records by hand. Separate clones or a changed remote require a new explicit selection; worktrees of the same checkout share the local binding.
 
 An archived project is recoverable state, not a missing or conflicting binding. When an owner receives `project.restore`, use the `projectId` and `expectedVersion` in its data and call that operation before retrying. A non-owner receives `project.member_list` instead: list the members, identify a project owner and explain that the owner must restore the exact project before this session can retry. Use `project.list` with `includeArchived: true` when an owner must first select the archived project. Never create or bind a replacement project to escape archive state.
 
@@ -14,7 +14,7 @@ Every new write or scaffold task settles its branch through the native questionn
 
 The choice belongs to that task and worktree, survives retry and client restart, and cannot be consumed by a different task. Reuse an existing answer rather than asking again. A named branch stays fixed through prepare, verify, close and commit; closing never replaces it. Return with `task.branch` using the same task slug and recorded branch when a gate reports a mismatch. Legacy tasks without a recorded branch and tasks explicitly kept on detached HEAD remain compatible; they are not restricted to a named branch. Older clients remain supported during the minimum-version compatibility window.
 
-Parallel development needs separate working directories. If another task owns the current worktree, offer a separate worktree through the questionnaire. Call `task.branch` with `externalTaskId`, `name`, and `worktreePath`; run bootstrap and all subsequent file, test and Git commands in its returned `repoRoot`. This creates or reuses an appropriate Git worktree and preserves the repository's project marker schema. Never switch another task's working directory. Reservations are shared by clients using the same worktree; close or abandon releases that task's reservation. An interrupted close can release it through resume.
+Parallel development needs separate working directories. If another task owns the current worktree, offer a separate worktree through the questionnaire. Call `task.branch` with `externalTaskId`, `name`, and `worktreePath`; run bootstrap and all subsequent file, test and Git commands in its returned `repoRoot`. This creates or reuses an appropriate Git worktree and uses the same user-local binding and repository identity without writing a project marker. Never switch another task's working directory. Reservations are shared by clients using the same worktree; close or abandon releases that task's reservation. An interrupted close can release it through resume.
 
 A repository holds as many tasks as the people working in it. Never treat somebody else's unfinished task as a reason this one cannot proceed: no task waits on another task's review, reconciliation, verification or close, and nothing that is already verified or closed is undone by what happens elsewhere. When `session.resume` reports more than one live task for this repository, it lists them and the right move is to ask the user which one this is, never to guess and never to adopt the one that happens to be most recent.
 
@@ -43,22 +43,21 @@ A request can be as short as "add the KYC flow from Figma". That is enough, and
 
 Then propose the `flow_logic` record and stop. The plan is not a message in the chat; it is the proposal, and the user approving it is the approval. Do not write the second screen before that approval exists — a flow's shape replicated across six screens costs six times as much to undo, and verification refuses a task that adds several screens without an approved flow record reconciled to it.
 
-### Work that spans both sides of a product
+### Work that spans multiple projects
 
-When the request covers both halves of a linked product — a flow that needs endpoints as well
-as screens — and the user's discipline covers both, it is one work item and two tasks: one in
-each repository. Verification and the commit gate stay per repository because a commit is.
+Before implementation, load `work_item.plan` for the selected requirement and inspect current and authorized linked API/flow contracts. Decide whether backend, web, mobile or several projects need changes, even if the user mentioned only one interface. Fullstack covers every development area but never grants project membership or permission to expand scope.
 
-Ask which side to start on and select the work item before opening the first task. When the work
-moves to the other side, open its task with the same `workItemId` and that repository's root —
-every tool takes `repoRoot`, and both stay open at once. The backend accepts that id only from the
-current project or a directly linked project the account can work in, and derives the display key
-from the work item. `context.prepare_change` then returns `siblingTasks`: the other task's
-objective, status and recent checkpoints, so a decision taken on one side is visible on the other
-without anyone repeating it. A legacy key is never an authorization boundary; key-only tasks can
-see siblings only inside directly linked projects where the account is already a member.
+If another project needs changes beyond the requested scope, explain the concrete missing behavior and use the native questionnaire to ask whether to include it. Do not use a chat instruction or invent approval. An explicit instruction already authorizing both sides is sufficient; reuse it. Call `work_item.confirm_plan` only with that approved scope, the common branch and a short reason. Resume an existing plan rather than asking again. An unavailable project needs administrator coordination; do not infer or bind its repository.
 
-Do not open the second task speculatively. Open it when the work actually reaches that side.
+One WorkItem UUID coordinates independent EngineeringTask runs, one per selected repository. Use the recorded branch name (for example `task/kan-101`) in each repository, and a separate worktree for each concurrent task. `task.branch` with the exact externalTaskId records the existing user choice and creates or adopts the branch in a suitable worktree. Use its returned repoRoot for subsequent tools and file commands. Never switch another task's reserved worktree.
+
+Open each side with the same workItemId and its own repository binding when work reaches that side. Each side has its own lease, reconciliation, verify, close and commit gate. Check `work_item.runs` and sibling checkpoints when handing off; one side completing does not prove all selected projects are complete. A plan's scope and branch cannot change while an implementation run is active. Read-only analysis does not acquire application write rights; its later write transition must satisfy discipline and the confirmed plan.
+
+### Administration, product management and QA
+
+Administrative authority and work discipline are independent. Organization admins can manage projects, assignments, repository URLs and work items in their organization. A global admin has those rights only in organizations they actively belong to. Ordinary users need a live explicit project assignment. Fullstack/backend/web/mobile/frontend disciplines govern implementation, while project overrides do not grant administration.
+
+An assigned product manager can create, edit, assign, archive and restore work items through the work_item tools. Designer work includes design context and requirement participation; it does not grant general application code leases. A tester can create an unassigned bug and record `work_item.record_test` evidence, then track it with `work_item.test_results`. QA evidence must contain no credentials, PII or production payloads and must identify the exact requirement version. A passed result never silently marks the requirement done. Organization administration separately permits backlog management regardless of discipline.
 
 ### A task that reports a defect
 

package/skill/references/questionnaires.md

@@ -40,7 +40,7 @@ The user may say mid-chat that they want to change organization or project, swit
 
 Switching off records the decision and ends the subject. Switching back on clears it and runs the organization and project questions again.
 
-Changing the organization always means asking for the project again afterwards, because a project belongs to exactly one organization and the old answer cannot survive the change. Run the organization questionnaire, then the project one, then bind the repository to the chosen project with `project.resolve` so the marker matches what the user just said.
+Changing the organization always means asking for the project again afterwards, because a project belongs to exactly one organization and the old answer cannot survive the change. Run the organization questionnaire, then the project one, then bind the repository to the chosen project with `project.resolve` so the local binding matches what the user just said.
 
 When the repository being bound already has a working system in it — code somebody else wrote, a shape nobody here decided — say so and offer the survey rather than starting as though the project began now. Ask whether to adopt it: read what is there, record its modules, its architecture and the discovery policy that matches its actual layout, and list where it diverges from the rules with what changing and keeping each one would cost. Do not offer a single choice between reworking the project and leaving it alone; that question is asked once per divergence, after the survey, and the adoption rule says why. The survey is a read-only task and changes nothing.
 
@@ -48,11 +48,11 @@ A task that is still open blocks the switch, and says so plainly. Its lease, its
 
 ## Unbound Repository
 
-Ask whether the current repository belongs to an existing accessible project, should become a new project, or should skip Engineering Memory for this task. When an existing project is chosen, present only projects returned for the authenticated user. Confirm before writing the marker.
+Ask whether the current repository belongs to an existing accessible project, should become a new project, or should skip Engineering Memory for this task. When an existing project is chosen, present only projects returned for the authenticated user. Confirm the project selection before saving its user-local binding; no repository file is written.
 
-For a repository the backend has not seen before, ask whether this is an existing codebase import or a greenfield project. Before a marker or backend task exists, an existing-codebase import may perform one bounded local read-only structural and Figma discovery pass. It must not edit code. Use the findings in a native questionnaire to confirm the initial project profile and the repository-relative patterns that identify new memory resources. Send them as `discoveryUnits`, one unit per kind the project actually has: a client project declares `screen_logic` and `component_mapping`, and a server-side project declares `module_logic`, `data_model` and `api_endpoint` against its own layout. Never ask a server-side project for screen patterns, and never invent a unit for a kind the repository does not contain. Then call `project.setup`; the backend creates the project, owner membership, active profile revision, and pinned discovery policy atomically. Write the returned marker only after that succeeds, then start the normal `session.bootstrap` lifecycle. Later discoveries are reviewable memory proposals.
+For a repository the backend has not seen before, ask whether this is an existing codebase import or a greenfield project. Before a local binding or backend task exists, an existing-codebase import may perform one bounded local read-only structural and Figma discovery pass. It must not edit code. Use the findings in a native questionnaire to confirm the initial project profile and the repository-relative patterns that identify new memory resources. Send them as `discoveryUnits`, one unit per kind the project actually has: a client project declares `screen_logic` and `component_mapping`, and a server-side project declares `module_logic`, `data_model` and `api_endpoint` against its own layout. Never ask a server-side project for screen patterns, and never invent a unit for a kind the repository does not contain. Then call `project.setup`; the backend creates the project, owner membership, active profile revision, and pinned discovery policy atomically. Persist the user-local binding only after that succeeds, then start the normal `session.bootstrap` lifecycle. Later discoveries are reviewable memory proposals.
 
-Greenfield setup asks for project name, framework, the response envelope, the exception model, authentication needs, localization languages, storage policy, and the initial discovery patterns. A client project is also asked for the Figma library and screen links if available, the design token sources, the page architecture and the navigation pattern; a server-side project is asked instead for the data layer, the migration tool and how configuration and secrets arrive. A Spring project must also name Maven or Gradle, its Java release, its exact Spring Boot version and its `javax` or `jakarta` namespace before any architecture template is offered; `Spring Boot` alone is not enough information to select compatible source. Record those confirmed values in `initialProjectProfile.metadata.runtimeContract` as `language: "java"`, `languageVersion`, `framework: "spring-boot"`, `frameworkVersion`, `buildTool` and `namespace`. Never infer or invent this object. The backend compares it with each source module and returns no incompatible module; an absent contract means broad Spring rules still apply but no constrained source template is offered. Ask what the project is before deciding which list applies. Do not write a marker unless the setup response contains the active initial profile and discovery policy.
+Greenfield setup asks for project name, framework, the response envelope, the exception model, authentication needs, localization languages, storage policy, and the initial discovery patterns. A client project is also asked for the Figma library and screen links if available, the design token sources, the page architecture and the navigation pattern; a server-side project is asked instead for the data layer, the migration tool and how configuration and secrets arrive. A Spring project must also name Maven or Gradle, its Java release, its exact Spring Boot version and its `javax` or `jakarta` namespace before any architecture template is offered; `Spring Boot` alone is not enough information to select compatible source. Record those confirmed values in `initialProjectProfile.metadata.runtimeContract` as `language: "java"`, `languageVersion`, `framework: "spring-boot"`, `frameworkVersion`, `buildTool` and `namespace`. Never infer or invent this object. The backend compares it with each source module and returns no incompatible module; an absent contract means broad Spring rules still apply but no constrained source template is offered. Ask what the project is before deciding which list applies. Do not save a binding unless the setup response contains the active initial profile and discovery policy.
 
 After setup, ask whether to build the project from the organization architecture templates. If the user accepts, follow `scaffolding.md`: confirm the optional modules, then confirm the package name and the concrete class name behind every rename placeholder in one questionnaire, then ask for each required asset role and each tenant-specific value the templates deliberately leave open.