amalgm 0.1.135 → 0.1.136

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

@@ -0,0 +1,143 @@
+'use strict';
+
+const {
+  compactionFinished,
+  compactionStarted,
+  errorEvent,
+  reasoningDelta,
+  textDelta,
+  toolCompleted,
+  toolStarted,
+  toolUpdated,
+  usageFinal,
+  warningEvent,
+} = require('../events');
+
+function contentToText(content) {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+  return content
+    .map((item) => (item && item.type === 'text' && typeof item.text === 'string' ? item.text : ''))
+    .filter(Boolean)
+    .join('\n');
+}
+
+// pi AgentMessage.usage ({input, output, cacheRead, cacheWrite, totalTokens,
+// cost.total, contextSize?}) -> exact per-step usage. Pi is the only harness
+// that reports native USD cost per message, so costUsd rides along.
+function piMessageUsage(message, base = {}) {
+  const usage = message?.usage;
+  if (!usage || typeof usage !== 'object') return null;
+  const total = Number(usage.totalTokens);
+  const hasTokens = ['input', 'output', 'cacheRead', 'cacheWrite'].some((key) => Number(usage[key]) > 0);
+  if (!hasTokens && !(Number.isFinite(total) && total > 0)) return null;
+  const contextSize = Number(usage.contextSize);
+  return usageFinal({
+    inputTokens: usage.input,
+    outputTokens: usage.output,
+    cacheReadTokens: usage.cacheRead,
+    cacheWriteTokens: usage.cacheWrite,
+    ...(Number.isFinite(contextSize) && contextSize > 0 ? { inputContextSize: contextSize, contextUsedTokens: contextSize } : {}),
+    costUsd: Number.isFinite(Number(usage.cost?.total)) ? Number(usage.cost.total) : null,
+    operation: 'chat_step',
+    billable: true,
+    exact: true,
+    source: 'pi_rpc_message_usage',
+  }, base);
+}
+
+// get_session_stats data -> context-circle snapshot (never billed; the exact
+// per-message records above are the billing source).
+function piSessionStatsUsage(stats, base = {}) {
+  const contextUsage = stats?.contextUsage;
+  if (!contextUsage || !Number.isFinite(Number(contextUsage.tokens))) return null;
+  return usageFinal({
+    usedTokens: contextUsage.tokens,
+    maxTokens: contextUsage.contextWindow,
+    totalProcessedTokens: stats?.tokens?.total,
+    costUsd: Number.isFinite(Number(stats?.cost)) ? Number(stats.cost) : null,
+    operation: 'context_snapshot',
+    billable: false,
+    exact: false,
+    source: 'pi_rpc_session_stats',
+  }, base);
+}
+
+// One pi RPC event -> amalgm events. `state` is per-prompt: providerSessionId
+// plus tool bookkeeping (tool_execution_start may race toolcall_end).
+function normalizePiEvent(event, state) {
+  const base = { providerSessionId: state.providerSessionId };
+  const type = event?.type;
+  if (type === 'message_update') {
+    const delta = event.assistantMessageEvent || {};
+    if (delta.type === 'text_delta' && delta.delta) return [textDelta(delta.delta, base)];
+    if (delta.type === 'thinking_delta' && delta.delta) return [reasoningDelta(delta.delta, base)];
+    if (delta.type === 'error' && delta.reason !== 'aborted') {
+      return [errorEvent(event.message?.errorMessage || event.message?.error || 'Pi model error', base)];
+    }
+    return [];
+  }
+  if (type === 'message_end') {
+    const message = event.message || {};
+    if (message.role && message.role !== 'assistant') return [];
+    const usage = piMessageUsage(message, base);
+    return usage ? [usage] : [];
+  }
+  if (type === 'tool_execution_start') {
+    state.tools.add(event.toolCallId);
+    return [toolStarted(event.toolCallId, {
+      ...base,
+      toolName: event.toolName || 'tool',
+      input: event.args,
+    })];
+  }
+  if (type === 'tool_execution_update') {
+    const text = contentToText(event.partialResult?.content);
+    if (!text) return [];
+    return [toolUpdated(event.toolCallId, {
+      ...base,
+      toolName: event.toolName || 'tool',
+      output: text,
+    })];
+  }
+  if (type === 'tool_execution_end') {
+    state.tools.delete(event.toolCallId);
+    const output = contentToText(event.result?.content);
+    return [toolCompleted(event.toolCallId, {
+      ...base,
+      toolName: event.toolName || 'tool',
+      ...(output ? { output } : {}),
+      isError: event.isError === true,
+      ...(event.isError === true ? { error: output || 'Tool call failed' } : {}),
+    })];
+  }
+  if (type === 'compaction_start') {
+    return [compactionStarted({ ...base, trigger: event.reason === 'manual' ? 'manual' : 'auto' })];
+  }
+  if (type === 'compaction_end') {
+    return [compactionFinished({
+      ...base,
+      trigger: event.reason === 'manual' ? 'manual' : 'auto',
+      preTokens: event.result?.tokensBefore,
+    })];
+  }
+  if (type === 'auto_retry_start') {
+    return [warningEvent(`Pi is retrying after a transient error${event.error ? `: ${event.error}` : ''}`, base)];
+  }
+  if (type === 'extension_error') {
+    return [warningEvent(`Pi extension error: ${event.error || 'unknown'}`, base)];
+  }
+  if (type === 'error') {
+    return [errorEvent(event.message || event.error || 'Pi agent error', base)];
+  }
+  // agent_start/agent_end/turn_start/turn_end/message_start/queue_update and
+  // toolcall_* deltas are lifecycle noise here; the adapter drives `done` off
+  // agent_end so it can attach the final context snapshot first.
+  return [];
+}
+
+module.exports = {
+  normalizePiEvent,
+  piMessageUsage,
+  piSessionStatsUsage,
+};

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

