apt-mcp-agent-setup 3.0.8 → 3.2.5

package/release-check.js

@@ -2,26 +2,42 @@
 const path = require('path');
 const os = require('os');
 const crypto = require('crypto');
-const { spawn, execFileSync } = require('child_process');
+const { spawn, spawnSync, execFileSync } = require('child_process');
 const assert = require('assert/strict');
 
 // Standalone: this file is also shipped as the signed dist prepublish gate.
-async function handshake(installed, workspace, fixture, realBackends = false) {
-  const child = spawn(process.execPath, ['--require', fixture, installed.launcherPath, '--path', workspace], {
+async function handshake(installed, workspace, fixture, realBackends = false, launcherArgs = [installed.launcherPath, '--path', workspace]) {
+  const child = spawn(process.execPath, ['--require', fixture, ...launcherArgs], {
     windowsHide: true,
     env: { ...process.env, APT_TEST_RELEASE: installed.path, APT_GATE_REAL: realBackends ? '1' : '0', MCP_SKIP_LICENSE_CHECK: '1', MCP_SKIP_INTEGRITY_CHECK: '0' },
     stdio: ['pipe', 'pipe', 'pipe']
   });
   let buffer = '', stderr = '', initialized = false, listed = false;
+  const checkBootstrappedWorkspace = message => {
+    const content = message.result?.content?.find(item => item.type === 'text');
+    assert.ok(content, 'Missing bootstrap result');
+    const actual = JSON.parse(content.text).workspace;
+    const identity = value => process.platform === 'win32' ? path.resolve(value).toLowerCase() : path.resolve(value);
+    assert.equal(identity(actual), identity(fs.realpathSync(workspace)), 'Launcher ignored its workspace binding');
+  };
   const checks = realBackends ? [
-    ['session_bootstrap', {sessionId:'package-gate',workspacePath:workspace}, /workspace/],
+    ['session_bootstrap', {sessionId:'package-gate'}, checkBootstrappedWorkspace],
+    ['model_list', {sessionId:'package-gate'}, /sources/],
     ['code_search', {query:'callee'}, /callee/],
     ['find_callers', {symbol:'callee'}, /caller/],
     ['find_callees', {symbol:'caller'}, /callee/],
     ['explore_code', {query:'callee'}, /callee/],
     ['list_code_files', {pattern:'sample.py'}, /sample\.py/],
     ['impact_analysis', {changed_files:['sample.py'],repo_root:workspace}, /sample\.py/]
-  ] : [];
+  ] : [['session_bootstrap', {sessionId:'package-gate'}, checkBootstrappedWorkspace]];
+  checks.push(['route_request', {sessionId:'package-gate',requestId:'package-readonly-route',
+    prompt:'Read-only inspection of Node.js backend sample.js. This is not a web or mobile application. Do not edit source.',
+    stack:'nodejs',target:'sample.js'}, message => {
+      const result = JSON.parse(message.result.content.find(item => item.type === 'text').text);
+      assert.equal(result.pipeline, 'read-only', 'Negated edit instruction was routed as a change');
+      assert.equal(result.authorizesEdits, false);
+      assert.notEqual(result.workflow, 'implement');
+    }]);
   let completed = 0;
   const send = message => child.stdin.write(JSON.stringify({ jsonrpc: '2.0', ...message }) + '\n');
   const next = () => {
@@ -49,14 +65,16 @@ async function handshake(installed, workspace, fixture, realBackends = false) {
             send({ id: 2, method: 'tools/list', params: {} });
           } else if (message.id === 2) {
             assert.ok(initialized);
-            for (const name of ['session_bootstrap', 'route_request', 'pipeline_status']) {
+            for (const name of ['session_bootstrap', 'route_request', 'model_list', 'context_load', 'pipeline_status']) {
               assert.ok(message.result?.tools?.some(tool => tool.name === name), `Missing ${name}: ${JSON.stringify(message)}`);
             }
             listed = true;
             next();
           } else if (message.id === 3 + completed && completed < checks.length) {
-            assert.ok(!message.error && !message.result?.isError, JSON.stringify(message));
-            assert.match(JSON.stringify(message.result), checks[completed][2]);
+            assert.ok(!message.error && !message.result?.isError, `${JSON.stringify(message)}\n${stderr}`);
+            const check = checks[completed][2];
+            if (typeof check === 'function') check(message);
+            else assert.match(JSON.stringify(message.result), check);
             completed++;
             next();
           }
@@ -70,17 +88,114 @@ async function handshake(installed, workspace, fixture, realBackends = false) {
     });
     send({ id: 1, method: 'initialize', params: { protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name: 'apt-package-gate', version: '1' } } });
   });
-}
+}
+
+function verifyPackagedQualityGate(installed, temp) {
+  const { assessReport } = require(path.join(installed.path, 'src/core/quality.js'));
+  const flutterStart = { type: 'testStart', test: { id: 1, name: 'native behavior' } };
+  const flutterDone = { type: 'testDone', testID: 1, result: 'success', skipped: false, hidden: false };
+  const completed = { type: 'done', success: true };
+  const flutterResult = events => assessReport('flutter-machine', events.map(event => JSON.stringify(event)).join('\n'),
+    { format: 'flutter-machine', testIds: ['native behavior'] }).status;
+  assert.equal(flutterResult([flutterStart, flutterDone, completed]), 'passed');
+  assert.equal(flutterResult([flutterStart, { ...flutterDone, skipped: true }, completed]), 'unverified');
+  assert.equal(flutterResult([flutterStart, { ...flutterDone, hidden: true }, completed]), 'unverified');
+  assert.equal(flutterResult([flutterStart, flutterDone]), 'unverified');
+  assert.notEqual(flutterResult([flutterStart, flutterDone, { ...completed, success: false }]), 'passed');
+  const { PipelineManager } = require(path.join(installed.path, 'src/proxy/pipeline.js'));
+  const workspace = path.join(temp, 'quality workspace');
+  fs.mkdirSync(workspace);
+  fs.writeFileSync(path.join(workspace, 'code.js'), 'exports.add = (a, b) => a + b;\n');
+  fs.writeFileSync(path.join(workspace, 'check.test.js'),
+    "const { test } = require('node:test'); const assert = require('node:assert/strict'); test('adds', () => assert.equal(require('./code').add(2, 3), 5));\n");
+  fs.writeFileSync(path.join(workspace, 'failing.test.js'),
+    "const { test } = require('node:test'); const assert = require('node:assert/strict'); test('adds', () => assert.equal(require('./code').add(2, 3), 6));\n");
+  fs.writeFileSync(path.join(workspace, 'package.json'), JSON.stringify({ scripts: {
+    test: 'node --test --test-reporter=tap check.test.js'
+  } }));
+  for (const skill of ['review', 'testing-patterns', 'tdd-loop', 'code-review-checklist']) {
+    const folder = path.join(workspace, '.agents', 'skills', skill);
+    fs.mkdirSync(folder, { recursive: true });
+    fs.writeFileSync(path.join(folder, 'SKILL.md'), skill);
+  }
+  const manager = new PipelineManager(workspace);
+  manager.env = { ...process.env }; delete manager.env.NODE_TEST_CONTEXT;
+  const plan = { criteria: [{ id: 'adds', expectedOutcome: 'add(2,3) is 5', source: 'user-request', checkIds: ['add-test'] }],
+    checks: [{ id: 'add-test', criterionIds: ['adds'], format: 'node-tap', testIds: ['adds'], required: true }],
+    reviews: [{ id: 'technical', required: true }] };
+  const start = options => manager.start({ task: options.task, pipeline: 'hotfix', sessionId: 'package-quality',
+    acceptanceCriteria: ['add(2,3) is 5'], workspace: { mode: 'current', confirmed: true }, ...options });
+  const routed = start({ task: 'web-quality', productImpact: true, productTarget: 'web' });
+  assert.equal(routed.success, true, JSON.stringify(routed));
+  const routedState = manager.readRun('web-quality', routed.runId);
+  assert.deepEqual(routedState.quality.plan.platforms, [{ id: 'web', checkIds: ['platform-web'] }]);
+  assert.ok(routedState.quality.plan.reviews.some(item => item.id === 'product'));
+  assert.equal(start({ task: 'web-bypass', qualityPlan: plan, productImpact: true, productTarget: 'web' }).code, 'INVALID_QUALITY_PLAN');
+  const lowered = start({ task: 'web-lowered', qualityPlan: plan, productImpact: false });
+  assert.equal(lowered.code, 'ACCEPTANCE_ALREADY_ACTIVE');
+  assert.equal(lowered.task, 'web-quality');
+  assert.equal(manager.reset({ task: 'web-quality', runId: routed.runId, confirm: true }).success, true);
+  const started = start({ task: 'functional-quality', qualityPlan: plan });
+  assert.equal(started.success, true, JSON.stringify(started));
+  const base = { task: 'functional-quality', runId: started.runId, sessionId: 'package-quality' };
+  let serial = 0;
+  const next = () => manager.next({ ...base, requestId: `package-${++serial}` });
+  const checkpoint = (attempt, extra = {}) => manager.checkpoint({ ...base, attemptId: attempt.attemptId,
+    actorId: attempt.actorId, step: attempt.step, status: 'completed', ...extra });
+  assert.equal(checkpoint(next()).success, true);
+  const writer = next();
+  const unrelated = manager.recordVerification({ ...base, attemptId: writer.attemptId, actorId: writer.actorId,
+    command: [process.execPath, '-e', 'process.exit(0)'], checkId: 'add-test' });
+  assert.equal(unrelated.evidence.quality.status, 'unverified');
+  assert.equal(checkpoint(writer, { evidenceIds: [unrelated.evidence.id] }).code, 'QUALITY_CHECK_REQUIRED');
+  const command = [process.execPath, '--test', '--test-reporter=tap', 'check.test.js'];
+  const failed = manager.recordVerification({ ...base, attemptId: writer.attemptId, actorId: writer.actorId,
+    command: [process.execPath, '--test', '--test-reporter=tap', 'failing.test.js'], checkId: 'add-test', reportFormat: 'node-tap' });
+  assert.equal(failed.evidence.quality.status, 'failed');
+  const passed = manager.recordVerification({ ...base, attemptId: writer.attemptId, actorId: writer.actorId,
+    command: ['npm', 'test'], checkId: 'add-test', reportFormat: 'node-tap' });
+  assert.equal(passed.evidence.quality.status, 'passed');
+  assert.deepEqual(passed.evidence.command, ['npm', 'test']);
+  if (process.platform === 'win32') assert.match(passed.evidence.executedCommand[1], /npm-cli\.js$/);
+  assert.equal(checkpoint(writer, { evidenceIds: [passed.evidence.id] }).success, true);
+  const reviewer = next();
+  const legacy = manager.checkpoint({ ...base, attemptId: reviewer.attemptId, actorId: reviewer.actorId,
+    action: 'review', review: { stage: 'quality', verdict: 'pass', reviewedScope: ['code.js'], findings: [] } });
+  assert.equal(legacy.code, 'REVIEW_STAGE_NOT_REQUIRED');
+  assert.deepEqual(legacy.requiredStages, ['technical']);
+  const review = verdict => manager.checkpoint({ ...base, attemptId: reviewer.attemptId, actorId: reviewer.actorId,
+    action: 'review', review: { stage: 'technical', verdict, reviewedScope: ['code.js'],
+      findings: verdict === 'fail' ? [{ id: 'regression', required: true, severity: 'high', message: 'Review finding remains open' }] : [] } });
+  const optional = manager.checkpoint({ ...base, attemptId: reviewer.attemptId, actorId: reviewer.actorId,
+    action: 'review', review: { stage: 'technical', verdict: 'pass', reviewedScope: ['code.js'],
+      findings: [{ id: 'regression', required: false, severity: 'low', message: 'Optional observation before escalation' }] } });
+  assert.equal(optional.success, true);
+  const defaultSeverity = manager.checkpoint({ ...base, attemptId: reviewer.attemptId, actorId: reviewer.actorId,
+    action: 'review', review: { stage: 'technical', verdict: 'pass', reviewedScope: ['code.js'],
+      findings: [{ id: 'regression', required: false, message: 'Implicit normal severity before escalation' }] } });
+  assert.equal(defaultSeverity.success, true);
+  assert.equal(manager.readRun(base.task, base.runId).quality.findings.regression.severity, 'normal');
+  const rejected = review('fail');
+  assert.equal(rejected.success, true, JSON.stringify({ reviewer, rejected }));
+  const escalated = manager.readRun(base.task, base.runId).quality.findings.regression;
+  assert.equal(escalated.required, true, 'A later required finding must promote the existing stable ID');
+  assert.equal(escalated.severity, 'high');
+  assert.equal(checkpoint(reviewer, { evidenceIds: [rejected.evidence.id] }).code, 'REVIEW_REQUIRED');
+  const omitted = review('pass');
+  assert.equal(omitted.success, true);
+  assert.equal(checkpoint(reviewer, { evidenceIds: [omitted.evidence.id] }).code, 'OPEN_FINDINGS');
+}
 
 async function main() {
   const args = process.argv.slice(2);
   const value = name => { const i = args.indexOf(name); return i < 0 ? null : args[i + 1]; };
-  const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'apt-package-gate-'));
-  const root = path.resolve(__dirname, '..');
-  const keep = args.includes('--keep');
-  try {
-    let dist = value('--dist'), publicKey;
-    if (!dist) {
+  const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'apt-package-gate-'));
+  const root = path.resolve(__dirname, '..');
+  const keep = args.includes('--keep');
+  try {
+    let dist = value('--dist'), publicKey;
+    const archive = value('--package') ? path.resolve(value('--package')) : null;
+    if (!dist && !archive) {
       const build = path.join(temp, 'build'); fs.mkdirSync(build);
       for (const item of ['src', 'bin', 'scripts', '.agents', 'docs', 'test', 'package.json', 'package-lock.json', 'README.md', 'LICENSE', '.npmignore']) {
         fs.cpSync(path.join(root, item), path.join(build, item), { recursive: true });
@@ -97,21 +212,118 @@ async function main() {
       finally { fs.closeSync(log); }
       dist = path.join(build, 'dist');
       execFileSync(process.execPath, ['-r', './test/setup.js', '--test', 'test/installer/runtime-store.test.js', 'test/proxy/transport-reliability.test.js'], { cwd: build, windowsHide: true, stdio: 'inherit' });
-    } else {
-      dist = path.resolve(dist);
-      publicKey = value('--public-key') ? fs.readFileSync(value('--public-key'), 'utf8') : require(path.join(dist, 'src/license/verify.js')).PRODUCTION_PUBLIC_KEY;
-    }
-    const npm = process.env.npm_execpath || path.join(path.dirname(process.execPath), 'node_modules/npm/bin/npm-cli.js');
-    const packed = JSON.parse(execFileSync(process.execPath, [npm, 'pack', '--ignore-scripts', '--json', '--pack-destination', temp], { cwd: dist, windowsHide: true, encoding: 'utf8' }));
-    execFileSync('tar', ['-xzf', path.join(temp, packed[0].filename), '-C', temp], { windowsHide: true });
-    const pkg = path.join(temp, 'package');
-    const installer = require(path.join(pkg, 'src/installer/runtime-store.js'));
-    const runtimeRoot = path.join(temp, 'runtime tiếng Việt');
-    const installed = installer.installRuntime(pkg, { root: runtimeRoot, publicKey });
+    } else if (dist) {
+      dist = path.resolve(dist);
+      publicKey = value('--public-key') ? fs.readFileSync(value('--public-key'), 'utf8') : require(path.join(dist, 'src/license/verify.js')).PRODUCTION_PUBLIC_KEY;
+    } else {
+      assert.ok(fs.existsSync(archive), `Package archive is missing: ${archive}`);
+      publicKey = value('--public-key') ? fs.readFileSync(value('--public-key'), 'utf8') : null;
+    }
+    let packed;
+    if (archive) packed = [{ filename: path.basename(archive) }];
+    else {
+      const npm = require(path.join(dist, 'src/core/npm-cli.js'))();
+      packed = JSON.parse(execFileSync(process.execPath, [npm, 'pack', '--ignore-scripts', '--json', '--pack-destination', temp], { cwd: dist, windowsHide: true, encoding: 'utf8' }));
+    }
+    execFileSync('tar', ['-xzf', archive || path.join(temp, packed[0].filename), '-C', temp], { windowsHide: true });
+    const pkg = path.join(temp, 'package');
+    if (!publicKey) publicKey = require(path.join(pkg, 'src/license/verify.js')).PRODUCTION_PUBLIC_KEY;
+    const installer = require(path.join(pkg, 'src/installer/runtime-store.js'));
+    const hostConfig = require(path.join(pkg, 'src/installer/platform-config.js'));
+    const runtimeRoot = path.join(temp, 'runtime tiếng Việt');
+    const installed = installer.installRuntime(pkg, { root: runtimeRoot, publicKey });
+    verifyPackagedQualityGate(installed, temp);
+    const globalConfig = path.join(temp, 'antigravity-global.json');
+    const workspaceA = path.join(temp, 'workspace A');
+    const workspaceB = path.join(temp, 'workspace B');
+    fs.mkdirSync(workspaceA); fs.mkdirSync(workspaceB);
+    hostConfig.deployProjectConfig('claude', workspaceA, installed.launcherPath);
+    const claudeServer = JSON.parse(fs.readFileSync(path.join(workspaceA, '.mcp.json'), 'utf8')).mcpServers['apt-mcp-agent'];
+    assert.equal(claudeServer.command, 'node');
+    assert.deepEqual(claudeServer.args, [installed.launcherPath.replace(/\\/g, '/'), '--path', workspaceA.replace(/\\/g, '/')]);
+    const { buildHookConfig } = require(path.join(pkg, 'src/core/host-adapters.js'));
+    const claudeHooks = buildHookConfig('claude-code', path.join(pkg, 'src/core/hook-bridge.js'), workspaceA).config.hooks;
+    for (const event of ['SessionStart', 'PreToolUse']) {
+      const handler = claudeHooks[event][0].hooks[0];
+      assert.equal(handler.command, 'node');
+      assert.deepEqual(handler.args.slice(0, 1), ['-e']);
+      const input = { session_id: 'claude-package-gate', cwd: workspaceA, permission_mode: 'default',
+        ...(event === 'PreToolUse' ? { tool_name: 'Read', tool_input: { file_path: path.join(workspaceA, 'sample.js') } } : {}) };
+      const result = spawnSync(handler.command, handler.args, { input: JSON.stringify(input), encoding: 'utf8', timeout: 10000, windowsHide: true });
+      assert.equal(result.status, 0, `${event}: ${result.stderr}`);
+      assert.ok(JSON.parse(result.stdout));
+    }
+    const { SessionRuntime } = require(path.join(pkg, 'src/core/session.js'));
+    const claudeSession = new SessionRuntime(workspaceA).status({ sessionId: 'claude-package-gate' });
+    assert.deepEqual(claudeSession.hookObservations['claude-code'].events.sort(), ['PreToolUse', 'SessionStart']);
+    fs.writeFileSync(globalConfig, JSON.stringify({ mcpServers: { custom: { command: 'custom' } } }));
+    for (const workspacePath of [workspaceA, workspaceB, workspaceA]) {
+      hostConfig.deployProjectConfig('antigravity', workspacePath, installed.launcherPath);
+      hostConfig.configureIDE('antigravity', installed.launcherPath, { configPathOverride: globalConfig, projectPath: workspacePath });
+    }
+    const { workspaceServerAlias } = require(path.join(pkg, 'src/core/workspace-path.js'));
+    const aliases = [workspaceA, workspaceB].map(workspaceServerAlias);
+    const globalServers = JSON.parse(fs.readFileSync(globalConfig, 'utf8')).mcpServers;
+    assert.notEqual(aliases[0], aliases[1]);
+    assert.equal(globalServers.custom.command, 'custom');
+    const packageHook = require(path.join(pkg, 'src/core/hook-bridge.js'));
+    const packageLicense = require(path.join(pkg, 'src/license/verify.js'));
+    const savedPublicKey = packageLicense.PRODUCTION_PUBLIC_KEY;
+    packageLicense.PRODUCTION_PUBLIC_KEY = publicKey;
+    try {
+      const signedCli = path.join(installed.path, 'bin/cli.js').replace(/\\/g, '/');
+      assert.equal(packageHook.isWriteTool('run_command', { command: `node "${signedCli}" doctor --project .` }, workspaceA), false);
+      assert.equal(packageHook.isWriteTool('run_command', { command: `node "${signedCli}" doctor --project . 2>&1` }, workspaceA), false);
+      assert.equal(packageHook.isWriteTool('run_command', { command: `node "${signedCli}" doctor --project . 2>&1 > sample.js` }, workspaceA), true);
+      assert.equal(packageHook.isWriteTool('run_command', { command: `node "${signedCli}" doctor --project . 2>&1; echo unsafe` }, workspaceA), true);
+      assert.equal(packageHook.isWriteTool('run_command', { command: 'npm test 2>&1' }, workspaceA), false);
+      assert.equal(packageHook.isWriteTool('run_command', { command: 'git diff 2>&1' }, workspaceA), false);
+      assert.equal(packageHook.isWriteTool('run_command', { command: 'npm test 2>&1 > sample.js' }, workspaceA), true);
+      assert.equal(packageHook.isWriteTool('run_command', { command: `node "${signedCli}" update --project .` }, workspaceA), true);
+      assert.equal(packageHook.isWriteTool('run_command', { command: `node "${signedCli}" doctor --project .; echo unsafe` }, workspaceA), true);
+    } finally { packageLicense.PRODUCTION_PUBLIC_KEY = savedPublicKey; }
+    for (const [index, workspacePath] of [workspaceA, workspaceB].entries()) {
+      assert.deepEqual(globalServers[aliases[index]].args, [installed.launcherPath.replace(/\\/g, '/'), '--path', workspacePath.replace(/\\/g, '/')]);
+      const localServers = JSON.parse(fs.readFileSync(path.join(workspacePath, '.agents/mcp_config.json'), 'utf8')).mcpServers;
+      assert.ok(localServers[aliases[index]]);
+      assert.equal(localServers['apt-mcp-agent'], undefined);
+    }
+    const metadataWorkspace = path.join(temp, 'codex metadata workspace');
+    fs.mkdirSync(metadataWorkspace);
+    const metadataScript = path.join(temp, 'codex-metadata-fixture.js');
+    const metadataSession = '01a0e102-b189-7b70-bde8-f93a55ac6594';
+    const metadataAttempt = 'd5ac530c-8201-423e-b7c9-f2203132ee71';
+    const metadataName = `apt_${metadataAttempt.replace(/-/g, '')}`;
+    const metadataHome = path.join(temp, 'codex-home');
+    const metadataSessions = path.join(metadataHome, 'sessions', '2026', '09', '27');
+    fs.mkdirSync(metadataSessions, { recursive: true });
+    const metadataChildId = '01a0e103-b7d1-7650-a63b-fe2290282b4e';
+    const metadataRollout = path.join(metadataSessions, `rollout-2026-09-27T10-58-32-${metadataChildId}.jsonl`);
+    const metadataNow = Math.floor(Date.now() / 1000);
+    fs.writeFileSync(metadataRollout, JSON.stringify({ type: 'turn_context', timestamp: new Date().toISOString(),
+      payload: { model: 'gpt-6-luna', effort: 'low' } }) + '\n');
+    const metadataThread = { id: metadataChildId, model: 'stale-thread-model', reasoningEffort: 'high', path: metadataRollout,
+      parentThreadId: metadataSession, cwd: metadataWorkspace, createdAt: metadataNow,
+      source: { subAgent: { thread_spawn: { parent_thread_id: metadataSession,
+        agent_path: `/root/${metadataName}` } } } };
+    fs.writeFileSync(metadataScript, `const readline = require('readline');
+      readline.createInterface({ input: process.stdin }).on('line', line => {
+        const message = JSON.parse(line);
+        if (message.method === 'initialize') process.stdout.write(JSON.stringify({ id: message.id, result: {} }) + '\\n');
+        if (message.method === 'thread/list') process.stdout.write(JSON.stringify({ id: message.id,
+          result: { data: [${JSON.stringify(metadataThread)}], nextCursor: null } }) + '\\n');
+        if (message.method === 'thread/turns/list') process.stdout.write(JSON.stringify({ id: message.id,
+          result: { data: [{ status: 'completed', startedAt: ${metadataNow}, completedAt: ${metadataNow + 2} }], nextCursor: null } }) + '\\n');
+      });`);
+    const metadata = require(path.join(installed.path, 'src/core/codex-host-metadata.js'));
+    assert.deepEqual(await metadata.verifyWorker({ workspace: metadataWorkspace, sessionId: metadataSession,
+      attemptId: metadataAttempt, nativeTaskName: metadataName, reservedAt: new Date().toISOString() },
+    { command: process.execPath, args: [metadataScript], timeoutMs: 3000, codexHome: metadataHome }),
+    { hostWorkerId: metadataChildId, model: 'gpt-6-luna', reasoningEffort: 'low', source: 'codex-app-server+rollout' });
     fs.writeFileSync(path.join(runtimeRoot, 'updates.json'), JSON.stringify({ checkedAt: Date.now() }));
-    const workspace = path.join(temp, 'workspace thử nghiệm'); fs.mkdirSync(workspace);
+    const workspace = path.join(temp, 'workspace thử nghiệm'); fs.mkdirSync(path.join(workspace, '.agents'), { recursive: true });
     const fixture = path.join(temp, 'backend-fixture.cjs');
-    fs.writeFileSync(fixture, `const path = require('path'), Module = require('module');
+    fs.writeFileSync(fixture, `const path = require('path'), Module = require('module');
       const root = process.env.APT_TEST_RELEASE, load = Module._load;
       Module._load = function(id, parent, isMain) {
         const result = load.apply(this, arguments);
@@ -119,12 +331,16 @@ async function main() {
         if (file === path.join(root, 'src/proxy/backends.js')) {
           const original = result.spawnBackends;
           result.spawnBackends = workspace => process.env.APT_GATE_REAL === '1'
-            ? Object.fromEntries(Object.entries(original(workspace)).filter(([name]) => ['codegraph','code-review-graph'].includes(name))) : {};
+            ? Object.fromEntries(Object.entries(original(workspace)).filter(([name]) => ['codegraph','code-review-graph','server-memory'].includes(name))) : {};
         }
         if (file === path.join(root, 'src/proxy/server.js')) result.ProxyServer.prototype.checkLatestVersion = async () => {};
         return result;
-      };`);
-    await handshake(installed, workspace, fixture);
+      };`);
+    for (const [index, workspacePath] of [workspaceA, workspaceB].entries()) {
+      await handshake(installed, workspacePath, fixture, false, globalServers[aliases[index]].args);
+    }
+    await handshake(installed, workspaceA, fixture, false, claudeServer.args);
+    await handshake(installed, workspace, fixture);
     const good = fs.readFileSync(installed.launcherPath);
     for (const old of ['_0x5e52();', "require('./server.js');"]) {
       fs.writeFileSync(installed.launcherPath, old);
@@ -155,7 +371,8 @@ async function main() {
         assert.throws(() => process.kill(pid, 0), {code:'ESRCH'});
         fs.utimesSync(nativeLock, new Date(0), new Date(0));
       }
-      if (cycle === 1) fs.writeFileSync(path.join(realWorkspace, '.agents/.data/graph/graph.db'), 'package recovery fixture');
+      const reviewCache = path.join(realWorkspace, '.agents/.data/graph-2.3.9');
+      if (cycle === 1) fs.writeFileSync(path.join(reviewCache, 'graph.db'), 'package recovery fixture');
       execFileSync(process.execPath, [indexCli, realWorkspace], { windowsHide:true, stdio:'inherit', timeout:120000 });
       const report = JSON.parse(fs.readFileSync(reportFile, 'utf8'));
       assert.equal(report.status, 'built');
@@ -168,7 +385,7 @@ async function main() {
       }
       await handshake(installed, realWorkspace, fixture, true);
     }
-    console.log(`Package gate passed: ${packed[0].filename}; fresh install + two repairs, initialize/tools/list/EOF, signature verification enabled.`);
+    console.log(`Package gate passed: ${packed[0].filename}; quality policy, fresh install + two repairs, initialize/tools/list/EOF, signature verification enabled.`);
   } finally {
     if (keep) console.log(`Validation artifacts: ${temp}`);
     else fs.rmSync(temp, { recursive: true, force: true });