@genesislcap/ai-assistant 15.19.0 → 15.19.1

package/dist/esm/utils/cost-session-history.test.js

@@ -1,174 +0,0 @@
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { clearCostSessionHistory, costHistoryStorageKey, formatCostSessionDate, loadCostSessionHistory, resolveBankedUsage, saveCostSessionHistory, sortRecordsByRecency, upsertRecord, } from './cost-session-history';
-import { emptyUsage } from './sum-usage';
-const scope = `test-${Date.now()}`;
-const usage = (costUsd) => ({
-    costUsd,
-    uncachedInputTokens: 100000,
-    cacheReadTokens: 1200000,
-    cacheWriteTokens: 60000,
-    outputTokens: 40000,
-});
-const sampleRecord = (overrides = {}) => (Object.assign({ id: 'rec-1', projectKey: 'proj-1', title: 'Equity Options Pricer', updatedAt: '2026-06-14T12:00:00.000Z', usage: usage(1.86), 
-    // Present by default so `delete record.banked` in the legacy-row cases actually removes
-    // something, and so the storage round-trip covers it.
-    banked: usage(0.5), models: [{ model: 'claude-sonnet-4-6', provider: 'anthropic' }] }, overrides));
-const suite = createLogicSuite('costSessionHistory');
-suite('uses a scoped storage key', () => {
-    assert.is(costHistoryStorageKey('my-app'), 'genesis-ai-assistant:cost-history:my-app');
-});
-suite('upsertRecord prepends a project it has not seen', () => {
-    var _a, _b;
-    const first = upsertRecord([], sampleRecord({ id: 'a', projectKey: 'a', title: 'First' }));
-    const both = upsertRecord(first, sampleRecord({ id: 'b', projectKey: 'b', title: 'Second' }));
-    assert.is(both.length, 2);
-    // Insertion order, not recency — display ordering is sortRecordsByRecency's job.
-    assert.is((_a = both[0]) === null || _a === void 0 ? void 0 : _a.id, 'b', 'most recently added is prepended');
-    assert.is((_b = both[1]) === null || _b === void 0 ? void 0 : _b.id, 'a');
-});
-suite('upsertRecord replaces a project in place rather than stacking a second row', () => {
-    var _a, _b;
-    const seeded = [
-        sampleRecord({ id: 'b', projectKey: 'b', usage: usage(2) }),
-        sampleRecord({ id: 'a', projectKey: 'a', usage: usage(1) }),
-    ];
-    // Re-reporting a project must REPLACE its row. Appending here is what made a single
-    // project's spend count once per refresh in any total summed over the list.
-    const next = upsertRecord(seeded, sampleRecord({ id: 'a', projectKey: 'a', usage: usage(9.5) }));
-    assert.is(next.length, 2);
-    // Replaced in place rather than moved — the stored array is not a recency ordering.
-    assert.is((_a = next[1]) === null || _a === void 0 ? void 0 : _a.projectKey, 'a');
-    assert.is((_b = next[1]) === null || _b === void 0 ? void 0 : _b.usage.costUsd, 9.5);
-    assert.is(next.reduce((sum, r) => sum + r.usage.costUsd, 0), 11.5);
-});
-suite('round-trips records through storage', () => {
-    var _a, _b, _c, _d;
-    clearCostSessionHistory(scope);
-    const records = upsertRecord([], sampleRecord({ id: 'a', projectKey: 'a', usage: usage(3.5) }));
-    saveCostSessionHistory(scope, records);
-    const loaded = loadCostSessionHistory(scope);
-    assert.is(loaded.length, 1);
-    assert.is((_a = loaded[0]) === null || _a === void 0 ? void 0 : _a.usage.costUsd, 3.5);
-    assert.is((_b = loaded[0]) === null || _b === void 0 ? void 0 : _b.usage.cacheReadTokens, 1200000, 'buckets survive serialization');
-    assert.is((_d = (_c = loaded[0]) === null || _c === void 0 ? void 0 : _c.banked) === null || _d === void 0 ? void 0 : _d.costUsd, 0.5, 'banked survives serialization');
-    clearCostSessionHistory(scope);
-});
-suite('discards legacy rows that predate the per-project key', () => {
-    var _a;
-    clearCostSessionHistory(scope);
-    const legacy = sampleRecord({ id: 'old' });
-    delete legacy.projectKey;
-    saveCostSessionHistory(scope, [legacy, sampleRecord({ id: 'new' })]);
-    const loaded = loadCostSessionHistory(scope);
-    // A keyless row can never be matched to a project, so pooling it with the new rows
-    // would permanently double-count whichever project it came from.
-    assert.is(loaded.length, 1);
-    assert.is((_a = loaded[0]) === null || _a === void 0 ? void 0 : _a.id, 'new');
-    clearCostSessionHistory(scope);
-});
-suite('discards rows whose usage is not fully numeric', () => {
-    var _a;
-    clearCostSessionHistory(scope);
-    const broken = sampleRecord({ id: 'broken' });
-    // A half-shaped `usage` is worse than a missing row: it sums as NaN and poisons every
-    // total on the Usage tab, with no clue where the NaN came from.
-    delete broken.usage.outputTokens;
-    saveCostSessionHistory(scope, [broken, sampleRecord({ id: 'ok', projectKey: 'ok' })]);
-    const loaded = loadCostSessionHistory(scope);
-    assert.is(loaded.length, 1);
-    assert.is((_a = loaded[0]) === null || _a === void 0 ? void 0 : _a.id, 'ok');
-    clearCostSessionHistory(scope);
-});
-suite('discards rows whose banked figure is half-shaped', () => {
-    var _a;
-    clearCostSessionHistory(scope);
-    const broken = sampleRecord({ id: 'broken', banked: Object.assign({}, usage(2)) });
-    // A malformed `banked` poisons the lifetime total exactly as a malformed `usage` does,
-    // since the two are added together to produce it.
-    delete broken.banked.cacheWriteTokens;
-    saveCostSessionHistory(scope, [broken, sampleRecord({ id: 'ok', projectKey: 'ok' })]);
-    const loaded = loadCostSessionHistory(scope);
-    assert.is(loaded.length, 1);
-    assert.is((_a = loaded[0]) === null || _a === void 0 ? void 0 : _a.id, 'ok');
-    clearCostSessionHistory(scope);
-});
-suite('keeps a row whose banked figure is absent', () => {
-    clearCostSessionHistory(scope);
-    const legacy = sampleRecord({ id: 'legacy' });
-    delete legacy.banked;
-    saveCostSessionHistory(scope, [legacy]);
-    assert.is(loadCostSessionHistory(scope).length, 1, 'absent is valid, unlike half-shaped');
-    clearCostSessionHistory(scope);
-});
-suite('formats session dates for display', () => {
-    assert.is(formatCostSessionDate('2026-06-14T12:00:00.000Z'), 'Jun 14, 2026');
-});
-suite('sortRecordsByRecency puts the most recently worked-on project first', () => {
-    const records = [
-        sampleRecord({ id: 'old', projectKey: 'old', updatedAt: '2026-01-01T00:00:00.000Z' }),
-        sampleRecord({ id: 'newest', projectKey: 'newest', updatedAt: '2026-08-04T09:00:00.000Z' }),
-        sampleRecord({ id: 'mid', projectKey: 'mid', updatedAt: '2026-05-01T00:00:00.000Z' }),
-    ];
-    const sorted = sortRecordsByRecency(records);
-    assert.equal(sorted.map((r) => r.id), ['newest', 'mid', 'old']);
-    // Read-time ordering, so the caller's array must be left alone.
-    assert.equal(records.map((r) => r.id), ['old', 'newest', 'mid'], 'input not mutated');
-});
-suite('sortRecordsByRecency overrides insertion order, which upsert leaves alone', () => {
-    var _a, _b;
-    // The behaviour this fixes: revisiting a project replaces its row IN PLACE, so insertion order
-    // strands it wherever it was first seen. Display order must come from updatedAt instead.
-    let records = upsertRecord([], sampleRecord({ id: 'a', projectKey: 'a', updatedAt: '2026-01-01T00:00:00.000Z' }));
-    records = upsertRecord(records, sampleRecord({ id: 'b', projectKey: 'b', updatedAt: '2026-02-01T00:00:00.000Z' }));
-    // Work on 'a' again — newer than 'b', but upsert keeps it in slot 1.
-    records = upsertRecord(records, sampleRecord({ id: 'a', projectKey: 'a', updatedAt: '2026-03-01T00:00:00.000Z' }));
-    assert.is((_a = records[1]) === null || _a === void 0 ? void 0 : _a.id, 'a', 'stored order is unchanged by the revisit');
-    assert.is((_b = sortRecordsByRecency(records)[0]) === null || _b === void 0 ? void 0 : _b.id, 'a', 'display order tracks the revisit');
-});
-suite('banks nothing for a project with no prior row', () => {
-    assert.equal(resolveBankedUsage(undefined, true), emptyUsage());
-    assert.equal(resolveBankedUsage(undefined, false), emptyUsage());
-});
-suite('carries the prior banked figure forward when the transcript is authoritative', () => {
-    // Restored transcript: it already re-proves everything after the row's own banked figure,
-    // so only that figure carries over. Taking `usage` here is the compounding double-count.
-    const prior = sampleRecord({ usage: usage(10), banked: Object.assign({}, usage(4)) });
-    assert.is(resolveBankedUsage(prior, true).costUsd, 4);
-});
-suite('banks the whole prior total when the transcript starts empty', () => {
-    // Nothing on screen accounts for the previous total, so all of it must carry over or the
-    // next turn rewrites the row down to just that turn.
-    const prior = sampleRecord({ usage: usage(10), banked: Object.assign({}, usage(4)) });
-    assert.is(resolveBankedUsage(prior, false).costUsd, 10);
-});
-suite('treats a row predating the banked field as nothing banked', () => {
-    const legacy = sampleRecord({ usage: usage(7) });
-    delete legacy.banked;
-    assert.equal(resolveBankedUsage(legacy, true), emptyUsage());
-    // Without persistence the legacy total still carries, so upgrading loses no spend.
-    assert.is(resolveBankedUsage(legacy, false).costUsd, 7);
-});
-suite('is stable across repeated reloads — the regression this guards', () => {
-    // Simulate the reload cycle: usage = banked + whatever the transcript proves. With a
-    // restored transcript (worth 6 on top of 4 banked) the row must land on 10 every time,
-    // not 10 → 14 → 18 as it did when a reload re-banked the restored history.
-    const transcript = 6;
-    let row = sampleRecord({ usage: usage(10), banked: Object.assign({}, usage(4)) });
-    for (let reload = 0; reload < 3; reload += 1) {
-        const banked = resolveBankedUsage(row, true);
-        row = Object.assign(Object.assign({}, row), { banked, usage: Object.assign({}, usage(banked.costUsd + transcript)) });
-        assert.is(row.usage.costUsd, 10, `reload ${reload}`);
-    }
-});
-suite('accumulates across reloads when the transcript does not persist', () => {
-    // The mirror case: each page-load starts from an empty transcript, so the row must grow by
-    // whatever that load spends rather than being overwritten by it.
-    let row = sampleRecord({ usage: usage(10), banked: Object.assign({}, usage(4)) });
-    for (const spend of [2, 3]) {
-        const banked = resolveBankedUsage(row, false);
-        row = Object.assign(Object.assign({}, row), { banked, usage: Object.assign({}, usage(banked.costUsd + spend)) });
-    }
-    // 10 banked, +2 → 12; then 12 banked, +3 → 15. Never decreases.
-    assert.is(row.usage.costUsd, 15);
-});
-suite.run();

