@genesislcap/ai-assistant 15.2.0 → 15.3.0

package/dist/dts/state/persistence/diagnostics.d.ts

@@ -39,13 +39,21 @@ export interface DebugLog {
     meta: unknown;
 }
 /**
- * Stable identity for a message diagnostic entry — `timestamp::role::subAgentOf`.
+ * Stable identity for a message diagnostic entry — `timestamp::role::subAgentOf::category`.
  * Used by the forward-capture delta (skip already-emitted messages) and by the
  * restore watermark (skip messages already present in a prior load's stream).
  * `null` when the entry has no timestamp → treat as always-new. Shared so the
  * element's diagnostics capture and the `SessionPersister`'s restore watermark
  * compute identity identically (GENC-1351 §5.8/§5.10).
  *
+ * `category` is part of the key because the reasoning/narration/answer split (GENC-1411) emits
+ * SEVERAL messages from one model response — the thought summary, any interstitial narration, and
+ * the answer/tool-call message — which share `timestamp` + `role` + `subAgentOf`. Keying on those
+ * alone collapsed them to one, so the forward-capture dropped all but the first: a server
+ * generation's answer message vanished from the persisted debug log while its reasoning survived
+ * (GENC-1461). `category` is stable across a message's in-place annotation (only `toolCalls` change,
+ * which is deliberately excluded), so a genuine re-append of the same message still dedups.
+ *
  * @internal
  */
 export declare function diagnosticsMessageKey(entry: DiagnosticEntry): string | null;

