wehub-resource-sync
1017 lines
40 KiB
TypeScript
1017 lines
40 KiB
TypeScript
import { describe, expect, it } from 'vitest';
|
|
|
|
import {
|
|
buildFirstTaskWorkspaceOrientationBlock,
|
|
buildInstructorRuntimeBrief,
|
|
buildPriorSubmissionsBlock,
|
|
buildScaffoldStateLine,
|
|
buildScenarioAwarenessBlock,
|
|
cleanInstructorCommitText,
|
|
cleanSetupFollowupText,
|
|
ensureNonEmptyInstructorMessages,
|
|
shouldHoldSetupFollowupPreview,
|
|
shouldReportEmptyOutput,
|
|
stageSynthesisOwed,
|
|
stripLeakedToolJson,
|
|
stripOrphanTrailingQuestion,
|
|
stripPrematureNextTaskSetup,
|
|
} from '@/lib/pbl/v2/agents/instructor';
|
|
import {
|
|
microtaskEngagement,
|
|
milestoneSynthesisSatisfied,
|
|
recordEvent,
|
|
} from '@/lib/pbl/v2/operations/engagement';
|
|
import type { PBLMilestone, PBLProjectV2 } from '@/lib/pbl/v2/types';
|
|
|
|
const now = '2026-05-29T00:00:00.000Z';
|
|
|
|
function milestone(args: Partial<PBLMilestone> & Pick<PBLMilestone, 'id' | 'title' | 'order'>) {
|
|
return {
|
|
status: 'locked',
|
|
description: '',
|
|
microtasks: [],
|
|
documents: [],
|
|
...args,
|
|
} satisfies PBLMilestone;
|
|
}
|
|
|
|
function makeProject(): PBLProjectV2 {
|
|
return {
|
|
uiPhase: 'workspace',
|
|
title: 'Build a HashMap Playground',
|
|
description:
|
|
'Create a tiny interactive project that lets a learner add, lookup, update, and delete keys while seeing collisions at a beginner-friendly level.',
|
|
learningObjective: 'Learn HashMap operations by building and testing a concrete toy tool.',
|
|
proficiency: 'beginner',
|
|
language: 'zh-CN',
|
|
tags: ['hashmap'],
|
|
status: 'active',
|
|
roles: [{ id: 'role-i', type: 'instructor', name: 'Instructor' }],
|
|
milestones: [
|
|
milestone({
|
|
id: 'ms-2',
|
|
title: 'Wire the interactive demo',
|
|
order: 1,
|
|
status: 'locked',
|
|
description: 'Turn the core operations into a visible playground.',
|
|
briefing: 'Connect each operation to a small learner-visible action.',
|
|
completionCriteria: 'The learner can demonstrate add, lookup, update, and delete.',
|
|
microtasks: [
|
|
{
|
|
id: 'mt-3',
|
|
title: 'Add buttons for each operation',
|
|
description: 'Create controls that trigger each HashMap operation.',
|
|
status: 'todo',
|
|
assignee: 'user',
|
|
hints: ['Start with add and lookup before delete.'],
|
|
order: 0,
|
|
},
|
|
],
|
|
documents: [],
|
|
}),
|
|
milestone({
|
|
id: 'ms-1',
|
|
title: 'Model the core HashMap behavior',
|
|
order: 0,
|
|
status: 'active',
|
|
description: 'Represent the map as buckets and make the basic operations work.',
|
|
briefing: 'Help the learner connect keys, hashes, buckets, and values.',
|
|
completionCriteria:
|
|
'The learner has working behavior and can explain what happens on lookup.',
|
|
microtasks: [
|
|
{
|
|
id: 'mt-2',
|
|
title: 'Implement lookup',
|
|
description: 'Use a key to find the right bucket and return the stored value.',
|
|
status: 'in_progress',
|
|
assignee: 'user',
|
|
hints: ['Ask what should happen when the key is missing.'],
|
|
order: 1,
|
|
},
|
|
{
|
|
id: 'mt-1',
|
|
title: 'Sketch buckets',
|
|
description: 'Draw or describe how keys land in buckets before coding.',
|
|
status: 'completed',
|
|
assignee: 'user',
|
|
hints: [],
|
|
order: 0,
|
|
},
|
|
],
|
|
documents: [],
|
|
}),
|
|
],
|
|
submissions: [
|
|
{
|
|
id: 'sub-1',
|
|
microtaskId: 'mt-2',
|
|
milestoneId: 'ms-1',
|
|
kind: 'text',
|
|
content: 'I wrote lookup and handled missing keys with undefined.',
|
|
createdAt: '2026-05-29T00:10:00.000Z',
|
|
},
|
|
],
|
|
evaluations: [
|
|
{
|
|
id: 'eval-1',
|
|
kind: 'task',
|
|
microtaskId: 'mt-2',
|
|
milestoneId: 'ms-1',
|
|
feedback: 'Older feedback before the latest submission.',
|
|
strengths: ['Understands buckets'],
|
|
improvements: ['Check missing keys'],
|
|
score: 70,
|
|
createdAt: '2026-05-29T00:05:00.000Z',
|
|
},
|
|
],
|
|
threads: [{ agentId: 'role-i', messages: [] }],
|
|
engagementEvents: [],
|
|
pendingHandover: {
|
|
completedMilestoneId: 'ms-0',
|
|
completedMilestoneTitle: 'Setup',
|
|
nextMilestoneId: 'ms-1',
|
|
nextMilestoneTitle: 'Model the core HashMap behavior',
|
|
nextTaskId: 'mt-1',
|
|
nextTaskTitle: 'Sketch buckets',
|
|
consumed: false,
|
|
},
|
|
createdAt: now,
|
|
updatedAt: now,
|
|
};
|
|
}
|
|
|
|
describe('PBL v2 — Instructor operating brief', () => {
|
|
it('anchors the instructor in project facts, roadmap, active task, and controls', () => {
|
|
const project = makeProject();
|
|
const activeMilestone = project.milestones[1];
|
|
const activeTask = activeMilestone.microtasks[0];
|
|
|
|
const brief = buildInstructorRuntimeBrief(project, activeMilestone, activeTask);
|
|
|
|
expect(brief).toContain('Build a HashMap Playground');
|
|
expect(brief).toContain('Learn HashMap operations');
|
|
expect(brief).toContain(
|
|
'Current location: milestone 1 "Model the core HashMap behavior", microtask 2/2 "Implement lookup"',
|
|
);
|
|
expect(brief).toContain('(2) Implement lookup [in progress');
|
|
expect(brief).toContain('Task intent: Use a key to find the right bucket');
|
|
expect(brief).toContain('Milestone 2: Wire the interactive demo [locked]');
|
|
expect(brief).toContain('latest submission is newer than the latest task evaluation');
|
|
expect(brief).toContain('right-side submission panel');
|
|
expect(brief).toContain('Continue button');
|
|
expect(brief).toContain('Pending stage handover');
|
|
});
|
|
|
|
it('instructs the LLM to drive difficulty changes via the adjust_difficulty tool (sole mechanism, no regex)', () => {
|
|
// There is no longer any per-message regex detector for learner difficulty
|
|
// requests — the runtime brief is what makes the LLM call adjust_difficulty,
|
|
// so this guards that the contract is present and unambiguous.
|
|
const project = makeProject();
|
|
const activeMilestone = project.milestones[1];
|
|
const activeTask = activeMilestone.microtasks[0];
|
|
|
|
const brief = buildInstructorRuntimeBrief(project, activeMilestone, activeTask);
|
|
|
|
expect(brief).toContain('adjust_difficulty');
|
|
expect(brief).toMatch(/EVERY learner message/i);
|
|
expect(brief).toMatch(/ONLY way difficulty changes/i);
|
|
// Must instruct SEMANTIC judgement, not keyword / fixed-pattern matching.
|
|
expect(brief).toMatch(/by MEANING — not by keywords/i);
|
|
});
|
|
|
|
it('treats the right-side submission panel as the only readiness path', () => {
|
|
const project = makeProject();
|
|
const milestone = project.milestones[1]; // ms-1
|
|
const noSubmissionTask = milestone.microtasks.find((t) => t.id === 'mt-1')!; // 0 submissions
|
|
const brief = buildInstructorRuntimeBrief(project, milestone, noSubmissionTask);
|
|
|
|
expect(brief).toContain('task readiness comes only from work submitted and evaluated');
|
|
expect(brief).toContain('right-side submission panel is REQUIRED');
|
|
expect(brief).toContain('Do not say that chat alone completed the task');
|
|
|
|
expect(brief).not.toContain('right-side submission panel is OPTIONAL');
|
|
expect(brief).not.toContain('completed directly in the chat');
|
|
expect(brief).not.toContain('do not route them to the panel');
|
|
});
|
|
|
|
it('does not reorder the project while building the prompt context', () => {
|
|
const project = makeProject();
|
|
const milestoneOrderBefore = project.milestones.map((m) => m.id);
|
|
const taskOrderBefore = project.milestones[1].microtasks.map((t) => t.id);
|
|
|
|
buildInstructorRuntimeBrief(
|
|
project,
|
|
project.milestones[1],
|
|
project.milestones[1].microtasks[0],
|
|
);
|
|
|
|
expect(project.milestones.map((m) => m.id)).toEqual(milestoneOrderBefore);
|
|
expect(project.milestones[1].microtasks.map((t) => t.id)).toEqual(taskOrderBefore);
|
|
});
|
|
});
|
|
|
|
describe('PBL v2 — first-task workspace orientation', () => {
|
|
function firstTaskProject(): PBLProjectV2 {
|
|
const project = makeProject();
|
|
project.milestones[1].microtasks[0].status = 'todo';
|
|
project.milestones[1].microtasks[1].status = 'in_progress';
|
|
return project;
|
|
}
|
|
|
|
it('adds workspace usage guidance for the first milestone first task in open-task phases', () => {
|
|
const project = firstTaskProject();
|
|
const milestone = project.milestones[1]; // order 0
|
|
const microtask = milestone.microtasks.find((t) => t.id === 'mt-1')!; // order 0
|
|
|
|
const block = buildFirstTaskWorkspaceOrientationBlock({
|
|
project,
|
|
milestone,
|
|
microtask,
|
|
phase: 'greeting',
|
|
});
|
|
|
|
expect(block).toContain('First-task workspace orientation');
|
|
expect(block).toContain('left side is the task sidebar');
|
|
expect(block).toContain('center is the Instructor interaction area');
|
|
expect(block).toContain('right side');
|
|
expect(block).toContain('final deliverable should be submitted on the right');
|
|
expect(block).toContain('copying/pasting text');
|
|
expect(block).toContain('PDF or an image/screenshot');
|
|
expect(block).toContain('feedback card');
|
|
expect(block).toContain('click the button that appears to advance');
|
|
expect(block).toContain('ask and discuss anything with the Instructor');
|
|
});
|
|
|
|
it('does not add the orientation for later tasks or normal instructing turns', () => {
|
|
const project = makeProject();
|
|
const milestone = project.milestones[1];
|
|
const laterTask = milestone.microtasks.find((t) => t.id === 'mt-2')!;
|
|
|
|
expect(
|
|
buildFirstTaskWorkspaceOrientationBlock({
|
|
project,
|
|
milestone,
|
|
microtask: laterTask,
|
|
phase: 'setup',
|
|
}),
|
|
).toBe('');
|
|
|
|
const firstTask = milestone.microtasks.find((t) => t.id === 'mt-1')!;
|
|
expect(
|
|
buildFirstTaskWorkspaceOrientationBlock({
|
|
project,
|
|
milestone,
|
|
microtask: firstTask,
|
|
phase: 'instructing',
|
|
}),
|
|
).toBe('');
|
|
});
|
|
|
|
it('NEVER adds the ordinary workspace orientation to a scenario project (it has its own prep briefing)', () => {
|
|
const project = makeProject();
|
|
// make it a scenario project; first milestone first task, greeting phase —
|
|
// the exact condition that would fire the orientation for an ordinary project.
|
|
project.scenario = {
|
|
setting: 's',
|
|
characters: [{ id: 'c1', name: '小皮', persona: 'p', situation: 'x' }],
|
|
} as PBLProjectV2['scenario'];
|
|
project.milestones[0].scenarioStage = 'prep';
|
|
const milestone = project.milestones[0];
|
|
const microtask = milestone.microtasks[0];
|
|
expect(
|
|
buildFirstTaskWorkspaceOrientationBlock({ project, milestone, microtask, phase: 'greeting' }),
|
|
).toBe('');
|
|
});
|
|
});
|
|
|
|
describe('PBL v2 — Instructor advance handoff text cleanup', () => {
|
|
it('dedupes an accidental repeated old-task wrap-up sentence', () => {
|
|
const result = cleanInstructorCommitText(
|
|
'对，这三行已经满足本步要求：print() 在 if 里面，只有 has_card 为 True 时才会输出“可以进门”。对，这三行已经满足本步要求：print() 在 if 里面，只有 has_card 为 True 时才会输出“可以进门”。',
|
|
);
|
|
|
|
expect(result.changed).toBe(true);
|
|
expect(result.text).toBe(
|
|
'对，这三行已经满足本步要求：print() 在 if 里面，只有 has_card 为 True 时才会输出“可以进门”。',
|
|
);
|
|
});
|
|
|
|
it('removes leaked observation tool JSON from committed instructor text', () => {
|
|
const result = stripLeakedToolJson(
|
|
'{"kind":"concept_unlocked","note":"学习者提交了 print(left_money)，正确用 print 输出了剩余金额变量。","signature":"print_left_money_output"}可以，这一步已经能把剩余金额显示出来了。',
|
|
);
|
|
|
|
expect(result.changed).toBe(true);
|
|
expect(result.text).toBe('可以，这一步已经能把剩余金额显示出来了。');
|
|
});
|
|
|
|
it('wires next-task cleanup into committed instructor text when context is provided', () => {
|
|
const result = cleanInstructorCommitText(
|
|
[
|
|
'很好，你已经验证了值传递为什么不会改变原变量。',
|
|
'',
|
|
'现在进入第三步：运行程序并观察值传递的局限。我们先运行一次，看看输出。',
|
|
].join('\n'),
|
|
{ nextMicrotaskTitle: '运行程序并观察值传递的局限' },
|
|
);
|
|
|
|
expect(result.changed).toBe(true);
|
|
expect(result.text).toBe('很好，你已经验证了值传递为什么不会改变原变量。');
|
|
});
|
|
|
|
it('does not strip transition language from generic committed text without next-task context', () => {
|
|
const text = '下一步我们把代码运行一次，看看终端输出是否符合预期。';
|
|
expect(cleanInstructorCommitText(text)).toEqual({ text, changed: false });
|
|
});
|
|
|
|
it('keeps normal teaching questions unless the commit context asks for statement-only text', () => {
|
|
const text = '你觉得 input() 返回的是什么类型呢？';
|
|
expect(cleanInstructorCommitText(text)).toEqual({ text, changed: false });
|
|
expect(cleanInstructorCommitText(text, { stripFinalReverseQuestion: true })).toEqual({
|
|
text,
|
|
changed: false,
|
|
});
|
|
});
|
|
|
|
it('removes orphan final reverse-questions for statement-only commits', () => {
|
|
const result = cleanInstructorCommitText(
|
|
'很好，你已经让程序正确输出了问候。input() 拿到的内容为什么要先存进变量再用呢？',
|
|
{ stripFinalReverseQuestion: true },
|
|
);
|
|
|
|
expect(result.changed).toBe(true);
|
|
expect(result.text).toBe('很好，你已经让程序正确输出了问候。');
|
|
});
|
|
|
|
it('keeps the old-task wrap-up and removes a same-message next-task opener', () => {
|
|
const result = stripPrematureNextTaskSetup(
|
|
[
|
|
'很好，你已经验证了值传递为什么不会改变原变量。',
|
|
'',
|
|
'现在进入第三步：运行程序并观察值传递的局限。我们先运行一次，看看输出。',
|
|
].join('\n'),
|
|
'运行程序并观察值传递的局限',
|
|
);
|
|
|
|
expect(result.stripped).toBe(true);
|
|
expect(result.text).toBe('很好，你已经验证了值传递为什么不会改变原变量。');
|
|
});
|
|
|
|
it('leaves normal old-task feedback unchanged when it does not open the next task', () => {
|
|
const text = '很好，这一步你已经能说清楚 swap(a, b) 为什么只改了副本。';
|
|
const result = stripPrematureNextTaskSetup(text, '运行程序并观察值传递的局限');
|
|
|
|
expect(result).toEqual({ text, stripped: false });
|
|
});
|
|
|
|
it('also removes a clear next-task transition even when the title is paraphrased', () => {
|
|
const result = stripPrematureNextTaskSetup(
|
|
'你的解释是对的：值传递只改了函数里的副本。\n\n下一步我们开始做指针版本，先把函数参数改成地址。',
|
|
'编写指针版本的swap函数',
|
|
);
|
|
|
|
expect(result.stripped).toBe(true);
|
|
expect(result.text).toBe('你的解释是对的：值传递只改了函数里的副本。');
|
|
});
|
|
|
|
it('removes cross-milestone Continue guidance from the old-task wrap-up', () => {
|
|
const result = stripPrematureNextTaskSetup(
|
|
'这一阶段你已经把添加和展示清单跑通了。\n\n下一阶段我们会给清单加上"删除"功能——点击右侧的 Continue 按钮继续吧 👉',
|
|
undefined,
|
|
'实现删除功能',
|
|
);
|
|
|
|
expect(result.stripped).toBe(true);
|
|
expect(result.text).toBe('这一阶段你已经把添加和展示清单跑通了。');
|
|
});
|
|
|
|
it('removes previous-task praise from a setup opener after the divider', () => {
|
|
const result = cleanSetupFollowupText(
|
|
'很好，if 这一行已经像门禁机的“判断入口”了；现在我们要把判断成立时真正发生的事放进去。\n\n这一步的计划很简单：在 if has_card: 的下一行缩进 4 个空格，然后写一行 print()。',
|
|
);
|
|
|
|
expect(result.changed).toBe(true);
|
|
expect(result.text).toBe(
|
|
'现在我们要把判断成立时真正发生的事放进去。\n\n这一步的计划很简单：在 if has_card: 的下一行缩进 4 个空格，然后写一行 print()。',
|
|
);
|
|
});
|
|
|
|
it('removes vague setup lead-ins so the next action is explicit', () => {
|
|
const result = cleanSetupFollowupText(
|
|
'很接近第一个可运行成果了；这一步的意义是确认代码不只是“看起来对”，而是真的能在屏幕上产生预期输出。\n\n按这个小计划来：保持 has_card = True 不变，运行当前 Python 文件，然后看终端里是否出现“可以进门”。',
|
|
);
|
|
|
|
expect(result.changed).toBe(true);
|
|
expect(result.text).toBe(
|
|
'这一步的意义是确认代码不只是“看起来对”，而是真的能在屏幕上产生预期输出。\n\n保持 has_card = True 不变，运行当前 Python 文件，然后看终端里是否出现“可以进门”。',
|
|
);
|
|
});
|
|
|
|
it('holds early setup-followup tokens that still look like previous-task praise', () => {
|
|
const raw = '很好，上一任务已经完成得很稳';
|
|
expect(shouldHoldSetupFollowupPreview(raw, cleanSetupFollowupText(raw))).toBe(true);
|
|
});
|
|
|
|
it('releases setup-followup streaming once the cleaned next-task opener is available', () => {
|
|
const raw = '很好，上一任务已经完成得很稳；现在我们要读取用户输入的温度。';
|
|
const cleaned = cleanSetupFollowupText(raw);
|
|
expect(cleaned.changed).toBe(true);
|
|
expect(shouldHoldSetupFollowupPreview(raw, cleaned)).toBe(false);
|
|
expect(cleaned.text).toBe('现在我们要读取用户输入的温度。');
|
|
});
|
|
});
|
|
|
|
describe('PBL v2 — orphan trailing reverse-question cleanup', () => {
|
|
it('removes a trailing reverse-question sentence after the review', () => {
|
|
const result = stripOrphanTrailingQuestion(
|
|
'很好，你已经让程序正确输出了问候。input() 拿到的内容为什么要先存进变量再用呢？',
|
|
);
|
|
expect(result.changed).toBe(true);
|
|
expect(result.text).toBe('很好，你已经让程序正确输出了问候。');
|
|
});
|
|
|
|
it('cuts an explicit closing lead-in even when comma-joined to the praise', () => {
|
|
const result = stripOrphanTrailingQuestion(
|
|
'很好，你已经正确输出了问候，最后确认一下 input() 为什么要存进变量呢？',
|
|
);
|
|
expect(result.changed).toBe(true);
|
|
expect(result.text).toBe('很好，你已经正确输出了问候');
|
|
});
|
|
|
|
it('handles an English trailing question', () => {
|
|
const result = stripOrphanTrailingQuestion(
|
|
'Nice, your script greets the user. In your own words, why did we store input() in a variable?',
|
|
);
|
|
expect(result.changed).toBe(true);
|
|
expect(result.text).toBe('Nice, your script greets the user.');
|
|
});
|
|
|
|
it('leaves a statement-only message unchanged', () => {
|
|
const text = '很好，你已经正确输出了问候，方向完全对。';
|
|
const result = stripOrphanTrailingQuestion(text);
|
|
expect(result).toEqual({ text, changed: false });
|
|
});
|
|
|
|
it('never blanks a message that is only a single question', () => {
|
|
const text = '你觉得 input() 返回的是什么类型呢？';
|
|
const result = stripOrphanTrailingQuestion(text);
|
|
expect(result.changed).toBe(false);
|
|
expect(result.text).toBe(text);
|
|
});
|
|
|
|
it('peels multiple trailing question sentences but keeps the review', () => {
|
|
const result = stripOrphanTrailingQuestion(
|
|
'对，循环跑通了。你觉得 range() 的上界为什么不包含自己？再想想 step 是怎么回事？',
|
|
);
|
|
expect(result.changed).toBe(true);
|
|
expect(result.text).toBe('对，循环跑通了。');
|
|
});
|
|
|
|
it('P3: does not mis-cut a version/decimal number into a fragment', () => {
|
|
const result = stripOrphanTrailingQuestion('装好了，你用了 v2.0 对吧？');
|
|
expect(result.changed).toBe(false);
|
|
expect(result.text).toBe('装好了，你用了 v2.0 对吧？');
|
|
});
|
|
|
|
it('P3: an English decimal is not treated as a sentence boundary', () => {
|
|
const result = stripOrphanTrailingQuestion('You set version 2.5 already?');
|
|
expect(result.changed).toBe(false);
|
|
expect(result.text).toBe('You set version 2.5 already?');
|
|
});
|
|
|
|
it('P3: cuts at the sentence boundary before a lead-in (no dangling connector)', () => {
|
|
const result = stripOrphanTrailingQuestion(
|
|
'很好，程序跑起来了。我们最后看一下，为什么要先读输入呢？',
|
|
);
|
|
expect(result.changed).toBe(true);
|
|
expect(result.text).toBe('很好，程序跑起来了。');
|
|
});
|
|
|
|
it('P3: trims a dangling connector when a lead-in is comma+connector fused', () => {
|
|
const result = stripOrphanTrailingQuestion('不错，那我们最后确认一下为什么？');
|
|
expect(result.changed).toBe(true);
|
|
expect(result.text).toBe('不错');
|
|
});
|
|
});
|
|
|
|
describe('PBL v2 — stage synthesis checkpoint gate', () => {
|
|
it('is not owed when the milestone has no synthesisCheck', () => {
|
|
const project = makeProject();
|
|
const ms = project.milestones[1]; // ms-1, active
|
|
const lastTask = ms.microtasks.find((t) => t.id === 'mt-2')!;
|
|
expect(stageSynthesisOwed(project, ms, lastTask)).toBe(false);
|
|
});
|
|
|
|
it('is owed on the last microtask of a core (synthesisCheck) stage', () => {
|
|
const project = makeProject();
|
|
const ms = project.milestones[1]; // ms-1: mt-1 completed, mt-2 in_progress
|
|
ms.synthesisCheck = { coreConcept: '为什么用哈希能 O(1) 查找' };
|
|
const lastTask = ms.microtasks.find((t) => t.id === 'mt-2')!;
|
|
expect(stageSynthesisOwed(project, ms, lastTask)).toBe(true);
|
|
});
|
|
|
|
it('is NOT owed when the microtask is not the last of the core stage', () => {
|
|
const project = makeProject();
|
|
const ms = project.milestones[1];
|
|
ms.synthesisCheck = { coreConcept: '哈希查找' };
|
|
// Add a still-open sibling so mt-2 is no longer the last.
|
|
ms.microtasks.push({
|
|
id: 'mt-extra',
|
|
title: 'Extra step',
|
|
status: 'todo',
|
|
assignee: 'user',
|
|
hints: [],
|
|
order: 2,
|
|
});
|
|
const midTask = ms.microtasks.find((t) => t.id === 'mt-2')!;
|
|
expect(stageSynthesisOwed(project, ms, midTask)).toBe(false);
|
|
});
|
|
|
|
it('clears the gate once a stage_synthesis_check is recorded', () => {
|
|
const project = makeProject();
|
|
const ms = project.milestones[1];
|
|
ms.synthesisCheck = { coreConcept: '哈希查找' };
|
|
const lastTask = ms.microtasks.find((t) => t.id === 'mt-2')!;
|
|
|
|
expect(milestoneSynthesisSatisfied(project, ms.id)).toBe(false);
|
|
expect(stageSynthesisOwed(project, ms, lastTask)).toBe(true);
|
|
|
|
recordEvent(project, 'stage_synthesis_check', {
|
|
microtaskId: lastTask.id,
|
|
milestoneId: ms.id,
|
|
payload: {
|
|
question: '回看整个阶段，哈希为什么能让查找变快？',
|
|
learner_answer: '因为用 key 直接算出桶位置，不用一个个找。',
|
|
quality: 'strong',
|
|
},
|
|
});
|
|
|
|
expect(milestoneSynthesisSatisfied(project, ms.id)).toBe(true);
|
|
expect(stageSynthesisOwed(project, ms, lastTask)).toBe(false);
|
|
});
|
|
|
|
it('absorbs the microtask closing gate: a stage_synthesis_check sets the closing fields', () => {
|
|
const project = makeProject();
|
|
const ms = project.milestones[1];
|
|
const lastTask = ms.microtasks.find((t) => t.id === 'mt-2')!;
|
|
recordEvent(project, 'stage_synthesis_check', {
|
|
microtaskId: lastTask.id,
|
|
milestoneId: ms.id,
|
|
payload: {
|
|
question: '整个阶段你怎么总结？',
|
|
learner_answer: 'key→hash→bucket→value。',
|
|
quality: 'ok',
|
|
},
|
|
});
|
|
const summary = microtaskEngagement(project, lastTask.id);
|
|
expect(summary.closingQuestion).toBe('整个阶段你怎么总结？');
|
|
expect(summary.closingAnswer).toBe('key→hash→bucket→value。');
|
|
expect(summary.closingQuality).toBe('ok');
|
|
});
|
|
|
|
it('P2b: gate also accepts a closing_check on the last microtask (wrong-tool robustness)', () => {
|
|
const project = makeProject();
|
|
const ms = project.milestones[1]; // last microtask by order is mt-2
|
|
expect(milestoneSynthesisSatisfied(project, ms.id)).toBe(false);
|
|
recordEvent(project, 'closing_check', {
|
|
microtaskId: 'mt-2',
|
|
milestoneId: ms.id,
|
|
payload: { question: '为什么查找快？', learner_answer: '直接算桶位置。', quality: 'ok' },
|
|
});
|
|
expect(milestoneSynthesisSatisfied(project, ms.id)).toBe(true);
|
|
});
|
|
|
|
it('P2b: a closing_check on a NON-last microtask does not satisfy the gate', () => {
|
|
const project = makeProject();
|
|
const ms = project.milestones[1];
|
|
recordEvent(project, 'closing_check', {
|
|
microtaskId: 'mt-1', // completed, order 0 — not the last
|
|
milestoneId: ms.id,
|
|
payload: { question: 'q', learner_answer: 'a', quality: 'ok' },
|
|
});
|
|
expect(milestoneSynthesisSatisfied(project, ms.id)).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe('PBL v2 — instructor sees earlier submissions across the project (#519)', () => {
|
|
it('digests an earlier task submission with how it was assessed', () => {
|
|
const project = makeProject();
|
|
// Make the evaluation NEWER than the submission so it is genuinely this
|
|
// submission's assessment (the fixture default has an older eval — see the
|
|
// stale-eval test below).
|
|
project.evaluations[0].createdAt = '2026-05-29T00:15:00.000Z';
|
|
// Active = mt-1 (no submission). mt-2 carries the only submission + eval.
|
|
const block = buildPriorSubmissionsBlock(project, 'mt-1');
|
|
expect(block).toContain('Model the core HashMap behavior / Implement lookup');
|
|
expect(block).toContain('handled missing keys with undefined'); // the submitted content
|
|
expect(block).toContain('score 70'); // how it was assessed
|
|
expect(block).toContain('to improve: Check missing keys');
|
|
});
|
|
|
|
it('does not borrow a stale score when the latest submission postdates the eval', () => {
|
|
// Fixture: submission at 00:10, evaluation at 00:05 → the learner has a
|
|
// newer, not-yet-evaluated version. The Instructor must NOT be told it
|
|
// "scored 70" (that score belongs to a previous version).
|
|
const project = makeProject();
|
|
const block = buildPriorSubmissionsBlock(project, 'mt-1');
|
|
expect(block).toContain('latest version not yet evaluated');
|
|
expect(block).not.toContain('score 70');
|
|
});
|
|
|
|
it('marks an earlier submission with no evaluation as not yet scored', () => {
|
|
const project = makeProject();
|
|
project.evaluations = [];
|
|
const block = buildPriorSubmissionsBlock(project, 'mt-1');
|
|
expect(block).toContain('not yet scored');
|
|
expect(block).not.toContain('score 70');
|
|
});
|
|
|
|
it("excludes the active task's own submission (no duplication of the current task)", () => {
|
|
const project = makeProject();
|
|
// mt-2 is the only task with a submission; when it is ACTIVE the prior
|
|
// block has nothing left to show.
|
|
expect(buildPriorSubmissionsBlock(project, 'mt-2')).toBe('');
|
|
});
|
|
|
|
it('returns empty when there are no submissions at all', () => {
|
|
const project = makeProject();
|
|
project.submissions = [];
|
|
expect(buildPriorSubmissionsBlock(project, 'mt-1')).toBe('');
|
|
});
|
|
|
|
it('drops entries that do not fit the budget and marks truncation', () => {
|
|
const project = makeProject();
|
|
const block = buildPriorSubmissionsBlock(project, 'mt-1', { maxChars: 200 });
|
|
expect(block).toContain('truncated to keep context bounded');
|
|
expect(block).not.toContain('handled missing keys with undefined');
|
|
});
|
|
});
|
|
|
|
describe('PBL v2 — scaffolding state release verdict (P2 ①②)', () => {
|
|
const base = {
|
|
learnerTurnCount: 1,
|
|
errorCount: 0,
|
|
repeatErrorCount: 0,
|
|
struggles: [] as string[],
|
|
questionsRaised: 0,
|
|
conceptsUnlocked: [] as string[],
|
|
};
|
|
|
|
it('HOLDs on the first attempt for a beginner', () => {
|
|
const line = buildScaffoldStateLine({ ...base }, { tier: 'beginner', submissionCount: 0 });
|
|
expect(line).toContain('HOLD');
|
|
});
|
|
|
|
it('RELEASEs for a beginner after one stuck signal (repeat error)', () => {
|
|
const line = buildScaffoldStateLine(
|
|
{ ...base, errorCount: 1, repeatErrorCount: 1 },
|
|
{ tier: 'beginner', submissionCount: 0 },
|
|
);
|
|
expect(line).toContain('RELEASE');
|
|
});
|
|
|
|
it('requires two units before RELEASE at intermediate', () => {
|
|
const one = buildScaffoldStateLine(
|
|
{ ...base, struggles: ['s1'] },
|
|
{ tier: 'intermediate', submissionCount: 0 },
|
|
);
|
|
expect(one).toContain('HOLD');
|
|
const two = buildScaffoldStateLine(
|
|
{ ...base, struggles: ['s1', 's2'] },
|
|
{ tier: 'intermediate', submissionCount: 0 },
|
|
);
|
|
expect(two).toContain('RELEASE');
|
|
});
|
|
|
|
it('counts genuine attempts (errors+submissions), not raw message count', () => {
|
|
// 5 chatty turns, zero real attempts → still HOLD for a beginner.
|
|
const line = buildScaffoldStateLine(
|
|
{ ...base, learnerTurnCount: 5 },
|
|
{ tier: 'beginner', submissionCount: 0 },
|
|
);
|
|
expect(line).toContain('HOLD');
|
|
});
|
|
|
|
it('treats a second genuine attempt as a release unit', () => {
|
|
const line = buildScaffoldStateLine(
|
|
{ ...base, errorCount: 2 },
|
|
{ tier: 'beginner', submissionCount: 0 },
|
|
);
|
|
expect(line).toContain('RELEASE');
|
|
});
|
|
|
|
it('suppressVerdict drops the verdict + instruction but keeps stats', () => {
|
|
const line = buildScaffoldStateLine(
|
|
{ ...base, errorCount: 1, repeatErrorCount: 1 },
|
|
{ tier: 'beginner', submissionCount: 0, suppressVerdict: true },
|
|
);
|
|
expect(line).not.toContain('RELEASE');
|
|
expect(line).not.toContain('HOLD');
|
|
expect(line).toContain('genuine attempts');
|
|
expect(line).toContain('stuck signals');
|
|
});
|
|
|
|
it('suppressVerdict keeps stats even when release would fire', () => {
|
|
// Same input that would trigger RELEASE without suppress — with
|
|
// suppress the verdict is absent but the data line is intact.
|
|
const line = buildScaffoldStateLine(
|
|
{ ...base, errorCount: 1, repeatErrorCount: 1 },
|
|
{ tier: 'beginner', submissionCount: 0, suppressVerdict: true },
|
|
);
|
|
expect(line).toContain('## Scaffolding state');
|
|
expect(line).toContain('learner messages');
|
|
expect(line).not.toMatch(/RELEASE|HOLD/);
|
|
});
|
|
|
|
it('treats an empty/unset tier as the no-evidence default (intermediate), not beginner', () => {
|
|
// Guards the DEFAULT_TIER consistency gap: the tier-guidance block already
|
|
// resolves '' → intermediate, so the scaffold label + release threshold
|
|
// must match (otherwise the prompt shows intermediate guidance + beginner
|
|
// disclosure ladder simultaneously).
|
|
const unset = buildScaffoldStateLine({ ...base }, { tier: '', submissionCount: 0 });
|
|
expect(unset).toContain('tier intermediate');
|
|
expect(unset).not.toContain('tier beginner');
|
|
// Empty tier must use the intermediate release threshold (2 units): one
|
|
// stuck signal HOLDs (a beginner would RELEASE here).
|
|
const oneSignal = buildScaffoldStateLine(
|
|
{ ...base, struggles: ['s1'] },
|
|
{ tier: '', submissionCount: 0 },
|
|
);
|
|
expect(oneSignal).toContain('HOLD');
|
|
expect(oneSignal).toContain('L3 after 2 unit');
|
|
});
|
|
});
|
|
|
|
describe('PBL v2 — shouldReportEmptyOutput (suppress only on real user-perceivable output)', () => {
|
|
// Reviewer finding (#593): the old predicate suppressed the empty-output
|
|
// error whenever ANY tool ran (`toolCalled`). That was too broad — a
|
|
// tool *call* is not the same as a user-perceivable result. A turn that
|
|
// only called an internal tool with no text can leave the learner with total
|
|
// silence. The predicate now keys off genuine user-perceivable output:
|
|
// scenario auto-completion (mainTurnAdvanced), committed text, or the
|
|
// difficulty ack (producedAck).
|
|
it('reports the empty-output error on a genuinely empty turn: no text, no advance, no ack', () => {
|
|
expect(
|
|
shouldReportEmptyOutput({
|
|
mainTurnAdvanced: false,
|
|
assistantText: ' ',
|
|
producedAck: false,
|
|
}),
|
|
).toBe(true);
|
|
});
|
|
|
|
it('reports empty output when a tool ran but produced NO user-perceivable result', () => {
|
|
// This is the reviewer case the old code wrongly suppressed: a bare
|
|
// internal tool call with no text, no scenario auto-completion, no ack →
|
|
// the learner saw nothing, so the retry fallback MUST fire.
|
|
expect(
|
|
shouldReportEmptyOutput({
|
|
mainTurnAdvanced: false,
|
|
assistantText: '',
|
|
producedAck: false,
|
|
}),
|
|
).toBe(true);
|
|
});
|
|
|
|
it('does NOT report empty output when the turn produced scenario auto-completion', () => {
|
|
expect(
|
|
shouldReportEmptyOutput({
|
|
mainTurnAdvanced: true,
|
|
assistantText: '',
|
|
producedAck: false,
|
|
}),
|
|
).toBe(false);
|
|
});
|
|
|
|
it('does NOT report empty output when a difficulty ack was committed', () => {
|
|
expect(
|
|
shouldReportEmptyOutput({
|
|
mainTurnAdvanced: false,
|
|
assistantText: '',
|
|
producedAck: true,
|
|
}),
|
|
).toBe(false);
|
|
});
|
|
|
|
it('does NOT report empty output when committed text exists', () => {
|
|
expect(
|
|
shouldReportEmptyOutput({
|
|
mainTurnAdvanced: false,
|
|
assistantText: '好的，我们换个角度来讲。',
|
|
producedAck: false,
|
|
}),
|
|
).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe('PBL v2 — Instructor model message guard', () => {
|
|
it('adds a user anchor when history is empty', () => {
|
|
expect(ensureNonEmptyInstructorMessages([], '请介绍项目')).toEqual([
|
|
{ role: 'user', content: '请介绍项目' },
|
|
]);
|
|
});
|
|
|
|
it('keeps valid conversation history and trims blank content', () => {
|
|
expect(
|
|
ensureNonEmptyInstructorMessages(
|
|
[
|
|
{ role: 'user', content: ' 你好 ' },
|
|
{ role: 'assistant', content: ' 好的 ' },
|
|
{ role: 'user', content: ' ' },
|
|
],
|
|
'fallback',
|
|
),
|
|
).toEqual([
|
|
{ role: 'user', content: '你好' },
|
|
{ role: 'assistant', content: '好的' },
|
|
]);
|
|
});
|
|
|
|
it('keeps memory but still adds a user anchor when only system memory exists', () => {
|
|
expect(
|
|
ensureNonEmptyInstructorMessages(
|
|
[{ role: 'system', content: 'Earlier conversation memory' }],
|
|
'继续当前任务',
|
|
),
|
|
).toEqual([
|
|
{ role: 'system', content: 'Earlier conversation memory' },
|
|
{ role: 'user', content: '继续当前任务' },
|
|
]);
|
|
});
|
|
});
|
|
|
|
describe('PBL v2 — Instructor scenario awareness block (Increment 2)', () => {
|
|
// A coherent scenario project: fixed prep → scene → wrapup skeleton.
|
|
function scenarioProject(): PBLProjectV2 {
|
|
const p = makeProject();
|
|
p.scenario = {
|
|
setting: '校园咖啡馆的午后',
|
|
goal: '练习倾听与共情',
|
|
characters: [
|
|
{
|
|
id: 'char-1',
|
|
name: '林夏',
|
|
persona: '内向的同学，说话轻声细语',
|
|
situation: '这周失恋，情绪低落',
|
|
},
|
|
],
|
|
};
|
|
p.schemaVersion = 1;
|
|
p.milestones = [
|
|
milestone({
|
|
id: 'ms-prep',
|
|
title: '准备',
|
|
order: 0,
|
|
status: 'active',
|
|
scenarioStage: 'prep',
|
|
}),
|
|
milestone({ id: 'ms-scene', title: '和林夏聊一聊', order: 1, scenarioStage: 'roleplay' }),
|
|
milestone({ id: 'ms-wrap', title: '收尾', order: 2, scenarioStage: 'wrapup' }),
|
|
];
|
|
return p;
|
|
}
|
|
|
|
const prepOf = (p: PBLProjectV2) => p.milestones.find((m) => m.scenarioStage === 'prep')!;
|
|
const sceneOf = (p: PBLProjectV2) => p.milestones.find((m) => m.scenarioStage === 'roleplay')!;
|
|
const wrapOf = (p: PBLProjectV2) => p.milestones.find((m) => m.scenarioStage === 'wrapup')!;
|
|
|
|
it('returns empty string for an ordinary (non-scenario) project', () => {
|
|
expect(
|
|
buildScenarioAwarenessBlock({
|
|
project: makeProject(),
|
|
milestone: makeProject().milestones[0],
|
|
phase: 'greeting',
|
|
}),
|
|
).toBe('');
|
|
});
|
|
|
|
it('mentions setting, character (with situation), goal and scene stage', () => {
|
|
const p = scenarioProject();
|
|
const block = buildScenarioAwarenessBlock({
|
|
project: p,
|
|
milestone: prepOf(p),
|
|
phase: 'greeting',
|
|
});
|
|
expect(block).toContain('校园咖啡馆的午后');
|
|
expect(block).toContain('林夏');
|
|
expect(block).toContain('这周失恋，情绪低落');
|
|
expect(block).toContain('和林夏聊一聊');
|
|
expect(block).toContain('练习倾听与共情');
|
|
});
|
|
|
|
it('prep GREETING: specs the full structured opening briefing (8 parts + markdown + sidebar CTA, no impersonation)', () => {
|
|
const p = scenarioProject();
|
|
const block = buildScenarioAwarenessBlock({
|
|
project: p,
|
|
milestone: prepOf(p),
|
|
phase: 'greeting',
|
|
});
|
|
expect(block).toContain('write the OPENING briefing');
|
|
expect(block).toContain('LEFT sidebar');
|
|
// a couple of the mandatory parts
|
|
expect(block).toContain('warm greeting');
|
|
expect(block).toContain('self-introduction');
|
|
expect(block).toMatch(/not.*impersonate/i);
|
|
// Formatting stability fix: the briefing must explicitly OVERRIDE the global
|
|
// brevity / "don't format like a form" rules and make rich formatting a hard
|
|
// requirement, so the opener doesn't randomly collapse into a flat paragraph.
|
|
expect(block).toMatch(/EXCEPTION to the global brevity rules/i);
|
|
expect(block).toMatch(/Formatting is MANDATORY/i);
|
|
expect(block).toMatch(/section heading/i);
|
|
expect(block).toMatch(/bullet points/i);
|
|
expect(block).toMatch(/paragraph-only opening .* is WRONG/i);
|
|
// Prep gives the learner nothing to DO — no task / warm-up / quiz, and no
|
|
// question that expects an answer (only inviting THEM to ask the coach).
|
|
expect(block).toMatch(/Do NOT set any task, warm-up, mini-exercise, or quiz/i);
|
|
expect(block).toMatch(/End on part 8/i);
|
|
});
|
|
|
|
it('prep GREETING with scenario.rules: REQUIRES a rules section that teaches the rules', () => {
|
|
const p = scenarioProject();
|
|
p.scenario!.rules = '6 人局；翻前/翻后下注；牌型大小；Pot Odds 的含义';
|
|
const block = buildScenarioAwarenessBlock({
|
|
project: p,
|
|
milestone: prepOf(p),
|
|
phase: 'greeting',
|
|
});
|
|
expect(block).toMatch(/Rules — REQUIRED/i);
|
|
expect(block).toMatch(/bullet points/i);
|
|
// does NOT carry the "no special rule-set" escape hatch
|
|
expect(block).not.toMatch(/no special rule-set/i);
|
|
});
|
|
|
|
it('prep GREETING without scenario.rules: forbids inventing rules (e.g. comfort-a-friend)', () => {
|
|
const p = scenarioProject();
|
|
expect(p.scenario!.rules).toBeUndefined();
|
|
const block = buildScenarioAwarenessBlock({
|
|
project: p,
|
|
milestone: prepOf(p),
|
|
phase: 'greeting',
|
|
});
|
|
expect(block).toMatch(/no special rule-set/i);
|
|
expect(block).not.toMatch(/Rules — REQUIRED/i);
|
|
});
|
|
|
|
it('prep INSTRUCTING (follow-up): answer only, cannot advance, no impersonation', () => {
|
|
const p = scenarioProject();
|
|
const block = buildScenarioAwarenessBlock({
|
|
project: p,
|
|
milestone: prepOf(p),
|
|
phase: 'instructing',
|
|
});
|
|
expect(block).toContain('answering a follow-up');
|
|
expect(block).toMatch(/cannot.*advance/i);
|
|
expect(block).toMatch(/not.*impersonate/i);
|
|
});
|
|
|
|
it('wrapup stage: grounds the debrief in the real transcript; auto-closing, no confirm, no questions', () => {
|
|
const p = scenarioProject();
|
|
const block = buildScenarioAwarenessBlock({
|
|
project: p,
|
|
milestone: wrapOf(p),
|
|
phase: 'instructing',
|
|
});
|
|
expect(block).toContain('WRAPUP stage');
|
|
expect(block).toMatch(/light/i);
|
|
// Grounded in what actually happened (the role-play transcript), not invented.
|
|
expect(block).toMatch(/What actually happened in the scene/i);
|
|
expect(block).toMatch(/never invent/i);
|
|
// The session auto-completes — the instructor must not ask the learner to
|
|
// confirm / reply / click, and must not ask ANY question.
|
|
expect(block).toMatch(/session ENDS automatically/i);
|
|
expect(block).toMatch(/Do NOT ask the learner ANY question/i);
|
|
expect(block).toMatch(/Do NOT request a reply, confirmation/i);
|
|
// Explicit override of the reused teaching rules (so "ask a question / hand
|
|
// off the next action" cannot leak into a terminal summary).
|
|
expect(block).toMatch(/EXCEPTION to the teaching rules/i);
|
|
expect(block).toMatch(/NO next task/i);
|
|
});
|
|
|
|
it('scene stage: tells the instructor the scene is handed off + do not impersonate', () => {
|
|
const p = scenarioProject();
|
|
const block = buildScenarioAwarenessBlock({
|
|
project: p,
|
|
milestone: sceneOf(p),
|
|
phase: 'instructing',
|
|
});
|
|
expect(block).toContain('handed off');
|
|
expect(block).toMatch(/not.*impersonate/i);
|
|
});
|
|
|
|
it('degrades to empty when scenario has a cast but no scene stage', () => {
|
|
const p = scenarioProject();
|
|
p.milestones = p.milestones.map((m) => ({ ...m, scenarioStage: undefined }));
|
|
expect(
|
|
buildScenarioAwarenessBlock({ project: p, milestone: p.milestones[0], phase: 'greeting' }),
|
|
).toBe('');
|
|
});
|
|
|
|
it('degrades to empty when scenario has no characters', () => {
|
|
const p = scenarioProject();
|
|
p.scenario!.characters = [];
|
|
expect(
|
|
buildScenarioAwarenessBlock({ project: p, milestone: p.milestones[0], phase: 'greeting' }),
|
|
).toBe('');
|
|
});
|
|
});
|