amalgm 0.1.74 → 0.1.75

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amalgm",
-  "version": "0.1.74",
+  "version": "0.1.75",
   "description": "Amalgm local computer runtime: login, MCP, chat, events, previews, and tunnels.",
   "license": "UNLICENSED",
   "private": false,

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

@@ -102,8 +102,8 @@ class ChatCore {
       this.turns.mark(entry.turnId, 'cancelling');
       await this.runtime.stop(sessionId);
     }
-    if (entry.finalized && typeof entry.finalized.then === 'function') {
-      await entry.finalized;
+    if (entry.streamCompleted && typeof entry.streamCompleted.then === 'function') {
+      await entry.streamCompleted;
     }
     return true;
   }
@@ -196,6 +196,10 @@ class ChatCore {
     };
     entry.streamEnded = false;
     let resolveFinalized = null;
+    let resolveStreamCompleted = null;
+    entry.streamCompleted = new Promise((resolve) => {
+      resolveStreamCompleted = resolve;
+    });
     entry.finalized = new Promise((resolve) => {
       resolveFinalized = resolve;
     });
@@ -216,18 +220,15 @@ class ChatCore {
     let providerSessionId = contract.providerSessionId || null;
     let stopReason = 'end_turn';
     let sawDone = false;
-    let finalDoneEvent = null;
-    let finalDoneChunk = null;
 
     const append = (e, options = {}) => {
       const emitFrame = options.emitFrame !== false;
-      const visible = options.visible !== false;
       const nextProviderSessionId = e.providerSessionId || providerSessionId;
       const nextUsage = e.type === 'usage.final' ? e.usage : usage;
       let chunk = null;
       if (emitFrame) {
         const frame = frameFor(e, { sessionId: contract.sessionId, providerSessionId: nextProviderSessionId, usage: nextUsage });
-        chunk = this.turns.addChunk(turnId, (index) => withSseId(frame, index), { visible, seal: e.type === 'done' });
+        chunk = this.turns.addChunk(turnId, (index) => withSseId(frame, index), { seal: e.type === 'done' });
         if (!chunk) throw new Error('Raw stream write failed before event application');
       }
       if (e.providerSessionId) providerSessionId = e.providerSessionId;
@@ -238,8 +239,6 @@ class ChatCore {
       if (e.type === 'done') {
         sawDone = true;
         stopReason = e.stopReason || stopReason;
-        finalDoneEvent = e;
-        finalDoneChunk = chunk;
       }
       parts.apply(e);
       return chunk;
@@ -248,20 +247,22 @@ class ChatCore {
     try {
       try {
         const stream = await this.runtime.prompt(contract, runtimeInput);
-        for await (const e of stream) append(e, { visible: e.type !== 'done' });
+        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,
-          }), { visible: false });
+          }));
         }
       } catch (err) {
         append(errorEvent(err.message, { providerSessionId }));
-        append(done({ providerSessionId, stopReason: 'error' }), { visible: false });
+        append(done({ providerSessionId, stopReason: 'error' }));
         stopReason = 'error';
       }
       entry.streamEnded = true;
+      this.turns.mark(turnId, stopReason === 'error' ? 'error' : stopReason === 'cancelled' ? 'cancelled' : 'complete');
+      if (resolveStreamCompleted) resolveStreamCompleted();
 
       const savedParts = parts.finalize();
       this.turns.setParts(turnId, savedParts);
@@ -288,15 +289,10 @@ class ChatCore {
         this.turns.mark(turnId, 'save_failed');
         throw err;
       }
-      if (finalDoneChunk) {
-        this.turns.releaseChunk(turnId, finalDoneChunk.index);
-      } else {
-        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 (resolveStreamCompleted) resolveStreamCompleted();
       if (resolveFinalized) resolveFinalized();
     }
   }

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

@@ -47,23 +47,10 @@ class TurnStore {
     if (Number.isInteger(entry.sealedIndex)) return null;
     const index = entry.chunks.length;
     const data = typeof frame === 'function' ? frame(index) : frame;
-    const visible = options.visible !== false;
-    const chunk = { index, data, timestamp: Date.now(), visible };
+    const chunk = { index, data, timestamp: Date.now() };
     entry.chunks.push(chunk);
     if (options.seal === true) entry.sealedIndex = index;
     entry.updatedAt = Date.now();
-    if (visible) this.emit(turnId, chunk, entry);
-    return chunk;
-  }
-
-  releaseChunk(turnId, index) {
-    const entry = this.turns.get(turnId);
-    if (!entry || !['streaming', 'cancelling'].includes(entry.status)) return null;
-    const chunk = entry.chunks.find((candidate) => candidate.index === index);
-    if (!chunk) return null;
-    if (chunk.visible !== false) return chunk;
-    chunk.visible = true;
-    entry.updatedAt = Date.now();
     this.emit(turnId, chunk, entry);
     return chunk;
   }
