engineering-memory 1.7.0 → 1.9.0

package/dispatcher/sections.mjs

@@ -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/install/commands.mjs

@@ -6,16 +6,19 @@ import { delimiter, join } from 'node:path';
 const metaCharacters = /([()\][%!^"`<>&|;, *?])/g;
 const defaultPathExtensions = '.COM;.EXE;.BAT;.CMD';
 const shimExtension = /\.(?:cmd|bat)$/i;
+const npmShimPath = /node_modules[\\/]\.bin[\\/][^\\/]+\.cmd$/i;
 const pathSeparators = /[/\\]/;
 
 export async function runCommand(command, args, options = {}) {
   const environment = options.env ?? process.env;
   const invocation = await planInvocation(command, args, environment, options);
+  const captureOutput = options.captureOutput !== false;
   return await new Promise((resolve) => {
     const child = spawn(invocation.command, invocation.args, {
       cwd: options.cwd,
       env: environment,
       shell: false,
+      ...(captureOutput ? {} : { stdio: 'ignore' }),
       windowsHide: true,
       windowsVerbatimArguments: invocation.verbatim,
     });
@@ -38,6 +41,24 @@ export async function runCommand(command, args, options = {}) {
   });
 }
 
+export function prependEnvironmentPath(environment, directory) {
+  const pathKeys = Object.keys(environment).filter(
+    (key) => key.toLowerCase() === 'path',
+  );
+  const pathKey =
+    pathKeys.find((key) => Boolean(environment[key])) ?? pathKeys[0] ?? 'PATH';
+  const current = pathKeys
+    .map((key) => environment[key])
+    .filter(Boolean)
+    .join(delimiter);
+  environment[pathKey] = current
+    ? `${directory}${delimiter}${current}`
+    : directory;
+  for (const duplicate of pathKeys) {
+    if (duplicate !== pathKey) delete environment[duplicate];
+  }
+}
+
 export async function planInvocation(
   command,
   args,
@@ -58,9 +79,13 @@ export async function planInvocation(
     return { command: executable, args, verbatim: false };
   }
   const comSpec = environment.ComSpec ?? environment.COMSPEC ?? 'cmd.exe';
-  const line = [escapeCommand(executable), ...args.map(escapeArgument)].join(
-    ' ',
-  );
+  const doubleEscapeMetaCharacters = npmShimPath.test(executable);
+  const line = [
+    escapeCommand(executable),
+    ...args.map((argument) =>
+      escapeArgument(argument, doubleEscapeMetaCharacters),
+    ),
+  ].join(' ');
   return {
     command: comSpec,
     args: ['/d', '/s', '/c', `"${line}"`],
@@ -80,7 +105,10 @@ export async function resolveWindowsExecutable(command, environment) {
   if (pathSeparators.test(command)) {
     return await firstExistingFile(command, extensions, carriesExtension);
   }
-  const searchPath = environment.Path ?? environment.PATH ?? '';
+  const searchPath = Object.entries(environment)
+    .filter(([key, value]) => key.toLowerCase() === 'path' && Boolean(value))
+    .map(([, value]) => value)
+    .join(delimiter);
   for (const directory of searchPath.split(delimiter).filter(Boolean)) {
     const candidate = await firstExistingFile(
       join(unquote(directory), command),
@@ -122,13 +150,14 @@ function escapeCommand(value) {
   return String(value).replace(metaCharacters, '^$1');
 }
 
-function escapeArgument(value) {
+function escapeArgument(value, doubleEscapeMetaCharacters) {
   const escaped = String(value)
-    .replace(/(\\*)"/g, '$1$1\\"')
-    .replace(/(\\*)$/, '$1$1');
-  return `"${escaped}"`
-    .replace(metaCharacters, '^$1')
-    .replace(metaCharacters, '^$1');
+    .replace(/(?=(\\+?)?)\1"/g, '$1$1\\"')
+    .replace(/(?=(\\+?)?)\1$/, '$1$1');
+  const quoted = `"${escaped}"`.replace(metaCharacters, '^$1');
+  return doubleEscapeMetaCharacters
+    ? quoted.replace(metaCharacters, '^$1')
+    : quoted;
 }
 
 export function commandFailure(command, result) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engineering-memory",
-  "version": "1.7.0",
+  "version": "1.9.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

@@ -14,7 +14,7 @@ export function loadBridgeConfig(env = process.env) {
         cacheMaxEntries: positiveInteger(env.ENGINEERING_MEMORY_CACHE_MAX_ENTRIES, 64),
         cacheMaxBytes: positiveInteger(env.ENGINEERING_MEMORY_CACHE_MAX_BYTES, 5 * 1024 * 1024),
         cacheMaxAgeMs: positiveInteger(env.ENGINEERING_MEMORY_CACHE_MAX_AGE_MS, 24 * 60 * 60 * 1000),
-        markerSchemaVersion: positiveInteger(env.ENGINEERING_MEMORY_MARKER_SCHEMA_VERSION, 1),
+        markerSchemaVersion: positiveInteger(env.ENGINEERING_MEMORY_MARKER_SCHEMA_VERSION, 2),
         credentialService: env.ENGINEERING_MEMORY_CREDENTIAL_SERVICE ?? 'engineering-memory',
         credentialAccount: env.ENGINEERING_MEMORY_CREDENTIAL_ACCOUNT ?? 'default',
     };
@@ -26,6 +26,7 @@ export function apiStateRoot(config) {
     return join(config.stateRoot, 'origins', apiNamespaceKey(config.apiBaseUrl));
 }
 export const endpoints = {
+    auditList: '/audit',
     authRefresh: '/auth/refresh',
     authLogout: '/auth/logout',
     authBrowserStart: '/auth/browser/start',
@@ -49,6 +50,8 @@ export const endpoints = {
     taskScaffoldApplication: '/tasks/scaffold-application',
     organizationList: '/organizations',
     organizationCreate: '/organizations',
+    organizationMemberList: (organizationId) => `/organizations/${organizationId}/members`,
+    organizationMemberUpsert: (organizationId) => `/organizations/${organizationId}/members`,
     taskVerify: '/runtime/task/verify',
     taskClose: '/runtime/task/close',
     taskAbandon: '/runtime/task/abandon',
@@ -57,7 +60,12 @@ export const endpoints = {
     projectList: '/projects',
     projectResolve: '/projects/resolve',
     projectBind: (projectId) => `/projects/${projectId}/bind`,
+    projectArchive: (projectId) => `/projects/${projectId}`,
+    projectRestore: (projectId) => `/projects/${projectId}/restore`,
     projectMemberAdd: (projectId) => `/projects/${projectId}/members`,
+    projectMemberList: (projectId) => `/projects/${projectId}/members`,
+    workItemList: (projectId) => `/projects/${projectId}/work-items`,
+    workItemGet: (projectId, workItemId) => `/projects/${projectId}/work-items/${workItemId}`,
     projectLink: '/projects/link',
     projectUnlink: '/projects/unlink',
     projectLinks: (projectId) => `/projects/${projectId}/links`,

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 {
@@ -19,16 +20,110 @@ export class GitInspector {
         }
         return await canonicalPath(result.stdout.trim());
     }
-    async fingerprint(repoRoot) {
-        const [remote, firstCommit] = await Promise.all([
-            this.gitValue(repoRoot, ['config', '--get', 'remote.origin.url']),
-            this.gitValue(repoRoot, ['rev-list', '--max-parents=0', 'HEAD']),
-        ]);
+    async fingerprint(repoRoot, identityVersion = 2) {
+        if (!Number.isSafeInteger(identityVersion) || identityVersion < 1) {
+            throw new Error('Repository identity version must be a positive integer');
+        }
+        const remote = await this.gitValue(repoRoot, ['config', '--get', 'remote.origin.url']);
         const identity = remote
-            ? `${canonicalRemoteIdentity(remote)}\n${firstCommit ?? ''}`
-            : `${(await this.mainWorktree(repoRoot)).toLowerCase()}\n${firstCommit ?? ''}`;
+            ? canonicalRemoteIdentity(remote)
+            : (await this.mainWorktree(repoRoot)).toLowerCase();
+        if (identityVersion === 1) {
+            const firstCommit = await this.gitValue(repoRoot, ['rev-list', '--max-parents=0', 'HEAD']);
+            return sha256(`${identity}\n${firstCommit ?? ''}`);
+        }
         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',
@@ -46,20 +141,13 @@ export class GitInspector {
         const changedPaths = head
             ? await this.changedPathsAgainstHead(root)
             : await this.unbornChangedPaths(root);
-        const normalizedManifest = changedPaths.map(({ path, originalPath, status, contentHash, size, mode }) => ({
-            path,
-            originalPath: originalPath ?? null,
-            status: semanticStatus(status),
-            contentHash,
-            size,
-            mode: mode ?? null,
-        }));
+        const hashManifest = canonicalHashManifest(changedPaths);
         return {
             repoRoot: root,
             head,
             changedPaths,
-            worktreeHash: sha256(`${stableStringify(normalizedManifest)}\n`),
-            diffHash: sha256(`${head ?? '<unborn>'}\n${stableStringify(normalizedManifest)}\n`),
+            worktreeHash: sha256(`${stableStringify(hashManifest)}\n`),
+            diffHash: sha256(`${head ?? '<unborn>'}\n${stableStringify(hashManifest)}\n`),
         };
     }
     async stagedManifest(repoRoot) {
@@ -364,6 +452,41 @@ function semanticStatus(status) {
     }
     return status.trim() || status;
 }
+function canonicalHashManifest(entries) {
+    const byPath = new Map();
+    const renamedSources = new Set();
+    for (const entry of entries) {
+        const status = semanticStatus(entry.status);
+        const deleted = status === 'D';
+        if (status === 'R') {
+            if (!entry.originalPath) {
+                throw new Error(`Git rename is missing its original path: ${entry.path}`);
+            }
+            renamedSources.add(entry.originalPath);
+        }
+        byPath.set(entry.path, {
+            path: entry.path,
+            originalPath: null,
+            status: status === 'C' || status === 'R' ? 'A' : status,
+            contentHash: deleted ? null : entry.contentHash,
+            size: deleted ? null : entry.size,
+            mode: deleted ? null : (entry.mode ?? null),
+        });
+    }
+    for (const path of renamedSources) {
+        if (!byPath.has(path)) {
+            byPath.set(path, {
+                path,
+                originalPath: null,
+                status: 'D',
+                contentHash: null,
+                size: null,
+                mode: null,
+            });
+        }
+    }
+    return [...byPath.values()].sort((left, right) => left.path.localeCompare(right.path));
+}
 function deduplicateChangedPaths(entries) {
     const byPath = new Map();
     for (const entry of entries) {

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

@@ -32,6 +32,7 @@ export class VerificationGate {
             taskClosed: input.taskClosed ?? false,
             taskVersion: input.taskVersion ?? null,
             taskChanges,
+            branch: input.branch ?? null,
         }, this.root);
     }
     async verify(repoRoot) {
@@ -79,6 +80,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 +129,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 +144,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/mcp/tool-definitions.js

@@ -44,6 +44,7 @@ const checkpointBase = {
     idempotencyKey: z.string().uuid().optional(),
 };
 export const engineeringMemoryToolNames = [
+    'audit.list',
     'session.entry',
     'session.set_decision',
     'session.decline_update',
@@ -65,15 +66,23 @@ export const engineeringMemoryToolNames = [
     'task.verify',
     'task.close',
     'task.abandon',
+    'task.branch',
     'architecture.plan',
     'architecture.module',
     'architecture.record_application',
     'organization.list',
     'organization.create',
+    'organization.member_list',
+    'organization.member_upsert',
     'project.setup',
     'project.list',
     'project.resolve',
+    'project.archive',
+    'project.restore',
     'project.member_add',
+    'project.member_list',
+    'work_item.list',
+    'work_item.get',
     'project.clone',
     'project.link',
     'project.unlink',
@@ -97,6 +106,31 @@ const reconciliationEntry = z.object({
     reason: z.string().optional(),
 });
 export function registerEngineeringMemoryTools(server, service) {
+    server.registerTool('audit.list', {
+        description: 'List one authorized organization or project audit trail with an exact cursor. Choose exactly one scope and send both cursor fields together.',
+        inputSchema: z
+            .object({
+            organizationId: z.string().uuid().optional(),
+            projectId: z.string().uuid().optional(),
+            beforeCreatedAt: z.string().datetime({ offset: true }).optional(),
+            beforeId: z.string().uuid().optional(),
+            limit: z.number().int().min(1).max(100).optional(),
+        })
+            .superRefine((value, context) => {
+            if (Boolean(value.organizationId) === Boolean(value.projectId)) {
+                context.addIssue({
+                    code: 'custom',
+                    message: 'Choose exactly one organizationId or projectId.',
+                });
+            }
+            if (Boolean(value.beforeCreatedAt) !== Boolean(value.beforeId)) {
+                context.addIssue({
+                    code: 'custom',
+                    message: 'Send beforeCreatedAt and beforeId together.',
+                });
+            }
+        }),
+    }, async (input) => toolResult(await service.auditList(input)));
     server.registerTool('session.entry', {
         description: 'The first call of every session in a repository, before answering anything about the project. Reports whether the user is signed in, whether this repository is bound, what this user decided about it last time, and the one thing to do now. A repository the user switched Engineering Memory off in reports that, and is left alone.',
         inputSchema: z.object({ repoRoot: optionalRepoRoot }),
@@ -131,6 +165,7 @@ export function registerEngineeringMemoryTools(server, service) {
             objective: z.string().min(2),
             taskKind: z.string().min(2),
             workItemKey: z.string().min(1).optional(),
+            workItemId: z.string().uuid().optional(),
             mode: z.enum(['write', 'read_only', 'scaffold']).optional(),
             knownRevisions: z.record(z.string(), z.number().int().min(0)).optional(),
         }),
@@ -394,6 +429,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({
@@ -401,6 +446,19 @@ export function registerEngineeringMemoryTools(server, service) {
             slug: z.string().min(2).max(120),
         }),
     }, async (input) => toolResult(await service.organizationCreate(input)));
+    server.registerTool('organization.member_list', {
+        description: "List an organization's members and roles so a member who cannot perform an owner-only recovery can coordinate with an owner.",
+        inputSchema: z.object({ organizationId: z.string().uuid() }),
+    }, async (input) => toolResult(await service.organizationMemberList(input)));
+    server.registerTool('organization.member_upsert', {
+        description: 'Add or update an existing Engineering Memory account in an organization. Only an organization owner may call this; use it before adding that account to a child project.',
+        inputSchema: z.object({
+            organizationId: z.string().uuid(),
+            email: z.string().email(),
+            role: z.enum(['owner', 'member']),
+            discipline: z.enum(['backend', 'frontend', 'fullstack']),
+        }),
+    }, 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.',
         inputSchema: z.object({
@@ -429,7 +487,7 @@ export function registerEngineeringMemoryTools(server, service) {
         }),
     }, async (input) => toolResult(await service.projectSetup(input)));
     server.registerTool('architecture.plan', {
-        description: 'List the organization architecture modules in apply order with their manifests, rename map, asset contract and tenant-specific points. Returns no file bodies.',
+        description: 'List only architecture modules compatible with the approved project runtime contract, in apply order with their manifests, rename map, asset contract and tenant-specific points. Returns no file bodies; an empty plan means continue without scaffolding.',
         inputSchema: z.object({
             projectId: z.string().uuid(),
             sessionId: z.string().uuid(),
@@ -465,9 +523,9 @@ export function registerEngineeringMemoryTools(server, service) {
         inputSchema: z.object({}),
     }, async () => toolResult(await service.organizationList()));
     server.registerTool('project.list', {
-        description: 'List projects available to the authenticated user so the agent can present them through the native questionnaire UI.',
-        inputSchema: z.object({}),
-    }, async () => toolResult(await service.projectList()));
+        description: 'List projects available to the authenticated user, optionally including archived projects that need restoration.',
+        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.',
         inputSchema: z.object({
@@ -476,14 +534,52 @@ export function registerEngineeringMemoryTools(server, service) {
             projectId: z.string().uuid().optional(),
         }),
     }, async (input) => toolResult(await service.projectResolve(input)));
+    server.registerTool('project.archive', {
+        description: 'Archive a project at an explicit version while preserving its repository identity and history.',
+        inputSchema: z.object({
+            projectId: z.string().uuid(),
+            expectedVersion: z.number().int().min(1),
+        }),
+    }, async (input) => toolResult(await service.projectArchive(input)));
+    server.registerTool('project.restore', {
+        description: 'Restore an archived project at the version returned by project.list with includeArchived enabled.',
+        inputSchema: z.object({
+            projectId: z.string().uuid(),
+            expectedVersion: z.number().int().min(1),
+        }),
+    }, async (input) => toolResult(await service.projectRestore(input)));
     server.registerTool('project.member_add', {
-        description: 'Add an existing Engineering Memory account to a project with an explicit role.',
+        description: 'Add or update an existing Engineering Memory account with an explicit project role and optional discipline override.',
         inputSchema: z.object({
             projectId: z.string().min(1),
             email: z.string().email(),
             role: z.enum(['owner', 'maintainer', 'member', 'reader']),
+            discipline: z.enum(['backend', 'frontend', 'fullstack']).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)));
+    server.registerTool('work_item.list', {
+        description: 'List selectable work items for a project before opening an engineering run in this chat.',
+        inputSchema: z.object({
+            projectId: z.string().uuid(),
+            status: z
+                .enum(['backlog', 'ready', 'in_progress', 'in_review', 'done', 'cancelled'])
+                .optional(),
+            priority: z.enum(['lowest', 'low', 'medium', 'high', 'highest']).optional(),
+            assigneeUserId: z.string().uuid().optional(),
+            includeArchived: z.boolean().optional(),
+        }),
+    }, async (input) => toolResult(await service.workItemList(input)));
+    server.registerTool('work_item.get', {
+        description: 'Load one project work item, including acceptance criteria and dependencies, before starting or resuming its engineering run.',
+        inputSchema: z.object({
+            projectId: z.string().uuid(),
+            workItemId: z.string().uuid(),
+        }),
+    }, async (input) => toolResult(await service.workItemGet(input)));
     server.registerTool('auth.logout', {
         description: 'Revoke the refresh session and delete local credentials; transient revoke failures preserve the session unless the user explicitly confirms local-only logout.',
         inputSchema: z.object({

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

@@ -18,7 +18,7 @@ export class RepositoryResolver {
             throw new Error('Explicit project does not match the repository marker');
         }
         const [repoFingerprint, git] = await Promise.all([
-            this.git.fingerprint(repoRoot),
+            this.git.fingerprint(repoRoot, marker?.schemaVersion ?? this.markerSchemaVersion),
             this.git.manifest(repoRoot),
         ]);
         return {

package/runtime/dist/src/runtime/active-context-store.js

@@ -43,6 +43,16 @@ export class ActiveContextStore {
         const pointers = await this.list(repoFingerprint);
         return pointers.find((pointer) => pointer.taskSlug === taskSlug) ?? null;
     }
+    async loadForSession(repoFingerprint, sessionId) {
+        if (!isUuid(sessionId)) {
+            throw new Error('Context session identifier is invalid');
+        }
+        const matches = (await this.list(repoFingerprint)).filter((pointer) => pointer.sessionId === sessionId);
+        if (matches.length > 1) {
+            throw new Error('Context session has more than one active task pointer');
+        }
+        return matches[0] ?? null;
+    }
     async list(repoFingerprint) {
         assertFingerprint(repoFingerprint);
         await this.adoptLegacyPointer(repoFingerprint);
@@ -112,7 +122,7 @@ export class ActiveContextStore {
     async setChangeBaseline(repoFingerprint, sessionId, manifest, leasePaths, taskSnapshot) {
         const pointer = taskSnapshot
             ? await this.loadForTask(repoFingerprint, taskSnapshot.taskId)
-            : await this.load(repoFingerprint);
+            : await this.loadForSession(repoFingerprint, sessionId);
         if (!pointer || pointer.sessionId !== sessionId) {
             throw new Error('Change baseline does not match the active repository session');
         }
@@ -163,9 +173,7 @@ export class ActiveContextStore {
     }
     async clearVerificationIntent(repoFingerprint, taskId) {
         await this.exclusive(repoFingerprint, async () => {
-            const pointer = taskId
-                ? await this.loadForTask(repoFingerprint, taskId)
-                : await this.load(repoFingerprint);
+            const pointer = await this.loadForTask(repoFingerprint, taskId);
             if (!pointer?.verificationIntent) {
                 return;
             }
@@ -199,9 +207,7 @@ export class ActiveContextStore {
     }
     async clearCloseIntent(repoFingerprint, taskId) {
         await this.exclusive(repoFingerprint, async () => {
-            const pointer = taskId
-                ? await this.loadForTask(repoFingerprint, taskId)
-                : await this.load(repoFingerprint);
+            const pointer = await this.loadForTask(repoFingerprint, taskId);
             if (!pointer?.closeIntent) {
                 return;
             }