@@ -5,7 +5,9 @@ const { PORT, PROXY_BASE_URL, ensureFreshProxyToken } = require('../chat-server/
 const db = require('../chat-server/db');
 const { CodexAdapter } = require('./adapters/codex');
 const { ClaudeAdapter } = require('./adapters/claude');
+const { CursorAdapter } = require('./adapters/cursor');
 const { OpenCodeAdapter } = require('./adapters/opencode');
+const { PiAdapter } = require('./adapters/pi');
 const { ChatCore } = require('./engine');
 const { forwardEgress, parseEgressPath } = require('./egress');
 const { forwardMcpRelay, parseMcpRelayPath } = require('./tooling/mcp-relay');
@@ -60,7 +62,9 @@ function createCore(options = {}) {
     adapters: {
       claude_code: () => new ClaudeAdapter(),
       codex: () => new CodexAdapter(),
+      cursor: () => new CursorAdapter(),
       opencode: () => new OpenCodeAdapter(),
+      pi: () => new PiAdapter(),
     },
   });
   return new ChatCore({ db, runtime, turns, options: { ...options, port: PORT } });

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

@@ -0,0 +1,178 @@
+'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, coerceAuth, runtimeEnv } = require('../auth');
+const { agentToHarness, canonicalModel, cliModelFor } = require('../contract');
+const { cursorPromptUsage, cursorStopReason, normalizeCursorUpdate } = require('../normalizers/cursor');
+const { __private: cursorPrivate } = require('../adapters/cursor');
+const { syncCursorProviderAuth } = require('../tooling/native-config');
+
+const { matchAcpModel, pickPermissionOption } = cursorPrivate;
+
+test('cursor harness resolves through contract model naming', () => {
+  assert.equal(agentToHarness('cursor'), 'cursor');
+  assert.equal(canonicalModel('cursor/composer-2.5', 'cursor'), 'cursor/composer-2.5');
+  assert.equal(canonicalModel('anthropic/claude-opus-4.8', 'cursor'), 'anthropic/claude-opus-4.8');
+  assert.equal(cliModelFor({ harness: 'cursor', modelId: 'cursor/composer-2.5' }), 'composer-2.5');
+  assert.equal(cliModelFor({ harness: 'cursor', modelId: 'anthropic/claude-opus-4.8', cliModel: 'claude-opus-4-8' }), 'claude-opus-4-8');
+});
+
+test('cursor is provider_auth-only with a stable per-agent CLI home', () => {
+  assert.equal(coerceAuth('cursor', 'amalgm'), 'provider_auth');
+  assert.equal(coerceAuth('cursor', 'byok'), 'provider_auth');
+  const envelope = authEnvelope({
+    harness: 'cursor',
+    authMethod: 'provider_auth',
+    sessionId: 'session-test',
+    amalgmDir: '/tmp/amalgm-test',
+    agentConfigId: 'qa-agent',
+  });
+  assert.equal(envelope.method, 'provider_auth');
+  assert.equal(envelope.runtimeHome, '/tmp/amalgm-test/cli-homes/cursor/agents/qa-agent/home');
+  const env = runtimeEnv({ harness: 'cursor', authMethod: 'provider_auth', auth: envelope }, { PATH: '/bin', HOME: '/Users/example' });
+  assert.equal(env.HOME, envelope.runtimeHome);
+});
+
+test('matchAcpModel resolves amalgm cliModels to exact ACP model ids', () => {
+  const availableModels = [
+    { modelId: 'default[]', name: 'Auto' },
+    { modelId: 'composer-2.5[fast=true]', name: 'composer-2.5' },
+    { modelId: 'claude-opus-4-8[thinking=true,context=300k,effort=high,fast=false]', name: 'claude-opus-4-8' },
+    { modelId: 'gpt-5.3-codex[reasoning=medium,fast=false]', name: 'gpt-5.3-codex' },
+  ];
+  assert.equal(matchAcpModel(availableModels, 'composer-2.5').modelId, 'composer-2.5[fast=true]');
+  assert.equal(matchAcpModel(availableModels, 'cursor/composer-2.5').modelId, 'composer-2.5[fast=true]');
+  assert.equal(matchAcpModel(availableModels, 'auto').modelId, 'default[]');
+  assert.equal(matchAcpModel(availableModels, 'claude-opus-4-8').modelId, 'claude-opus-4-8[thinking=true,context=300k,effort=high,fast=false]');
+  // Legacy effort/speed suffixes strip down to the ACP base model.
+  assert.equal(matchAcpModel(availableModels, 'gpt-5.3-codex-high').modelId, 'gpt-5.3-codex[reasoning=medium,fast=false]');
+  assert.equal(matchAcpModel(availableModels, 'claude-opus-4-8-thinking-high-fast').modelId, 'claude-opus-4-8[thinking=true,context=300k,effort=high,fast=false]');
+  assert.equal(matchAcpModel(availableModels, 'not-a-model'), null);
+});
+
+test('permission requests prefer allow_always then allow_once', () => {
+  assert.equal(pickPermissionOption([
+    { optionId: 'r', kind: 'reject_once' },
+    { optionId: 'a1', kind: 'allow_once' },
+    { optionId: 'aa', kind: 'allow_always' },
+  ]).optionId, 'aa');
+  assert.equal(pickPermissionOption([
+    { optionId: 'r', kind: 'reject_once' },
+    { optionId: 'a1', kind: 'allow_once' },
+  ]).optionId, 'a1');
+  assert.equal(pickPermissionOption([]), null);
+});
+
+test('cursor normalizer maps ACP session updates to amalgm events', () => {
+  const state = { providerSessionId: 'prov-1', tools: new Map() };
+
+  const text = normalizeCursorUpdate({ sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'hi' } }, state);
+  assert.equal(text[0].type, 'text.delta');
+  assert.equal(text[0].text, 'hi');
+  assert.equal(text[0].providerSessionId, 'prov-1');
+
+  const thought = normalizeCursorUpdate({ sessionUpdate: 'agent_thought_chunk', content: { type: 'text', text: 'hm' } }, state);
+  assert.equal(thought[0].type, 'reasoning.delta');
+
+  const started = normalizeCursorUpdate({
+    sessionUpdate: 'tool_call',
+    toolCallId: 't1',
+    title: '`ls`',
+    kind: 'execute',
+    status: 'pending',
+    rawInput: { command: 'ls' },
+  }, state);
+  assert.equal(started[0].type, 'tool.started');
+  assert.equal(started[0].toolCallId, 't1');
+  assert.equal(started[0].kind, 'bash');
+  assert.deepEqual(started[0].input, { command: 'ls' });
+
+  const completed = normalizeCursorUpdate({
+    sessionUpdate: 'tool_call_update',
+    toolCallId: 't1',
+    status: 'completed',
+    rawOutput: { exitCode: 0, stdout: 'file.txt\n', stderr: '' },
+  }, state);
+  assert.equal(completed[0].type, 'tool.completed');
+  assert.equal(completed[0].isError, false);
+  assert.equal(completed[0].toolName, '`ls`');
+  assert.deepEqual(completed[0].output, { text: 'file.txt', exitCode: 0 });
+
+  const editStarted = normalizeCursorUpdate({
+    sessionUpdate: 'tool_call', toolCallId: 't2', title: 'Edit File', kind: 'edit', status: 'pending', rawInput: {},
+  }, state);
+  assert.equal(editStarted[0].kind, 'file_edit');
+  const editDone = normalizeCursorUpdate({
+    sessionUpdate: 'tool_call_update',
+    toolCallId: 't2',
+    status: 'completed',
+    content: [{ type: 'diff', path: '/tmp/a.txt', oldText: null, newText: 'hello' }],
+  }, state);
+  assert.equal(editDone[0].type, 'tool.completed');
+  assert.deepEqual(editDone[0].output, { path: '/tmp/a.txt', oldText: null, newText: 'hello' });
+
+  const failed = normalizeCursorUpdate({
+    sessionUpdate: 'tool_call', toolCallId: 't3', title: 'Read File', kind: 'read', status: 'pending', rawInput: {},
+  }, state) && normalizeCursorUpdate({
+    sessionUpdate: 'tool_call_update', toolCallId: 't3', status: 'failed',
+  }, state);
+  assert.equal(failed[0].type, 'tool.completed');
+  assert.equal(failed[0].isError, true);
+
+  assert.deepEqual(normalizeCursorUpdate({ sessionUpdate: 'user_message_chunk', content: { type: 'text', text: 'replay' } }, state), []);
+  assert.deepEqual(normalizeCursorUpdate({ sessionUpdate: 'session_info_update', title: 'x' }, state), []);
+});
+
+test('cursor usage mappings stay honest about exactness', () => {
+  const state = { providerSessionId: 'prov-1', tools: new Map() };
+  const snapshot = normalizeCursorUpdate({ sessionUpdate: 'usage_update', used: 1200, size: 200000 }, state);
+  assert.equal(snapshot[0].type, 'usage.final');
+  assert.equal(snapshot[0].usage.billable, false);
+  assert.equal(snapshot[0].usage.exact, false);
+  assert.equal(snapshot[0].usage.usedTokens, 1200);
+  assert.equal(snapshot[0].usage.maxTokens, 200000);
+
+  assert.equal(cursorPromptUsage(undefined), null);
+  assert.equal(cursorPromptUsage({}), null);
+  const exact = cursorPromptUsage({ input_tokens: 10, output_tokens: 20, cached_read_tokens: 5, total_tokens: 35 });
+  assert.equal(exact.usage.exact, true);
+  assert.equal(exact.usage.billable, true);
+  assert.equal(exact.usage.operation, 'chat_turn');
+  assert.equal(exact.usage.tokenList.total, 35);
+});
+
+test('cursor stop reasons map onto amalgm done reasons', () => {
+  assert.equal(cursorStopReason('end_turn'), 'end_turn');
+  assert.equal(cursorStopReason('cancelled'), 'cancelled');
+  assert.equal(cursorStopReason('refusal'), 'refusal');
+  assert.equal(cursorStopReason('max_tokens'), 'max_tokens');
+  assert.equal(cursorStopReason(undefined), 'end_turn');
+});
+
+test('cursor provider auth sync seeds the managed home without clobbering it', () => {
+  const nativeHome = fs.mkdtempSync(path.join(os.tmpdir(), 'cursor-native-'));
+  const runtimeHome = fs.mkdtempSync(path.join(os.tmpdir(), 'cursor-runtime-'));
+  const previousNative = process.env.AMALGM_NATIVE_HOME;
+  process.env.AMALGM_NATIVE_HOME = nativeHome;
+  try {
+    fs.mkdirSync(path.join(nativeHome, '.cursor'), { recursive: true });
+    fs.writeFileSync(path.join(nativeHome, '.cursor', 'cli-config.json'), '{"version":1}');
+
+    syncCursorProviderAuth(runtimeHome);
+    assert.equal(fs.readFileSync(path.join(runtimeHome, '.cursor', 'cli-config.json'), 'utf8'), '{"version":1}');
+
+    // The copy is seed-only: a config evolved inside the managed home wins.
+    fs.writeFileSync(path.join(runtimeHome, '.cursor', 'cli-config.json'), '{"version":2}');
+    syncCursorProviderAuth(runtimeHome);
+    assert.equal(fs.readFileSync(path.join(runtimeHome, '.cursor', 'cli-config.json'), 'utf8'), '{"version":2}');
+  } finally {
+    if (previousNative === undefined) delete process.env.AMALGM_NATIVE_HOME;
+    else process.env.AMALGM_NATIVE_HOME = previousNative;
+    fs.rmSync(nativeHome, { recursive: true, force: true });
+    fs.rmSync(runtimeHome, { recursive: true, force: true });
+  }
+});

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