@@ -90,12 +77,9 @@ class TurnStore {
     this.listeners.delete(turnId);
   }
 
-  chunksAfter(turnId, afterIndex = -1, options = {}) {
+  chunksAfter(turnId, afterIndex = -1) {
     const entry = this.turns.get(turnId);
-    const visibleOnly = options.visibleOnly === true;
-    return entry
-      ? entry.chunks.filter((chunk) => chunk.index > afterIndex && (!visibleOnly || chunk.visible !== false))
-      : [];
+    return entry ? entry.chunks.filter((chunk) => chunk.index > afterIndex) : [];
   }
 
   subscribe(turnId, callback) {

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

@@ -59,10 +59,6 @@ function normalizeAfterIndex(afterIndex) {
   return Number.isFinite(afterIndex) ? afterIndex : -1;
 }
 
-function visibleChunks(entry) {
-  return entry.chunks.filter((chunk) => chunk.visible !== false);
-}
-
 function writeTurnTail(core, entry, sse, options = {}) {
   const format = options.format || 'frame';
   let lastSent = normalizeAfterIndex(options.afterIndex);
@@ -73,7 +69,7 @@ function writeTurnTail(core, entry, sse, options = {}) {
       sse.write(namedSse('chunk', {
         codeSessionId: current.sessionId,
         chunk,
-        total: visibleChunks(current).length,
+        total: current.chunks.length,
       }));
     } else {
       sse.write(chunk.data);
@@ -85,7 +81,7 @@ function writeTurnTail(core, entry, sse, options = {}) {
     if (format === 'raw-temp') {
       sse.write(namedSse('complete', {
         codeSessionId: current.sessionId,
-        total: visibleChunks(current).length,
+        total: current.chunks.length,
       }));
       sse.end();
       return;
@@ -105,7 +101,7 @@ function writeTurnTail(core, entry, sse, options = {}) {
   });
   sse.addCleanup(off);
 
-  const existing = visibleChunks(entry).filter((chunk) => chunk.index > lastSent);
+  const existing = entry.chunks.filter((chunk) => chunk.index > lastSent);
   if (format === 'raw-temp') {
     sse.write(namedSse('existing', {
       codeSessionId: entry.sessionId,

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

@@ -88,11 +88,10 @@ test('title generation waits for user save and does not block a fast turn', asyn
   await waitTick();
 
   assert.equal(titleStarted, false, 'title generation should not race ahead of the user message save');
-  assert.equal(frames.some((frame) => frame.includes('"complete"')), false, 'complete waits for final persistence');
+  assert.equal(frames.some((frame) => frame.includes('"complete"')), true, 'complete follows raw stream, not final persistence');
 
   resolveUserSave();
   await run;
-  assert.equal(frames.some((frame) => frame.includes('"complete"')), true, 'turn completes after persistence settles');
   assert.equal(frames.some((frame) => frame.includes('"title_generated"')), false, 'pending title should not hold the stream open');
   await waitTick();
   assert.equal(titleStarted, true, 'title generation should start after the user message save settles');
@@ -103,7 +102,7 @@ test('title generation waits for user save and does not block a fast turn', asyn
   assert.equal(frames.some((frame) => frame.includes('"title_generated"')), false);
 });
 
-test('complete frame waits for assistant message save', async () => {
+test('complete frame is visible before assistant message save settles', async () => {
   let resolveAssistantSave;
   const db = {
     saveUserMessage: async () => true,
@@ -127,18 +126,16 @@ test('complete frame waits for assistant message save', async () => {
   await waitTick();
 
   assert.equal(frames.some((frame) => frame.includes('agent_message_chunk')), true, 'content should still stream immediately');
-  assert.equal(frames.some((frame) => frame.includes('"complete"')), false, 'complete must not outrun assistant save');
-  assert.equal(core.active('session-test').active, true, 'turn remains active while persistence is pending');
+  assert.equal(frames.some((frame) => frame.includes('"complete"')), true, 'complete follows raw-temp before assistant save');
+  assert.equal(core.active('session-test').active, false, 'turn is no longer active once raw stream completes');
   const pendingEntry = core.turns.latest('session-test');
   const pendingComplete = pendingEntry.chunks.find((chunk) => chunk.data.includes('"_type":"complete"'));
-  assert.ok(pendingComplete, 'raw-temp stores final complete before assistant save');
-  assert.equal(pendingComplete.visible, false, 'final complete is hidden from UI until assistant save succeeds');
+  assert.ok(pendingComplete, 'raw-temp stores final complete while assistant save is pending');
   assert.equal(pendingEntry.sealedIndex, pendingComplete.index, 'final complete seals the raw-temp log');
 
   resolveAssistantSave();
   await run;
 
-  assert.equal(frames.some((frame) => frame.includes('"complete"')), true, 'complete is emitted after assistant save');
   assert.equal(core.turns.active('session-test'), null, 'temp/raw state clears after save and complete');
 });
 
@@ -203,7 +200,7 @@ test('provider streams while user save is pending but assistant save waits', asy
   await run;
 });
 
-test('stop waits for cancelled turn persistence', async () => {
+test('stop waits for cancelled raw stream but not persistence', async () => {
   let releaseRuntime;
   let resolveAssistantSave;
   const fakeRuntime = {
@@ -248,8 +245,8 @@ test('stop waits for cancelled turn persistence', async () => {
   });
   await waitTick();
 
-  assert.equal(stopResolved, false, 'stop should wait for cancelled turn persistence');
-  assert.equal(frames.some((frame) => frame.includes('"stopReason":"cancelled"')), false, 'cancelled complete waits for save');
+  assert.equal(stopResolved, true, 'stop resolves once cancelled raw stream completes');
+  assert.equal(frames.some((frame) => frame.includes('"stopReason":"cancelled"')), true, 'cancelled complete follows raw stream before save');
 
   resolveAssistantSave();
   assert.equal(await stop, true);
@@ -261,7 +258,7 @@ test('stop waits for cancelled turn persistence', async () => {
   assert.equal(core.turns.latest('session-test'), null, 'cancelled raw-temp clears after save');
 });
 
-test('new turn waits for active turn finalization before starting', async () => {
+test('new turn can start after prior raw stream completes while save is pending', async () => {
   let resolveFirstSave;
   let stopCalls = 0;
   const prompts = [];
@@ -315,8 +312,8 @@ test('new turn waits for active turn finalization before starting', async () =>
   }));
   await waitTick();
 
-  assert.deepEqual(prompts, ['first'], 'second provider turn should not start before first finalizes');
-  assert.equal(dbCalls.some((call) => call[0] === 'saveUserMessage' && call[1] === 'user-test-2'), false, 'second turn persistence waits too');
+  assert.deepEqual(prompts, ['first', 'second'], 'second provider turn starts after first raw stream completes');
+  assert.equal(dbCalls.some((call) => call[0] === 'saveUserMessage' && call[1] === 'user-test-2'), true, 'second turn persistence starts independently');
   assert.equal(stopCalls, 0, 'finished stream should be awaited, not stopped during final save');
 
   resolveFirstSave();
@@ -324,5 +321,4 @@ test('new turn waits for active turn finalization before starting', async () =>
   await second;
 
   assert.deepEqual(prompts, ['first', 'second']);
-  assert.equal(dbCalls.some((call) => call[0] === 'saveUserMessage' && call[1] === 'user-test-2'), true);
 });

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

@@ -108,9 +108,11 @@ test('POST /chat streams from the same indexed raw chunks as /raw-temp', async (
     assert.match(rawExisting, /"index":0/);
     assert.match(rawExisting, /agent_message_chunk/);
 
+    const completeFrame = firstChatFrame.includes('"complete"')
+      ? firstChatFrame
+      : await readUntil(chatReader, '"complete"');
+    assert.match(completeFrame, /"stopReason":"end_turn"/);
     resolveAssistantSave();
-    const rest = await readUntil(chatReader, '"complete"');
-    assert.match(rest, /"stopReason":"end_turn"/);
   } finally {
     await new Promise((resolve) => server.close(resolve));
   }