engineering-memory 1.11.8 → 1.11.10

package/install/installer.mjs

@@ -4,14 +4,21 @@ import { fileURLToPath } from 'node:url';
 import { dispatcherSections } from '../dispatcher/sections.mjs';
 import { upsertManagedSection } from '../dispatcher/managed-section.mjs';
 import { normalizeApiUrl } from './api-url.mjs';
+import {
+  applyCodexApproval,
+  codexHome,
+  planCodexApproval,
+} from './codex-approval.mjs';
 import { runCommand } from './commands.mjs';
 import {
   exists,
   installManagedBridgeRuntime,
   installManagedDirectory,
   InstallTransaction,
+  pruneReleases,
   readJson,
   readText,
+  rememberFile,
   replaceFile,
   writeJson,
 } from './files.mjs';
@@ -54,7 +61,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,
@@ -93,7 +101,8 @@ export async function installEngineeringMemory(options = {}) {
       `Refusing to overwrite unmanaged installer state: ${statePath}`,
     );
   }
-  const codexDispatcherPath = join(homeDir, '.codex', 'AGENTS.md');
+  const codexConfigHome = codexHome(homeDir, options.env);
+  const codexDispatcherPath = join(codexConfigHome, 'AGENTS.md');
   const claudeDispatcherPath = join(homeDir, '.claude', 'CLAUDE.md');
   const clientTargets = {
     codex: {
@@ -141,6 +150,12 @@ export async function installEngineeringMemory(options = {}) {
       };
     }),
   );
+  const codexApprovalPlan = installedClients.includes('codex')
+    ? await planCodexApproval({
+        codexHome: codexConfigHome,
+        state: existingState?.mcp?.codex?.approval,
+      })
+    : null;
   const hookPlan = await planGitHook({
     repoRoot: options.repoRoot ? resolve(options.repoRoot) : null,
     mode: options.hookMode ?? 'cancel',
@@ -153,15 +168,29 @@ 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),
+      },
     );
+    if (codexApprovalPlan) {
+      await rememberFile(codexApprovalPlan.path, transaction);
+    }
     const mcp = {
       ...(existingState?.mcp ?? {}),
       ...(await applyMcpRegistrations(mcpPlans, commandRunner, transaction)),
     };