@@ -0,0 +1,182 @@
+'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, coerceAuth, runtimeEnv } = require('../auth');
+const { agentToHarness, canonicalModel, cliModelFor } = require('../contract');
+const { normalizePiEvent, piMessageUsage, piSessionStatsUsage } = require('../normalizers/pi');
+const { finalizeTurnUsage } = require('../usage');
+const { __private: piPrivate } = require('../adapters/pi');
+
+test('pi harness resolves gateway model naming', () => {
+  assert.equal(agentToHarness('pi'), 'pi');
+  assert.equal(canonicalModel('pi-anthropic-claude-sonnet-4.6', 'pi'), 'anthropic/claude-sonnet-4.6');
+  assert.equal(canonicalModel('vercel/deepseek/deepseek-v4-pro', 'pi'), 'deepseek/deepseek-v4-pro');
+  assert.equal(canonicalModel('anthropic/claude-haiku-4.5', 'pi'), 'anthropic/claude-haiku-4.5');
+  assert.equal(canonicalModel('pi-prime-intellect-intellect-3', 'pi'), 'prime-intellect/intellect-3');
+  assert.equal(cliModelFor({ harness: 'pi', modelId: 'pi-anthropic-claude-sonnet-4.6' }), 'anthropic/claude-sonnet-4.6');
+  assert.equal(cliModelFor({ harness: 'pi', modelId: 'anthropic/claude-haiku-4.5', cliModel: 'vercel/anthropic/claude-haiku-4.5' }), 'anthropic/claude-haiku-4.5');
+});
+
+test('pi supports all auth methods with a stable per-agent home and gateway env', () => {
+  assert.equal(coerceAuth('pi', 'amalgm'), 'amalgm');
+  assert.equal(coerceAuth('pi', 'byok'), 'byok');
+  assert.equal(coerceAuth('pi', 'provider_auth'), 'provider_auth');
+  const envelope = authEnvelope({
+    harness: 'pi',
+    authMethod: 'amalgm',
+    sessionId: 'session-pi',
+    proxyToken: 'proxy-token',
+    localBaseUrl: 'http://127.0.0.1:8084',
+    proxyBaseUrl: 'https://proxy.example.test',
+    amalgmDir: '/tmp/amalgm-test',
+    userId: 'user-123',
+  });
+  assert.equal(envelope.runtimeHome, '/tmp/amalgm-test/cli-homes/pi/agents/pi/home');
+  // Pi appends /v1/messages itself, so egress terminates at /ai_gateway.
+  assert.equal(envelope.baseUrl, 'http://127.0.0.1:8084/egress/session-pi/ai_gateway');
+  assert.equal(envelope.forwardBaseUrl, 'https://proxy.example.test/ai_gateway');
+  const env = runtimeEnv({ harness: 'pi', authMethod: 'amalgm', auth: envelope }, { PATH: '/bin' });
+  assert.equal(env.AI_GATEWAY_API_KEY, envelope.tokenRef);
+  assert.equal(env.AI_GATEWAY_BASE_URL, undefined);
+  assert.equal(env.HOME, envelope.runtimeHome);
+});
+
+test('pi adapter args carry model, thinking, system prompt, resume, and egress extension', () => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'pi-home-'));
+  try {
+    const contract = {
+      cliModel: 'anthropic/claude-haiku-4.5',
+      reasoningEffort: 'high',
+      providerSessionId: '/sessions/prior.jsonl',
+      authMethod: 'amalgm',
+      auth: { baseUrl: 'http://127.0.0.1:8084/egress/s/ai_gateway' },
+      systemPrompt: 'be helpful',
+      agentConfig: null,
+    };
+    const args = piPrivate.buildArgs(contract, home);
+    assert.deepEqual(args.slice(0, 6), ['--mode', 'rpc', '--provider', 'vercel-ai-gateway', '--model', 'anthropic/claude-haiku-4.5']);
+    assert.ok(args.includes('--thinking') && args[args.indexOf('--thinking') + 1] === 'high');
+    assert.ok(args.includes('--session') && args[args.indexOf('--session') + 1] === '/sessions/prior.jsonl');
+    const extension = args[args.indexOf('--extension') + 1];
+    assert.ok(extension.startsWith(home));
+    const source = fs.readFileSync(extension, 'utf8');
+    assert.match(source, /registerProvider\("vercel-ai-gateway"/);
+    assert.match(source, /AMALGM_PI_GATEWAY_BASE_URL/);
+    // provider_auth spawns without the egress extension.
+    const nativeArgs = piPrivate.buildArgs({ ...contract, authMethod: 'provider_auth', providerSessionId: null }, home);
+    assert.equal(nativeArgs.includes('--extension'), false);
+    assert.equal(nativeArgs.includes('--session'), false);
+  } finally {
+    fs.rmSync(home, { recursive: true, force: true });
+  }
+});
+
+test('pi normalizer maps rpc events to amalgm events', () => {
+  const state = { providerSessionId: 'sess.jsonl', tools: new Set() };
+
+  const text = normalizePiEvent({ type: 'message_update', assistantMessageEvent: { type: 'text_delta', delta: 'hi' } }, state);
+  assert.equal(text[0].type, 'text.delta');
+  assert.equal(text[0].text, 'hi');
+
+  const thinking = normalizePiEvent({ type: 'message_update', assistantMessageEvent: { type: 'thinking_delta', delta: 'hm' } }, state);
+  assert.equal(thinking[0].type, 'reasoning.delta');
+
+  const started = normalizePiEvent({ type: 'tool_execution_start', toolCallId: 'c1', toolName: 'bash', args: { command: 'ls' } }, state);
+  assert.equal(started[0].type, 'tool.started');
+  assert.equal(started[0].kind, 'bash');
+
+  const updated = normalizePiEvent({
+    type: 'tool_execution_update',
+    toolCallId: 'c1',
+    toolName: 'bash',
+    partialResult: { content: [{ type: 'text', text: 'partial' }] },
+  }, state);
+  assert.equal(updated[0].type, 'tool.updated');
+  assert.equal(updated[0].output, 'partial');
+
+  const completed = normalizePiEvent({
+    type: 'tool_execution_end',
+    toolCallId: 'c1',
+    toolName: 'bash',
+    result: { content: [{ type: 'text', text: 'done output' }] },
+    isError: false,
+  }, state);
+  assert.equal(completed[0].type, 'tool.completed');
+  assert.equal(completed[0].output, 'done output');
+  assert.equal(completed[0].isError, false);
+
+  const err = normalizePiEvent({
+    type: 'message_update',
+    message: { errorMessage: 'boom' },
+    assistantMessageEvent: { type: 'error', reason: 'error' },
+  }, state);
+  assert.equal(err[0].type, 'error');
+  assert.equal(err[0].message, 'boom');
+  assert.deepEqual(normalizePiEvent({
+    type: 'message_update',
+    assistantMessageEvent: { type: 'error', reason: 'aborted' },
+  }, state), []);
+
+  const compaction = normalizePiEvent({ type: 'compaction_end', reason: 'threshold', result: { tokensBefore: 1000 } }, state);
+  assert.equal(compaction[0].type, 'compaction.finished');
+  assert.equal(compaction[0].preTokens, 1000);
+});
+
+test('pi usage is exact per assistant message with native cost', () => {
+  const usage = piMessageUsage({
+    role: 'assistant',
+    usage: {
+      input: 100,
+      output: 50,
+      cacheRead: 400,
+      cacheWrite: 20,
+      totalTokens: 570,
+      cost: { total: 0.0123 },
+    },
+  });
+  assert.equal(usage.usage.exact, true);
+  assert.equal(usage.usage.billable, true);
+  assert.equal(usage.usage.operation, 'chat_step');
+  assert.equal(usage.usage.costUsd, 0.0123);
+  assert.deepEqual(usage.usage.tokenList, { input: 100, output: 50, cacheRead: 400, cacheWrite: 20, thought: 0, total: 570 });
+  assert.equal(piMessageUsage({ role: 'assistant' }), null);
+  assert.equal(piMessageUsage({ role: 'assistant', usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0 } }), null);
+
+  const snapshot = piSessionStatsUsage({
+    tokens: { total: 105000 },
+    cost: 0.45,
+    contextUsage: { tokens: 60000, contextWindow: 200000, percent: 30 },
+  });
+  assert.equal(snapshot.usage.billable, false);
+  assert.equal(snapshot.usage.exact, false);
+  assert.equal(snapshot.usage.usedTokens, 60000);
+  assert.equal(snapshot.usage.maxTokens, 200000);
+  assert.equal(piSessionStatsUsage({ tokens: { total: 10 } }), null);
+});
+
+test('pi turn usage sums exact steps and keeps native gateway cost', () => {
+  const step = (input, output, cost) => piMessageUsage({
+    role: 'assistant',
+    usage: { input, output, cacheRead: 0, cacheWrite: 0, totalTokens: input + output, cost: { total: cost } },
+  }).usage;
+  const snapshot = piSessionStatsUsage({
+    tokens: { total: 400 },
+    cost: 0.03,
+    contextUsage: { tokens: 300, contextWindow: 200000 },
+  }).usage;
+  const turn = finalizeTurnUsage({
+    contract: { harness: 'pi' },
+    usageRecords: [step(100, 50, 0.01), snapshot, step(120, 30, 0.02)],
+  });
+  assert.equal(turn.operation, 'chat_turn');
+  assert.equal(turn.exact, true);
+  assert.deepEqual([turn.tokenList.input, turn.tokenList.output], [220, 80]);
+  assert.equal(turn.costUsd.toFixed(2), '0.03');
+  assert.equal(turn.marketCostUsd.toFixed(2), '0.03');
+  // Snapshot-only records (no exact steps) must not produce a billing row.
+  assert.equal(finalizeTurnUsage({ contract: { harness: 'pi' }, usageRecords: [snapshot] }), null);
+});

