@amalgm/chat 0.2.2 → 0.2.3

package/docs/contracts/input-and-execution.md

@@ -34,9 +34,10 @@ discovery and resolution; start and send consume its result.
    defaults or fallback auth modes.
 4. A model is identified by `(agent revision, provider id, model id)`. Model
    settings are ACP session-config selections scoped inside that model choice.
-5. Ordinary tools and MCP tools are selected through one immutable toolset
-   revision. `amalgm-tools` resolves that revision to the complete official ACP
-   MCP server configuration during preparation; Chat adds no ambient server.
+5. Ordinary tools and MCP tools are selected through one immutable deployment-
+   head revision, never a local SQLite sequence. `amalgm-tools` resolves that
+   exact revision to the complete official ACP `McpServer[]` configuration
+   during preparation; Chat adds no ambient server or latest-version fallback.
 6. Secrets are not execution-contract values. Auth names an opaque binding; the
    authorized host resolves secrets into the opaque prepared binding.
 7. A cwd is an absolute, already-materialized path on the selected computer. A
@@ -57,6 +58,10 @@ discovery and resolution; start and send consume its result.
     before prompting. No adapter may silently ignore an attachment, auth mode,
     tool, permission mode, model setting, provider/model choice, cwd, agent
     revision, or computer placement.
+13. Machine, project, and exact Agent-revision instructions compose once during
+    preparation. They are not prompt parts. Native adapters use a real
+    system/developer channel; ACP agents must advertise the `amalgm.dev`
+    session-instructions extension.
 
 ## Public path
 

package/host/adapters/acp-capabilities.js

@@ -1,5 +1,7 @@
 import { UnsupportedExecutionInputError } from './input-capabilities.js';
 
+export const AMALGM_ACP_META_KEY = 'amalgm.dev';
+
 /** Validate optional ACP inputs against the capabilities negotiated at initialize. */
 export function assertAcpMcpCapabilities(adapterId, capabilities, servers) {
   const mcp = capabilities?.mcpCapabilities || {};
@@ -28,3 +30,33 @@ export function assertAcpPromptCapabilities(adapterId, capabilities, prompt) {
     }
   }
 }
+
+/**
+ * ACP v1 has no system-prompt field. Apply instructions only through the
+ * advertised Amalgm lifecycle extension; never turn them into prompt content.
+ */
+export function acpSessionParams(adapterId, capabilities, contract, mcpServers) {
+  const instructions = contract?.instructions || { text: '', revisionId: null };
+  const text = String(instructions.text || '').trim();
+  if (!text) return { cwd: contract.cwd, mcpServers };
+  const extension = capabilities?._meta?.[AMALGM_ACP_META_KEY];
+  if (extension?.sessionInstructions !== true) {
+    throw new UnsupportedExecutionInputError(
+      adapterId,
+      'instructions',
+      `agent does not advertise the ACP ${AMALGM_ACP_META_KEY} sessionInstructions extension`,
+    );
+  }
+  return {
+    cwd: contract.cwd,
+    mcpServers,
+    _meta: {
+      [AMALGM_ACP_META_KEY]: {
+        sessionInstructions: {
+          revisionId: instructions.revisionId,
+          text,
+        },
+      },
+    },
+  };
+}

package/host/adapters/acp.js

@@ -3,10 +3,13 @@
 import { PROTOCOL_VERSION } from '@agentclientprotocol/sdk';
 import { toAcpMcpServers } from '../tooling/mcp-bundle.js';
 import { prepareHarnessRuntime } from '../tooling/runtime-home.js';
-import { composeSystemPrompt } from '../tooling/system-prompt.js';
 import { requestPermission } from '../permissions.js';
 import { AcpClient } from './acp-client.js';
-import { assertAcpMcpCapabilities, assertAcpPromptCapabilities } from './acp-capabilities.js';
+import {
+  acpSessionParams,
+  assertAcpMcpCapabilities,
+  assertAcpPromptCapabilities,
+} from './acp-capabilities.js';
 import { nativeInputCapabilities, UnsupportedExecutionInputError } from './input-capabilities.js';
 import { acpPromptParts } from './prompt.js';
 