+    const codexApproval = codexApprovalPlan
+      ? await applyCodexApproval(codexApprovalPlan, transaction)
+      : null;
+    if (codexApproval && !codexApproval.skipped) {
+      mcp.codex = { ...mcp.codex, approval: codexApprovalPlan.intended };
+    }
     let skillHash;
     for (const plan of clientPlans) {
       const installedHash = await installManagedDirectory(
@@ -183,7 +212,8 @@ export async function installEngineeringMemory(options = {}) {
       skillHash,
       runtime: {
         path: runtimePath,
-        sourceHash: runtimeHash,
+        sourceHash: runtime.sourceHash,
+        release: runtime.releasePath,
         bridgeEntry,
         gateEntry,
       },
@@ -206,9 +236,11 @@ export async function installEngineeringMemory(options = {}) {
       apiUrl,
       clientVersion,
       runtimePath,
+      release: runtime.releasePath,
       bridgeEntry,
       gateEntry,
       hook: hookResult,
+      ...(codexApproval ? { codexApproval } : {}),
     };
   } catch (error) {
     try {
@@ -222,6 +254,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.8",
+  "version": "1.11.10",
   "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

@@ -1,3 +1,3 @@
 {
-  "gitHead": "eefcf3aac9c83ba9d0126d05309ca100947317d3"
+  "gitHead": "875304dd11735e1bf2817ae59e75b54186e5071a"
 }

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),
@@ -58,6 +61,7 @@ export const endpoints = {
     taskVerify: '/runtime/task/verify',
     taskClose: '/runtime/task/close',
     taskAbandon: '/runtime/task/abandon',
+    taskStatus: (taskId) => `/runtime/task/${taskId}/status`,
     taskCommitGate: '/runtime/task/commit-gate',
     projectSetup: '/projects/setup',
     projectList: '/projects',

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

@@ -242,6 +242,39 @@ export class GitInspector {
         ]);
         return ref ? ref.replace(/^origin\//, '') : null;
     }
+    async pushDestination(repoRoot) {
+        const branch = await this.currentBranch(repoRoot);
+        const upstream = branch
+            ? await this.gitValue(repoRoot, ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'])
+            : null;
+        const listed = await this.runner.run('git', ['remote'], { cwd: repoRoot });
+        const remotes = listed.exitCode === 0 ? listed.stdout.split(/\r?\n/).filter(Boolean) : [];
+        const configured = (branch &&
+            (await this.gitValue(repoRoot, ['config', '--get', `branch.${branch}.pushRemote`]))) ||
+            (await this.gitValue(repoRoot, ['config', '--get', 'remote.pushDefault'])) ||
+            (branch && (await this.gitValue(repoRoot, ['config', '--get', `branch.${branch}.remote`]))) ||
+            'origin';
+        const remote = remotes.includes(configured) ? configured : null;
+        const pushUrl = remote
+            ? await this.gitValue(repoRoot, ['remote', 'get-url', '--push', remote])
+            : null;
+        const remoteHead = remote
+            ? await this.gitValue(repoRoot, [
+                'symbolic-ref',
+                '--short',
+                '-q',
+                `refs/remotes/${remote}/HEAD`,
+            ])
+            : null;
+        return {
+            branch,
+            upstream,
+            remote,
+            pushUrl: pushUrl ? withoutCredentials(pushUrl) : null,
+            remoteDefaultBranch: remoteHead ? remoteHead.slice(`${remote}/`.length) : null,
+            headCommit: await this.gitValue(repoRoot, ['rev-parse', '--verify', '-q', 'HEAD']),
+        };
+    }
     async protectedBranchNames(repoRoot) {
         const names = new Set(['main', 'master', 'develop', 'prod']);
         const fallback = await this.defaultBranch(repoRoot);
@@ -286,6 +319,14 @@ export class GitInspector {
         }
         return await canonicalPath(resolve(commonDirectory, '..'));
     }
+    async identity(repoRoot) {
+        const root = await this.findRoot(repoRoot);
+        const [head, branch] = await Promise.all([
+            this.gitValue(root, ['rev-parse', 'HEAD']),
+            this.currentBranch(root),
+        ]);
+        return { repoRoot: root, head, branch };
+    }
     async manifest(repoRoot) {
         const root = await this.findRoot(repoRoot);
         const head = await this.gitValue(root, ['rev-parse', 'HEAD']);
@@ -301,6 +342,30 @@ export class GitInspector {
             diffHash: sha256(`${head ?? '<unborn>'}\n${stableStringify(hashManifest)}\n`),
         };
     }
+    async manifestAgainst(repoRoot, baseCommit) {
+        const root = await this.findRoot(repoRoot);
+        const head = await this.gitValue(root, ['rev-parse', 'HEAD']);
+        const changedPaths = await this.changedPathsAgainstHead(root, baseCommit);
+        const hashManifest = canonicalHashManifest(changedPaths);
+        return {
+            repoRoot: root,
+            head,
+            baseCommit,
+            changedPaths,
+            worktreeHash: sha256(`${stableStringify(hashManifest)}\n`),
+            diffHash: sha256(`${baseCommit}\n${head ?? '<unborn>'}\n${stableStringify(hashManifest)}\n`),
+        };
+    }
+    async isAncestor(repoRoot, ancestor, descendant = 'HEAD') {
+        const result = await this.runner.run('git', ['merge-base', '--is-ancestor', ancestor, descendant], { cwd: repoRoot });
+        return result.exitCode === 0;
+    }
+    async committedPaths(repoRoot, baseCommit) {
+        const result = await this.runner.run('git', ['diff', '--name-only', '-z', '--find-renames', baseCommit, 'HEAD', '--'], { cwd: repoRoot });
+        if (result.exitCode !== 0)
+            throw new Error(`Git committed diff failed: ${result.stderr.trim()}`);
+        return result.stdout.split('\0').filter(Boolean).map(normalizeGitPath).sort();
+    }
     async stagedManifest(repoRoot) {
         const root = await this.findRoot(repoRoot);
         let result = await this.runner.run('git', ['diff', '--cached', '--name-status', '-z', '--find-renames', '--find-copies', 'HEAD', '--'], { cwd: root });
@@ -357,10 +422,10 @@ export class GitInspector {
         }
         return result.sort((left, right) => left.path.localeCompare(right.path));
     }
-    async changedPathsAgainstHead(repoRoot) {
+    async changedPathsAgainstHead(repoRoot, ref = 'HEAD') {
         const [tracked, raw, untracked] = await Promise.all([
-            this.runner.run('git', ['diff', 'HEAD', '--name-status', '-z', '--find-renames', '--find-copies', '--'], { cwd: repoRoot }),
-            this.runner.run('git', ['diff', 'HEAD', '--raw', '-z', '--no-abbrev', '--'], {
+            this.runner.run('git', ['diff', ref, '--name-status', '-z', '--find-renames', '--find-copies', '--'], { cwd: repoRoot }),
+            this.runner.run('git', ['diff', ref, '--raw', '-z', '--no-abbrev', '--'], {
                 cwd: repoRoot,
             }),
             this.runner.run('git', ['ls-files', '--others', '--exclude-standard', '-z'], {
@@ -699,6 +764,20 @@ function canonicalRemoteIdentity(remote) {
         return `local/${normalizeRemotePath(trimmed.replace(/[?#].*$/, ''))}`;
     }
 }
+function withoutCredentials(remote) {
+    if (!/^[A-Za-z][A-Za-z0-9+.-]*:\/\//.test(remote))
+        return remote;
+    try {
+        const url = new URL(remote);
+        if (url.protocol === 'http:' || url.protocol === 'https:')
+            url.username = ''; // a pasted token sits here
+        url.password = '';
+        return url.toString();
+    }
+    catch {
+        return remote.replace(/\/\/[^/@]*@/, '//');
+    }
+}
 function normalizeRemotePath(path) {
     const normalized = path
         .replace(/\\/g, '/')

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

@@ -151,23 +151,34 @@ export class VerificationGate {
             };
         }
         const actualSource = receipt.source ? await this.git.sourceIdentity(repoRoot) : null;
+        const ahead = receipt.branch &&
+            receipt.source &&
+            actualSource &&
+            actualSource.sourceCommit !== receipt.source.sourceCommit &&
+            (await this.git.isAncestor(repository.repoRoot, receipt.source.sourceCommit)) &&
+            (await this.git.committedPaths(repository.repoRoot, receipt.source.sourceCommit)).every((path) => receipt.taskChanges.some((change) => change.path === path))
+            ? await this.git.manifestAgainst(repository.repoRoot, receipt.source.sourceCommit)
+            : null;
+        const committedAhead = ahead?.diffHash === receipt.diffHash;
+        const current = ahead && committedAhead ? ahead : manifest;
         if (receipt.source &&
+            !committedAhead &&
             (!actualSource ||
                 actualSource.sourceCommit !== receipt.source.sourceCommit ||
                 actualSource.treeHash !== receipt.source.treeHash)) {
             return {
                 allowed: false,
                 reason: 'source_commit_mismatch',
-                diffHash: manifest.diffHash,
+                diffHash: current.diffHash,
                 taskId: receipt.taskId,
                 details: ['Return to the task source commit or start a task for the current source.'],
             };
         }
-        if (receipt.diffHash !== manifest.diffHash) {
+        if (receipt.diffHash !== current.diffHash) {
             return {
                 allowed: false,
                 reason: 'git_diff_changed_after_verify',
-                diffHash: manifest.diffHash,
+                diffHash: current.diffHash,
                 taskId: receipt.taskId,
             };
         }
@@ -175,7 +186,7 @@ export class VerificationGate {
             return {
                 allowed: false,
                 reason: 'no_task_changes_staged',
-                diffHash: manifest.diffHash,
+                diffHash: current.diffHash,
                 taskId: receipt.taskId,
             };
         }
@@ -183,7 +194,7 @@ export class VerificationGate {
             return {
                 allowed: false,
                 reason: 'staged_change_outside_task',
-                diffHash: manifest.diffHash,
+                diffHash: current.diffHash,
                 taskId: receipt.taskId,
             };
         }
@@ -191,22 +202,24 @@ export class VerificationGate {
             return {
                 allowed: false,
                 reason: 'online_commit_gate_unavailable',
-                diffHash: manifest.diffHash,
+                diffHash: current.diffHash,
                 taskId: receipt.taskId,
             };
         }
         try {
             const attestation = await this.commitGateAttestor({
-                source: actualSource
-                    ? {
-                        ...actualSource,
-                        ...(receipt.source?.linked ? { linked: receipt.source.linked } : {}),
-                    }
-                    : undefined,
+                source: committedAhead
+                    ? receipt.source
+                    : actualSource
+                        ? {
+                            ...actualSource,
+                            ...(receipt.source?.linked ? { linked: receipt.source.linked } : {}),
+                        }
+                        : undefined,
                 taskId: receipt.taskId,
                 projectId: receipt.projectId,
                 repoFingerprint: receipt.repoFingerprint,
-                diffHash: manifest.diffHash,
+                diffHash: current.diffHash,
                 expectedTaskVersion: receipt.taskVersion,
                 branch: branch ?? undefined,
             });
@@ -214,11 +227,11 @@ export class VerificationGate {
             if (result?.allowed !== true ||
                 result.taskId !== receipt.taskId ||
                 result.taskVersion !== receipt.taskVersion ||
-                result.diffHash !== manifest.diffHash) {
+                result.diffHash !== current.diffHash) {
                 return {
                     allowed: false,
                     reason: 'online_commit_gate_mismatch',
-                    diffHash: manifest.diffHash,
+                    diffHash: current.diffHash,
                     taskId: receipt.taskId,
                 };
             }
@@ -227,7 +240,7 @@ export class VerificationGate {
             return {
                 allowed: false,
                 reason: 'online_commit_gate_rejected',
-                diffHash: manifest.diffHash,
+                diffHash: current.diffHash,
                 taskId: receipt.taskId,
                 details: [error instanceof Error ? error.message : String(error)],
             };
@@ -235,7 +248,7 @@ export class VerificationGate {
         return {
             allowed: true,
             reason: 'verified',
-            diffHash: manifest.diffHash,
+            diffHash: current.diffHash,
             taskId: receipt.taskId,
         };
     }

package/runtime/dist/src/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/onboarding-tools.js

@@ -1,6 +1,6 @@
 import * as z from 'zod/v4';
 import { sha256, stableStringify } from '../utilities/hash.js';
-import { askQuestionnaire } from './questionnaire-tools.js';
+import { answerChoice, answerData, askQuestionnaire } from './questionnaire-tools.js';
 const uuid = z.string().uuid();
 const hash = z.string().regex(/^[a-f0-9]{64}$/);
 const project = { projectId: uuid };
@@ -468,7 +468,7 @@ export function registerOnboardingTools(server, service) {
         inputSchema: z.object(run),
     }, async (input) => output(await service.onboardingRequest('verify', body(input))));
     server.registerTool('memory.catalog', {
-        description: 'Page accessible memory resource headers by id. Read all pages using the last id when a page is full. includeArchived exposes retired identities for refresh and rename preservation.',
+        description: 'Page accessible memory resource headers by id: each entry names its current revision and its size in characters instead of carrying its content. Pass the response nextAfterId as afterId to read the next page; nextAfterId is null once nothing more remains. includeArchived exposes retired identities for refresh and rename preservation.',
         inputSchema: z.object({
             ...project,
             ...page,
@@ -479,7 +479,7 @@ export function registerOnboardingTools(server, service) {
         }),
     }, async (input) => output(await service.onboardingRequest('catalog', body(input))));
     server.registerTool('memory.read_revisions', {
-        description: 'Read selected immutable revisions in an authorized context session and record receipts. Bounds keep large project learning independent of normal task context limits.',
+        description: 'Read selected immutable revisions in an authorized context session and record receipts. One response carries what fits its size budget, in the order requested, as items; the revisions it did not carry are listed in remainingRevisionIds, to pass to the next call. Bounds keep large project learning independent of normal task context limits.',
         inputSchema: z.object({
             ...project,
             sessionId: uuid,
@@ -533,19 +533,6 @@ export function registerOnboardingTools(server, service) {
         })));
     });
 }
-function answerChoice(result) {
-    return answerData(result)?.choice;
-}
-function answerData(result) {
-    const response = result;
-    const text = response.content?.find((item) => item.type === 'text')?.text;
-    if (!text)
-        return undefined;
-    const value = JSON.parse(text);
-    return value.ok && value.data?.status === 'answered' && value.data.answerAvailable
-        ? value.data.answer
-        : undefined;
-}
 async function approveOnboarding(server, service, input, context, initialize) {
     const preparation = !input.projectId;
     const scope = { repoRoot: input.repoRoot, preparation };