amalgm 0.1.51 → 0.1.52

package/runtime/scripts/amalgm-mcp/workflows/store.js

@@ -0,0 +1,237 @@
+'use strict';
+
+/**
+ * Workflow storage — ~/.amalgm/workflows.json.
+ *
+ * Workflows are the executable primitive. Event triggers match inbound events
+ * and point at one or more workflow ids; scheduled tasks remain a separate
+ * working path.
+ */
+
+const crypto = require('crypto');
+const { STORAGE_DIR, WORKFLOWS_FILE } = require('../config');
+const { ensureDir, readJson, writeJsonAtomic } = require('../lib/storage');
+const { appendStateEvent } = require('../state/events');
+const { compileWorkflowText } = require('./compiler');
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function normalizeStringList(values) {
+  if (!Array.isArray(values)) return [];
+  return [...new Set(values
+    .filter((value) => typeof value === 'string')
+    .map((value) => value.trim())
+    .filter(Boolean))];
+}
+
+function normalizeWorkflowRecord(workflow) {
+  const workflowText = String(workflow.workflowText || workflow.workflow || '').trim();
+  let workflowIr = workflow.workflowIr && workflow.workflowIr.version === 1 ? workflow.workflowIr : null;
+  let compilerErrors = null;
+
+  if (workflowText) {
+    try {
+      workflowIr = compileWorkflowText(workflowText);
+    } catch (error) {
+      workflowIr = null;
+      compilerErrors = [error.message || String(error)];
+    }
+  }
+
+  return {
+    id: workflow.id || crypto.randomUUID(),
+    name: workflow.name || 'Untitled workflow',
+    description: workflow.description || '',
+    enabled: workflow.enabled !== false,
+    projectPath: workflow.projectPath || null,
+    workflowText,
+    workflowIr,
+    compilerErrors,
+    allowlist: workflow.allowlist && typeof workflow.allowlist === 'object' ? workflow.allowlist : {},
+    limits: workflow.limits && typeof workflow.limits === 'object' ? workflow.limits : {},
+    triggerIds: normalizeStringList(workflow.triggerIds),
+    internal: workflow.internal === true,
+    createdAt: workflow.createdAt || nowIso(),
+    updatedAt: workflow.updatedAt || null,
+  };
+}
+
+function ensureWorkflowDirs() {
+  ensureDir(STORAGE_DIR);
+  if (!readJson(WORKFLOWS_FILE, null)) {
+    writeJsonAtomic(WORKFLOWS_FILE, { version: 1, workflows: [] });
+  }
+}
+
+function migrateWorkflowsData(data) {
+  let changed = false;
+  const rawWorkflows = Array.isArray(data?.workflows) ? data.workflows : [];
+  const workflows = rawWorkflows
+    .filter((workflow) => workflow && (workflow.workflowText || workflow.workflow || workflow.workflowIr))
+    .map((workflow) => {
+      const normalized = normalizeWorkflowRecord(workflow);
+      if (JSON.stringify(normalized) !== JSON.stringify(workflow)) changed = true;
+      return normalized;
+    });
+
+  if (workflows.length !== rawWorkflows.length) changed = true;
+  if (data?.version !== 1) changed = true;
+
+  return {
+    changed,
+    data: {
+      version: 1,
+      workflows,
+    },
+  };
+}
+
+function loadWorkflows() {
+  ensureWorkflowDirs();
+  const raw = readJson(WORKFLOWS_FILE, { version: 1, workflows: [] });
+  const migrated = migrateWorkflowsData(raw);
+  if (migrated.changed) writeJsonAtomic(WORKFLOWS_FILE, migrated.data);
+  return migrated.data;
+}
+
+function publishWorkflowsChange(data, source = 'workflows') {
+  try {
+    appendStateEvent({
+      resource: 'workflows',
+      op: 'replace',
+      value: Array.isArray(data?.workflows) ? data.workflows : [],
+      source,
+    });
+  } catch (error) {
+    console.warn('[Workflows] Local Live Store publish failed:', error.message);
+  }
+}
+
+function saveWorkflows(data, options = {}) {
+  ensureWorkflowDirs();
+  const normalized = migrateWorkflowsData(data).data;
+  writeJsonAtomic(WORKFLOWS_FILE, normalized);
+  publishWorkflowsChange(normalized, options.source || 'workflows:save');
+}
+
+function getWorkflowById(workflowId) {
+  if (!workflowId) return null;
+  return loadWorkflows().workflows.find((workflow) => workflow.id === workflowId) || null;
+}
+
+function createWorkflow(input) {
+  const data = loadWorkflows();
+  const workflow = normalizeWorkflowRecord({
+    ...input,
+    id: input.id || crypto.randomUUID(),
+    createdAt: input.createdAt || nowIso(),
+    updatedAt: input.updatedAt || null,
+  });
+  if (!workflow.workflowText) throw new Error('workflowText is required.');
+  if (workflow.compilerErrors?.length) throw new Error(workflow.compilerErrors.join('\n'));
+  data.workflows.push(workflow);
+  saveWorkflows(data, { source: 'workflow:create' });
+  return workflow;
+}
+
+function updateWorkflow(workflowId, updates) {
+  const data = loadWorkflows();
+  const index = data.workflows.findIndex((workflow) => workflow.id === workflowId);
+  if (index === -1) throw new Error(`Workflow not found: ${workflowId}`);
+  const workflow = normalizeWorkflowRecord({
+    ...data.workflows[index],
+    ...updates,
+    id: workflowId,
+    updatedAt: nowIso(),
+  });
+  if (!workflow.workflowText) throw new Error('workflowText is required.');
+  if (workflow.compilerErrors?.length) throw new Error(workflow.compilerErrors.join('\n'));
+  data.workflows[index] = workflow;
+  saveWorkflows(data, { source: 'workflow:update' });
+  return workflow;
+}
+
+function deleteWorkflow(workflowId) {
+  const data = loadWorkflows();
+  const index = data.workflows.findIndex((workflow) => workflow.id === workflowId);
+  if (index === -1) throw new Error(`Workflow not found: ${workflowId}`);
+  const [deleted] = data.workflows.splice(index, 1);
+  saveWorkflows(data, { source: 'workflow:delete' });
+  return deleted;
+}
+
+function upsertWorkflowFromTrigger(trigger) {
+  if (!trigger?.workflowText && !trigger?.workflow && !trigger?.workflowIr) return null;
+  const data = loadWorkflows();
+  const workflowId = trigger.workflowId || `workflow:${trigger.id}`;
+  const index = data.workflows.findIndex((workflow) => workflow.id === workflowId);
+  const existing = index === -1 ? null : data.workflows[index];
+  const next = normalizeWorkflowRecord({
+    ...(existing || {}),
+    id: workflowId,
+    name: trigger.workflowName || trigger.name || 'Untitled workflow',
+    description: trigger.description || '',
+    enabled: trigger.enabled !== false,
+    projectPath: trigger.projectPath || null,
+    workflowText: trigger.workflowText || trigger.workflow || '',
+    workflowIr: trigger.workflowIr || null,
+    allowlist: trigger.allowlist || {},
+    limits: trigger.limits || {},
+    triggerIds: [trigger.id],
+    internal: trigger.internal === true,
+    createdAt: index === -1 ? (trigger.createdAt || nowIso()) : existing.createdAt,
+    updatedAt: index === -1 ? null : existing.updatedAt,
+  });
+
+  if (existing && JSON.stringify(existing) === JSON.stringify(next)) return existing;
+  if (existing) next.updatedAt = nowIso();
+  if (index === -1) data.workflows.push(next);
+  else data.workflows[index] = next;
+  saveWorkflows(data, { source: 'workflow:migrate-trigger' });
+  return next;
+}
+
+function syncWorkflowTriggerLinks(triggers) {
+  const data = loadWorkflows();
+  let changed = false;
+
+  const triggerIdsByWorkflow = new Map();
+  for (const trigger of Array.isArray(triggers) ? triggers : []) {
+    const triggerId = String(trigger?.id || '').trim();
+    if (!triggerId) continue;
+    const workflowIds = normalizeStringList(trigger.workflowIds);
+    for (const workflowId of workflowIds) {
+      if (!triggerIdsByWorkflow.has(workflowId)) triggerIdsByWorkflow.set(workflowId, []);
+      triggerIdsByWorkflow.get(workflowId).push(triggerId);
+    }
+  }
+
+  const workflows = data.workflows.map((workflow) => {
+    const nextTriggerIds = normalizeStringList(
+      triggerIdsByWorkflow.has(workflow.id) ? triggerIdsByWorkflow.get(workflow.id) : [],
+    );
+    if (JSON.stringify(nextTriggerIds) === JSON.stringify(workflow.triggerIds || [])) return workflow;
+    changed = true;
+    return {
+      ...workflow,
+      triggerIds: nextTriggerIds,
+      updatedAt: nowIso(),
+    };
+  });
+
+  if (changed) saveWorkflows({ ...data, workflows }, { source: 'workflow:sync-trigger-links' });
+}
+
+module.exports = {
+  createWorkflow,
+  deleteWorkflow,
+  getWorkflowById,
+  loadWorkflows,
+  normalizeWorkflowRecord,
+  saveWorkflows,
+  syncWorkflowTriggerLinks,
+  updateWorkflow,
+  upsertWorkflowFromTrigger,
+};

