engineering-memory 1.11.7 → 1.11.9

package/dispatcher/sections.mjs

@@ -9,7 +9,7 @@ Call \`session.entry\` before you answer anything in a repository, whatever the
 - Switched off: say nothing about Engineering Memory, offer nothing, hint at nothing, however useful it would be for what was asked. They turned it off; raising it again is what this prevents. Record it back on only when they ask.
 - Bound: continue into the lifecycle.
 
-\`session.entry\` also reports this client's version. When it says an update is available, offer once to run \`npx engineering-memory@latest install\` and tell the user the client restarts afterwards. If they decline, record it with \`session.decline_update\` and never raise that version again. When it says an update is required, there is no choice to offer: say that this client is older than the backend supports, give the command, and do not carry on as though the lifecycle works.
+\`session.entry\` also reports this client's version. When it says an update is available, offer once to run \`npx engineering-memory@latest install\` and tell the user that the running bridge switches to the new release by itself on its next call, so nothing needs restarting; only a bridge older than 1.11.9 needs the client restarted once after that install. If they decline, record it with \`session.decline_update\` and never raise that version again. When it says an update is required, there is no choice to offer: say that this client is older than the backend supports, give the command, and do not carry on as though the lifecycle works.
 
 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.
 

package/install/files.mjs

@@ -11,7 +11,13 @@ import {
   rm,
   writeFile,
 } from 'node:fs/promises';
-import { basename, dirname, join } from 'node:path';
+import { basename, dirname, join, resolve } from 'node:path';
+import {
+  launcherPackageJson,
+  launcherSource,
+  normalizeRelativeEntry,
+  releasePointerName,
+} from './launcher.mjs';
 
 export class InstallTransaction {
   constructor() {
@@ -110,6 +116,7 @@ export async function installManagedDirectory(
 ) {
   const artifact = options.artifact ?? 'skill';
   const artifactLabel = artifact === 'skill' ? 'skill' : 'bridge runtime';
+  const accepted = new Set([artifact, ...(options.replaces ?? [])]);
   const sourceHash = await hashDirectory(source);
   const manifestPath = join(destination, '.engineering-memory-install.json');
   if (await exists(destination)) {
@@ -117,7 +124,7 @@ export async function installManagedDirectory(
     if (
       manifest?.product !== 'engineering-memory' ||
       manifest?.schemaVersion !== 1 ||
-      (manifest.artifact ?? 'skill') !== artifact
+      !accepted.has(manifest.artifact ?? 'skill')
     ) {
       throw new Error(
         `Refusing to overwrite an unmanaged ${artifactLabel} directory: ${destination}`,
@@ -151,6 +158,7 @@ export async function installManagedDirectory(
         schemaVersion: 1,
         artifact,
         sourceHash,
+        ...(options.manifest ?? {}),
       },
       null,
       2,
@@ -181,9 +189,22 @@ export async function installManagedDirectory(
 
 export async function installManagedBridgeRuntime(
   source,
-  destination,
+  runtimeRoot,
   transaction,
+  options = {},
 ) {
+  const bridgeEntry = normalizeRelativeEntry(
+    options.bridgeEntry ?? 'dist/src/index.js',
+    'Bridge entry',
+  );
+  const gateEntry = normalizeRelativeEntry(
+    options.gateEntry ?? 'dist/src/git/pre-commit.js',
+    'Git gate entry',
+  );
+  const clientVersion =
+    typeof options.clientVersion === 'string' && options.clientVersion
+      ? options.clientVersion
+      : null;
   const packageJsonPath = join(source, 'package.json');
   const packageLockPath = join(source, 'package-lock.json');
   const nodeModulesPath = join(source, 'node_modules');
@@ -209,10 +230,8 @@ export async function installManagedBridgeRuntime(
     packageJson,
     packageLock,
   );
-  await mkdir(dirname(destination), { recursive: true });
-  const bundle = await mkdtemp(
-    join(dirname(destination), '.bridge-runtime-source-'),
-  );
+  await mkdir(runtimeRoot, { recursive: true });
+  const bundle = await mkdtemp(join(runtimeRoot, '.bridge-runtime-source-'));
   try {
     await copyDirectory(join(source, 'dist'), join(bundle, 'dist'));
     await copyFile(packageJsonPath, join(bundle, 'package.json'));
@@ -230,14 +249,101 @@ export async function installManagedBridgeRuntime(
         join(bundle, ...packageEntry.path.split('/')),
       );
     }
-    return await installManagedDirectory(bundle, destination, transaction, {
+    for (const [entry, label] of [
+      [bridgeEntry, 'Bridge entry'],
+      [gateEntry, 'Git gate entry'],
+    ]) {
+      if (!(await exists(join(bundle, ...entry.split('/'))))) {
+        throw new Error(`${label} is missing from the built bridge: ${entry}`);
+      }
+    }
+    const sourceHash = await hashDirectory(bundle);
+    const releasePath = join(runtimeRoot, 'releases', sourceHash.slice(0, 16));
+    const installedAt = new Date().toISOString();
+    await installManagedDirectory(bundle, releasePath, transaction, {
       artifact: 'bridge-runtime',
+      manifest: { clientVersion, installedAt },
     });
+    const launcherPath = join(runtimeRoot, 'bridge');
+    const launcherStage = await mkdtemp(join(runtimeRoot, '.bridge-launcher-'));
+    try {
+      await writeAtomic(
+        join(launcherStage, 'package.json'),
+        launcherPackageJson,
+      );
+      await writeAtomic(
+        join(launcherStage, ...bridgeEntry.split('/')),
+        launcherSource('bridgeEntry', bridgeEntry),
+      );
+      await writeAtomic(
+        join(launcherStage, ...gateEntry.split('/')),
+        launcherSource('gateEntry', gateEntry),
+      );
+      await installManagedDirectory(launcherStage, launcherPath, transaction, {
+        artifact: 'bridge-launcher',
+        replaces: ['bridge-runtime'],
+      });
+    } finally {
+      await rm(launcherStage, { recursive: true, force: true });
+    }
+    await writeJson(
+      join(runtimeRoot, releasePointerName),
+      {
+        product: 'engineering-memory',
+        schemaVersion: 1,
+        version: clientVersion,
+        sourceHash,
+        path: releasePath,
+        bridgeEntry,
+        gateEntry,
+        installedAt,
+      },
+      transaction,
+    );
+    return { sourceHash, releasePath, launcherPath, bridgeEntry, gateEntry };
   } finally {
     await rm(bundle, { recursive: true, force: true });
   }
 }
 
+export async function pruneReleases(runtimeRoot, options = {}) {
+  const keep = Math.max(1, options.keep ?? 3);
+  const releasesPath = join(runtimeRoot, 'releases');
+  if (!(await exists(releasesPath))) return [];
+  const pointer = await readJson(join(runtimeRoot, releasePointerName));
+  const currentPath =
+    pointer && typeof pointer.path === 'string' ? resolve(pointer.path) : null;
+  const candidates = [];
+  for (const entry of await readdir(releasesPath, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const path = join(releasesPath, entry.name);
+    if (currentPath && resolve(path) === currentPath) continue;
+    const manifest = await readJson(
+      join(path, '.engineering-memory-install.json'),
+    );
+    if (
+      manifest?.product !== 'engineering-memory' ||
+      manifest.artifact !== 'bridge-runtime'
+    ) {
+      continue;
+    }
+    const installedAt = Date.parse(String(manifest.installedAt ?? ''));
+    candidates.push({
+      path,
+      installedAt: Number.isNaN(installedAt)
+        ? (await lstat(path)).mtimeMs
+        : installedAt,
+    });
+  }
+  candidates.sort((left, right) => right.installedAt - left.installedAt);
+  const removed = [];
+  for (const candidate of candidates.slice(keep - 1)) {
+    await rm(candidate.path, { recursive: true, force: true });
+    removed.push(candidate.path);
+  }
+  return removed;
+}
+
 export async function hashDirectory(root, options = {}) {
   const hash = createHash('sha256');
   const excluded = new Set(options.exclude ?? []);

package/install/installer.mjs

@@ -10,6 +10,7 @@ import {
   installManagedBridgeRuntime,
   installManagedDirectory,
   InstallTransaction,
+  pruneReleases,
   readJson,
   readText,
   replaceFile,
@@ -54,7 +55,8 @@ export async function installEngineeringMemory(options = {}) {
     options.gateEntry ??
       join(bridgeRuntimeSource, 'dist', 'src', 'git', 'pre-commit.js'),
   );
-  const runtimePath = join(homeDir, '.engineering-memory', 'runtime', 'bridge');
+  const runtimeRoot = join(homeDir, '.engineering-memory', 'runtime');
+  const runtimePath = join(runtimeRoot, 'bridge');
   const bridgeEntry = stableRuntimeEntry(
     bridgeRuntimeSource,
     runtimePath,
@@ -153,10 +155,15 @@ export async function installEngineeringMemory(options = {}) {
   const transaction = new InstallTransaction();
   let result;
   try {
-    const runtimeHash = await installManagedBridgeRuntime(
+    const runtime = await installManagedBridgeRuntime(
       bridgeRuntimeSource,
-      runtimePath,
+      runtimeRoot,
       transaction,
+      {
+        clientVersion,
+        bridgeEntry: relative(bridgeRuntimeSource, sourceBridgeEntry),
+        gateEntry: relative(bridgeRuntimeSource, sourceGateEntry),
+      },
     );
     const mcp = {
       ...(existingState?.mcp ?? {}),
@@ -183,7 +190,8 @@ export async function installEngineeringMemory(options = {}) {
       skillHash,
       runtime: {
         path: runtimePath,
-        sourceHash: runtimeHash,
+        sourceHash: runtime.sourceHash,
+        release: runtime.releasePath,
         bridgeEntry,
         gateEntry,
       },
@@ -206,6 +214,7 @@ export async function installEngineeringMemory(options = {}) {
       apiUrl,
       clientVersion,
       runtimePath,
+      release: runtime.releasePath,
       bridgeEntry,
       gateEntry,
       hook: hookResult,
@@ -222,6 +231,13 @@ export async function installEngineeringMemory(options = {}) {
     throw error;
   }
   await transaction.commit();
+  try {
+    result.prunedReleases = await pruneReleases(runtimeRoot);
+  } catch (error) {
+    result.prunedReleases = [];
+    result.releasePruneProblem =
+      error instanceof Error ? error.message : String(error);
+  }
   return result;
 }
 

package/install/launcher.mjs

@@ -0,0 +1,95 @@
+export const launcherPackageJson = `${JSON.stringify(
+  {
+    name: 'engineering-memory-bridge-launcher',
+    private: true,
+    type: 'module',
+  },
+  null,
+  2,
+)}\n`;
+
+export const releasePointerName = 'current.json';
+
+export function normalizeRelativeEntry(entry, label) {
+  const normalized = String(entry).replaceAll('\\', '/').replace(/^\.\//, '');
+  const segments = normalized.split('/');
+  if (
+    normalized === '' ||
+    normalized.startsWith('/') ||
+    /^[A-Za-z]:/.test(normalized) ||
+    segments.some(
+      (segment) => segment === '' || segment === '..' || segment === '.',
+    )
+  ) {
+    throw new Error(
+      `${label} must be a relative path inside the release: ${entry}`,
+    );
+  }
+  if (segments[0] !== 'dist') {
+    throw new Error(
+      `${label} must be inside the built dist directory: ${entry}`,
+    );
+  }
+  return normalized;
+}
+
+export function launcherSource(kind, relativeEntry) {
+  if (kind !== 'bridgeEntry' && kind !== 'gateEntry') {
+    throw new Error(`Unknown launcher kind: ${kind}`);
+  }
+  const depth = normalizeRelativeEntry(relativeEntry, 'Launcher entry').split(
+    '/',
+  ).length;
+  const ascend = Array.from({ length: depth }, () => "'..'").join(', ');
+  const label = kind === 'bridgeEntry' ? 'bridge' : 'Git gate';
+  return [
+    '#!/usr/bin/env node',
+    "import { readFile } from 'node:fs/promises';",
+    "import { dirname, isAbsolute, join, resolve } from 'node:path';",
+    "import { fileURLToPath, pathToFileURL } from 'node:url';",
+    '',
+    `const runtimeRoot = resolve(dirname(fileURLToPath(import.meta.url)), ${ascend});`,
+    `const pointerPath = join(runtimeRoot, ${JSON.stringify(releasePointerName)});`,
+    `const installCommand = 'npx engineering-memory@latest install';`,
+    '',
+    'function stop(message) {',
+    "  process.stderr.write(message + '\\n');",
+    '  process.exit(1);',
+    '}',
+    '',
+    'let pointer;',
+    'try {',
+    "  pointer = JSON.parse(await readFile(pointerPath, 'utf8'));",
+    '} catch (error) {',
+    '  stop(',
+    `    'The Engineering Memory ${label} cannot start: ' +`,
+    '      pointerPath +',
+    "      ' is unreadable (' +",
+    '      (error instanceof Error ? error.message : String(error)) +',
+    "      '). Run ' +",
+    '      installCommand +',
+    "      '.',",
+    '  );',
+    '}',
+    'if (',
+    '  !pointer ||',
+    "  pointer.product !== 'engineering-memory' ||",
+    "  typeof pointer.path !== 'string' ||",
+    `  typeof pointer.${kind} !== 'string'`,
+    ') {',
+    '  stop(',
+    `    'The Engineering Memory ${label} cannot start: ' +`,
+    '      pointerPath +',
+    "      ' does not name a release. Run ' +",
+    '      installCommand +',
+    "      '.',",
+    '  );',
+    '}',
+    'const releasePath = isAbsolute(pointer.path)',
+    '  ? pointer.path',
+    '  : resolve(runtimeRoot, pointer.path);',
+    'process.env.ENGINEERING_MEMORY_RUNTIME_CURRENT = pointerPath;',
+    `await import(pathToFileURL(join(releasePath, ...pointer.${kind}.split('/'))).href);`,
+    '',
+  ].join('\n');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engineering-memory",
-  "version": "1.11.7",
+  "version": "1.11.9",
   "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/build.json

@@ -0,0 +1,3 @@
+{
+  "gitHead": "3b5175e578b3d631932b079b5678afe13dc4f00d"
+}

package/runtime/dist/src/config.js

@@ -10,6 +10,9 @@ export function loadBridgeConfig(env = process.env) {
         apiBaseUrl: (env.ENGINEERING_MEMORY_API_URL ?? 'http://127.0.0.1:3000').replace(/\/$/, ''),
         stateRoot: resolve(env.ENGINEERING_MEMORY_STATE_DIR ?? join(homedir(), '.engineering-memory')),
         clientVersion: env.ENGINEERING_MEMORY_CLIENT_VERSION ?? null,
+        runtimeCurrentPath: env.ENGINEERING_MEMORY_RUNTIME_CURRENT
+            ? resolve(env.ENGINEERING_MEMORY_RUNTIME_CURRENT)
+            : null,
         requestTimeoutMs: positiveInteger(env.ENGINEERING_MEMORY_TIMEOUT_MS, 15_000),
         cacheMaxEntries: positiveInteger(env.ENGINEERING_MEMORY_CACHE_MAX_ENTRIES, 64),
         cacheMaxBytes: positiveInteger(env.ENGINEERING_MEMORY_CACHE_MAX_BYTES, 5 * 1024 * 1024),

package/runtime/dist/src/index.js

@@ -1,88 +1,32 @@
 #!/usr/bin/env node
-import { WorktreePool } from './runtime/worktree-pool.js';
-import { WorktreePolicyCache } from './runtime/worktree-policy.js';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { serveStdio } from '@modelcontextprotocol/server/stdio';
-import { BrowserAuthCoordinator } from './auth/browser-auth.js';
-import { createCredentialStore } from './auth/credential-store.js';
-import { EtagCache } from './cache/etag-cache.js';
-import { apiNamespaceKey, apiStateRoot, endpoints, loadBridgeConfig } from './config.js';
-import { GitInspector } from './git/git-inspector.js';
-import { VerificationGate } from './git/verification-gate.js';
-import { JournalStore } from './journal/journal-store.js';
-import { createEngineeringMemoryServer } from './mcp/server.js';
-import { RepositoryResolver } from './project/repository.js';
-import { ApiClient } from './runtime/api-client.js';
-import { BridgeService } from './runtime/bridge-service.js';
-import { OfflineOutbox } from './runtime/offline-outbox.js';
-import { ActiveContextStore } from './runtime/active-context-store.js';
-import { RepositoryDecisionStore } from './runtime/repository-decision-store.js';
-import { ShadowNoticeStore } from './runtime/shadow-notice-store.js';
-import { UpdateChoiceStore } from './runtime/update-choice-store.js';
-import { PrincipalStateGuard } from './runtime/principal-state.js';
-import { OnboardingStore } from './runtime/onboarding-store.js';
-import { QuestionnaireStore } from './runtime/questionnaire-store.js';
-export function createBridgeService() {
+import { loadBridgeConfig } from './config.js';
+import { createMcpServer } from './mcp/server.js';
+import { createRuntime } from './runtime/runtime-entry.js';
+import { RuntimeHost, readCurrentRelease } from './runtime/runtime-host.js';
+export { createBridgeService } from './runtime/create-bridge-service.js';
+const releaseRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..');
+export async function createServer() {
     const config = loadBridgeConfig();
-    const apiNamespace = apiNamespaceKey(config.apiBaseUrl);
-    const stateRoot = apiStateRoot(config);
-    const credentials = createCredentialStore({
-        service: config.credentialService,
-        account: `${config.credentialAccount}:${apiNamespace}`,
-        stateRoot,
+    const server = createMcpServer();
+    let version = config.clientVersion;
+    const currentPath = config.runtimeCurrentPath;
+    if (currentPath) {
+        const current = await readCurrentRelease(currentPath);
+        if ('release' in current && current.path === releaseRoot)
+            version = current.release.version ?? version;
+    }
+    const host = new RuntimeHost({
+        server,
+        release: { path: releaseRoot, version, module: { createRuntime } },
+        ...(currentPath ? { currentPath } : {}),
+        log: (message) => process.stderr.write(`${message}\n`),
     });
-    const cache = new EtagCache({
-        stateRoot,
-        maxEntries: config.cacheMaxEntries,
-        maxBytes: config.cacheMaxBytes,
-        maxAgeMs: config.cacheMaxAgeMs,
-    });
-    const client = new ApiClient({
-        baseUrl: config.apiBaseUrl,
-        timeoutMs: config.requestTimeoutMs,
-        credentials,
-        cache,
-        refreshPath: endpoints.authRefresh,
-    });
-    const git = new GitInspector();
-    const outbox = new OfflineOutbox(stateRoot);
-    const activeContexts = new ActiveContextStore(stateRoot);
-    const repositoryDecisions = new RepositoryDecisionStore(stateRoot);
-    const updateChoices = new UpdateChoiceStore(stateRoot);
-    const shadowNotices = new ShadowNoticeStore(stateRoot);
-    const worktreePool = new WorktreePool(stateRoot, {
-        pendingWork: async (entry) => {
-            if (!entry.taskId)
-                return false;
-            const pointer = await activeContexts.loadForTask(entry.repoFingerprint, entry.taskId);
-            return Boolean(pointer?.verificationIntent ||
-                pointer?.closeIntent ||
-                (await outbox.listForTask(entry.taskId)).length);
-        },
-    });
-    const gate = new VerificationGate(stateRoot, git, outbox, undefined, worktreePool);
-    const principalState = new PrincipalStateGuard(stateRoot, credentials, cache, outbox, activeContexts, gate);
-    return new BridgeService({
-        worktreePool,
-        worktreePolicy: new WorktreePolicyCache(stateRoot),
-        client,
-        credentials,
-        browserAuth: new BrowserAuthCoordinator(client, credentials),
-        repositories: new RepositoryResolver(git, config.markerSchemaVersion, stateRoot),
-        journal: new JournalStore(stateRoot),
-        outbox,
-        gate,
-        activeContexts,
-        repositoryDecisions,
-        updateChoices,
-        shadowNotices,
-        questionnaires: new QuestionnaireStore(stateRoot),
-        onboarding: new OnboardingStore(stateRoot),
-        clientVersion: config.clientVersion,
-        principalState,
-    });
-}
-export function createServer() {
-    return createEngineeringMemoryServer(createBridgeService());
+    host.start();
+    host.watch(15_000);
+    return server;
 }
 void serveStdio(createServer);
 //# sourceMappingURL=index.js.map

package/runtime/dist/src/mcp/server.js

@@ -2,17 +2,24 @@ import { registerWorktreeTools } from './worktree-tools.js';
 import { McpServer } from '@modelcontextprotocol/server';
 import { registerOnboardingTools } from './onboarding-tools.js';
 import { registerEngineeringMemoryTools, registerQuestionnaireTools } from './tool-definitions.js';
-export function createEngineeringMemoryServer(service) {
-    const server = new McpServer({
+export const serverInstructions = 'Start with session.entry and follow the returned lifecycle. Do not block independent task work on memory.propose_revision drafting, submission or approval. If the host permits background agents or concurrent calls, dispatch independent proposals and continue useful work; otherwise checkpoint the draft and defer submission until needed. Checkpoint, correction, reconciliation, self-review and scaffold receipts use the durable local outbox; after deliveryStatus pending, continue independent work without polling or resending. Inventory upload, claim-bound evidence submission and test-result reporting may overlap independent analysis using host-permitted concurrent calls. Wait only when the next operation needs the result; required task deliveries must settle before verification. Preserve task/source identity and native user approval; never treat pending work as verified.';
+export function createMcpServer() {
+    return new McpServer({
         name: 'engineering-memory',
         version: '0.1.0',
     }, {
-        instructions: 'Start with session.entry and follow the returned lifecycle. Do not block independent task work on memory.propose_revision drafting, submission or approval. If the host permits background agents or concurrent calls, dispatch independent proposals and continue useful work; otherwise checkpoint the draft and defer submission until needed. Checkpoint, correction, reconciliation, self-review and scaffold receipts use the durable local outbox; after deliveryStatus pending, continue independent work without polling or resending. Inventory upload, claim-bound evidence submission and test-result reporting may overlap independent analysis using host-permitted concurrent calls. Wait only when the next operation needs the result; required task deliveries must settle before verification. Preserve task/source identity and native user approval; never treat pending work as verified.',
+        instructions: serverInstructions,
     });
-    registerEngineeringMemoryTools(server, service);
-    registerQuestionnaireTools(server, service);
-    registerOnboardingTools(server, service);
-    registerWorktreeTools(server, service);
+}
+export function registerAllTools(host, service) {
+    registerEngineeringMemoryTools(host, service);
+    registerQuestionnaireTools(host, service);
+    registerOnboardingTools(host, service);
+    registerWorktreeTools(host, service);
+}
+export function createEngineeringMemoryServer(service) {
+    const server = createMcpServer();
+    registerAllTools(server, service);
     return server;
 }
 //# sourceMappingURL=server.js.map

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

@@ -0,0 +1,12 @@
+export function recordingHost(server) {
+    const tools = [];
+    const registerTool = (name, config, callback) => {
+        tools.push({ name, config, callback });
+        return undefined;
+    };
+    return {
+        host: { registerTool: registerTool, server },
+        tools,
+    };
+}
+//# sourceMappingURL=tool-host.js.map