package/dist/dts/state/persistence/diagnostics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"diagnostics.d.ts","sourceRoot":"","sources":["../../../../src/state/persistence/diagnostics.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;;;;;;;GASG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,SAAS,GAAG,MAAM,GAAG,OAAO,GAAG,eAAe,CAAC;IACrD,kFAAkF;IAClF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,wEAAwE;IACxE,IAAI,CAAC,EAAE,OAAO,CAAC;IACf;;;;;OAKG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,mFAAmF;AACnF,MAAM,WAAW,QAAQ;IACvB,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,QAAQ,EAAE,eAAe,EAAE,CAAC;IAC5B,IAAI,EAAE,OAAO,CAAC;CACf;AAED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,GAAG,IAAI,CAI3E;AASD;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,eAAe,EAAE,EAAE,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,QAAQ,CA+BhG"}
+{"version":3,"file":"diagnostics.d.ts","sourceRoot":"","sources":["../../../../src/state/persistence/diagnostics.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;;;;;;;GASG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,SAAS,GAAG,MAAM,GAAG,OAAO,GAAG,eAAe,CAAC;IACrD,kFAAkF;IAClF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,wEAAwE;IACxE,IAAI,CAAC,EAAE,OAAO,CAAC;IACf;;;;;OAKG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,mFAAmF;AACnF,MAAM,WAAW,QAAQ;IACvB,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,QAAQ,EAAE,eAAe,EAAE,CAAC;IAC5B,IAAI,EAAE,OAAO,CAAC;CACf;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,GAAG,IAAI,CAI3E;AASD;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,eAAe,EAAE,EAAE,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,QAAQ,CA+BhG"}

package/dist/dts/state/persistence/session-persister.d.ts

@@ -165,6 +165,18 @@ export declare class SessionPersister {
      * (§5.8). Skips messages present at restore or already appended; emits each turn
      * (by turn-index) and meta-event (by index) once; appends a `meta-snapshot` only
      * when the block changed. Advances the shared per-session cursors as it goes.
+     *
+     * TODO(GENC-1461, longer-term): this whole delta step exists only because the element *pulls* the
+     * ENTIRE debug log on every throttled flush (`getDiagnosticEntries()` returns the full timeline),
+     * so we must diff it against per-session cursors to append only the new tail — and messages, unlike
+     * events (monotonic `index`) and turns (`turnIndex`), have no stable positional cursor (compaction
+     * rewrites ranges, tool-call messages are annotated in place, synthetic messages are spliced in,
+     * restore reloads them), forcing a content-derived identity (`diagnosticsMessageKey`). That
+     * identity is inherently fragile: it was too coarse for the reasoning/answer/tool-call split and
+     * silently dropped co-timestamped messages (GENC-1461; fixed for now by adding `category`). The
+     * robust fix is to invert the flow — have the driver *push* each diagnostic entry exactly once at
+     * creation (an append-only event stream) instead of the element pulling-and-diffing — which removes
+     * the message-identity key and this dedup entirely. Bigger change; deferred.
      */
     private collectDiagnosticsDelta;
     /** Cancel any pending timers. Called on explicit session teardown. */

package/dist/dts/state/persistence/session-persister.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session-persister.d.ts","sourceRoot":"","sources":["../../../../src/state/persistence/session-persister.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sCAAsC,CAAC;AAWrE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAC3D,OAAO,EAAyB,KAAK,eAAe,EAAE,MAAM,eAAe,CAAC;AAE5E,OAAO,KAAK,EAAE,wBAAwB,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAsCnG;;;;;;;GAOG;AACH,MAAM,WAAW,oBAAoB;IACnC,8DAA8D;IAC9D,QAAQ,EAAE,MAAM,CAAC;IACjB,oFAAoF;IACpF,cAAc,EAAE,MAAM,wBAAwB,CAAC;IAC/C,+EAA+E;IAC/E,aAAa,EAAE,MAAM,MAAM,EAAE,CAAC;IAC9B,oEAAoE;IACpE,SAAS,EAAE,MAAM,QAAQ,GAAG,SAAS,CAAC;IACtC,mEAAmE;IACnE,QAAQ,EAAE,MAAM,kBAAkB,GAAG,SAAS,CAAC;IAC/C;;;;OAIG;IACH,oBAAoB,EAAE,MAAM,eAAe,EAAE,CAAC;CAC/C;AAED;;;;;;;;;;;;;;GAcG;AACH,qBAAa,gBAAgB;IA0Bf,OAAO,CAAC,IAAI;IAzBxB,OAAO,CAAC,UAAU,CAAC,CAAgC;IACnD,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,iBAAiB,CAAC,CAAgC;IAC1D,OAAO,CAAC,kBAAkB,CAAK;IAC/B;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAA+B;IAC7C;;;;;OAKG;IACH,OAAO,CAAC,kBAAkB,CAAmC;IAC7D;;;;;OAKG;IACH,OAAO,CAAC,uBAAuB,CAAS;gBAEpB,IAAI,EAAE,oBAAoB;IAE9C;;;;;;;;;;OAUG;IACH,UAAU,CAAC,IAAI,EAAE,oBAAoB,GAAG,IAAI;IAI5C,0FAA0F;IAC1F,IAAI,iBAAiB,IAAI,kBAAkB,GAAG,IAAI,CAEjD;IAED,uFAAuF;IACvF,IAAI,sBAAsB,IAAI,OAAO,CAEpC;IAED,OAAO,KAAK,QAAQ,GAEnB;IAED,OAAO,CAAC,OAAO;IAIf;;;;;OAKG;IACH,YAAY,IAAI,IAAI;IAapB;;;;;OAKG;IACH,iBAAiB,IAAI,IAAI;IAOzB;;;;OAIG;YACW,cAAc;IAsJ5B;;;;;;OAMG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAoK9B;;;;;;;OAOG;IACH,OAAO,CAAC,uBAAuB;IAU/B;;;;OAIG;IACG,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IAiBvC;;;;OAIG;IACG,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAatC;;;;;OAKG;IACH,eAAe,CAAC,KAAK,EAAE,kBAAkB,GAAG,IAAI;IAchD;;;;;;OAMG;IACH,mBAAmB,IAAI,IAAI;IAiB3B;;;;;;OAMG;IACG,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IAYvC;;;;;OAKG;IACH,OAAO,CAAC,uBAAuB;IAwC/B,sEAAsE;IACtE,OAAO,IAAI,IAAI;CAMhB"}
+{"version":3,"file":"session-persister.d.ts","sourceRoot":"","sources":["../../../../src/state/persistence/session-persister.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sCAAsC,CAAC;AAWrE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAC3D,OAAO,EAAyB,KAAK,eAAe,EAAE,MAAM,eAAe,CAAC;AAE5E,OAAO,KAAK,EAAE,wBAAwB,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAsCnG;;;;;;;GAOG;AACH,MAAM,WAAW,oBAAoB;IACnC,8DAA8D;IAC9D,QAAQ,EAAE,MAAM,CAAC;IACjB,oFAAoF;IACpF,cAAc,EAAE,MAAM,wBAAwB,CAAC;IAC/C,+EAA+E;IAC/E,aAAa,EAAE,MAAM,MAAM,EAAE,CAAC;IAC9B,oEAAoE;IACpE,SAAS,EAAE,MAAM,QAAQ,GAAG,SAAS,CAAC;IACtC,mEAAmE;IACnE,QAAQ,EAAE,MAAM,kBAAkB,GAAG,SAAS,CAAC;IAC/C;;;;OAIG;IACH,oBAAoB,EAAE,MAAM,eAAe,EAAE,CAAC;CAC/C;AAED;;;;;;;;;;;;;;GAcG;AACH,qBAAa,gBAAgB;IA0Bf,OAAO,CAAC,IAAI;IAzBxB,OAAO,CAAC,UAAU,CAAC,CAAgC;IACnD,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,iBAAiB,CAAC,CAAgC;IAC1D,OAAO,CAAC,kBAAkB,CAAK;IAC/B;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAA+B;IAC7C;;;;;OAKG;IACH,OAAO,CAAC,kBAAkB,CAAmC;IAC7D;;;;;OAKG;IACH,OAAO,CAAC,uBAAuB,CAAS;gBAEpB,IAAI,EAAE,oBAAoB;IAE9C;;;;;;;;;;OAUG;IACH,UAAU,CAAC,IAAI,EAAE,oBAAoB,GAAG,IAAI;IAI5C,0FAA0F;IAC1F,IAAI,iBAAiB,IAAI,kBAAkB,GAAG,IAAI,CAEjD;IAED,uFAAuF;IACvF,IAAI,sBAAsB,IAAI,OAAO,CAEpC;IAED,OAAO,KAAK,QAAQ,GAEnB;IAED,OAAO,CAAC,OAAO;IAIf;;;;;OAKG;IACH,YAAY,IAAI,IAAI;IAapB;;;;;OAKG;IACH,iBAAiB,IAAI,IAAI;IAOzB;;;;OAIG;YACW,cAAc;IAsJ5B;;;;;;OAMG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAoK9B;;;;;;;OAOG;IACH,OAAO,CAAC,uBAAuB;IAU/B;;;;OAIG;IACG,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IAiBvC;;;;OAIG;IACG,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAatC;;;;;OAKG;IACH,eAAe,CAAC,KAAK,EAAE,kBAAkB,GAAG,IAAI;IAchD;;;;;;OAMG;IACH,mBAAmB,IAAI,IAAI;IAiB3B;;;;;;OAMG;IACG,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IAYvC;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,uBAAuB;IAwC/B,sEAAsE;IACtE,OAAO,IAAI,IAAI;CAMhB"}

package/dist/esm/state/persistence/diagnostics.js

@@ -8,19 +8,27 @@
  * @packageDocumentation
  */
 /**
- * Stable identity for a message diagnostic entry — `timestamp::role::subAgentOf`.
+ * Stable identity for a message diagnostic entry — `timestamp::role::subAgentOf::category`.
  * Used by the forward-capture delta (skip already-emitted messages) and by the
  * restore watermark (skip messages already present in a prior load's stream).
  * `null` when the entry has no timestamp → treat as always-new. Shared so the
  * element's diagnostics capture and the `SessionPersister`'s restore watermark
  * compute identity identically (GENC-1351 §5.8/§5.10).
  *
+ * `category` is part of the key because the reasoning/narration/answer split (GENC-1411) emits
+ * SEVERAL messages from one model response — the thought summary, any interstitial narration, and
+ * the answer/tool-call message — which share `timestamp` + `role` + `subAgentOf`. Keying on those
+ * alone collapsed them to one, so the forward-capture dropped all but the first: a server
+ * generation's answer message vanished from the persisted debug log while its reasoning survived
+ * (GENC-1461). `category` is stable across a message's in-place annotation (only `toolCalls` change,
+ * which is deliberately excluded), so a genuine re-append of the same message still dedups.
+ *
  * @internal
  */
 export function diagnosticsMessageKey(entry) {
-    var _a, _b;
+    var _a, _b, _c;
     return typeof entry.timestamp === 'string'
-        ? `${entry.timestamp}::${(_a = entry.role) !== null && _a !== void 0 ? _a : ''}::${(_b = entry.subAgentOf) !== null && _b !== void 0 ? _b : ''}`
+        ? `${entry.timestamp}::${(_a = entry.role) !== null && _a !== void 0 ? _a : ''}::${(_b = entry.subAgentOf) !== null && _b !== void 0 ? _b : ''}::${(_c = entry.category) !== null && _c !== void 0 ? _c : ''}`
         : null;
 }
 // Tie-break co-timestamped entries by cause → call → output (event, turn, message),

package/dist/esm/state/persistence/diagnostics.test.js

@@ -1,5 +1,5 @@
 import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { assembleDebugLog } from './diagnostics';
+import { assembleDebugLog, diagnosticsMessageKey } from './diagnostics';
 // GENC-1351 §5.8: `assembleDebugLog` reassembles the forward-only diagnostics
 // stream back into the `{ readme, timeline, meta }` debug-log shape — timeline
 // sorted by timestamp, meta-snapshots pulled out with the latest winning.
@@ -70,3 +70,38 @@ Suite('collapses exact-duplicate entries but keeps genuinely-distinct ones', ()
     assert.is(timeline.filter((e) => e.type === 'assistant.connected').length, 2, 'two distinct connects (different index) kept; the repeated connA collapsed');
 });
 Suite.run();
+// GENC-1461: the reasoning/narration/answer split (GENC-1411) emits several messages from ONE model
+// response, so they share `timestamp` + `role` + `subAgentOf`. The message identity key must still
+// tell them apart — otherwise the forward-capture dedup treats them as one and drops all but the
+// first (a server generation's answer message vanished from the persisted download while its
+// reasoning survived).
+const KeySuite = createLogicSuite('diagnosticsMessageKey');
+KeySuite('gives co-timestamped split messages (reasoning vs answer) distinct keys', () => {
+    const base = {
+        kind: 'message',
+        role: 'assistant',
+        timestamp: '2026-01-01T00:00:05.000Z',
+    };
+    const reasoning = Object.assign(Object.assign({}, base), { category: 'reasoning', content: 'thinking…' });
+    const answer = Object.assign(Object.assign({}, base), { content: 'the generated code' }); // no category = the answer
+    const kReasoning = diagnosticsMessageKey(reasoning);
+    const kAnswer = diagnosticsMessageKey(answer);
+    assert.ok(kReasoning, 'reasoning message has a key');
+    assert.ok(kAnswer, 'answer message has a key');
+    assert.not.equal(kReasoning, kAnswer, 'a reasoning and an answer split from one response must not collide');
+});
+KeySuite('still collapses a genuine re-append of the same message (same key)', () => {
+    const m = {
+        kind: 'message',
+        role: 'assistant',
+        timestamp: '2026-01-01T00:00:05.000Z',
+        category: 'reasoning',
+        content: 'thinking…',
+    };
+    // Two instances / a reload re-appending the SAME message must still share one key.
+    assert.equal(diagnosticsMessageKey(m), diagnosticsMessageKey(Object.assign({}, m)));
+});
+KeySuite('returns null when the entry has no timestamp (treated as always-new)', () => {
+    assert.is(diagnosticsMessageKey({ kind: 'message', role: 'assistant' }), null);
+});
+KeySuite.run();

package/dist/esm/state/persistence/session-persister.js

@@ -585,6 +585,18 @@ export class SessionPersister {
      * (§5.8). Skips messages present at restore or already appended; emits each turn
      * (by turn-index) and meta-event (by index) once; appends a `meta-snapshot` only
      * when the block changed. Advances the shared per-session cursors as it goes.
+     *
+     * TODO(GENC-1461, longer-term): this whole delta step exists only because the element *pulls* the
+     * ENTIRE debug log on every throttled flush (`getDiagnosticEntries()` returns the full timeline),
+     * so we must diff it against per-session cursors to append only the new tail — and messages, unlike
+     * events (monotonic `index`) and turns (`turnIndex`), have no stable positional cursor (compaction
+     * rewrites ranges, tool-call messages are annotated in place, synthetic messages are spliced in,
+     * restore reloads them), forcing a content-derived identity (`diagnosticsMessageKey`). That
+     * identity is inherently fragile: it was too coarse for the reasoning/answer/tool-call split and
+     * silently dropped co-timestamped messages (GENC-1461; fixed for now by adding `category`). The
+     * robust fix is to invert the flow — have the driver *push* each diagnostic entry exactly once at
+     * creation (an append-only event stream) instead of the element pulling-and-diffing — which removes
+     * the message-identity key and this dedup entirely. Bigger change; deferred.
      */
     collectDiagnosticsDelta() {
         var _a;

package/dist/esm/state/persistence/session-persister.test.js

@@ -263,6 +263,9 @@ const metaSnap = (dedupSignature, meta) => ({
     meta,
     dedupSignature,
 });
+// A diagnostic MESSAGE entry as the reasoning/narration/answer split (GENC-1411) produces them —
+// several messages from ONE response, sharing timestamp + role, differing by `category` / content.
+const diagMsg = (over = {}) => (Object.assign({ kind: 'message', role: 'assistant', timestamp: '2026-01-01T00:00:05.000Z', content: '' }, over));
 Suite('scheduleDiagnostics() appends the collected delta once per window', () => __awaiter(void 0, void 0, void 0, function* () {
     const { p, f } = makePersister({ diagnosticEntries: [evt(0), evt(1)] });
     p.scheduleDiagnostics();
@@ -311,4 +314,26 @@ Suite('flushDiagnostics() dedups meta-snapshots by dedupSignature, not the volat
     yield p.flushDiagnostics();
     assert.is(f.appended.length, 2, 'changed config → re-appended');
 }));
+Suite('flushDiagnostics() keeps co-timestamped split messages (reasoning + answer), not deduped as one', () => __awaiter(void 0, void 0, void 0, function* () {
+    // GENC-1461: the reasoning/narration/answer split emits several messages from ONE response, so
+    // they share timestamp + role + subAgentOf. The forward-capture keyed only on those, so it
+    // emitted the reasoning message and dropped the answer as a "duplicate" — a server generation's
+    // answer message vanished from the persisted download while its reasoning survived. Both must be
+    // captured.
+    const reasoning = diagMsg({ category: 'reasoning', content: 'thinking…' });
+    const answer = diagMsg({ content: 'the generated code' }); // no category = the answer/tool-call slot
+    const { p, f } = makePersister({ diagnosticEntries: [reasoning, answer] });
+    yield p.flushDiagnostics();
+    assert.is(f.appended.length, 1, 'one flush');
+    assert.is(f.appended[0].length, 2, 'both the reasoning and the answer message are captured, not collapsed to one');
+}));
+Suite('flushDiagnostics() still dedups a genuine re-append of the same message across flushes', () => __awaiter(void 0, void 0, void 0, function* () {
+    // The dedup must still stop the SAME message being re-appended on every throttled flush.
+    const m = diagMsg({ category: 'reasoning', content: 'thinking…' });
+    const { p, f } = makePersister({ diagnosticEntries: [m] });
+    yield p.flushDiagnostics();
+    assert.is(f.appended.length, 1, 'first flush appends the message');
+    yield p.flushDiagnostics();
+    assert.is(f.appended.length, 1, 'unchanged message → no re-append');
+}));
 Suite.run();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@genesislcap/ai-assistant",
   "description": "Genesis AI Assistant micro-frontend",
-  "version": "15.2.0",
+  "version": "15.3.0",
   "license": "SEE LICENSE IN license.txt",
   "main": "dist/esm/index.js",
   "types": "dist/ai-assistant.d.ts",
@@ -73,26 +73,26 @@
     }
   },
   "devDependencies": {
-    "@genesislcap/foundation-testing": "15.2.0",
-    "@genesislcap/genx": "15.2.0",
-    "@genesislcap/rollup-builder": "15.2.0",
-    "@genesislcap/ts-builder": "15.2.0",
-    "@genesislcap/uvu-playwright-builder": "15.2.0",
-    "@genesislcap/vite-builder": "15.2.0",
-    "@genesislcap/webpack-builder": "15.2.0",
+    "@genesislcap/foundation-testing": "15.3.0",
+    "@genesislcap/genx": "15.3.0",
+    "@genesislcap/rollup-builder": "15.3.0",
+    "@genesislcap/ts-builder": "15.3.0",
+    "@genesislcap/uvu-playwright-builder": "15.3.0",
+    "@genesislcap/vite-builder": "15.3.0",
+    "@genesislcap/webpack-builder": "15.3.0",
     "@types/dompurify": "^3.0.5",
     "@types/marked": "^5.0.2",
     "esbuild": "0.25.12"
   },
   "dependencies": {
-    "@genesislcap/foundation-ai": "15.2.0",
-    "@genesislcap/foundation-logger": "15.2.0",
-    "@genesislcap/foundation-notifications": "15.2.0",
-    "@genesislcap/foundation-redux": "15.2.0",
-    "@genesislcap/foundation-ui": "15.2.0",
-    "@genesislcap/foundation-utils": "15.2.0",
-    "@genesislcap/rapid-design-system": "15.2.0",
-    "@genesislcap/web-core": "15.2.0",
+    "@genesislcap/foundation-ai": "15.3.0",
+    "@genesislcap/foundation-logger": "15.3.0",
+    "@genesislcap/foundation-notifications": "15.3.0",
+    "@genesislcap/foundation-redux": "15.3.0",
+    "@genesislcap/foundation-ui": "15.3.0",
+    "@genesislcap/foundation-utils": "15.3.0",
+    "@genesislcap/rapid-design-system": "15.3.0",
+    "@genesislcap/web-core": "15.3.0",
     "dompurify": "^3.3.1",
     "marked": "^17.0.3"
   },
@@ -105,5 +105,5 @@
     "access": "public"
   },
   "customElements": "dist/custom-elements.json",
-  "gitHead": "c39af72807245ad2240adf75233c2769213d9aba"
+  "gitHead": "a8d2fa3336de2307fb9b82d4be1d4939ac847d14"
 }

package/src/state/persistence/diagnostics.test.ts

@@ -1,5 +1,5 @@
 import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { assembleDebugLog, type DiagnosticEntry } from './diagnostics';
+import { assembleDebugLog, diagnosticsMessageKey, type DiagnosticEntry } from './diagnostics';
 
 // GENC-1351 §5.8: `assembleDebugLog` reassembles the forward-only diagnostics
 // stream back into the `{ readme, timeline, meta }` debug-log shape — timeline
@@ -93,3 +93,47 @@ Suite('collapses exact-duplicate entries but keeps genuinely-distinct ones', ()
 });
 
 Suite.run();