package/dist/esm/utils/derive-cost-session-title.test.js

@@ -1,37 +0,0 @@
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { deriveCostSessionTitleFromMessages, resolveCostSessionTitle, truncateCostSessionTitle, } from './derive-cost-session-title';
-const suite = createLogicSuite('deriveCostSessionTitle');
-const userMsg = (content) => ({ role: 'user', content });
-suite('truncateCostSessionTitle keeps first sentence only', () => {
-    assert.is(truncateCostSessionTitle('Build a trade blotter. With FX options and limits.'), 'Build a trade blotter');
-});
-suite('truncateCostSessionTitle caps word count', () => {
-    const long = 'one two three four five six seven eight nine ten eleven twelve thirteen fourteen';
-    assert.is(truncateCostSessionTitle(long), 'one two three four five six seven eight nine ten…');
-});
-suite('truncateCostSessionTitle caps character count on one long word', () => {
-    const word = 'a'.repeat(80);
-    assert.is(truncateCostSessionTitle(word).length, 60);
-    assert.ok(truncateCostSessionTitle(word).endsWith('…'));
-});
-suite('deriveCostSessionTitleFromMessages skips empty and uses first user turn', () => {
-    assert.is(deriveCostSessionTitleFromMessages([
-        { role: 'assistant', content: 'Hi' },
-        { role: 'user', content: '   ' },
-        { role: 'user', content: 'Equity options pricer for desk' },
-    ]), 'Equity options pricer for desk');
-});
-suite('resolveCostSessionTitle prefers app title over messages', () => {
-    assert.is(resolveCostSessionTitle({
-        appTitle: 'fx-trading',
-        messages: [userMsg('Something else entirely')],
-        headerTitle: 'Genesis Assistant',
-    }), 'fx-trading');
-});
-suite('resolveCostSessionTitle falls back to first user message', () => {
-    assert.is(resolveCostSessionTitle({
-        messages: [userMsg('Search for recent trades in APAC')],
-        headerTitle: 'Genesis Assistant',
-    }), 'Search for recent trades in APAC');
-});
-suite.run();

