677 lines
25 KiB
TypeScript
677 lines
25 KiB
TypeScript
import { describe, it, expect } from 'vitest';
|
||
import type { MemoryFrame, Importance, FrameType, FrameSource } from '@waggle/core';
|
||
import type { AgentPersona } from '../src/personas.js';
|
||
import type { TaskShape } from '../src/task-shape.js';
|
||
import type { ContextFrames } from '../src/orchestrator.js';
|
||
import {
|
||
PromptAssembler,
|
||
type AssembleInput,
|
||
type RecalledMemory,
|
||
} from '../src/prompt-assembler.js';
|
||
|
||
// ── Fixtures ─────────────────────────────────────────────────────────
|
||
|
||
let nextFrameId = 1;
|
||
function frame(
|
||
content: string,
|
||
opts: { type?: FrameType; importance?: Importance; source?: FrameSource } = {},
|
||
): MemoryFrame {
|
||
return {
|
||
id: nextFrameId++,
|
||
frame_type: opts.type ?? 'I',
|
||
gop_id: 'gop-1',
|
||
t: 0,
|
||
base_frame_id: null,
|
||
content,
|
||
importance: opts.importance ?? 'normal',
|
||
source: opts.source ?? 'user_stated',
|
||
access_count: 0,
|
||
created_at: '2026-04-17T10:00:00Z',
|
||
last_accessed: '2026-04-17T10:00:00Z',
|
||
};
|
||
}
|
||
|
||
function persona(overrides: Partial<AgentPersona> = {}): AgentPersona {
|
||
return {
|
||
id: 'researcher',
|
||
name: 'Researcher',
|
||
description: 'You are a researcher focused on evidence-based analysis.',
|
||
icon: 'search',
|
||
systemPrompt: '',
|
||
modelPreference: 'claude-opus-4-7',
|
||
tools: ['search_memory', 'save_memory'],
|
||
workspaceAffinity: [],
|
||
suggestedCommands: [],
|
||
defaultWorkflow: null,
|
||
tagline: 'Evidence-first thinker.',
|
||
...overrides,
|
||
};
|
||
}
|
||
|
||
function emptyContext(): ContextFrames {
|
||
return {
|
||
stateFrames: [],
|
||
recentChanges: [],
|
||
activeWork: [],
|
||
keyEntities: [],
|
||
personalPreferences: [],
|
||
};
|
||
}
|
||
|
||
function emptyRecalled(): RecalledMemory {
|
||
return { workspace: [], personal: [], scanSafe: true };
|
||
}
|
||
|
||
function shape(type: TaskShape['type'], confidence = 0.8): TaskShape {
|
||
return {
|
||
type,
|
||
confidence,
|
||
signals: [],
|
||
complexity: 'moderate',
|
||
};
|
||
}
|
||
|
||
function baseInput(overrides: Partial<AssembleInput> = {}): AssembleInput {
|
||
return {
|
||
corePrompt: 'You are Waggle, a memory-first AI colleague.',
|
||
persona: persona(),
|
||
context: emptyContext(),
|
||
recalled: emptyRecalled(),
|
||
query: 'test query',
|
||
tier: 'mid',
|
||
...overrides,
|
||
};
|
||
}
|
||
|
||
function defaultScaffold(body: string): string {
|
||
return `If the user specifies a response format, follow it exactly. Otherwise: ${body}`;
|
||
}
|
||
|
||
// ── Tests ────────────────────────────────────────────────────────────
|
||
|
||
describe('PromptAssembler.assemble', () => {
|
||
const assembler = new PromptAssembler();
|
||
|
||
it('includes Identity and Persona in every output', () => {
|
||
const out = assembler.assemble(baseInput());
|
||
expect(out.system).toContain('# Identity');
|
||
expect(out.system).toContain('## Persona: Researcher');
|
||
expect(out.debug.sectionsIncluded).toContain('Identity');
|
||
expect(out.debug.sectionsIncluded).toContain('Persona');
|
||
});
|
||
|
||
it('packages the persona operating instructions exactly once', () => {
|
||
const marker = 'PERSONA_OPERATING_RAIL_UNIQUE';
|
||
const out = assembler.assemble(baseInput({
|
||
persona: persona({ systemPrompt: `${marker}\nAlways ground claims in evidence.` }),
|
||
}));
|
||
|
||
expect(out.system).toContain(marker);
|
||
expect(out.system.match(new RegExp(marker, 'g'))).toHaveLength(1);
|
||
});
|
||
|
||
it('small tier caps State frames at 3', () => {
|
||
const frames: MemoryFrame[] = [];
|
||
for (let i = 0; i < 10; i++) {
|
||
frames.push(frame(`State frame ${i}`, { type: 'I', importance: 'important' }));
|
||
}
|
||
const out = assembler.assemble(
|
||
baseInput({
|
||
tier: 'small',
|
||
context: { ...emptyContext(), stateFrames: frames },
|
||
}),
|
||
);
|
||
const stateBlock = out.system.split('# State\n')[1]?.split('\n\n')[0] ?? '';
|
||
const stateLines = stateBlock.split('\n').filter(l => l.startsWith('-'));
|
||
expect(stateLines.length).toBeLessThanOrEqual(3);
|
||
});
|
||
|
||
it('frontier tier emits no Response-format section', () => {
|
||
const out = assembler.assemble(
|
||
baseInput({ tier: 'frontier', taskShape: shape('plan-execute', 0.9) }),
|
||
);
|
||
expect(out.system).not.toContain('# Response format');
|
||
expect(out.responseScaffold).toBeNull();
|
||
expect(out.debug.scaffoldApplied).toBe(false);
|
||
});
|
||
|
||
it('mid + plan-execute yields "State plan. Execute. Report." scaffold', () => {
|
||
const out = assembler.assemble(
|
||
baseInput({ tier: 'mid', taskShape: shape('plan-execute', 0.8) }),
|
||
);
|
||
expect(out.responseScaffold).toBe(defaultScaffold('State plan. Execute. Report.'));
|
||
expect(out.system).toContain('# Response format');
|
||
expect(out.debug.scaffoldApplied).toBe(true);
|
||
});
|
||
|
||
it('small + compare yields the long assumption/trade-offs/recommendation scaffold', () => {
|
||
const out = assembler.assemble(
|
||
baseInput({ tier: 'small', taskShape: shape('compare', 0.7) }),
|
||
);
|
||
expect(out.responseScaffold).toBe(
|
||
defaultScaffold('State the assumption. List the trade-offs. Give the recommendation.'),
|
||
);
|
||
});
|
||
|
||
it('makes every generic review scaffold explicitly subordinate to the user response format', () => {
|
||
for (const tier of ['small', 'mid'] as const) {
|
||
for (const scaffoldStyle of ['compression', 'expansion'] as const) {
|
||
const out = assembler.assemble(
|
||
baseInput({
|
||
query: 'Review this release decision and explain the issues.',
|
||
tier,
|
||
taskShape: shape('review', 0.9),
|
||
}),
|
||
{ scaffoldStyle },
|
||
);
|
||
expect(out.responseScaffold).toMatch(
|
||
/^If the user specifies a response format, follow it exactly\. Otherwise:/,
|
||
);
|
||
expect(out.debug.scaffoldApplied).toBe(true);
|
||
expect(out.debug.exclusiveResponseContract).toBe(false);
|
||
expect(out.debug.scaffoldSuppressed).toBe(false);
|
||
}
|
||
}
|
||
});
|
||
|
||
it.each([
|
||
'Return JSON only.',
|
||
'Return only the code.',
|
||
'Reply with exactly "PASS" and nothing else.',
|
||
'Only use JSON.parse and explain the result.',
|
||
'Never answer with only JSON; include a narrative.',
|
||
])('does not infer free-form language and keeps the scaffold safely conditional: %s', (query) => {
|
||
const out = assembler.assemble(
|
||
baseInput({ query, tier: 'small', taskShape: shape('review', 0.9) }),
|
||
);
|
||
|
||
expect(out.responseScaffold).toMatch(
|
||
/^If the user specifies a response format, follow it exactly\. Otherwise:/,
|
||
);
|
||
expect(out.debug.exclusiveResponseContract).toBe(false);
|
||
expect(out.debug.scaffoldSuppressed).toBe(false);
|
||
});
|
||
|
||
it('lets code-owned contracts explicitly suppress a scaffold without magic prompt wording', () => {
|
||
const out = assembler.assemble(
|
||
baseInput({
|
||
query: 'Review the release evidence.',
|
||
tier: 'small',
|
||
taskShape: shape('review', 0.9),
|
||
}),
|
||
{ exclusiveResponseContract: true },
|
||
);
|
||
|
||
expect(out.responseScaffold).toBeNull();
|
||
expect(out.debug.exclusiveResponseContract).toBe(true);
|
||
expect(out.debug.scaffoldSuppressed).toBe(true);
|
||
});
|
||
|
||
it('treats an explicitly bounded rewrite as closed-world and suppresses outside context', () => {
|
||
const out = assembler.assemble(
|
||
baseInput({
|
||
query: 'Rewrite this into a crisp executive memo. Preserve the facts and add no new claims: API tests pass.',
|
||
tier: 'mid',
|
||
taskShape: shape('decide', 0.9),
|
||
context: {
|
||
...emptyContext(),
|
||
stateFrames: [frame('State says shipping now is safe.')],
|
||
recentChanges: [frame('Recent changes say all gaps are closed.', { type: 'P' })],
|
||
activeWork: [{ category: 'task', content: 'Ship immediately.', priority: 1 }],
|
||
},
|
||
recalled: {
|
||
workspace: [],
|
||
personal: [],
|
||
scanSafe: true,
|
||
renderedText: '# Recalled Memories\n- Shipping now is safe.',
|
||
},
|
||
}),
|
||
);
|
||
|
||
expect(out.responseScaffold).toBeNull();
|
||
expect(out.debug.closedWorldRewrite).toBe(true);
|
||
expect(out.debug.scaffoldSuppressed).toBe(true);
|
||
expect(out.debug.sectionsIncluded).not.toContain('State');
|
||
expect(out.debug.sectionsIncluded).not.toContain('Recent changes');
|
||
expect(out.debug.sectionsIncluded).not.toContain('Active work');
|
||
expect(out.debug.sectionsIncluded).not.toContain('Recalled memory');
|
||
expect(out.system).not.toContain('State says shipping now is safe.');
|
||
expect(out.system).not.toContain('Recent changes say all gaps are closed.');
|
||
expect(out.system).not.toContain('Ship immediately.');
|
||
expect(out.system).not.toContain('Shipping now is safe.');
|
||
expect(out.system).toContain('# Closed-world rewrite');
|
||
expect(out.system).toContain('Do not add implications, explanations, rationale, risks');
|
||
expect(out.debug.sectionsIncluded.at(-1)).toBe('Closed-world rewrite');
|
||
});
|
||
|
||
it('does not infer a closed-world boundary from an ordinary rewrite request', () => {
|
||
const out = assembler.assemble(
|
||
baseInput({
|
||
query: 'Rewrite this product launch note to sound clearer.',
|
||
tier: 'mid',
|
||
taskShape: shape('draft', 0.9),
|
||
}),
|
||
);
|
||
|
||
expect(out.debug.closedWorldRewrite).toBe(false);
|
||
expect(out.system).not.toContain('# Closed-world rewrite');
|
||
});
|
||
|
||
it('recognizes a boundary-first closed-world rewrite directive', () => {
|
||
const out = assembler.assemble(
|
||
baseInput({
|
||
query: 'Using only the provided text, condense this into three bullets.',
|
||
tier: 'mid',
|
||
taskShape: shape('decide', 0.9),
|
||
}),
|
||
);
|
||
|
||
expect(out.debug.closedWorldRewrite).toBe(true);
|
||
expect(out.responseScaffold).toBeNull();
|
||
expect(out.system).toContain('# Closed-world rewrite');
|
||
});
|
||
|
||
it('does not mistake a quoted transform phrase for a rewrite directive', () => {
|
||
const out = assembler.assemble(
|
||
baseInput({
|
||
query: 'Explain what “rewrite this” means without adding new facts.',
|
||
tier: 'mid',
|
||
taskShape: shape('review', 0.9),
|
||
}),
|
||
);
|
||
|
||
expect(out.debug.closedWorldRewrite).toBe(false);
|
||
expect(out.responseScaffold).toBe(defaultScaffold('Briefly state assumption, then recommendation.'));
|
||
expect(out.system).not.toContain('# Closed-world rewrite');
|
||
});
|
||
|
||
it('draft shape emits no scaffold at any tier', () => {
|
||
for (const tier of ['small', 'mid', 'frontier'] as const) {
|
||
const out = assembler.assemble(
|
||
baseInput({ tier, taskShape: shape('draft', 0.9) }),
|
||
);
|
||
expect(out.responseScaffold).toBeNull();
|
||
expect(out.debug.scaffoldApplied).toBe(false);
|
||
}
|
||
});
|
||
|
||
it('mixed shape emits no scaffold at any tier', () => {
|
||
for (const tier of ['small', 'mid', 'frontier'] as const) {
|
||
const out = assembler.assemble(
|
||
baseInput({ tier, taskShape: shape('mixed', 0.9) }),
|
||
);
|
||
expect(out.responseScaffold).toBeNull();
|
||
}
|
||
});
|
||
|
||
it('confidence below 0.3 threshold: no scaffold even if shape would scaffold', () => {
|
||
const out = assembler.assemble(
|
||
baseInput({ tier: 'small', taskShape: shape('research', 0.1) }),
|
||
);
|
||
expect(out.responseScaffold).toBeNull();
|
||
expect(out.debug.scaffoldApplied).toBe(false);
|
||
});
|
||
|
||
it('custom confidenceThreshold lets high-confidence scaffolds through', () => {
|
||
const out = assembler.assemble(
|
||
baseInput({ tier: 'small', taskShape: shape('research', 0.2) }),
|
||
{ confidenceThreshold: 0.15 },
|
||
);
|
||
expect(out.responseScaffold).toBe(
|
||
defaultScaffold('Cite the frame. Quote the relevant fragment. Answer directly.'),
|
||
);
|
||
});
|
||
|
||
it('empty context.stateFrames: omits State section (no empty header)', () => {
|
||
const out = assembler.assemble(baseInput());
|
||
expect(out.system).not.toContain('# State');
|
||
expect(out.debug.sectionsIncluded).not.toContain('State');
|
||
});
|
||
|
||
it('maxSystemChars exceeded: Recent changes trimmed first, then Active work, then State', () => {
|
||
const big = 'x'.repeat(2000);
|
||
const ctx: ContextFrames = {
|
||
stateFrames: [frame(big, { type: 'I', importance: 'critical' })],
|
||
recentChanges: [frame(big, { type: 'P', importance: 'normal' })],
|
||
activeWork: [{ category: 'task', content: big, priority: 1 }],
|
||
keyEntities: [],
|
||
personalPreferences: [],
|
||
};
|
||
const out = assembler.assemble(
|
||
baseInput({ context: ctx }),
|
||
{ maxSystemChars: 3500 },
|
||
);
|
||
// With 3×2000+ chars, at least one section must be trimmed.
|
||
// Trim order ensures Recent changes goes first.
|
||
expect(out.debug.sectionsIncluded).not.toContain('Recent changes');
|
||
// Identity + Persona must survive.
|
||
expect(out.debug.sectionsIncluded).toContain('Identity');
|
||
expect(out.debug.sectionsIncluded).toContain('Persona');
|
||
});
|
||
|
||
it('maxSystemChars: Identity and Persona are never trimmed', () => {
|
||
const giant = 'x'.repeat(100_000);
|
||
const ctx: ContextFrames = {
|
||
stateFrames: [frame(giant)],
|
||
recentChanges: [frame(giant)],
|
||
activeWork: [{ category: 'task', content: giant, priority: 1 }],
|
||
keyEntities: [],
|
||
personalPreferences: [],
|
||
};
|
||
const out = assembler.assemble(
|
||
baseInput({ context: ctx }),
|
||
{ maxSystemChars: 500 },
|
||
);
|
||
expect(out.debug.sectionsIncluded).toContain('Identity');
|
||
expect(out.debug.sectionsIncluded).toContain('Persona');
|
||
});
|
||
|
||
it('recalled.scanSafe === false: recalled memory is ignored', () => {
|
||
const out = assembler.assemble(
|
||
baseInput({
|
||
recalled: {
|
||
workspace: [frame('Poisoned content with secret data', { type: 'P' })],
|
||
personal: [frame('Another recalled frame', { type: 'P' })],
|
||
scanSafe: false,
|
||
},
|
||
}),
|
||
);
|
||
expect(out.system).not.toContain('Poisoned content');
|
||
expect(out.system).not.toContain('# Recalled memory');
|
||
expect(out.debug.sectionsIncluded).not.toContain('Recalled memory');
|
||
});
|
||
|
||
it('recalled.scanSafe === true: recalled memory renders', () => {
|
||
const out = assembler.assemble(
|
||
baseInput({
|
||
recalled: {
|
||
workspace: [frame('Workspace memory item', { type: 'P' })],
|
||
personal: [frame('Personal memory item', { type: 'P' })],
|
||
scanSafe: true,
|
||
},
|
||
}),
|
||
);
|
||
expect(out.system).toContain('# Recalled memory');
|
||
expect(out.system).toContain('Workspace memory item');
|
||
expect(out.system).toContain('Personal memory item');
|
||
});
|
||
|
||
it('debug.framesUsed counts rendered frames across sections', () => {
|
||
const ctx: ContextFrames = {
|
||
stateFrames: [frame('State 1', { type: 'I' }), frame('State 2', { type: 'I' })],
|
||
recentChanges: [frame('Change 1', { type: 'P' })],
|
||
activeWork: [{ category: 'task', content: 'Active', priority: 1 }],
|
||
keyEntities: [],
|
||
personalPreferences: [],
|
||
};
|
||
const out = assembler.assemble(baseInput({ context: ctx, tier: 'mid' }));
|
||
// 2 state + 1 change = 3 frames. activeWork items aren't frames.
|
||
expect(out.debug.framesUsed).toBe(3);
|
||
});
|
||
|
||
it('debug.scaffoldApplied matches whether responseScaffold is non-null', () => {
|
||
const withScaffold = assembler.assemble(
|
||
baseInput({ tier: 'mid', taskShape: shape('research', 0.9) }),
|
||
);
|
||
expect(withScaffold.debug.scaffoldApplied).toBe(withScaffold.responseScaffold !== null);
|
||
|
||
const withoutScaffold = assembler.assemble(
|
||
baseInput({ tier: 'frontier', taskShape: shape('research', 0.9) }),
|
||
);
|
||
expect(withoutScaffold.debug.scaffoldApplied).toBe(withoutScaffold.responseScaffold !== null);
|
||
});
|
||
|
||
it('ranks I-frames by importance then recency', () => {
|
||
const ctx: ContextFrames = {
|
||
stateFrames: [
|
||
frame('Old normal', { type: 'I', importance: 'normal' }),
|
||
frame('New critical', { type: 'I', importance: 'critical' }),
|
||
frame('Middle important', { type: 'I', importance: 'important' }),
|
||
],
|
||
recentChanges: [],
|
||
activeWork: [],
|
||
keyEntities: [],
|
||
personalPreferences: [],
|
||
};
|
||
const out = assembler.assemble(baseInput({ context: ctx, tier: 'small' }));
|
||
const stateSection = out.system.split('# State\n')[1]?.split('\n\n')[0] ?? '';
|
||
const firstLine = stateSection.split('\n')[0];
|
||
expect(firstLine).toContain('critical');
|
||
expect(firstLine).toContain('New critical');
|
||
});
|
||
|
||
it('dedupes frames by id', () => {
|
||
const f = frame('Duplicate', { type: 'I' });
|
||
const ctx: ContextFrames = {
|
||
stateFrames: [f, f, f],
|
||
recentChanges: [],
|
||
activeWork: [],
|
||
keyEntities: [],
|
||
personalPreferences: [],
|
||
};
|
||
const out = assembler.assemble(baseInput({ context: ctx, tier: 'mid' }));
|
||
expect(out.debug.framesUsed).toBe(1);
|
||
});
|
||
|
||
it('debug.totalChars matches system.length exactly', () => {
|
||
const out = assembler.assemble(baseInput());
|
||
expect(out.debug.totalChars).toBe(out.system.length);
|
||
});
|
||
|
||
it('userPrefix is empty string in v1', () => {
|
||
const out = assembler.assemble(baseInput());
|
||
expect(out.userPrefix).toBe('');
|
||
});
|
||
|
||
it('tierOverride takes precedence over input.tier', () => {
|
||
const out = assembler.assemble(
|
||
baseInput({ tier: 'frontier', taskShape: shape('research', 0.9) }),
|
||
{ tierOverride: 'small' },
|
||
);
|
||
expect(out.debug.tier).toBe('small');
|
||
// Small + research + high confidence → scaffold applies
|
||
expect(out.responseScaffold).not.toBeNull();
|
||
});
|
||
});
|
||
|
||
// ── v5: scaffoldStyle (compression vs expansion) ─────────────────────
|
||
//
|
||
// See PromptAssembler v5 brief §7.3, §12.2.
|
||
//
|
||
// v5 adds an EXPANSION variant alongside v4's COMPRESSION scaffolds.
|
||
// The hypothesis: dense instruction-tuned models (Gemma family) benefit
|
||
// from expansion scaffolds that give them more structure to fill, rather
|
||
// than compression scaffolds that tell them to say less.
|
||
|
||
describe('PromptAssembler.assemble — v5 scaffoldStyle', () => {
|
||
const assembler = new PromptAssembler();
|
||
|
||
it('default style equals explicit compression (v4 parity)', () => {
|
||
const noStyle = assembler.assemble(
|
||
baseInput({ tier: 'small', taskShape: shape('compare', 0.8) }),
|
||
);
|
||
const explicit = assembler.assemble(
|
||
baseInput({ tier: 'small', taskShape: shape('compare', 0.8) }),
|
||
{ scaffoldStyle: 'compression' },
|
||
);
|
||
expect(noStyle.responseScaffold).toBe(explicit.responseScaffold);
|
||
expect(noStyle.system).toBe(explicit.system);
|
||
});
|
||
|
||
it('compression + small + compare preserves the v4 body after the safety qualifier', () => {
|
||
const out = assembler.assemble(
|
||
baseInput({ tier: 'small', taskShape: shape('compare', 0.8) }),
|
||
{ scaffoldStyle: 'compression' },
|
||
);
|
||
expect(out.responseScaffold).toBe(
|
||
defaultScaffold('State the assumption. List the trade-offs. Give the recommendation.'),
|
||
);
|
||
});
|
||
|
||
it('compression + mid + plan-execute preserves the v4 body after the safety qualifier', () => {
|
||
const out = assembler.assemble(
|
||
baseInput({ tier: 'mid', taskShape: shape('plan-execute', 0.8) }),
|
||
{ scaffoldStyle: 'compression' },
|
||
);
|
||
expect(out.responseScaffold).toBe(defaultScaffold('State plan. Execute. Report.'));
|
||
});
|
||
|
||
it('compression + small + research preserves the v4 body after the safety qualifier', () => {
|
||
const out = assembler.assemble(
|
||
baseInput({ tier: 'small', taskShape: shape('research', 0.8) }),
|
||
{ scaffoldStyle: 'compression' },
|
||
);
|
||
expect(out.responseScaffold).toBe(
|
||
defaultScaffold('Cite the frame. Quote the relevant fragment. Answer directly.'),
|
||
);
|
||
});
|
||
|
||
it('expansion + small + compare includes Factors and Confidence keywords', () => {
|
||
const out = assembler.assemble(
|
||
baseInput({ tier: 'small', taskShape: shape('compare', 0.8) }),
|
||
{ scaffoldStyle: 'expansion' },
|
||
);
|
||
expect(out.responseScaffold).not.toBeNull();
|
||
expect(out.responseScaffold).toContain('Factors');
|
||
expect(out.responseScaffold).toContain('confidence');
|
||
expect(out.responseScaffold).toContain('Trade-offs');
|
||
expect(out.responseScaffold).toContain('Recommendation');
|
||
expect(out.responseScaffold).toContain('Assumption');
|
||
});
|
||
|
||
it('expansion + small + decide produces same template as compare (shared analysis block)', () => {
|
||
const compareOut = assembler.assemble(
|
||
baseInput({ tier: 'small', taskShape: shape('compare', 0.8) }),
|
||
{ scaffoldStyle: 'expansion' },
|
||
);
|
||
const decideOut = assembler.assemble(
|
||
baseInput({ tier: 'small', taskShape: shape('decide', 0.8) }),
|
||
{ scaffoldStyle: 'expansion' },
|
||
);
|
||
const reviewOut = assembler.assemble(
|
||
baseInput({ tier: 'small', taskShape: shape('review', 0.8) }),
|
||
{ scaffoldStyle: 'expansion' },
|
||
);
|
||
expect(decideOut.responseScaffold).toBe(compareOut.responseScaffold);
|
||
expect(reviewOut.responseScaffold).toBe(compareOut.responseScaffold);
|
||
});
|
||
|
||
it('expansion + small + plan-execute uses named-phases template', () => {
|
||
const out = assembler.assemble(
|
||
baseInput({ tier: 'small', taskShape: shape('plan-execute', 0.8) }),
|
||
{ scaffoldStyle: 'expansion' },
|
||
);
|
||
expect(out.responseScaffold).not.toBeNull();
|
||
expect(out.responseScaffold).toContain('named phases');
|
||
expect(out.responseScaffold).toContain('Goal');
|
||
expect(out.responseScaffold).toContain('Steps');
|
||
expect(out.responseScaffold).toContain('Dependencies');
|
||
expect(out.responseScaffold).toContain('Blockers');
|
||
expect(out.responseScaffold).toContain('timeline');
|
||
expect(out.responseScaffold).toContain('critical-path');
|
||
});
|
||
|
||
it('expansion + small + research uses three-part template', () => {
|
||
const out = assembler.assemble(
|
||
baseInput({ tier: 'small', taskShape: shape('research', 0.8) }),
|
||
{ scaffoldStyle: 'expansion' },
|
||
);
|
||
expect(out.responseScaffold).not.toBeNull();
|
||
expect(out.responseScaffold).toContain('Direct answer');
|
||
expect(out.responseScaffold).toContain('Source');
|
||
expect(out.responseScaffold).toContain('Context');
|
||
expect(out.responseScaffold).toContain('three parts');
|
||
});
|
||
|
||
it('expansion + mid produces shorter variant than small for same shape', () => {
|
||
const small = assembler.assemble(
|
||
baseInput({ tier: 'small', taskShape: shape('compare', 0.8) }),
|
||
{ scaffoldStyle: 'expansion' },
|
||
);
|
||
const mid = assembler.assemble(
|
||
baseInput({ tier: 'mid', taskShape: shape('compare', 0.8) }),
|
||
{ scaffoldStyle: 'expansion' },
|
||
);
|
||
expect(mid.responseScaffold).not.toBeNull();
|
||
expect(mid.responseScaffold!.length).toBeLessThan(small.responseScaffold!.length);
|
||
});
|
||
|
||
it('expansion + draft shape → null at every tier (creative never scaffolded)', () => {
|
||
for (const tier of ['small', 'mid', 'frontier'] as const) {
|
||
const out = assembler.assemble(
|
||
baseInput({ tier, taskShape: shape('draft', 0.9) }),
|
||
{ scaffoldStyle: 'expansion' },
|
||
);
|
||
expect(out.responseScaffold).toBeNull();
|
||
expect(out.debug.scaffoldApplied).toBe(false);
|
||
}
|
||
});
|
||
|
||
it('expansion + mixed shape → null at every tier', () => {
|
||
for (const tier of ['small', 'mid', 'frontier'] as const) {
|
||
const out = assembler.assemble(
|
||
baseInput({ tier, taskShape: shape('mixed', 0.9) }),
|
||
{ scaffoldStyle: 'expansion' },
|
||
);
|
||
expect(out.responseScaffold).toBeNull();
|
||
}
|
||
});
|
||
|
||
it('expansion + frontier → null (expansion forced to compression at frontier)', () => {
|
||
// Per §7.3: "Frontier tier receives compression scaffold regardless of
|
||
// scaffoldStyle request." Since compression[*][frontier] = null in v4,
|
||
// expansion at frontier also yields null. Don't risk v4's F > E
|
||
// replication by applying expansion to frontier models.
|
||
for (const shapeType of ['compare', 'decide', 'review', 'plan-execute', 'research'] as const) {
|
||
const out = assembler.assemble(
|
||
baseInput({ tier: 'frontier', taskShape: shape(shapeType, 0.9) }),
|
||
{ scaffoldStyle: 'expansion' },
|
||
);
|
||
expect(out.responseScaffold).toBeNull();
|
||
}
|
||
});
|
||
|
||
it('expansion respects confidence threshold (same gate as compression)', () => {
|
||
const out = assembler.assemble(
|
||
baseInput({ tier: 'small', taskShape: shape('compare', 0.1) }),
|
||
{ scaffoldStyle: 'expansion' },
|
||
);
|
||
expect(out.responseScaffold).toBeNull();
|
||
});
|
||
|
||
it('debug.scaffoldStyle reflects the requested style', () => {
|
||
const defaultOut = assembler.assemble(
|
||
baseInput({ tier: 'small', taskShape: shape('compare', 0.8) }),
|
||
);
|
||
expect(defaultOut.debug.scaffoldStyle).toBe('compression');
|
||
|
||
const compressionOut = assembler.assemble(
|
||
baseInput({ tier: 'small', taskShape: shape('compare', 0.8) }),
|
||
{ scaffoldStyle: 'compression' },
|
||
);
|
||
expect(compressionOut.debug.scaffoldStyle).toBe('compression');
|
||
|
||
const expansionOut = assembler.assemble(
|
||
baseInput({ tier: 'small', taskShape: shape('compare', 0.8) }),
|
||
{ scaffoldStyle: 'expansion' },
|
||
);
|
||
expect(expansionOut.debug.scaffoldStyle).toBe('expansion');
|
||
});
|
||
|
||
it('debug.scaffoldStyle populated even when no scaffold is emitted (frontier / draft / low-conf)', () => {
|
||
const frontierOut = assembler.assemble(
|
||
baseInput({ tier: 'frontier', taskShape: shape('compare', 0.9) }),
|
||
{ scaffoldStyle: 'expansion' },
|
||
);
|
||
expect(frontierOut.debug.scaffoldStyle).toBe('expansion');
|
||
expect(frontierOut.debug.scaffoldApplied).toBe(false);
|
||
|
||
const draftOut = assembler.assemble(
|
||
baseInput({ tier: 'small', taskShape: shape('draft', 0.9) }),
|
||
{ scaffoldStyle: 'expansion' },
|
||
);
|
||
expect(draftOut.debug.scaffoldStyle).toBe('expansion');
|
||
expect(draftOut.debug.scaffoldApplied).toBe(false);
|
||
});
|
||
});
|