+
+// GENC-1461: the reasoning/narration/answer split (GENC-1411) emits several messages from ONE model
+// response, so they share `timestamp` + `role` + `subAgentOf`. The message identity key must still
+// tell them apart — otherwise the forward-capture dedup treats them as one and drops all but the
+// first (a server generation's answer message vanished from the persisted download while its
+// reasoning survived).
+const KeySuite = createLogicSuite('diagnosticsMessageKey');
+
+KeySuite('gives co-timestamped split messages (reasoning vs answer) distinct keys', () => {
+  const base = {
+    kind: 'message' as const,
+    role: 'assistant',
+    timestamp: '2026-01-01T00:00:05.000Z',
+  };
+  const reasoning: DiagnosticEntry = { ...base, category: 'reasoning', content: 'thinking…' };
+  const answer: DiagnosticEntry = { ...base, content: 'the generated code' }; // no category = the answer
+  const kReasoning = diagnosticsMessageKey(reasoning);
+  const kAnswer = diagnosticsMessageKey(answer);
+  assert.ok(kReasoning, 'reasoning message has a key');
+  assert.ok(kAnswer, 'answer message has a key');
+  assert.not.equal(
+    kReasoning,
+    kAnswer,
+    'a reasoning and an answer split from one response must not collide',
+  );
+});
+
+KeySuite('still collapses a genuine re-append of the same message (same key)', () => {
+  const m: DiagnosticEntry = {
+    kind: 'message',
+    role: 'assistant',
+    timestamp: '2026-01-01T00:00:05.000Z',
+    category: 'reasoning',
+    content: 'thinking…',
+  };
+  // Two instances / a reload re-appending the SAME message must still share one key.
+  assert.equal(diagnosticsMessageKey(m), diagnosticsMessageKey({ ...m }));
+});
+
+KeySuite('returns null when the entry has no timestamp (treated as always-new)', () => {
+  assert.is(diagnosticsMessageKey({ kind: 'message', role: 'assistant' }), null);
+});
+
+KeySuite.run();