@@ -125,6 +128,7 @@ export class AcpAdapter {
       authModes: ['platform', 'subscription', 'byok'],
       modelSettings: 'negotiated',
       tools: true,
+      instructions: 'acp_extension',
     });
   }
 
@@ -149,7 +153,6 @@ export class AcpAdapter {
       client,
       capabilities: {},
       permissionMode: contract.permissionMode,
-      needsSystemPrompt: false,
       activePrompt: false,
     };
     client.onRequest((method, params) => this.handleRequest(session, method, params));
@@ -170,7 +173,7 @@ export class AcpAdapter {
 
     const mcpServers = toAcpMcpServers(contract);
     assertAcpMcpCapabilities('acp', session.capabilities, mcpServers);
-    const sessionParams = { cwd: contract.cwd, mcpServers };
+    const sessionParams = acpSessionParams('acp', session.capabilities, contract, mcpServers);
     let response;
     if (session.providerSessionId) {
       if (session.capabilities.loadSession === true) {
@@ -189,7 +192,6 @@ export class AcpAdapter {
     } else {
       response = await client.request('session/new', sessionParams, 600000);
       session.providerSessionId = response?.sessionId || null;
-      session.needsSystemPrompt = true;
     }
     if (!session.providerSessionId) throw new Error('ACP agent did not return a sessionId');
     await applyConfiguration(client, session.providerSessionId, response, contract, launch);
@@ -244,16 +246,10 @@ export class AcpAdapter {
       if (message.params?.update) queue.push(message.params.update);
       wakeLoop();
     });
-    let preamble = '';
-    if (session.needsSystemPrompt) {
-      const systemPrompt = composeSystemPrompt(contract);
-      if (systemPrompt) preamble = `<system-instructions>\n${systemPrompt}\n</system-instructions>`;
-      session.needsSystemPrompt = false;
-    }
     session.activePrompt = true;
     session.client.request('session/prompt', {
       sessionId: session.providerSessionId,
-      prompt: acpPromptParts(prompt, preamble),
+      prompt: acpPromptParts(prompt),
     }, 0).then(() => {
       finished = true;
       wakeLoop();

package/host/adapters/claude.js

@@ -21,7 +21,7 @@ import { toClaudeMcpServers } from '../tooling/mcp-bundle.js';
 import { bundledClaudeBinary } from '../tooling/native-binaries.js';
 import { importPackage } from '../tooling/package-import.js';
 import { prepareHarnessRuntime } from '../tooling/runtime-home.js';
-import { composeSystemPrompt } from '../tooling/system-prompt.js';
+import { preparedSystemPrompt } from '../tooling/system-prompt.js';
 import { allowed, requestPermission } from '../permissions.js';
 import {
   COMMON_REASONING_SETTINGS,
@@ -55,6 +55,7 @@ class ClaudeAdapter {
       authModes: ['platform', 'subscription', 'byok'],
       modelSettings: [...COMMON_REASONING_SETTINGS, ...COMMON_SPEED_SETTINGS],
       tools: true,
+      instructions: 'native',
     });
   }
 
@@ -70,7 +71,7 @@ class ClaudeAdapter {
 
   options(contract, extra = {}) {
     const runtime = prepareHarnessRuntime(contract);
-    const systemPrompt = composeSystemPrompt(contract);
+    const systemPrompt = preparedSystemPrompt(contract);
     const pathToClaudeCodeExecutable = process.env.CLAUDE_CODE_BINARY || bundledClaudeBinary();
     const settings = {
       ...this.renderers.toClaudeSettings(contract.agentConfig),

package/host/adapters/codex.js

@@ -17,11 +17,11 @@ import path from 'node:path';
 import { createEventConstructors } from '../../dist/events/index.js';
 import { codexErrorMessage, createCodexNormalizer } from '../../dist/normalizers/codex.js';
 import { recordNativeEvent } from '../recorder.js';
-import { relayedMcpServers, toCodexMcpToml } from '../tooling/mcp-bundle.js';
+import { codexMcpSectionName, relayedMcpServers, toCodexMcpToml } from '../tooling/mcp-bundle.js';
 import { bundledCodexBinary, bundledCodexPathDirs, executableExists, findOnPath } from '../tooling/native-binaries.js';
 import { syncCodexProviderAuth } from '../tooling/native-config.js';
 import { prepareHarnessRuntime } from '../tooling/runtime-home.js';
-import { composeSystemPrompt } from '../tooling/system-prompt.js';
+import { preparedSystemPrompt } from '../tooling/system-prompt.js';
 import { requestPermission } from '../permissions.js';
 import {
   COMMON_REASONING_SETTINGS,
@@ -447,7 +447,7 @@ function generatedCodexHookTrust(contract, renderers = defaultRenderers) {
 }
 
 function generatedMcpSectionNames(contract) {
-  return relayedMcpServers(contract).map((server) => `mcp_servers.${server.name}`);
+  return relayedMcpServers(contract).map((server) => codexMcpSectionName(server.name));
 }
 
 function buildCodexConfig(contract, existingConfig, syncInfo, renderers = defaultRenderers) {
@@ -524,6 +524,7 @@ class CodexAdapter {
       authModes: ['platform', 'subscription', 'byok'],
       modelSettings: [...COMMON_REASONING_SETTINGS, ...COMMON_SPEED_SETTINGS],
       tools: true,
+      instructions: 'native',
     });
   }
 
@@ -541,7 +542,7 @@ class CodexAdapter {
       sandbox: fullAccess ? 'danger-full-access' : 'workspace-write',
       modelProvider: contract.authMethod === 'amalgm' ? 'amalgm' : 'openai',
       serviceTier: serviceTierForContract(contract),
-      developerInstructions: composeSystemPrompt(contract) || null,
+      developerInstructions: preparedSystemPrompt(contract) || null,
       persistExtendedHistory: true,
     };
     const session = {
@@ -571,6 +572,7 @@ class CodexAdapter {
       'item/commandExecution/requestApproval',
       'item/fileChange/requestApproval',
       'item/permissions/requestApproval',
+      'mcpServer/elicitation/request',
       'execCommandApproval',
       'applyPatchApproval',
     ]);
@@ -580,8 +582,12 @@ class CodexAdapter {
       : await requestPermission(this.permissionPort, {
           adapterId: 'codex',
           providerSessionId: session.providerSessionId,
-          kind: method.includes('fileChange') || method === 'applyPatchApproval' ? 'file_change' : 'command',
-          title: params.reason || params.command || 'Codex requests permission',
+          kind: method === 'mcpServer/elicitation/request'
+            ? 'mcp_tool'
+            : method.includes('fileChange') || method === 'applyPatchApproval'
+              ? 'file_change'
+              : 'command',
+          title: params.message || params.reason || params.command || 'Codex requests permission',
           input: params,
         });
     const allow = decision.outcome === 'allow_once' || decision.outcome === 'allow_always';
@@ -603,6 +609,13 @@ class CodexAdapter {
         scope: always ? 'session' : 'turn',
       };
     }
+    if (method === 'mcpServer/elicitation/request') {
+      return {
+        action: allow ? 'accept' : decision.outcome === 'cancel' ? 'cancel' : 'decline',
+        content: allow ? decision.updatedInput || null : null,
+        _meta: null,
+      };
+    }
     return {
       decision: allow
         ? (always ? 'approved_for_session' : 'approved')

package/host/adapters/cursor.js

@@ -1,7 +1,7 @@
 // Cursor Agent Client Protocol adapter. The generic ACP transport lives in
 // ./acp-client.js; this file is the
 // cursor parameterization (binary resolution, model translation, permission
-// auto-grant, first-prompt system preamble).
+// handling, and ACP lifecycle inputs).
 //
 // Laws come from ../../dist: event constructors via `createEventConstructors`,
 // the normalizer via `createCursorNormalizer`, `cursorStopReason`, and
@@ -16,10 +16,13 @@ import { recordNativeEvent } from '../recorder.js';
 import { toAcpMcpServers } from '../tooling/mcp-bundle.js';
 import { executableExists, findOnPath } from '../tooling/native-binaries.js';
 import { prepareHarnessRuntime } from '../tooling/runtime-home.js';
-import { composeSystemPrompt } from '../tooling/system-prompt.js';
 import { requestPermission } from '../permissions.js';
 import { AcpClient } from './acp-client.js';
-import { assertAcpMcpCapabilities, assertAcpPromptCapabilities } from './acp-capabilities.js';
+import {
+  acpSessionParams,
+  assertAcpMcpCapabilities,
+  assertAcpPromptCapabilities,
+} from './acp-capabilities.js';
 import {
   COMMON_REASONING_SETTINGS,
   COMMON_SPEED_SETTINGS,
@@ -140,6 +143,7 @@ class CursorAdapter {
       authModes: ['subscription', 'byok'],
       modelSettings: [...COMMON_REASONING_SETTINGS, ...COMMON_SPEED_SETTINGS],
       tools: true,
+      instructions: 'acp_extension',
     });
   }
 
@@ -157,7 +161,6 @@ class CursorAdapter {
       sessionId: contract.sessionId,
       providerSessionId: contract.providerSessionId || null,
       client,
-      needsSystemPrompt: false,
       modelWarning: null,
       activePrompt: null,
       cancelRequested: false,
@@ -173,7 +176,7 @@ class CursorAdapter {
     session.capabilities = initialized?.agentCapabilities || {};
     const mcpServers = toAcpMcpServers(contract);
     assertAcpMcpCapabilities('cursor', session.capabilities, mcpServers);
-    const sessionParams = { cwd: contract.cwd, mcpServers };
+    const sessionParams = acpSessionParams('cursor', session.capabilities, contract, mcpServers);
     let acpSession = null;
     if (session.providerSessionId) {
       // session/load replays history as session/update notifications; nothing is
@@ -189,7 +192,6 @@ class CursorAdapter {
     if (!acpSession) {
       acpSession = await client.request('session/new', sessionParams);
       session.providerSessionId = acpSession.sessionId;
-      session.needsSystemPrompt = true;
     }
     await this.selectModel(session, acpSession, contract);
     return session;
@@ -296,17 +298,9 @@ class CursorAdapter {
       });
       for (const e of normalizeCursorUpdate(params.update || {}, state)) push(e);
     });
-    let preamble = '';
-    if (session.needsSystemPrompt) {
-      // ACP has no system-prompt slot; a fresh native session gets the composed
-      // instructions as a preamble on its first prompt only.
-      const systemPrompt = composeSystemPrompt(contract);
-      if (systemPrompt) preamble = `<system-instructions>\n${systemPrompt}\n</system-instructions>`;
-      session.needsSystemPrompt = false;
-    }
     session.client.request('session/prompt', {
       sessionId: session.providerSessionId,
-      prompt: acpPromptParts(input, preamble),
+      prompt: acpPromptParts(input),
     }, 0).then((result) => {
       recordNativeEvent('cursor.acp.prompt_result', result, {
         providerSessionId: session.providerSessionId,

package/host/adapters/input-capabilities.js

@@ -29,6 +29,7 @@ export function nativeInputCapabilities(input = {}) {
       ? 'negotiated'
       : Object.freeze([...(input.modelSettings || [])]),
     tools: input.tools === true,
+    instructions: input.instructions || 'unsupported',
     permissionModes: Object.freeze([...(input.permissionModes || ['ask', 'full_access'])]),
   });
 }

package/host/adapters/opencode.js

@@ -12,7 +12,7 @@ import { toOpenCodeMcpConfig } from '../tooling/mcp-bundle.js';
 import { bundledOpenCodeBinary, executableExists, findOnPath } from '../tooling/native-binaries.js';
 import { importPackage } from '../tooling/package-import.js';
 import { prepareHarnessRuntime } from '../tooling/runtime-home.js';
-import { composeSystemPrompt } from '../tooling/system-prompt.js';
+import { preparedSystemPrompt } from '../tooling/system-prompt.js';
 import { requestPermission } from '../permissions.js';
 import { nativeInputCapabilities, UnsupportedExecutionInputError } from './input-capabilities.js';
 import { openCodePromptParts } from './prompt.js';
@@ -58,7 +58,7 @@ function selectedVariant(contract) {
 function configFor(contract) {
   const model = splitModel(contract.cliModel || contract.usageModelId, contract.auth);
   const variant = selectedVariant(contract);
-  const systemPrompt = composeSystemPrompt(contract);
+  const systemPrompt = preparedSystemPrompt(contract);
   const permission = contract.permissionMode === 'full_access' ? 'allow' : 'ask';
   const config = {
     logLevel: process.env.OPENCODE_LOG_LEVEL || 'ERROR',
@@ -241,6 +241,7 @@ class OpenCodeAdapter {
       authModes: ['platform', 'subscription', 'byok'],
       modelSettings: ['variant'],
       tools: true,
+      instructions: 'native',
     });
   }
 
@@ -423,7 +424,7 @@ class OpenCodeAdapter {
             model,
             ...(variant ? { variant } : {}),
             agent: process.env.AMALGM_CHAT_OPENCODE_AGENT || 'build',
-            system: composeSystemPrompt(contract) || undefined,
+            system: preparedSystemPrompt(contract) || undefined,
             parts: openCodePromptParts(input),
           },
         });

package/host/adapters/pi.js

@@ -15,7 +15,7 @@ import { recordNativeEvent } from '../recorder.js';
 import { relayedMcpServers } from '../tooling/mcp-bundle.js';
 import { executableExists, findOnPath } from '../tooling/native-binaries.js';
 import { prepareHarnessRuntime } from '../tooling/runtime-home.js';
-import { composeSystemPrompt } from '../tooling/system-prompt.js';
+import { preparedSystemPrompt } from '../tooling/system-prompt.js';
 import {
   COMMON_REASONING_SETTINGS,
   nativeInputCapabilities,
@@ -344,7 +344,7 @@ function buildArgs(contract, runtimeHome) {
   const args = ['--mode', 'rpc', '--provider', provider, '--model', piModel(contract, provider)];
   const thinking = thinkingLevelFor(contract);
   if (thinking) args.push('--thinking', thinking);
-  const systemPrompt = composeSystemPrompt(contract);
+  const systemPrompt = preparedSystemPrompt(contract);
   if (systemPrompt) args.push('--system-prompt', systemPrompt);
   if (contract.providerSessionId) args.push('--session', contract.providerSessionId);
   if (contract.authMethod === 'amalgm') args.push('--extension', ensureEgressExtension(runtimeHome));
@@ -362,6 +362,7 @@ class PiAdapter {
       authModes: ['platform', 'subscription', 'byok'],
       modelSettings: COMMON_REASONING_SETTINGS,
       tools: true,
+      instructions: 'native',
     });
   }
 

package/host/adapters/prompt.js

@@ -56,9 +56,8 @@ function textProjection(part) {
   return null;
 }
 
-export function acpPromptParts(prompt, preamble = '') {
-  const parts = prompt.parts.map((part) => structuredClone(part));
-  return preamble ? [{ type: 'text', text: preamble }, ...parts] : parts;
+export function acpPromptParts(prompt) {
+  return prompt.parts.map((part) => structuredClone(part));
 }
 
 export function codexPromptInput(prompt) {

package/host/auth.js

@@ -230,7 +230,7 @@ export function runtimeEnv(contract, baseEnv = process.env) {
     }
   }
   env.IS_SANDBOX = '1';
-  if (baseEnv.AMALGM_RUNTIME_TOKEN) env.AMALGM_RUNTIME_TOKEN = baseEnv.AMALGM_RUNTIME_TOKEN;
+  if (contract.runtimeToken) env.AMALGM_RUNTIME_TOKEN = contract.runtimeToken;
   if (contract.authMethod === 'amalgm' || contract.authMethod === 'byok') {
     if (contract.harness === 'claude_code') {
       if (contract.authMethod === 'amalgm') {

package/host/http.d.ts

@@ -14,6 +14,10 @@ export interface ChatHttpHandlerOptions<Binding = unknown, RuntimeSession = unkn
     readonly serverName: string;
     readonly search: string;
   }>;
+  readonly generateTitle?: (input: Readonly<{
+    readonly conversationId: string;
+    readonly message: string;
+  }>) => AsyncIterable<string>;
 }
 
 export type ChatAuxiliaryHandler<Input> = (

package/host/http.js

@@ -1,3 +1,5 @@
+import { normalizeGeneratedTitle, titleMessageExcerpt } from './title-generator.js';
+
 const JSON_HEADERS = Object.freeze({
   'content-type': 'application/json; charset=utf-8',
   'cache-control': 'no-store',
@@ -100,6 +102,29 @@ async function streamTurn(response, updates, completion) {
   }
 }
 
+async function streamGeneratedTitle(response, chunks, persist) {
+  response.writeHead(200, {
+    'content-type': 'text/plain; charset=utf-8',
+    'cache-control': 'no-store',
+  });
+  response.flushHeaders?.();
+  let generated = '';
+  let streamed = '';
+  for await (const chunk of chunks) {
+    if (typeof chunk !== 'string' || !chunk) continue;
+    generated += chunk;
+    const title = normalizeGeneratedTitle(generated);
+    if (title.startsWith(streamed)) {
+      const addition = title.slice(streamed.length);
+      if (addition && !response.destroyed) response.write(addition);
+      streamed = title;
+    }
+  }
+  const title = normalizeGeneratedTitle(generated);
+  if (title) await persist(title);
+  if (!response.destroyed) response.end();
+}
+
 /** Node HTTP adapter over the public Chat capability. */
 export function createChatHttpHandler(options) {
   if (!options?.chat) throw new TypeError('createChatHttpHandler requires chat');
@@ -189,6 +214,24 @@ export function createChatHttpHandler(options) {
         await streamTurn(response, stream, stream.completion);
         return true;
       }
+      if (method === 'POST' && path[2] === 'title' && path.length === 3) {
+        if (typeof options.generateTitle !== 'function') {
+          sendJson(response, 501, errorBody(Object.assign(new Error('Title generation is not configured'), {
+            code: 'TITLE_GENERATION_NOT_CONFIGURED',
+          })));
+          return true;
+        }
+        const body = await readJson(request, bodyLimit);
+        const message = titleMessageExcerpt(body.message);
+        if (!message.trim()) throw Object.assign(new Error('message is required'), { code: 'INVALID_REQUEST' });
+        await chat.inspectSession(conversationId);
+        await streamGeneratedTitle(
+          response,
+          options.generateTitle({ conversationId, message }),
+          (title) => chat.updateTitle(conversationId, title),
+        );
+        return true;
+      }
       if (method === 'GET' && path[2] === 'turns' && path[3] && path[4] === 'events') {
         const after = Number(url.searchParams.get('afterSequence') || request.headers['last-event-id'] || 0);
         const updates = chat.reconnectTurn(conversationId, path[3], after);

package/host/index.d.ts

@@ -7,6 +7,47 @@ import type {
 } from '../dist/index.js';
 import type { ConversationStorePort, ConversationTurn } from '../dist/conversations/index.js';
 import type { ChatHttpHandler } from './http.js';
+import type { ExecutionContract, ToolSelection } from '../dist/execution/index.js';
+import type { McpServer } from '@agentclientprotocol/sdk';
+
+export interface ResolvedAgentExecution {
+  readonly agentConfig?: Readonly<Record<string, unknown>>;
+  readonly compiledAgentInstructions?: string;
+  readonly acpLaunch?: Readonly<Record<string, unknown>> | null;
+}
+
+export interface PreparedInstructionBundle {
+  readonly text: string;
+  readonly revisionId: string | null;
+}
+
+export interface NativeExecutionPreparerOptions {
+  readonly currentComputerId?: string | null;
+  readonly localBaseUrl?: string | (() => string | null) | null;
+  readonly runtimeToken?: string | (() => string | null) | null;
+  readonly amalgmDir?: string;
+  readonly runtimeHomeRoot?: string;
+  readonly proxyBaseUrl?: string;
+  readonly resolveTools?: (
+    selection: ToolSelection,
+    contract: ExecutionContract,
+  ) => readonly McpServer[] | Promise<readonly McpServer[]>;
+  readonly resolveAgent?: (
+    selection: ExecutionContract['agent'],
+    contract: ExecutionContract,
+  ) => ResolvedAgentExecution | Promise<ResolvedAgentExecution>;
+  readonly resolveInstructions?: (
+    contract: ExecutionContract,
+    agent: ResolvedAgentExecution,
+  ) => string | Promise<string>;
+  readonly projectContextPromptBlock?: (contract: ExecutionContract) => string;
+  readonly [key: string]: unknown;
+}
+
+export interface NativeChatRuntimeOptions extends NativeExecutionPreparerOptions {
+  readonly adapters?: Readonly<Record<string, (options: Readonly<Record<string, unknown>>) => unknown>>;
+  readonly requestPermission?: ((request: unknown) => Promise<unknown>) | null;
+}
 
 export interface PlatformCredentialBroker {
   authorize(request: Readonly<{
@@ -27,7 +68,7 @@ export interface CreateChatHostOptions<Binding = unknown, RuntimeSession = unkno
   readonly databasePath?: string;
   readonly conversations?: ConversationStorePort;
   readonly runtime?: ChatRuntimePort<Binding, RuntimeSession>;
-  readonly native?: Readonly<Record<string, unknown>> & {
+  readonly native?: NativeChatRuntimeOptions & {
     readonly credentialBroker?: PlatformCredentialBroker;
   };
   readonly uuid?: RandomUuidPort;
@@ -58,7 +99,7 @@ export { createChatHttpHandler } from './http.js';
 export type { ChatHttpHandler, ChatHttpHandlerOptions } from './http.js';
 
 export class NativeChatRuntime implements ChatRuntimePort<unknown, unknown> {
-  constructor(options?: Readonly<Record<string, unknown>>);
+  constructor(options?: NativeChatRuntimeOptions);
   prepareExecution(contract: import('../dist/execution/index.js').ExecutionContract): Promise<unknown>;
   startSession(request: import('../dist/sessions/index.js').RuntimeStartRequest<unknown>): Promise<unknown>;
   resumeSession(request: import('../dist/sessions/index.js').RuntimeResumeRequest<unknown>): Promise<unknown>;
@@ -66,10 +107,11 @@ export class NativeChatRuntime implements ChatRuntimePort<unknown, unknown> {
   interruptTurn(request: import('../dist/sessions/index.js').RuntimeInterruptRequest<unknown, unknown>): Promise<void>;
   checkpointSession(request: { readonly session: unknown }): unknown;
   closeSession(sessionId: string, session: unknown): Promise<void>;
+  generateTitle(input: Readonly<{ conversationId: string; message: string }>): AsyncIterable<string>;
 }
 
 export class NativeExecutionPreparer {
-  constructor(options?: Readonly<Record<string, unknown>>);
+  constructor(options?: NativeExecutionPreparerOptions);
   prepare(contract: import('../dist/execution/index.js').ExecutionContract): Promise<unknown>;
 }
 

package/host/index.js

@@ -38,6 +38,9 @@ export async function createChatHost(options) {
     ...(typeof runtime.forwardMcp === 'function'
       ? { forwardMcp: runtime.forwardMcp.bind(runtime) }
       : {}),
+    ...(typeof runtime.generateTitle === 'function'
+      ? { generateTitle: runtime.generateTitle.bind(runtime) }
+      : {}),
   });
   return Object.freeze({
     chat,

package/host/native-contract.js

@@ -1,9 +1,11 @@
-import { createHmac, randomBytes } from 'node:crypto';
+import { createHash, createHmac, randomBytes } from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import { authEnvelope } from './auth.js';
 import { amalgmDir } from './lib/runtime-paths.js';
 import { resolveNativeModel } from './model-resolution.js';
+import { normalizeAcpMcpServers } from './tooling/mcp-bundle.js';
+import { composeSystemPrompt } from './tooling/system-prompt.js';
 
 export { nativeModel } from './model-resolution.js';
 
@@ -54,6 +56,10 @@ export class NativeExecutionPreparer {
       agentConfig: {},
       compiledAgentInstructions: '',
     }));
+    this.resolveInstructions = options.resolveInstructions || (async (contract, agent) => composeSystemPrompt(
+      { compiledAgentInstructions: agent?.compiledAgentInstructions || '' },
+      { projectContextPromptBlock: options.projectContextPromptBlock },
+    ));
     this.validateModel = options.validateModel || (async () => undefined);
     this.resolveModel = options.resolveModel || resolveNativeModel;
     this.resolveAuth = options.resolveAuth || ((selection, contract, context) => authEnvelope({
@@ -71,6 +77,7 @@ export class NativeExecutionPreparer {
       agentConfigId: contract.agent.installationId,
     }));
     this.localBaseUrl = options.localBaseUrl || null;
+    this.runtimeToken = options.runtimeToken || null;
     this.amalgmDir = options.amalgmDir || amalgmDir();
     this.runtimeHomeRoot = path.resolve(
       options.runtimeHomeRoot || path.join(this.amalgmDir, 'cli-homes'),
@@ -87,6 +94,13 @@ export class NativeExecutionPreparer {
     return typeof value === 'string' && value.trim() ? value.replace(/\/$/, '') : null;
   }
 
+  resolveRuntimeToken() {
+    const value = typeof this.runtimeToken === 'function'
+      ? this.runtimeToken()
+      : this.runtimeToken;
+    return typeof value === 'string' && value.trim() ? value.trim() : null;
+  }
+
   async resolvePreparedAuth(selection, contract, context) {
     try {
       return await this.resolveAuth(selection, contract, context);
@@ -106,13 +120,13 @@ export class NativeExecutionPreparer {
 
     const authMethod = AUTH_METHOD[contract.auth.mode];
     const model = await this.resolveModel(contract);
-    const [tools, agent, , auth] = await Promise.all([
+    const [resolvedTools, agent, , auth] = await Promise.all([
       this.resolveTools(contract.tools, contract),
       this.resolveAgent(contract.agent, contract),
       this.validateModel(contract.model, contract.agent),
       this.resolvePreparedAuth(contract.auth, contract, { authMethod, modelId: model.usageModelId }),
     ]);
-    if (!Array.isArray(tools)) throw new Error('resolveTools must return ACP/native MCP server configs');
+    const tools = normalizeAcpMcpServers(resolvedTools);
     if (!auth || typeof auth !== 'object') {
       throw new InvalidPreparedAuthError('resolveAuth must return a prepared auth binding');
     }
@@ -127,6 +141,13 @@ export class NativeExecutionPreparer {
       mode: contract.auth.mode,
       bindingId: contract.auth.bindingId,
     });
+    const instructionText = String(await this.resolveInstructions(contract, agent) || '').trim();
+    const instructions = Object.freeze({
+      text: instructionText,
+      revisionId: instructionText
+        ? createHash('sha256').update(instructionText).digest('hex')
+        : null,
+    });
 
     return Object.freeze({
       adapterId: contract.agent.adapterId,
@@ -156,7 +177,7 @@ export class NativeExecutionPreparer {
         localBaseUrl: this.resolveLocalBaseUrl(),
         mcpServers: tools,
         toolSelection: contract.tools,
-        compiledAgentInstructions: agent?.compiledAgentInstructions || '',
+        instructions,
         permissionMode: contract.permissionMode,
         executionComputerId: contract.computerId,
         usageOwner: contract.auth.mode === 'platform' ? 'platform_proxy' : 'local_user',
@@ -179,6 +200,7 @@ export class NativeExecutionPreparer {
       assistantMessageId: turnId,
       userMessageId: null,
       providerSessionId,
+      runtimeToken: this.resolveRuntimeToken(),
       auth: sessionAuth(binding.base.auth, sessionId, this.localEgressSecret),
     };
   }