Files
gstack/test/design-completion-handoff.test.ts
T

151 lines
8.2 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import { describe, expect, test } from 'bun:test';
import * as fs from 'node:fs';
import * as os from 'node:os';
import * as path from 'node:path';
import { capturePlanCountQuestion, designStep0Boundary, hasNativePlanTerminal, nativePlanCallFingerprint, planCountQuestionPhase } from './helpers/claude-pty-runner';
import { isDesignCountFirstReview, isDesignCompletionHandoff, pickDesignCountQuestion } from './helpers/design-count-review';
import type { NativePlanQuestionCall } from './helpers/plan-count-transcript';
import captured from './fixtures/design-handoff-l-calls.json';
const calls = () => structuredClone(captured.calls) as NativePlanQuestionCall[];
const handoff = () => calls().at(-1)!;
const fingerprint = (call: NativePlanQuestionCall) => nativePlanCallFingerprint(call, 0, false);
function makePending(call: NativePlanQuestionCall) {
call.answered = false;
delete call.answers;
delete call.unansweredQuestionIndices;
return call;
}
function activeQuestion(call: NativePlanQuestionCall) {
const q = call.questions[0]!;
const visible = `☐ ${q.header}\n${q.question}\n` + q.options.map((option, i) =>
`${i ? ' ' : '❯'} ${i + 1}. ${option.label}`).join('\n') +
'\nEnter to select · ↑/↓ to navigate · Esc to cancel';
return capturePlanCountQuestion(visible, new Set(), 0, false, call)!;
}
describe('Design completed handoff without an offered manual action', () => {
test('the captured call is administrative, but its missing manual option is never invented', () => {
const call = handoff();
expect(isDesignCompletionHandoff(fingerprint(call))).toBe(true);
expect(pickDesignCountQuestion(fingerprint(call), fingerprint(call))).toBeNull();
makePending(call);
expect(isDesignCompletionHandoff(fingerprint(call))).toBe(false);
expect(pickDesignCountQuestion(fingerprint(call), activeQuestion(call))).toBeNull();
});
test('the full captured sequence retains all ten decisions and still exceeds the seven-call ceiling', () => {
const input = calls();
const original = structuredClone(input);
let started = false;
const counts = { setup: 0, review: 0, administrative: 0 };
for (const call of input) {
const phase = planCountQuestionPhase(fingerprint(call), started, designStep0Boundary,
isDesignCountFirstReview, undefined, isDesignCompletionHandoff);
started = phase.reviewStarted;
if (phase.administrative) counts.administrative++;
else if (phase.preReview) counts.setup++;
else counts.review++;
}
expect(counts).toEqual({ setup: 1, review: 10, administrative: 1 });
expect(counts.review).toBeGreaterThan(7);
expect(input).toEqual(original);
});
test('an explicit absence of outstanding work remains a closed recap', () => {
for (const recap of ['No unresolved design decisions.', 'Zero remaining contrast gaps.', 'No gap remains.']) {
const call = handoff();
const q = call.questions[0]!;
q.question = `Design review complete. ${recap} What’s next? <gstack-qid:plan-design-next-steps>`;
call.answers = { [q.question]: q.options[0]!.label };
expect(isDesignCompletionHandoff(fingerprint(call))).toBe(true);
}
});
test('an actual manual option is selected in either order only with active native identity', () => {
for (const reverse of [false, true]) {
const call = makePending(handoff());
call.questions[0]!.options.push({ label: "E) Skip — I'll handle next steps manually" });
if (reverse) call.questions[0]!.options.reverse();
expect(pickDesignCountQuestion(fingerprint(call), activeQuestion(call))).toBe(reverse ? 1 : 4);
expect(pickDesignCountQuestion(fingerprint(call), { ...fingerprint(call), signature: 'other' })).toBeNull();
}
});
test('remaining work, mixed actions and unknown identities stay substantive', () => {
const mutations: Array<(c: NativePlanQuestionCall) => void> = [
c => { c.questions[0]!.question = c.questions[0]!.question.replace('complete (', 'complete only after resolving contrast ('); },
c => { c.questions[0]!.question = c.questions[0]!.question.replace('review complete', 'review is not complete'); },
c => { c.questions[0]!.question = c.questions[0]!.question.replace('7 decisions made', 'one unresolved gap'); },
c => { c.questions[0]!.question = c.questions[0]!.question.replace('plan-design-next-steps', 'plan-design-contrast-finding'); },
c => { c.questions[0]!.question += ' <gstack-qid:plan-design-next-steps>'; },
c => { c.questions[0]!.question = 'Design review complete. One contrast gap remains unresolved. What’s next? <gstack-qid:plan-design-next-steps>'; },
c => { c.questions[0]!.question = 'Design review complete. One contrast gap remains. What’s next? <gstack-qid:plan-design-next-steps>'; },
c => { c.questions[0]!.question = 'Design review complete. There is an unresolved contrast gap. What’s next? <gstack-qid:plan-design-next-steps>'; },
c => { c.questions[0]!.question = c.questions[0]!.question.replace('What', '<gstack-qid malformed What'); },
c => { c.questions[0]!.header = 'Contrast gap'; },
c => { c.questions[0]!.options.push({ label: 'Add the missing contrast test' }); },
c => { c.questions[0]!.options[0]!.label = 'Run /plan-eng-review and fix contrast'; },
c => { c.questions.push(calls()[1]!.questions[0]!); },
c => { c.questions[0]!.multiSelect = true; },
];
for (const mutate of mutations) {
const call = handoff();
mutate(call);
call.answers = Object.fromEntries(call.questions.map(q => [q.question, q.options[0]!.label]));
expect(isDesignCompletionHandoff(fingerprint(call))).toBe(false);
const phase = planCountQuestionPhase(fingerprint(call), true, designStep0Boundary,
isDesignCountFirstReview, undefined, isDesignCompletionHandoff);
expect(phase.administrative).toBeUndefined();
expect(phase.preReview).toBe(false);
const pending = fingerprint(makePending(call));
expect(pickDesignCountQuestion(pending, pending)).toBeNull();
}
});
test('failed, partial, unanswered and free-form results cannot exclude a call', () => {
const mutations: Array<(c: NativePlanQuestionCall) => void> = [
c => { c.failed = true; },
c => { c.answered = false; },
c => { c.unansweredQuestionIndices = [0]; },
c => { c.answers = {}; },
c => { c.answers = { [c.questions[0]!.question]: 'First build a new interaction' }; },
];
for (const mutate of mutations) {
const call = handoff();
mutate(call);
expect(isDesignCompletionHandoff(fingerprint(call))).toBe(false);
}
});
test('the actual late handoff does not stale a valid report, while later real work and failed exits still do', () => {
const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'design-handoff-report-'));
const file = path.join(dir, 'plan.md');
try {
fs.writeFileSync(file, '# Reviewed plan\n\n## GSTACK REVIEW REPORT\n\n' +
'| Review | Status | Findings |\n|---|---|---|\n| Design | complete | resolved |\n\n' +
'VERDICT: DESIGN CLEARED — eng review required\n\nNO UNRESOLVED DECISIONS\n');
const input = calls();
const transcript = { status: 'ready' as const, calls: input, assistantMessages: [],
planReadyRequests: structuredClone(captured.planReadyRequests) };
const administrative = new Set(input.filter(c => isDesignCompletionHandoff(fingerprint(c)))
.map(c => fingerprint(c).signature));
const written = Date.parse('2026-09-08T23:19:12.049Z') / 1000;
fs.utimesSync(file, written, written);
const started = Date.parse('2026-09-08T23:09:43.875Z');
expect(hasNativePlanTerminal(transcript, file, started, 'plan_ready')).toBe(false);
expect(hasNativePlanTerminal(transcript, file, started, 'plan_ready', administrative)).toBe(true);
const stale = Date.parse(input[10]!.answeredAt!) / 1000 - 1;
fs.utimesSync(file, stale, stale);
expect(hasNativePlanTerminal(transcript, file, started, 'plan_ready', administrative)).toBe(false);
fs.utimesSync(file, written, written);
transcript.planReadyRequests[0]!.failed = true;
expect(hasNativePlanTerminal(transcript, file, started, 'plan_ready', administrative)).toBe(false);
} finally {
fs.rmSync(dir, { recursive: true, force: true });
}
});
});