package/dist/esm/utils/flatten-sub-agent-messages.test.js

@@ -1,139 +0,0 @@
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { flattenSubAgentMessages } from './flatten-sub-agent-messages';
-const msg = (overrides = {}) => (Object.assign({ role: 'assistant', content: '' }, overrides));
-/** A parent assistant message whose single tool call delegated to a sub-agent. */
-const delegating = (id, agentName, trace) => msg({
-    agentName,
-    toolCalls: [{ id, name: 'requestSubAgent', args: {}, subAgentTrace: trace }],
-});
-const suite = createLogicSuite('flattenSubAgentMessages');
-suite('returns an empty array for an empty list', () => {
-    assert.equal(flattenSubAgentMessages([]), []);
-});
-suite('emits top-level messages unchanged and tags none as sub-agent', () => {
-    const out = flattenSubAgentMessages([
-        msg({ role: 'user', content: 'hi', agentName: 'UI Builder' }),
-        msg({ content: 'hello', agentName: 'UI Builder' }),
-    ]);
-    assert.is(out.length, 2);
-    assert.is(out[0].kind, 'message');
-    assert.is(out[0].agentName, 'UI Builder');
-    // No depth/marker fields on top-level entries.
-    assert.is(out[0].subAgentDepth, undefined);
-    assert.is(out[0].subAgentName, undefined);
-    assert.is(out[1].subAgentOf, undefined);
-});
-suite('hoists a sub-agent trace to top-level entries after the spawning message', () => {
-    const trace = [
-        msg({
-            agentName: 'UI Architecture Planner',
-            content: '',
-            toolCalls: [{ id: 'g', name: 'grep_source', args: {} }],
-        }),
-        msg({
-            role: 'tool',
-            agentName: 'UI Architecture Planner',
-            toolResult: { toolCallId: 'g', content: 'result' },
-        }),
-    ];
-    const out = flattenSubAgentMessages([
-        delegating('tc1', 'UI Builder', trace),
-        msg({
-            role: 'tool',
-            agentName: 'UI Builder',
-            toolResult: { toolCallId: 'tc1', content: 'plan done' },
-        }),
-    ]);
-    // parent tool-call msg, then 2 hoisted children, then the parent tool-result msg.
-    assert.is(out.length, 4);
-    assert.is(out[0].agentName, 'UI Builder'); // parent unchanged
-    assert.is(out[1].agentName, 'UI Builder › UI Architecture Planner');
-    assert.is(out[2].agentName, 'UI Builder › UI Architecture Planner');
-    assert.is(out[3].agentName, 'UI Builder'); // parent tool-result, back at top level
-});
-suite('marks hoisted entries with depth, raw name, and the spawning tool-call id', () => {
-    const out = flattenSubAgentMessages([
-        delegating('tc1', 'UI Builder', [msg({ agentName: 'UI Architecture Planner', content: 'x' })]),
-    ]);
-    const child = out[1];
-    assert.is(child.subAgentDepth, 1);
-    assert.is(child.subAgentName, 'UI Architecture Planner');
-    assert.is(child.subAgentOf, 'tc1');
-});
-suite('moves the trace out — the emitted parent tool call no longer carries it (no duplication)', () => {
-    const trace = [msg({ agentName: 'Planner', content: 'only once' })];
-    const out = flattenSubAgentMessages([delegating('tc1', 'UI Builder', trace)]);
-    // The trace is stripped from the emitted tool call ...
-    assert.is(out[0].toolCalls[0].subAgentTrace, undefined);
-    // ... and surfaces exactly once, as a hoisted top-level entry.
-    const hoisted = out.filter((e) => e.subAgentDepth === 1);
-    assert.is(hoisted.length, 1);
-    assert.is(hoisted[0].content, 'only once');
-});
-suite('preserves per-message usage fields on hoisted entries', () => {
-    const out = flattenSubAgentMessages([
-        delegating('tc1', 'UI Builder', [
-            msg({
-                agentName: 'Planner',
-                model: 'claude-sonnet-4-6',
-                inputTokens: 100,
-                outputTokens: 20,
-                cost: 0.5,
-            }),
-        ]),
-    ]);
-    const child = out[1];
-    assert.is(child.model, 'claude-sonnet-4-6');
-    assert.is(child.inputTokens, 100);
-    assert.is(child.outputTokens, 20);
-    assert.is(child.cost, 0.5);
-});
-suite('composes the breadcrumb for nested sub-agents', () => {
-    const grandchild = [msg({ agentName: 'Grounding', content: 'deep' })];
-    const childTrace = [delegating('tc2', 'Planner', grandchild)];
-    const out = flattenSubAgentMessages([delegating('tc1', 'UI Builder', childTrace)]);
-    // top: UI Builder | depth1: Planner | depth2: Grounding
-    const depth1 = out.find((e) => e.subAgentDepth === 1);
-    const depth2 = out.find((e) => e.subAgentDepth === 2);
-    assert.is(depth1.agentName, 'UI Builder › Planner');
-    assert.is(depth2.agentName, 'UI Builder › Planner › Grounding');
-    assert.is(depth2.subAgentName, 'Grounding');
-    assert.is(depth2.subAgentOf, 'tc2');
-});
-suite('correlates two sub-agents spawned in the same parent turn', () => {
-    const parent = msg({
-        agentName: 'UI Builder',
-        toolCalls: [
-            {
-                id: 'a',
-                name: 'requestSubAgent',
-                args: {},
-                subAgentTrace: [msg({ agentName: 'Planner', content: 'p' })],
-            },
-            {
-                id: 'b',
-                name: 'requestSubAgent',
-                args: {},
-                subAgentTrace: [msg({ agentName: 'Reviewer', content: 'r' })],
-            },
-        ],
-    });
-    const out = flattenSubAgentMessages([parent]);
-    const planner = out.find((e) => e.subAgentName === 'Planner');
-    const reviewer = out.find((e) => e.subAgentName === 'Reviewer');
-    assert.is(planner.subAgentOf, 'a');
-    assert.is(reviewer.subAgentOf, 'b');
-    assert.is(planner.agentName, 'UI Builder › Planner');
-    assert.is(reviewer.agentName, 'UI Builder › Reviewer');
-});
-suite('falls back gracefully when the spawning message has no agentName', () => {
-    const out = flattenSubAgentMessages([
-        delegating('tc1', undefined, [
-            msg({ agentName: 'Planner', content: 'x' }),
-        ]),
-    ]);
-    // No parent name to prefix → show the sub-agent's own name unbreadcrumbed.
-    assert.is(out[1].agentName, 'Planner');
-    assert.is(out[1].subAgentName, 'Planner');
-});
-suite.run();