package/runtime/scripts/chat-core/tooling/native-config.js

@@ -332,6 +332,40 @@ function syncClaudeProviderAuth(runtimeHome) {
     : null;
 }
 
+// Cursor stores its login token in the macOS Keychain (service "cursor-access-token"),
+// not in a file, so warm auth in a managed home rides on the Keychains alias.
+// cli-config.json is copied once so the CLI starts from the user's preferences.
+function syncCursorProviderAuth(runtimeHome) {
+  if (!runtimeHome) return null;
+  const home = nativeHome();
+  const sourceDir = path.join(home, '.cursor');
+  fs.mkdirSync(runtimeHome, { recursive: true });
+  const keychain = ensureNativeKeychainAlias(runtimeHome);
+  const copiedAuth = copyFileIfPresent(
+    path.join(sourceDir, 'auth.json'),
+    path.join(runtimeHome, '.cursor', 'auth.json'),
+  );
+  const targetConfig = path.join(runtimeHome, '.cursor', 'cli-config.json');
+  const copiedConfig = !exists(targetConfig) && copyFileIfPresent(path.join(sourceDir, 'cli-config.json'), targetConfig);
+  return keychain || copiedAuth || copiedConfig
+    ? { sourceDir, runtimeHome, copied: copiedAuth || copiedConfig, keychain, authOnly: true }
+    : null;
+}
+
+// Pi keeps provider keys and custom-provider config under ~/.pi; auth.json is
+// the auth material, models.json/settings.json carry provider definitions the
+// managed home needs to resolve the same models.
+function syncPiProviderAuth(runtimeHome) {
+  if (!runtimeHome) return null;
+  const home = nativeHome();
+  const sourceDir = path.join(home, '.pi');
+  fs.mkdirSync(runtimeHome, { recursive: true });
+  const copied = ['agent/auth.json', 'agent/models.json', 'agent/settings.json']
+    .map((file) => copyFileIfPresent(path.join(sourceDir, file), path.join(runtimeHome, '.pi', file)))
+    .some(Boolean);
+  return copied ? { sourceDir, runtimeHome, copied: true, authOnly: true } : null;
+}
+
 function syncOpenCodeProviderAuth(runtimeHome) {
   if (!runtimeHome) return null;
   const home = nativeHome();
@@ -400,6 +434,8 @@ function syncNativeProviderAuth(contract) {
   if (contract.harness === 'codex') return syncCodexProviderAuth(runtimeHome);
   if (contract.harness === 'claude_code') return syncClaudeProviderAuth(runtimeHome);
   if (contract.harness === 'opencode') return syncOpenCodeProviderAuth(runtimeHome);
+  if (contract.harness === 'cursor') return syncCursorProviderAuth(runtimeHome);
+  if (contract.harness === 'pi') return syncPiProviderAuth(runtimeHome);
   return null;
 }
 
@@ -421,8 +457,10 @@ module.exports = {
   syncClaudeNativeConfig,
   syncCodexProviderAuth,
   syncCodexNativeConfig,
+  syncCursorProviderAuth,
   syncNativeHarnessConfig,
   syncNativeProviderAuth,
   syncOpenCodeProviderAuth,
   syncOpenCodeNativeConfig,
+  syncPiProviderAuth,
 };

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

@@ -267,6 +267,26 @@ function finalizeTurnUsage({ contract, usage, usageRecords } = {}) {
       ? [usage]
       : [];
 
+  if (contract?.harness === 'pi') {
+    // Pi reports exact per-message usage including native USD cost; a turn is
+    // the sum of its assistant messages, and the summed provider cost survives
+    // into the turn record instead of being re-derived from the catalog.
+    const exactRecords = records.filter((entry) => entry?.exact === true && entry.billable !== false);
+    const summed = summedTurnUsage(exactRecords, {
+      contextLimit: usage?.contextLimit,
+      inputContextSize: usage?.inputContextSize,
+      source: 'pi_rpc_step_sum',
+    });
+    if (summed) {
+      const costUsd = exactRecords.reduce((total, entry) => {
+        const cost = Number(entry.costUsd);
+        return Number.isFinite(cost) ? (total ?? 0) + cost : total;
+      }, null);
+      return { ...summed, costUsd, marketCostUsd: costUsd ?? summed.marketCostUsd };
+    }
+    return null;
+  }
+
   if (contract?.harness === 'codex') {
     const codexUsage = codexTurnUsage(records, {
       contextLimit: usage?.contextLimit,