package/src/state/persistence/diagnostics.ts

@@ -42,18 +42,26 @@ export interface DebugLog {
 }
 
 /**
- * Stable identity for a message diagnostic entry — `timestamp::role::subAgentOf`.
+ * Stable identity for a message diagnostic entry — `timestamp::role::subAgentOf::category`.
  * Used by the forward-capture delta (skip already-emitted messages) and by the
  * restore watermark (skip messages already present in a prior load's stream).
  * `null` when the entry has no timestamp → treat as always-new. Shared so the
  * element's diagnostics capture and the `SessionPersister`'s restore watermark
  * compute identity identically (GENC-1351 §5.8/§5.10).
  *
+ * `category` is part of the key because the reasoning/narration/answer split (GENC-1411) emits
+ * SEVERAL messages from one model response — the thought summary, any interstitial narration, and
+ * the answer/tool-call message — which share `timestamp` + `role` + `subAgentOf`. Keying on those
+ * alone collapsed them to one, so the forward-capture dropped all but the first: a server
+ * generation's answer message vanished from the persisted debug log while its reasoning survived
+ * (GENC-1461). `category` is stable across a message's in-place annotation (only `toolCalls` change,
+ * which is deliberately excluded), so a genuine re-append of the same message still dedups.
+ *
  * @internal
  */
 export function diagnosticsMessageKey(entry: DiagnosticEntry): string | null {
   return typeof entry.timestamp === 'string'
-    ? `${entry.timestamp}::${(entry.role as string) ?? ''}::${(entry.subAgentOf as string) ?? ''}`
+    ? `${entry.timestamp}::${(entry.role as string) ?? ''}::${(entry.subAgentOf as string) ?? ''}::${(entry.category as string) ?? ''}`
     : null;
 }
 