package/dist/esm/utils/history-transform.test.js

@@ -1,158 +0,0 @@
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { buildCompactionSummaryPrompt, compactionDividerLabel, COMPACT_KEEP_RECENT_MESSAGES, COMPACT_MIN_MESSAGES_TO_COMPACT, findCompactionCut, normalizeForProvider, transformHistoryForAgent, } from './history-transform';
-const asMsg = (o) => o;
-const user = (content) => asMsg({ role: 'user', content });
-const assistant = (content) => asMsg({ role: 'assistant', content });
-// GENC-1351 §5.7 — the pure compaction helpers (no DOM/provider deps).
-const Suite = createLogicSuite('history-transform-compaction');
-// ── findCompactionCut ─────────────────────────────────────────────────────────
-Suite('findCompactionCut returns null for a transcript too short to be worth compacting', () => {
-    assert.is(findCompactionCut([]), null);
-    // One below the floor (keep-recent + min-to-compact) → nothing to do.
-    const justUnder = Array.from({ length: COMPACT_KEEP_RECENT_MESSAGES + COMPACT_MIN_MESSAGES_TO_COMPACT - 1 }, (_, i) => (i % 2 === 0 ? user(`u${i}`) : assistant(`a${i}`)));
-    assert.is(findCompactionCut(justUnder), null);
-});
-Suite('findCompactionCut cuts at a user-message boundary, keeping the recent tail', () => {
-    // 10 messages alternating user/assistant; user at even indices.
-    const h = Array.from({ length: 10 }, (_, i) => i % 2 === 0 ? user(`u${i}`) : assistant(`a${i}`));
-    const cut = findCompactionCut(h);
-    // target = 10 - 4 = 6; history[6] is a user message → cut there.
-    assert.is(cut, 6);
-    assert.is(h[cut].role, 'user', 'tail must start on a user boundary');
-});
-Suite('findCompactionCut walks back to the nearest earlier user boundary', () => {
-    // user only at indices 0,1,3,5,7,9 — index 6 is assistant, so it walks back to 5.
-    const h = [
-        user('u0'),
-        user('u1'),
-        assistant('a2'),
-        user('u3'),
-        assistant('a4'),
-        user('u5'),
-        assistant('a6'),
-        user('u7'),
-        assistant('a8'),
-        user('u9'),
-    ];
-    // target = 6 (assistant) → walk back to 5 (user).
-    assert.is(findCompactionCut(h), 5);
-});
-Suite('findCompactionCut returns null when the only user turn is the first message', () => {
-    // No user boundary after index 0 → nothing can be summarized behind a boundary.
-    const h = [user('u0'), ...Array.from({ length: 9 }, (_, i) => assistant(`a${i}`))];
-    assert.is(findCompactionCut(h), null);
-});
-Suite('findCompactionCut includes an existing head summary in the region to compact (rolling)', () => {
-    const h = [
-        asMsg({ role: 'compacted-summary', content: 'prior', compaction: { compactedCount: 3 } }),
-        user('u1'),
-        assistant('a2'),
-        user('u3'),
-        assistant('a4'),
-        user('u5'),
-        assistant('a6'),
-        user('u7'),
-        assistant('a8'),
-        user('u9'),
-    ];
-    const cut = findCompactionCut(h);
-    assert.ok(cut != null && cut >= 1, 'cut should leave the head summary inside the compacted region');
-    assert.is(h.slice(0, cut)[0].role, 'compacted-summary', 'prior summary is folded back in');
-});
-// ── buildCompactionSummaryPrompt ──────────────────────────────────────────────
-Suite('buildCompactionSummaryPrompt wraps the transcript and labels roles', () => {
-    const { systemPrompt, userMessage } = buildCompactionSummaryPrompt([
-        user('book a trade'),
-        assistant('sure, which counterparty?'),
-    ]);
-    assert.ok(/summar/i.test(systemPrompt), 'system prompt frames a summarization task');
-    assert.ok(userMessage.includes('<conversation_history>'));
-    assert.ok(userMessage.includes('</conversation_history>'));
-    assert.ok(userMessage.includes('User: book a trade'));
-    assert.ok(userMessage.includes('Assistant: sure, which counterparty?'));
-});
-Suite('buildCompactionSummaryPrompt renders tool activity and a prior summary', () => {
-    const { userMessage } = buildCompactionSummaryPrompt([
-        asMsg({
-            role: 'compacted-summary',
-            content: 'earlier stuff',
-            compaction: { compactedCount: 2 },
-        }),
-        asMsg({
-            role: 'assistant',
-            content: '',
-            toolCalls: [{ id: 't1', name: 'searchTrades', args: {} }],
-        }),
-        asMsg({ role: 'tool', content: '', toolResult: { toolCallId: 't1', content: '3 hits' } }),
-    ]);
-    assert.ok(userMessage.includes('[Earlier summary] earlier stuff'));
-    assert.ok(userMessage.includes('searchTrades'), 'tool call name is preserved for continuity');
-    assert.ok(userMessage.includes('Tool result: 3 hits'));
-});
-Suite('buildCompactionSummaryPrompt folds in reasoning + narration, labelled Thinking / Working', () => {
-    const { userMessage } = buildCompactionSummaryPrompt([
-        asMsg({
-            role: 'assistant',
-            content: 'weigh the counterparty options',
-            category: 'reasoning',
-        }),
-        asMsg({ role: 'assistant', content: 'searching the trade blotter', category: 'narration' }),
-    ]);
-    assert.ok(userMessage.includes('Thinking: weigh the counterparty options'));
-    assert.ok(userMessage.includes('Working: searching the trade blotter'));
-});
-// ── normalizeForProvider (the no-leak guarantee) ──────────────────────────────
-Suite('normalizeForProvider translates compacted-summary into a <conversation_summary> user msg', () => {
-    const out = normalizeForProvider([
-        asMsg({ role: 'compacted-summary', content: 'the gist', compaction: { compactedCount: 9 } }),
-        user('and now?'),
-    ]);
-    assert.is(out[0].role, 'user', 'the raw display-only role is gone');
-    assert.ok(out[0].content.includes('<conversation_summary>'));
-    assert.ok(out[0].content.includes('the gist'));
-    assert.is(out[0].compaction, undefined, 'compaction metadata is dropped from the sent message');
-});
-Suite('normalizeForProvider never emits a compacted-summary role (no leak to a transport)', () => {
-    const out = normalizeForProvider([
-        asMsg({ role: 'compacted-summary', content: 's1', compaction: { compactedCount: 1 } }),
-        user('u'),
-        assistant('a'),
-        asMsg({ role: 'system-event', content: 'Switched agent' }),
-    ]);
-    assert.ok(out.every((m) => m.role !== 'compacted-summary'), 'no compacted-summary role survives normalization');
-});
-Suite('normalizeForProvider passes non-summary messages through untouched (same ref)', () => {
-    const u = user('hello');
-    const a = assistant('hi');
-    const out = normalizeForProvider([u, a]);
-    assert.is(out[0], u);
-    assert.is(out[1], a);
-});
-// ── compactionDividerLabel ────────────────────────────────────────────────────
-Suite('compactionDividerLabel pluralizes and falls back to 0', () => {
-    assert.is(compactionDividerLabel(asMsg({ role: 'compacted-summary', content: '', compaction: { compactedCount: 1 } })), 'Compacted 1 earlier message');
-    assert.is(compactionDividerLabel(asMsg({ role: 'compacted-summary', content: '', compaction: { compactedCount: 12 } })), 'Compacted 12 earlier messages');
-    assert.is(compactionDividerLabel(asMsg({ role: 'compacted-summary', content: '' })), 'Compacted 0 earlier messages');
-});
-// ── masking another agent's tool payload (GENC-1508) ─────────────────────────
-Suite('transformHistoryForAgent drops tool-result IMAGES, not just the text', () => {
-    const history = [
-        asMsg({
-            role: 'tool',
-            content: '',
-            agentName: 'other-agent',
-            toolResult: {
-                toolCallId: 'r1',
-                content: 'rendered the mockup',
-                attachments: [
-                    { kind: 'image', name: 'mockup.png', mimeType: 'image/png', data: 'a'.repeat(2000) },
-                ],
-            },
-        }),
-    ];
-    const out = transformHistoryForAgent(history, 'this-agent');
-    assert.ok(out[0].toolResult.content.includes('omitted'), 'the text is stubbed, as it always was');
-    assert.is(out[0].toolResult.attachments, undefined, "masking exists to keep another agent's payload out of context — an image IS the payload, " +
-        'and stubbing the prose while shipping the render defeats the mask where it matters most');
-});
-Suite.run();

