amalgm 0.1.69 → 0.1.71

package/runtime/scripts/chat-core/auth.js

@@ -9,7 +9,7 @@ const { resolveCredential } = require('./credentials/store');
 const AUTH_BY_HARNESS = {
   claude_code: ['amalgm', 'byok', 'provider_auth'],
   codex: ['amalgm', 'byok', 'provider_auth'],
-  opencode: ['amalgm', 'byok'],
+  opencode: ['amalgm', 'byok', 'provider_auth'],
 };
 
 function shellValue(raw) {
@@ -109,35 +109,15 @@ function providerAuthIdentity(harness) {
   return `${harness || 'provider'}:provider-default`;
 }
 
-function deriveAuthProfileId({ method, harness, userId, tokenFingerprint }) {
-  if (method === 'amalgm') {
-    return `amalgm-${fingerprint(userId || process.env.AMALGM_USER_ID || 'local') || 'local'}`;
-  }
-  if (method === 'byok') {
-    return `byok-${tokenFingerprint || 'default'}`;
-  }
-  if (method === 'provider_auth') {
-    return `provider-${fingerprint(providerAuthIdentity(harness)) || 'default'}`;
-  }
-  return 'default';
-}
-
-function runtimeHome({ amalgmDir, harness, authProfileId }) {
-  return path.join(amalgmDir, 'cli-homes', safePathSegment(harness), safePathSegment(authProfileId));
-}
-
-function pinnedRuntimeHome(amalgmDir, cliHomePath) {
-  if (typeof cliHomePath !== 'string' || !cliHomePath.trim()) return null;
-  const root = path.resolve(amalgmDir);
-  const resolved = path.resolve(cliHomePath.trim());
-  return resolved === root || resolved.startsWith(`${root}${path.sep}`) ? resolved : null;
+function runtimeHome({ amalgmDir, harness }) {
+  return path.join(amalgmDir, 'cli-homes', safePathSegment(harness), 'home');
 }
 
 function providerAuthFingerprint(harness) {
   return fingerprint(providerAuthIdentity(harness));
 }
 
-function authEnvelope({ harness, authMethod, sessionId, localBaseUrl, proxyToken, proxyBaseUrl, amalgmDir, userId, credentialId, modelId, cliHomePath, authProfileId }) {
+function authEnvelope({ harness, authMethod, sessionId, localBaseUrl, proxyToken, proxyBaseUrl, amalgmDir, userId, credentialId, modelId }) {
   const method = coerceAuth(harness, authMethod);
   const byok = readByokFile(amalgmDir);
   let baseUrl = null;
@@ -166,7 +146,6 @@ function authEnvelope({ harness, authMethod, sessionId, localBaseUrl, proxyToken
   } else if (method === 'provider_auth') {
     tokenFingerprint = providerAuthFingerprint(harness);
   }
-  const profileId = authProfileId || deriveAuthProfileId({ method, harness, userId, tokenFingerprint });
   return {
     method,
     baseUrl,
@@ -176,10 +155,7 @@ function authEnvelope({ harness, authMethod, sessionId, localBaseUrl, proxyToken
     forwardBaseUrl,
     tokenRef,
     tokenFingerprint,
-    authProfileId: profileId,
-    runtimeHome:
-      pinnedRuntimeHome(amalgmDir, cliHomePath)
-      || runtimeHome({ amalgmDir, harness, authProfileId: profileId }),
+    runtimeHome: runtimeHome({ amalgmDir, harness }),
   };
 }
 
@@ -203,6 +179,12 @@ function runtimeEnv(contract, baseEnv = process.env) {
     env.CLAUDE_CONFIG_DIR = contract.auth.runtimeHome;
     env.OPENCODE_HOME = contract.auth.runtimeHome;
     env.OPENCODE_CONFIG_DIR = contract.auth.runtimeHome;
+    if (contract.harness === 'opencode') {
+      env.XDG_CONFIG_HOME = path.join(contract.auth.runtimeHome, '.config');
+      env.XDG_DATA_HOME = path.join(contract.auth.runtimeHome, '.local', 'share');
+      env.XDG_STATE_HOME = path.join(contract.auth.runtimeHome, '.local', 'state');
+      env.XDG_CACHE_HOME = path.join(contract.auth.runtimeHome, '.cache');
+    }
     if (contract.harness === 'claude_code' && contract.authMethod === 'provider_auth') {
       delete env.CLAUDE_CONFIG_DIR;
     }

package/runtime/scripts/chat-core/contract.js

@@ -28,26 +28,31 @@ function canonicalModel(modelId, harness) {
       'haiku': 'anthropic/claude-haiku-4.5',
       'sonnet': 'anthropic/claude-sonnet-4.6',
       'sonnet[1m]': 'anthropic/claude-sonnet-4.6',
-      'opus': 'anthropic/claude-opus-4.7',
-      'opus1m': 'anthropic/claude-opus-4.7-1m',
-      'opus[1m]': 'anthropic/claude-opus-4.7-1m',
+      'opus': 'anthropic/claude-opus-4.8',
+      'opus1m': 'anthropic/claude-opus-4.8-1m',
+      'opus[1m]': 'anthropic/claude-opus-4.8-1m',
       'claude-code-haiku': 'anthropic/claude-haiku-4.5',
       'claude-code-sonnet': 'anthropic/claude-sonnet-4.6',
       'claude-code-sonnet-45': 'anthropic/claude-sonnet-4.6',
-      'claude-code-opus': 'anthropic/claude-opus-4.7',
-      'claude-code-opus-45': 'anthropic/claude-opus-4.7',
-      'claude-code-opus-46': 'anthropic/claude-opus-4.7',
-      'claude-code-opus-47': 'anthropic/claude-opus-4.7',
-      'claude-code-opus-4.5': 'anthropic/claude-opus-4.7',
-      'claude-code-opus-4-5': 'anthropic/claude-opus-4.7',
-      'claude-code-opus-4.6': 'anthropic/claude-opus-4.7',
-      'claude-code-opus-4-6': 'anthropic/claude-opus-4.7',
-      'claude-code-opus-4.7': 'anthropic/claude-opus-4.7',
-      'claude-code-opus-4-7': 'anthropic/claude-opus-4.7',
-      'claude-code-opus1m': 'anthropic/claude-opus-4.7-1m',
-      'claude-code-opus-1m': 'anthropic/claude-opus-4.7-1m',
-      'claude-code-opus-4.7-1m': 'anthropic/claude-opus-4.7-1m',
-      'claude-code-opus-4-7-1m': 'anthropic/claude-opus-4.7-1m',
+      'claude-code-opus': 'anthropic/claude-opus-4.8',
+      'claude-code-opus-45': 'anthropic/claude-opus-4.8',
+      'claude-code-opus-46': 'anthropic/claude-opus-4.8',
+      'claude-code-opus-47': 'anthropic/claude-opus-4.8',
+      'claude-code-opus-48': 'anthropic/claude-opus-4.8',
+      'claude-code-opus-4.5': 'anthropic/claude-opus-4.8',
+      'claude-code-opus-4-5': 'anthropic/claude-opus-4.8',
+      'claude-code-opus-4.6': 'anthropic/claude-opus-4.8',
+      'claude-code-opus-4-6': 'anthropic/claude-opus-4.8',
+      'claude-code-opus-4.7': 'anthropic/claude-opus-4.8',
+      'claude-code-opus-4-7': 'anthropic/claude-opus-4.8',
+      'claude-code-opus-4.8': 'anthropic/claude-opus-4.8',
+      'claude-code-opus-4-8': 'anthropic/claude-opus-4.8',
+      'claude-code-opus1m': 'anthropic/claude-opus-4.8-1m',
+      'claude-code-opus-1m': 'anthropic/claude-opus-4.8-1m',
+      'claude-code-opus-4.8-1m': 'anthropic/claude-opus-4.8-1m',
+      'claude-code-opus-4-8-1m': 'anthropic/claude-opus-4.8-1m',
+      'claude-code-opus-4.7-1m': 'anthropic/claude-opus-4.8-1m',
+      'claude-code-opus-4-7-1m': 'anthropic/claude-opus-4.8-1m',
       'claude-code-sonnet-4.5': 'anthropic/claude-sonnet-4.6',
       'claude-code-sonnet-4-5': 'anthropic/claude-sonnet-4.6',
       'claude-code-sonnet-4.6': 'anthropic/claude-sonnet-4.6',
@@ -57,25 +62,32 @@ function canonicalModel(modelId, harness) {
       'claude-haiku-4-5': 'anthropic/claude-haiku-4.5',
       'claude-sonnet-4-5': 'anthropic/claude-sonnet-4.6',
       'claude-sonnet-4-6': 'anthropic/claude-sonnet-4.6',
-      'claude-opus-4-5': 'anthropic/claude-opus-4.7',
-      'claude-opus-4-6': 'anthropic/claude-opus-4.7',
-      'claude-opus-4-7': 'anthropic/claude-opus-4.7',
-      'claude-opus-4-7-1m': 'anthropic/claude-opus-4.7-1m',
-      'claude-opus-4.7-1m': 'anthropic/claude-opus-4.7-1m',
+      'claude-opus-4-5': 'anthropic/claude-opus-4.8',
+      'claude-opus-4-6': 'anthropic/claude-opus-4.8',
+      'claude-opus-4-7': 'anthropic/claude-opus-4.8',
+      'claude-opus-4-8': 'anthropic/claude-opus-4.8',
+      'claude-opus-4-8-1m': 'anthropic/claude-opus-4.8-1m',
+      'claude-opus-4.8-1m': 'anthropic/claude-opus-4.8-1m',
+      'claude-opus-4-7-1m': 'anthropic/claude-opus-4.8-1m',
+      'claude-opus-4.7-1m': 'anthropic/claude-opus-4.8-1m',
       'anthropic/claude-haiku-4-5': 'anthropic/claude-haiku-4.5',
       'anthropic/claude-haiku-4.5': 'anthropic/claude-haiku-4.5',
       'anthropic/claude-sonnet-4-5': 'anthropic/claude-sonnet-4.6',
       'anthropic/claude-sonnet-4-6': 'anthropic/claude-sonnet-4.6',
       'anthropic/claude-sonnet-4.5': 'anthropic/claude-sonnet-4.6',
       'anthropic/claude-sonnet-4.6': 'anthropic/claude-sonnet-4.6',
-      'anthropic/claude-opus-4-5': 'anthropic/claude-opus-4.7',
-      'anthropic/claude-opus-4-6': 'anthropic/claude-opus-4.7',
-      'anthropic/claude-opus-4-7': 'anthropic/claude-opus-4.7',
-      'anthropic/claude-opus-4-7-1m': 'anthropic/claude-opus-4.7-1m',
-      'anthropic/claude-opus-4.5': 'anthropic/claude-opus-4.7',
-      'anthropic/claude-opus-4.6': 'anthropic/claude-opus-4.7',
-      'anthropic/claude-opus-4.7': 'anthropic/claude-opus-4.7',
-      'anthropic/claude-opus-4.7-1m': 'anthropic/claude-opus-4.7-1m',
+      'anthropic/claude-opus-4-5': 'anthropic/claude-opus-4.8',
+      'anthropic/claude-opus-4-6': 'anthropic/claude-opus-4.8',
+      'anthropic/claude-opus-4-7': 'anthropic/claude-opus-4.8',
+      'anthropic/claude-opus-4-8': 'anthropic/claude-opus-4.8',
+      'anthropic/claude-opus-4-8-1m': 'anthropic/claude-opus-4.8-1m',
+      'anthropic/claude-opus-4-7-1m': 'anthropic/claude-opus-4.8-1m',
+      'anthropic/claude-opus-4.5': 'anthropic/claude-opus-4.8',
+      'anthropic/claude-opus-4.6': 'anthropic/claude-opus-4.8',
+      'anthropic/claude-opus-4.7': 'anthropic/claude-opus-4.8',
+      'anthropic/claude-opus-4.8': 'anthropic/claude-opus-4.8',
+      'anthropic/claude-opus-4.8-1m': 'anthropic/claude-opus-4.8-1m',
+      'anthropic/claude-opus-4.7-1m': 'anthropic/claude-opus-4.8-1m',
     };
     if (aliases[cleaned]) return aliases[cleaned];
     if (cleaned.startsWith('anthropic/')) return cleaned.replace(/-(\d+)-(\d+)(?=$|-)/, '-$1.$2');
@@ -98,6 +110,8 @@ function cliModelFor({ harness, modelId, cliModel, reasoningEffort }) {
     const aliases = {
       'anthropic/claude-haiku-4.5': 'haiku',
       'anthropic/claude-sonnet-4.6': 'sonnet',
+      'anthropic/claude-opus-4.8': 'opus',
+      'anthropic/claude-opus-4.8-1m': 'opus[1m]',
       'anthropic/claude-opus-4.7': 'opus',
       'anthropic/claude-opus-4.7-1m': 'opus[1m]',
       'haiku': 'haiku',
@@ -347,8 +361,6 @@ function createContract(payload, options = {}) {
     userId,
     credentialId: payload.credentialId || payload.byokCredentialId || null,
     modelId,
-    cliHomePath: payload.cliHomePath || payload.cli_home_path || null,
-    authProfileId: payload.authProfileId || payload.auth_profile_id || null,
   });
   const contract = {
     sessionId,

package/runtime/scripts/chat-core/engine.js

@@ -179,7 +179,6 @@ class ChatCore {
         auth: {
           baseUrl: contract.auth.baseUrl,
           tokenFingerprint: contract.auth.tokenFingerprint,
-          authProfileId: contract.auth.authProfileId,
           runtimeHome: contract.auth.runtimeHome,
         },
       },

package/runtime/scripts/chat-core/normalizers/codex.js

@@ -7,8 +7,12 @@ const { normalizeUsage } = require('../usage');
 
 const NON_TOOL_ITEM_TYPES = new Set(['agentMessage', 'contextCompaction', 'reasoning', 'userMessage']);
 
+function codexToolCallId(item = {}) {
+  return item?.id || item?.callId || item?.call_id || item?.toolCallId || item?.tool_call_id;
+}
+
 function isCodexToolItem(item = {}) {
-  return Boolean(item?.id && item?.type && !NON_TOOL_ITEM_TYPES.has(item.type));
+  return Boolean(codexToolCallId(item) && item?.type && !NON_TOOL_ITEM_TYPES.has(item.type));
 }
 
 function codexToolName(item = {}) {
@@ -37,7 +41,10 @@ function codexToolInput(item = {}) {
     if (item[key] !== undefined) input[key] = item[key];
   }
   if (item.input && typeof item.input === 'object') Object.assign(input, item.input);
-  if (item.arguments && typeof item.arguments === 'object') Object.assign(input, item.arguments);
+  const args = parseObjectish(item.arguments);
+  if (args) Object.assign(input, args);
+  const rawInput = parseObjectish(item.rawInput);
+  if (rawInput) Object.assign(input, rawInput);
   if (item.action && typeof item.action === 'object') {
     if (useful(item.action.query) || !useful(input.query)) input.query = item.action.query;
     if (useful(item.action.url) || !useful(input.url)) input.url = item.action.url;
@@ -52,6 +59,18 @@ function useful(value) {
   return value !== undefined && value !== null && value !== '';
 }
 
+function parseObjectish(value) {
+  if (!value) return null;
+  if (typeof value === 'object' && !Array.isArray(value)) return value;
+  if (typeof value !== 'string') return null;
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
 function codexToolOutput(item = {}) {
   if (item.status === 'failed' && item.error) return '';
   const direct = item.aggregatedOutput ?? item.output ?? item.result ?? item.diff ?? item.error ?? item.message ?? item.text ?? item.finalText;
@@ -122,7 +141,7 @@ function codexDelta(msg, p = {}) {
 }
 
 function codexItemId(p = {}) {
-  return p.itemId || p.item?.id || p.id || p.callId || p.toolCallId;
+  return p.itemId || codexToolCallId(p.item) || p.id || p.callId || p.call_id || p.toolCallId || p.tool_call_id;
 }
 
 function codexTokenTotal(value = {}) {
@@ -248,11 +267,12 @@ function normalizeCodexNotification(msg, providerSessionId, state) {
     })];
   }
   if (method === 'item/started' && isCodexToolItem(p.item)) {
+    const toolCallId = codexToolCallId(p.item);
     const toolName = codexToolName(p.item);
     const input = codexToolInput(p.item);
     const detail = codexToolDetail(p.item);
     const metadata = codexToolMetadata(p.item);
-    return [toolStarted(p.item.id, {
+    return [toolStarted(toolCallId, {
       providerSessionId,
       toolName,
       title: codexToolTitle(p.item),
@@ -265,10 +285,11 @@ function normalizeCodexNotification(msg, providerSessionId, state) {
     })];
   }
   if (method === 'item/updated' && isCodexToolItem(p.item)) {
+    const toolCallId = codexToolCallId(p.item);
     const input = codexToolInput(p.item);
     const toolName = codexToolName(p.item);
     const metadata = codexToolMetadata(p.item);
-    return [toolUpdated(p.item.id, {
+    return [toolUpdated(toolCallId, {
       providerSessionId,
       toolName,
       title: codexToolTitle(p.item),
@@ -282,13 +303,14 @@ function normalizeCodexNotification(msg, providerSessionId, state) {
     })];
   }
   if (method === 'item/completed' && isCodexToolItem(p.item)) {
+    const toolCallId = codexToolCallId(p.item);
     const toolName = codexToolName(p.item);
     const input = codexToolInput(p.item);
     const output = codexToolOutput(p.item);
     const error = codexToolError(p.item);
     const metadata = codexToolMetadata(p.item);
     const detail = codexToolDetail(p.item);
-    return [toolCompleted(p.item.id, {
+    return [toolCompleted(toolCallId, {
       providerSessionId,
       toolName,
       title: codexToolTitle(p.item),
@@ -384,6 +406,7 @@ module.exports = {
   codexToolInput,
   codexToolDetail,
   codexToolError,
+  codexToolCallId,
   codexToolName,
   codexToolOutput,
   codexToolTitle,

package/runtime/scripts/chat-core/parts.js

@@ -24,6 +24,8 @@ function toToolPartType(name) {
     agent: 'task',
     task: 'task',
     askuserquestion: 'question',
+    toolsearch: 'toolSearch',
+    toolsearchtool: 'toolSearch',
   };
   return `tool-${aliases[clean] || clean}`;
 }

package/runtime/scripts/chat-core/tests/auth.test.js

@@ -1,37 +1,54 @@
 'use strict';
 
 const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
 const test = require('node:test');
 const { authEnvelope, runtimeEnv } = require('../auth');
 
-test('amalgm auth uses a pinned CLI home across sessions and proxy token refreshes', () => {
-  const first = authEnvelope({
-    harness: 'codex',
-    authMethod: 'amalgm',
-    sessionId: 'session-one',
-    proxyToken: 'proxy-token-one',
-    localBaseUrl: 'http://127.0.0.1:8084',
-    proxyBaseUrl: 'https://proxy.example.test',
-    amalgmDir: '/tmp/amalgm-test',
-    userId: 'user-123',
-  });
-  const second = authEnvelope({
-    harness: 'codex',
-    authMethod: 'amalgm',
-    sessionId: 'session-two',
-    proxyToken: 'proxy-token-two',
-    localBaseUrl: 'http://127.0.0.1:8084',
-    proxyBaseUrl: 'https://proxy.example.test',
-    amalgmDir: '/tmp/amalgm-test',
-    userId: 'user-123',
-  });
+test('codex always uses one canonical CLI home across auth methods and token refreshes', () => {
+  const amalgmDir = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-auth-test-'));
+  fs.writeFileSync(path.join(amalgmDir, '.amalgm-credentials'), 'OPENAI_API_KEY=sk-test\n');
+  try {
+    const first = authEnvelope({
+      harness: 'codex',
+      authMethod: 'amalgm',
+      sessionId: 'session-one',
+      proxyToken: 'proxy-token-one',
+      localBaseUrl: 'http://127.0.0.1:8084',
+      proxyBaseUrl: 'https://proxy.example.test',
+      amalgmDir,
+      userId: 'user-123',
+    });
+    const second = authEnvelope({
+      harness: 'codex',
+      authMethod: 'provider_auth',
+      sessionId: 'session-two',
+      proxyToken: 'proxy-token-two',
+      localBaseUrl: 'http://127.0.0.1:8084',
+      proxyBaseUrl: 'https://proxy.example.test',
+      amalgmDir,
+      userId: 'user-123',
+    });
+    const third = authEnvelope({
+      harness: 'codex',
+      authMethod: 'byok',
+      sessionId: 'session-three',
+      amalgmDir,
+      userId: 'user-123',
+    });
 
-  assert.notEqual(first.tokenFingerprint, second.tokenFingerprint);
-  assert.equal(first.runtimeHome, second.runtimeHome);
-  assert.match(first.runtimeHome, /\/tmp\/amalgm-test\/cli-homes\/codex\/amalgm-[0-9a-f]{16}$/);
+    assert.notEqual(first.tokenFingerprint, second.tokenFingerprint);
+    assert.equal(first.runtimeHome, second.runtimeHome);
+    assert.equal(second.runtimeHome, third.runtimeHome);
+    assert.equal(first.runtimeHome, path.join(amalgmDir, 'cli-homes', 'codex', 'home'));
+  } finally {
+    fs.rmSync(amalgmDir, { recursive: true, force: true });
+  }
 });
 
-test('opencode amalgm auth uses a pinned CLI home across sessions and proxy token refreshes', () => {
+test('opencode always uses one canonical CLI home across auth methods and token refreshes', () => {
   const first = authEnvelope({
     harness: 'opencode',
     authMethod: 'amalgm',
@@ -44,7 +61,7 @@ test('opencode amalgm auth uses a pinned CLI home across sessions and proxy toke
   });
   const second = authEnvelope({
     harness: 'opencode',
-    authMethod: 'amalgm',
+    authMethod: 'provider_auth',
     sessionId: 'session-two',
     proxyToken: 'proxy-token-two',
     localBaseUrl: 'http://127.0.0.1:8084',
@@ -56,13 +73,15 @@ test('opencode amalgm auth uses a pinned CLI home across sessions and proxy toke
 
   assert.notEqual(first.tokenFingerprint, second.tokenFingerprint);
   assert.equal(first.runtimeHome, second.runtimeHome);
-  assert.match(first.runtimeHome, /\/tmp\/amalgm-test\/cli-homes\/opencode\/amalgm-[0-9a-f]{16}$/);
+  assert.equal(first.runtimeHome, '/tmp/amalgm-test/cli-homes/opencode/home');
   assert.equal(env.HOME, first.runtimeHome);
   assert.equal(env.OPENCODE_HOME, first.runtimeHome);
   assert.equal(env.OPENCODE_CONFIG_DIR, first.runtimeHome);
+  assert.equal(env.XDG_CONFIG_HOME, '/tmp/amalgm-test/cli-homes/opencode/home/.config');
+  assert.equal(env.XDG_DATA_HOME, '/tmp/amalgm-test/cli-homes/opencode/home/.local/share');
 });
 
-test('claude provider auth uses a pinned CLI home with native config copied separately', () => {
+test('claude always uses one canonical CLI home', () => {
   const envelope = authEnvelope({
     harness: 'claude_code',
     authMethod: 'provider_auth',
@@ -70,7 +89,7 @@ test('claude provider auth uses a pinned CLI home with native config copied sepa
     amalgmDir: '/tmp/amalgm-test',
   });
 
-  assert.match(envelope.runtimeHome, /\/tmp\/amalgm-test\/cli-homes\/claude_code\/provider-[0-9a-f]{16}$/);
+  assert.equal(envelope.runtimeHome, '/tmp/amalgm-test/cli-homes/claude_code/home');
 
   const env = runtimeEnv({
     harness: 'claude_code',
@@ -88,19 +107,7 @@ test('claude provider auth uses a pinned CLI home with native config copied sepa
   assert.equal(env.ANTHROPIC_API_KEY, undefined);
 });
 
-test('codex provider auth uses a pinned provider home', () => {
-  const envelope = authEnvelope({
-    harness: 'codex',
-    authMethod: 'provider_auth',
-    sessionId: 'session-test',
-    amalgmDir: '/tmp/amalgm-test',
-  });
-
-  assert.match(envelope.runtimeHome, /\/tmp\/amalgm-test\/cli-homes\/codex\/provider-[0-9a-f]{16}$/);
-  assert.equal(envelope.runtimeHome.includes('/runtime/session-test/'), false);
-});
-
-test('stored CLI home path wins over derived path', () => {
+test('provided CLI home path cannot move an agent off its canonical home', () => {
   const envelope = authEnvelope({
     harness: 'codex',
     authMethod: 'amalgm',
@@ -114,6 +121,5 @@ test('stored CLI home path wins over derived path', () => {
     authProfileId: 'manual-profile',
   });
 
-  assert.equal(envelope.authProfileId, 'manual-profile');
-  assert.equal(envelope.runtimeHome, '/tmp/amalgm-test/cli-homes/codex/manual-profile');
+  assert.equal(envelope.runtimeHome, '/tmp/amalgm-test/cli-homes/codex/home');
 });

package/runtime/scripts/chat-core/tests/engine.test.js

@@ -14,7 +14,7 @@ function payload(overrides = {}) {
     userId: 'user-test',
     agentId: 'claude_code',
     authMethod: 'amalgm',
-    modelId: 'anthropic/claude-opus-4.7',
+    modelId: 'anthropic/claude-opus-4.8',
     cwd: process.cwd(),
     prompt: 'hello',
     proxyToken: 'proxy-token',

package/runtime/scripts/chat-core/tests/native-binaries.test.js

@@ -0,0 +1,126 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const { spawnSync } = require('node:child_process');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const test = require('node:test');
+const nativeBinaries = require('../tooling/native-binaries');
+
+function packagePath(root, packageName) {
+  return path.join(root, ...String(packageName).split('/'));
+}
+
+function writePackage(root, packageName) {
+  fs.mkdirSync(root, { recursive: true });
+  fs.writeFileSync(path.join(root, 'package.json'), `${JSON.stringify({ name: packageName, version: '0.0.0' }, null, 2)}\n`);
+}
+
+function writeExecutable(file) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  if (process.platform === 'win32') {
+    fs.writeFileSync(file, '@echo off\r\nexit /b 0\r\n');
+  } else {
+    fs.writeFileSync(file, '#!/bin/sh\nexit 0\n');
+    fs.chmodSync(file, 0o755);
+  }
+}
+
+function installFakePackagedAgentDeps(resourcesPath) {
+  const nodeModules = path.join(resourcesPath, 'app.asar.unpacked', 'node_modules');
+  const claudePackage = nativeBinaries.__private.claudeTargetPackage();
+  const codexTarget = nativeBinaries.__private.codexTarget();
+  const openCodePackage = nativeBinaries.__private.openCodePackageCandidates()[0];
+  assert.ok(claudePackage, 'current platform should have a Claude native package');
+  assert.ok(codexTarget, 'current platform should have a Codex native package');
+  assert.ok(openCodePackage, 'current platform should have an OpenCode native package');
+
+  writePackage(path.join(nodeModules, '@anthropic-ai', 'claude-agent-sdk'), '@anthropic-ai/claude-agent-sdk');
+  writePackage(path.join(nodeModules, '@openai', 'codex'), '@openai/codex');
+  writePackage(path.join(nodeModules, 'opencode-ai'), 'opencode-ai');
+
+  const claudeRoot = packagePath(
+    path.join(nodeModules, '@anthropic-ai', 'claude-agent-sdk', 'node_modules'),
+    claudePackage,
+  );
+  writePackage(claudeRoot, claudePackage);
+  const claude = path.join(claudeRoot, process.platform === 'win32' ? 'claude.exe' : 'claude');
+  writeExecutable(claude);
+
+  const codexRoot = packagePath(
+    path.join(nodeModules, '@openai', 'codex', 'node_modules'),
+    codexTarget.packageName,
+  );
+  writePackage(codexRoot, codexTarget.packageName);
+  const codex = path.join(codexRoot, 'vendor', codexTarget.triple, 'codex', codexTarget.binaryName);
+  writeExecutable(codex);
+
+  const openCodeRoot = packagePath(
+    path.join(nodeModules, 'opencode-ai', 'node_modules'),
+    openCodePackage,
+  );
+  writePackage(openCodeRoot, openCodePackage);
+  const opencode = path.join(openCodeRoot, 'bin', process.platform === 'win32' ? 'opencode.exe' : 'opencode');
+  writeExecutable(opencode);
+
+  return { claude, codex, opencode };
+}
+
+function withFakePackagedResources(fn) {
+  const previousResourcesPath = Object.getOwnPropertyDescriptor(process, 'resourcesPath');
+  const previousEnv = {
+    AMALGM_AGENT_BIN_DIR: process.env.AMALGM_AGENT_BIN_DIR,
+    AMALGM_NATIVE_NODE_MODULES: process.env.AMALGM_NATIVE_NODE_MODULES,
+    CLAUDE_CODE_BINARY: process.env.CLAUDE_CODE_BINARY,
+    PATH: process.env.PATH,
+  };
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-native-binaries-'));
+  const resourcesPath = path.join(root, 'resources');
+  const binDir = path.join(root, 'bin');
+  try {
+    Object.defineProperty(process, 'resourcesPath', {
+      value: resourcesPath,
+      configurable: true,
+    });
+    process.env.AMALGM_AGENT_BIN_DIR = binDir;
+    process.env.PATH = '';
+    delete process.env.AMALGM_NATIVE_NODE_MODULES;
+    delete process.env.CLAUDE_CODE_BINARY;
+    return fn({ root, resourcesPath, binDir });
+  } finally {
+    if (previousResourcesPath) {
+      Object.defineProperty(process, 'resourcesPath', previousResourcesPath);
+    } else {
+      delete process.resourcesPath;
+    }
+    for (const [key, value] of Object.entries(previousEnv)) {
+      if (value === undefined) delete process.env[key];
+      else process.env[key] = value;
+    }
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+
+test('packaged nested agent dependencies resolve to exact executable paths and spawnable shims', () => {
+  withFakePackagedResources(({ resourcesPath, binDir }) => {
+    const expected = installFakePackagedAgentDeps(resourcesPath);
+
+    assert.equal(nativeBinaries.__private.bundledClaudeBinary(), expected.claude);
+    assert.equal(nativeBinaries.bundledCodexBinary(), expected.codex);
+    assert.equal(nativeBinaries.bundledOpenCodeBinary(), expected.opencode);
+
+    const result = nativeBinaries.ensureAgentCommandShims({ quiet: true, logger: { log() {} } });
+    assert.equal(result.ok, true);
+    for (const command of ['claude', 'codex', 'opencode']) {
+      const shim = path.join(binDir, process.platform === 'win32' ? `${command}.cmd` : command);
+      assert.equal(fs.existsSync(shim), true);
+      const spawned = spawnSync(shim, ['--smoke'], {
+        stdio: 'ignore',
+        shell: process.platform === 'win32',
+        windowsHide: true,
+      });
+      assert.equal(spawned.status, 0, `${command} shim should spawn`);
+    }
+  });
+});