package/src/state/persistence/session-persister.test.ts

@@ -367,6 +367,16 @@ const metaSnap = (dedupSignature: string, meta: unknown): DiagnosticEntry => ({
   dedupSignature,
 });
 
+// A diagnostic MESSAGE entry as the reasoning/narration/answer split (GENC-1411) produces them —
+// several messages from ONE response, sharing timestamp + role, differing by `category` / content.
+const diagMsg = (over: Partial<DiagnosticEntry> = {}): DiagnosticEntry => ({
+  kind: 'message',
+  role: 'assistant',
+  timestamp: '2026-01-01T00:00:05.000Z',
+  content: '',
+  ...over,
+});
+
 Suite('scheduleDiagnostics() appends the collected delta once per window', async () => {
   const { p, f } = makePersister({ diagnosticEntries: [evt(0), evt(1)] });
   p.scheduleDiagnostics();
@@ -425,4 +435,38 @@ Suite(
   },
 );
 
+Suite(
+  'flushDiagnostics() keeps co-timestamped split messages (reasoning + answer), not deduped as one',
+  async () => {
+    // GENC-1461: the reasoning/narration/answer split emits several messages from ONE response, so
+    // they share timestamp + role + subAgentOf. The forward-capture keyed only on those, so it
+    // emitted the reasoning message and dropped the answer as a "duplicate" — a server generation's
+    // answer message vanished from the persisted download while its reasoning survived. Both must be
+    // captured.
+    const reasoning = diagMsg({ category: 'reasoning', content: 'thinking…' });
+    const answer = diagMsg({ content: 'the generated code' }); // no category = the answer/tool-call slot
+    const { p, f } = makePersister({ diagnosticEntries: [reasoning, answer] });
+    await p.flushDiagnostics();
+    assert.is(f.appended.length, 1, 'one flush');
+    assert.is(
+      f.appended[0].length,
+      2,
+      'both the reasoning and the answer message are captured, not collapsed to one',
+    );
+  },
+);
+
+Suite(
+  'flushDiagnostics() still dedups a genuine re-append of the same message across flushes',
+  async () => {
+    // The dedup must still stop the SAME message being re-appended on every throttled flush.
+    const m = diagMsg({ category: 'reasoning', content: 'thinking…' });
+    const { p, f } = makePersister({ diagnosticEntries: [m] });
+    await p.flushDiagnostics();
+    assert.is(f.appended.length, 1, 'first flush appends the message');
+    await p.flushDiagnostics();
+    assert.is(f.appended.length, 1, 'unchanged message → no re-append');
+  },
+);
+
 Suite.run();

package/src/state/persistence/session-persister.ts

@@ -638,6 +638,18 @@ export class SessionPersister {
    * (§5.8). Skips messages present at restore or already appended; emits each turn
    * (by turn-index) and meta-event (by index) once; appends a `meta-snapshot` only
    * when the block changed. Advances the shared per-session cursors as it goes.
+   *
+   * TODO(GENC-1461, longer-term): this whole delta step exists only because the element *pulls* the
+   * ENTIRE debug log on every throttled flush (`getDiagnosticEntries()` returns the full timeline),
+   * so we must diff it against per-session cursors to append only the new tail — and messages, unlike
+   * events (monotonic `index`) and turns (`turnIndex`), have no stable positional cursor (compaction
+   * rewrites ranges, tool-call messages are annotated in place, synthetic messages are spliced in,
+   * restore reloads them), forcing a content-derived identity (`diagnosticsMessageKey`). That
+   * identity is inherently fragile: it was too coarse for the reasoning/answer/tool-call split and
+   * silently dropped co-timestamped messages (GENC-1461; fixed for now by adding `category`). The
+   * robust fix is to invert the flow — have the driver *push* each diagnostic entry exactly once at
+   * creation (an append-only event stream) instead of the element pulling-and-diffing — which removes
+   * the message-identity key and this dedup entirely. Bigger change; deferred.
    */
   private collectDiagnosticsDelta(): DiagnosticEntry[] {
     const cursors = getDiagnosticsCursors(this.stateKey);