package/dist/esm/utils/message-partition.test.js

@@ -1,90 +0,0 @@
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { filterVisibleMessages, SESSION_RESTORED_LABEL, SESSION_RESTORE_FAILED_LABEL, trailingInteractionRow, } from './message-partition';
-const msg = (overrides = {}) => (Object.assign({ role: 'assistant', content: '' }, overrides));
-const interaction = (interactionId, resolved = false) => (Object.assign({ interactionId, componentName: 'test-widget', data: {} }, (resolved ? { resolved: { status: 'approved' } } : {})));
-const ALL_ON = {
-    showToolCalls: true,
-    showThinkingSteps: true,
-    showNarration: true,
-    showAgentSwitchIndicator: true,
-    showRestoreNotices: true,
-};
-const ALL_OFF = {
-    showToolCalls: false,
-    showThinkingSteps: false,
-    showNarration: false,
-    showAgentSwitchIndicator: false,
-    showRestoreNotices: false,
-};
-const trailing = createLogicSuite('trailingInteractionRow');
-trailing('is empty when there are no messages', () => {
-    assert.equal(trailingInteractionRow([]), []);
-});
-trailing('is empty when the last message has no interaction', () => {
-    assert.equal(trailingInteractionRow([msg({ content: 'hi' })]), []);
-});
-trailing('returns the last message when it carries an interaction (pending)', () => {
-    const pending = msg({ interaction: interaction('id-a') });
-    assert.equal(trailingInteractionRow([msg({ content: 'q' }), pending]), [pending]);
-});
-trailing('still returns the trailing interaction once it is resolved', () => {
-    // Keeps it in the pinned slot so resolving forwards in place without a rebuild.
-    const resolved = msg({ interaction: interaction('id-a', true) });
-    assert.equal(trailingInteractionRow([resolved]), [resolved]);
-});
-trailing('returns nothing once a newer non-interaction message arrives', () => {
-    // The interaction is no longer last, so it rejoins the scrolling list.
-    const earlier = msg({ interaction: interaction('id-a', true) });
-    assert.equal(trailingInteractionRow([earlier, msg({ content: 'next' })]), []);
-});
-trailing('returns the same message reference (lets FAST short-circuit rebind)', () => {
-    const pending = msg({ interaction: interaction('id-a') });
-    assert.is(trailingInteractionRow([pending])[0], pending);
-});
-const filter = createLogicSuite('filterVisibleMessages');
-filter('hides tool result messages regardless of toggles', () => {
-    const msgs = [msg({ role: 'tool', toolResult: { toolCallId: 't1', content: 'r' } })];
-    assert.equal(filterVisibleMessages(msgs, ALL_ON), []);
-});
-filter('hides tool-call messages when showToolCalls is off, shows them when on', () => {
-    const toolCall = msg({ toolCalls: [{ id: 't1', name: 'do', args: {} }] });
-    assert.equal(filterVisibleMessages([toolCall], ALL_OFF), []);
-    assert.equal(filterVisibleMessages([toolCall], ALL_ON), [toolCall]);
-});
-filter('hides thinking messages when showThinkingSteps is off', () => {
-    const thinking = msg({ thinking: true, content: 'hmm' });
-    assert.equal(filterVisibleMessages([thinking], ALL_OFF), []);
-    assert.equal(filterVisibleMessages([thinking], ALL_ON), [thinking]);
-});
-filter('hides system-event rows unless the agent-switch toggle is on', () => {
-    const event = msg({ role: 'system-event', content: 'switched' });
-    assert.equal(filterVisibleMessages([event], ALL_OFF), []);
-    assert.equal(filterVisibleMessages([event], ALL_ON), [event]);
-});
-filter('drops empty assistant messages', () => {
-    assert.equal(filterVisibleMessages([msg({ content: '   ' })], ALL_ON), []);
-});
-filter('keeps user and non-empty assistant messages with everything off', () => {
-    const user = msg({ role: 'user', content: 'hello' });
-    const reply = msg({ content: 'hi there' });
-    assert.equal(filterVisibleMessages([user, reply], ALL_OFF), [user, reply]);
-});
-// GENC-1351 §6: restore notices are gated by their own (persistence) toggle, NOT
-// by showAgentSwitchIndicator — the two unrelated switches must not cross-control.
-filter('restore notices follow showRestoreNotices; agent-switch rows follow showAgentSwitchIndicator', () => {
-    const restored = msg({ role: 'system-event', content: SESSION_RESTORED_LABEL });
-    const failed = msg({ role: 'system-event', content: SESSION_RESTORE_FAILED_LABEL });
-    const agentSwitch = msg({ role: 'system-event', content: 'Guided Booking' });
-    const rows = [restored, failed, agentSwitch];
-    // Persistence on, agent-switch off → only the restore notices show.
-    assert.equal(filterVisibleMessages(rows, Object.assign(Object.assign({}, ALL_OFF), { showRestoreNotices: true })), [
-        restored,
-        failed,
-    ]);
-    // Agent-switch on, persistence off → only the agent-switch indicator shows.
-    assert.equal(filterVisibleMessages(rows, Object.assign(Object.assign({}, ALL_OFF), { showAgentSwitchIndicator: true })), [
-        agentSwitch,
-    ]);
-});
-trailing.run();
-filter.run();