package/runtime/scripts/chat-core/adapters/claude.js

@@ -8,7 +8,7 @@ const { normalizeClaudeMessage, usageRecordsFromClaudeResult, usageFromClaude }
 const { recordNativeEvent } = require('../recorder');
 const { toClaudeMcpServers } = require('../tooling/mcp-bundle');
 const { bundledClaudeBinary } = require('../tooling/native-binaries');
-const { claudeNativeHookSettings } = require('../tooling/native-config');
+const { claudeNativeHookSettings, syncNativeHarnessConfig } = require('../tooling/native-config');
 const { importPackage } = require('../tooling/package-import');
 const { composeSystemPrompt } = require('../tooling/system-prompt');
 
@@ -32,6 +32,7 @@ class ClaudeAdapter {
   }
 
   options(contract, extra = {}) {
+    syncNativeHarnessConfig(contract);
     const systemPrompt = composeSystemPrompt(contract);
     const pathToClaudeCodeExecutable = process.env.CLAUDE_CODE_BINARY || bundledClaudeBinary();
     const settings = {

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

@@ -69,25 +69,80 @@ function coerceAuth(harness, requested) {
   return requested && supported.includes(requested) ? requested : supported[0];
 }
 
-function runtimeHome({ amalgmDir, sessionId, harness, authMethod, tokenFingerprint }) {
-  // Claude Code provider auth is tied to the user's real home/keychain context.
-  // Isolating HOME makes the bundled Claude binary look logged out on macOS.
-  if (authMethod === 'provider_auth' && harness !== 'codex') return null;
-  const suffix = tokenFingerprint || 'default';
-  return path.join(amalgmDir, 'runtime', sessionId, harness, suffix);
+function safePathSegment(value) {
+  const clean = String(value || '').trim().replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '');
+  return clean || 'default';
 }
 
-function providerAuthFingerprint(harness) {
-  if (harness !== 'codex') return null;
+function findStableJsonIdentity(value, depth = 0) {
+  if (!value || typeof value !== 'object' || depth > 4) return null;
+  const keys = ['account_id', 'accountId', 'user_id', 'userId', 'email', 'login', 'username', 'sub'];
+  for (const key of keys) {
+    const candidate = value[key];
+    if (typeof candidate === 'string' && candidate.trim()) return `${key}:${candidate.trim()}`;
+  }
+  for (const child of Object.values(value)) {
+    const found = findStableJsonIdentity(child, depth + 1);
+    if (found) return found;
+  }
+  return null;
+}
+
+function readJsonIdentity(file) {
   try {
-    const raw = fs.readFileSync(path.join(os.homedir(), '.codex', 'auth.json'), 'utf8');
-    return fingerprint(raw);
+    const raw = fs.readFileSync(file, 'utf8');
+    return findStableJsonIdentity(JSON.parse(raw));
   } catch {
     return null;
   }
 }
 
-function authEnvelope({ harness, authMethod, sessionId, localBaseUrl, proxyToken, proxyBaseUrl, amalgmDir, credentialId, modelId }) {
+function providerAuthIdentity(harness) {
+  if (harness === 'codex') {
+    return readJsonIdentity(path.join(os.homedir(), '.codex', 'auth.json')) || 'codex:provider-default';
+  }
+  if (harness === 'claude_code') {
+    return readJsonIdentity(path.join(os.homedir(), '.claude.json'))
+      || readJsonIdentity(path.join(os.homedir(), '.claude', 'auth.json'))
+      || 'claude_code:provider-default';
+  }
+  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 nativeProviderHome(harness) {
+  if (harness === 'claude_code') return os.homedir();
+  return null;
+}
+
+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 providerAuthFingerprint(harness) {
+  return fingerprint(providerAuthIdentity(harness));
+}
+
+function authEnvelope({ harness, authMethod, sessionId, localBaseUrl, proxyToken, proxyBaseUrl, amalgmDir, userId, credentialId, modelId, cliHomePath, authProfileId }) {
   const method = coerceAuth(harness, authMethod);
   const byok = readByokFile(amalgmDir);
   let baseUrl = null;
@@ -116,6 +171,7 @@ 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,
@@ -125,7 +181,11 @@ function authEnvelope({ harness, authMethod, sessionId, localBaseUrl, proxyToken
     forwardBaseUrl,
     tokenRef,
     tokenFingerprint,
-    runtimeHome: runtimeHome({ amalgmDir, sessionId, harness, authMethod: method, tokenFingerprint }),
+    authProfileId: profileId,
+    runtimeHome:
+      nativeProviderHome(method === 'provider_auth' ? harness : null)
+      || pinnedRuntimeHome(amalgmDir, cliHomePath)
+      || runtimeHome({ amalgmDir, harness, authProfileId: profileId }),
   };
 }
 
@@ -142,11 +202,21 @@ function runtimeEnv(contract, baseEnv = process.env) {
   for (const key of ['OPENAI_API_KEY', 'OPENAI_BASE_URL', 'ANTHROPIC_API_KEY', 'ANTHROPIC_BASE_URL', 'AI_GATEWAY_API_KEY', 'AI_GATEWAY_BASE_URL']) {
     delete env[key];
   }
+  if (contract.harness === 'claude_code' && contract.authMethod === 'provider_auth') {
+    env.HOME = os.homedir();
+    delete env.CLAUDE_CONFIG_DIR;
+    return {
+      ...env,
+      IS_SANDBOX: '1',
+      ...(baseEnv.AMALGM_RUNTIME_TOKEN ? { AMALGM_RUNTIME_TOKEN: baseEnv.AMALGM_RUNTIME_TOKEN } : {}),
+    };
+  }
   if (contract.auth.runtimeHome) {
     fs.mkdirSync(contract.auth.runtimeHome, { recursive: true });
     env.HOME = contract.auth.runtimeHome;
     env.CODEX_HOME = contract.auth.runtimeHome;
     env.CLAUDE_CONFIG_DIR = contract.auth.runtimeHome;
+    env.OPENCODE_HOME = contract.auth.runtimeHome;
     env.OPENCODE_CONFIG_DIR = contract.auth.runtimeHome;
   }
   env.IS_SANDBOX = '1';

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

@@ -326,6 +326,7 @@ function createContract(payload, options = {}) {
   const cwd = resolveCwd(payload.cwd, options);
   const localBaseUrl = options.localBaseUrl || `http://127.0.0.1:${options.port || runtimePort('chat-server')}`;
   const origin = normalizeOrigin({ ...payload, cwd });
+  const userId = payload.userId || options.userId || 'unknown-user';
   const auth = authEnvelope({
     harness,
     authMethod,
@@ -334,12 +335,15 @@ function createContract(payload, options = {}) {
     proxyToken: options.proxyToken || PROXY_TOKEN,
     proxyBaseUrl: options.proxyBaseUrl || PROXY_BASE_URL || 'https://amalgm-api-proxy-v2.fly.dev',
     amalgmDir: options.amalgmDir || AMALGM_DIR || path.join(process.env.HOME || '.', '.amalgm'),
+    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,
-    userId: payload.userId || options.userId || 'unknown-user',
+    userId,
     computerId: payload.computerId || process.env.AMALGM_CONTAINER_ID || 'local-computer',
     assistantMessageId,
     userMessageId: payload.userMessageId || null,

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

@@ -15,6 +15,13 @@ function warnIfDbNotSaved(result, label) {
   return true;
 }
 
+function assertDbSaved(result, label) {
+  if (result === false || result === null) {
+    throw new Error(`${label} was not saved; keeping temp/raw stream for reconnect`);
+  }
+  return true;
+}
+
 async function bestEffortDbSave(label, fn) {
   try {
     return warnIfDbNotSaved(await fn(), label);
@@ -43,6 +50,23 @@ async function withDeadline(label, promise, ms) {
   }
 }
 
+function scheduleTitleGeneration({ db, userMessageSave, contract, input, turns, turnId, writeFrame }) {
+  if (typeof db.generateAndSaveTitle !== 'function' || !input.text) return null;
+  return Promise.resolve(userMessageSave)
+    .then((saved) => {
+      if (saved === false || saved === null) return null;
+      return db.generateAndSaveTitle(contract.sessionId, input.text, (title) => {
+        const frame = titleFrame({ sessionId: contract.sessionId, title });
+        const chunk = turns.addChunk(turnId, (index) => withSseId(frame, index));
+        if (writeFrame && chunk) writeFrame(chunk.data);
+      });
+    })
+    .catch((err) => {
+      console.warn('[ChatCore] Title generation failed:', err.message);
+      return null;
+    });
+}
+
 class ChatCore {
   constructor({ db, runtime, turns, options = {} }) {
     this.db = db;
@@ -72,20 +96,31 @@ class ChatCore {
     };
   }
 
-  async stop(sessionId) {
+  async finalizeActiveTurn(sessionId) {
     const entry = this.turns.active(sessionId);
     if (!entry) return false;
-    this.turns.mark(entry.turnId, 'cancelling');
-    await this.runtime.stop(sessionId);
+    if (!entry.streamEnded) {
+      this.turns.mark(entry.turnId, 'cancelling');
+      await this.runtime.stop(sessionId);
+    }
+    if (entry.finalized && typeof entry.finalized.then === 'function') {
+      await entry.finalized;
+    }
     return true;
   }
 
+  async stop(sessionId) {
+    return this.finalizeActiveTurn(sessionId);
+  }
+
   async destroy(sessionId) {
     this.contracts.delete(sessionId);
     return this.runtime.destroy(sessionId);
   }
 
   async runTurn(payload, writeFrame) {
+    const sessionId = payload.codeSessionId || payload.sessionId;
+    if (sessionId) await this.finalizeActiveTurn(sessionId);
     const contract = this.contractFor(payload);
     await this.beginTurn(contract);
     const input = normalizeInput(payload);
@@ -121,10 +156,6 @@ class ChatCore {
         console.warn('[ChatCore] Failed to load cold-resume conversation history:', err.message);
       }
     }
-    const assistantPlaceholderSave = bestEffortDbSave(
-      'Assistant placeholder',
-      () => this.db.ensureAssistantMessage(msgConfig),
-    );
     this.db.mergeSessionMetadata(contract.sessionId, {
       contract: {
         userId: contract.userId,
@@ -148,6 +179,7 @@ class ChatCore {
         auth: {
           baseUrl: contract.auth.baseUrl,
           tokenFingerprint: contract.auth.tokenFingerprint,
+          authProfileId: contract.auth.authProfileId,
           runtimeHome: contract.auth.runtimeHome,
         },
       },
@@ -161,19 +193,23 @@ class ChatCore {
     });
     entry.persistence = {
       userMessageSaved: null,
-      assistantPlaceholderSaved: null,
       assistantMessageSaved: null,
     };
+    entry.streamEnded = false;
+    let resolveFinalized = null;
+    entry.finalized = new Promise((resolve) => {
+      resolveFinalized = resolve;
+    });
 
-    if (typeof this.db.generateAndSaveTitle === 'function' && input.text) {
-      this.db.generateAndSaveTitle(contract.sessionId, input.text, (title) => {
-        const frame = titleFrame({ sessionId: contract.sessionId, title });
-        const chunk = this.turns.addChunk(turnId, (index) => withSseId(frame, index));
-        if (writeFrame && chunk) writeFrame(chunk.data);
-      }).catch((err) => {
-        console.warn('[ChatCore] Title generation failed:', err.message);
-      });
-    }
+    scheduleTitleGeneration({
+      db: this.db,
+      userMessageSave,
+      contract,
+      input,
+      turns: this.turns,
+      turnId,
+      writeFrame,
+    });
 
     const parts = new PartAccumulator();
     let usage = null;
@@ -181,8 +217,10 @@ class ChatCore {
     let providerSessionId = contract.providerSessionId || null;
     let stopReason = 'end_turn';
     let sawDone = false;
+    let finalDoneEvent = null;
 
-    const append = (e) => {
+    const append = (e, options = {}) => {
+      const emitFrame = options.emitFrame !== false;
       if (e.providerSessionId) providerSessionId = e.providerSessionId;
       if (e.type === 'usage.final') {
         usage = e.usage;
@@ -191,62 +229,65 @@ class ChatCore {
       if (e.type === 'done') {
         sawDone = true;
         stopReason = e.stopReason || stopReason;
+        finalDoneEvent = e;
       }
       parts.apply(e);
+      if (!emitFrame) return;
       const frame = frameFor(e, { sessionId: contract.sessionId, providerSessionId, usage });
       const chunk = this.turns.addChunk(turnId, (index) => withSseId(frame, index));
       if (writeFrame && chunk) writeFrame(chunk.data);
     };
 
     try {
-      const stream = await this.runtime.prompt(contract, runtimeInput);
-      for await (const e of stream) append(e);
-      const current = this.turns.get(turnId);
-      if (!sawDone) {
-        append(done({
-          providerSessionId,
-          stopReason: current?.status === 'cancelling' ? 'cancelled' : stopReason,
-        }));
+      try {
+        const stream = await this.runtime.prompt(contract, runtimeInput);
+        for await (const e of stream) append(e, { emitFrame: e.type !== 'done' });
+        const current = this.turns.get(turnId);
+        if (!sawDone) {
+          append(done({
+            providerSessionId,
+            stopReason: current?.status === 'cancelling' ? 'cancelled' : stopReason,
+          }), { emitFrame: false });
+        }
+      } catch (err) {
+        append(errorEvent(err.message, { providerSessionId }));
+        append(done({ providerSessionId, stopReason: 'error' }), { emitFrame: false });
+        stopReason = 'error';
       }
-    } catch (err) {
-      append(errorEvent(err.message, { providerSessionId }));
-      append(done({ providerSessionId, stopReason: 'error' }));
-      stopReason = 'error';
-    }
+      entry.streamEnded = true;
 
-    const savedParts = parts.finalize();
-    this.turns.setParts(turnId, savedParts);
-    this.turns.mark(turnId, 'persisting');
-    const finalizePersistence = async () => {
-      const [userMessageSaved, assistantPlaceholderSaved, assistantMessageSaved] = await Promise.all([
-        userMessageSave,
-        assistantPlaceholderSave,
-        bestEffortDbSave('Assistant message', () => this.db.saveAssistantMessage(msgConfig, savedParts, providerSessionId, usage)),
-      ]);
-      if (entry.persistence) {
-        entry.persistence.userMessageSaved = userMessageSaved;
-        entry.persistence.assistantPlaceholderSaved = assistantPlaceholderSaved;
-        entry.persistence.assistantMessageSaved = assistantMessageSaved;
-      }
-      await logTurnUsage({
-        db: this.db,
-        contract,
-        messageId: contract.assistantMessageId,
-        usage,
-        usageRecords,
-      });
-      if (!assistantMessageSaved || !userMessageSaved || !assistantPlaceholderSaved) {
+      const savedParts = parts.finalize();
+      this.turns.setParts(turnId, savedParts);
+      const finalizePersistence = async () => {
+        const userMessageSaved = await userMessageSave;
+        assertDbSaved(userMessageSaved, 'User message');
+        const assistantMessageSaved = await this.db.saveAssistantMessage(msgConfig, savedParts, providerSessionId, usage);
+        if (entry.persistence) {
+          entry.persistence.userMessageSaved = userMessageSaved;
+          entry.persistence.assistantMessageSaved = assistantMessageSaved;
+        }
+        assertDbSaved(assistantMessageSaved, 'Assistant message');
+        await logTurnUsage({
+          db: this.db,
+          contract,
+          messageId: contract.assistantMessageId,
+          usage,
+          usageRecords,
+        });
+      };
+      try {
+        await finalizePersistence();
+      } catch (err) {
         this.turns.mark(turnId, 'save_failed');
-      } else {
-        this.turns.mark(turnId, stopReason === 'error' ? 'error' : stopReason === 'cancelled' ? 'cancelled' : 'complete');
-        this.turns.clear(turnId);
+        throw err;
       }
-    };
-    finalizePersistence().catch((err) => {
-      console.warn('[ChatCore] Persistence finalization failed:', err.message);
-      this.turns.mark(turnId, 'save_failed');
-    });
-    return { providerSessionId, usage, parts: savedParts, stopReason };
+      append(finalDoneEvent || done({ providerSessionId, stopReason }));
+      this.turns.mark(turnId, stopReason === 'error' ? 'error' : stopReason === 'cancelled' ? 'cancelled' : 'complete');
+      this.turns.clear(turnId);
+      return { providerSessionId, usage, parts: savedParts, stopReason };
+    } finally {
+      if (resolveFinalized) resolveFinalized();
+    }
   }
 }
 

package/runtime/scripts/chat-core/event-schema.js

@@ -96,6 +96,13 @@ const textDeltaEvent = baseEvent.extend({
   streamKind: z.literal('text').optional(),
 }).strict();
 
+const textBoundaryEvent = baseEvent.extend({
+  type: z.literal('text.boundary'),
+  streamKind: z.literal('text').optional(),
+  itemId: z.string().optional(),
+  reason: z.string().optional(),
+}).strict();
+
 const reasoningDeltaEvent = baseEvent.extend({
   type: z.literal('reasoning.delta'),
   text: z.string(),
@@ -194,6 +201,7 @@ const compactionFinishedEvent = baseEvent.extend({
 
 const amalgmEventSchema = z.discriminatedUnion('type', [
   textDeltaEvent,
+  textBoundaryEvent,
   reasoningDeltaEvent,
   toolStartedEvent,
   toolUpdatedEvent,