package/dist/esm/utils/resolve-cost-history-config.test.js

@@ -1,32 +0,0 @@
-import { assert, createLogicSuite } from '@genesislcap/foundation-testing';
-import { resolveCostHistoryConfig } from './resolve-cost-history-config';
-const Suite = createLogicSuite('resolveCostHistoryConfig');
-Suite('defaults to disabled with cost UI visible', () => {
-    const resolved = resolveCostHistoryConfig({});
-    assert.is(resolved.enabled, false);
-    assert.is(resolved.showCost, true);
-    assert.is(resolved.showTokens, true);
-    assert.is(resolved.badgeLabel, 'Currently building');
-});
-Suite('enables persistence only when costHistory.enabled is true', () => {
-    assert.is(resolveCostHistoryConfig({ costHistory: {} }).enabled, false);
-    assert.is(resolveCostHistoryConfig({ costHistory: { enabled: true } }).enabled, true);
-});
-Suite('reads costHistory fields', () => {
-    const resolved = resolveCostHistoryConfig({
-        costHistory: {
-            enabled: true,
-            title: 'My project',
-            scope: 'app-scope',
-            showCost: false,
-            showTokens: false,
-            badgeLabel: 'Building',
-        },
-    });
-    assert.is(resolved.title, 'My project');
-    assert.is(resolved.scope, 'app-scope');
-    assert.is(resolved.showCost, false);
-    assert.is(resolved.showTokens, false);
-    assert.is(resolved.badgeLabel, 'Building');
-});
-Suite.run();