import { expect, test } from "bun:test"; import { inputFor } from "./policy-initial.test-fixtures"; import { runRemainingTerminals } from "./policy-remaining-terminals"; import { capEvents, d01RecordedOpening, declarativeInput, editorInput, prepareRemaining, remainingPrefix, stateWithOption, terminalPolicy, } from "./policy-terminal.test-fixtures"; import { MAX_EVENTS, MAX_THREADS } from "./validation"; let question = "Should audit logs go in PostgreSQL or object storage?"; test.each(["member", "agent"] as const)( "direct alternatives retain exact options and working state for %s", kind => { let input = inputFor(question); if (kind === "agent") input.message.author = { kind: "agent" }; let before = structuredClone(input); let context = prepareRemaining(input); let result = runRemainingTerminals(context)!; expect(result.policyGate).toBe("direct alternatives accepted"); expect(result.events.map(event => event.type)).toEqual([ "thread.opened", "option.added", "option.added", ]); expect(result.events.map(event => event.origin)).toEqual( Array(3).fill(kind === "agent" ? "planner" : "classifier"), ); expect(result.outcomes.map(outcome => outcome.eventIds.length)).toEqual([2, 1]); expect(context.working.events).toEqual(result.events); expect(context.directQuestion).toBe(true); expect(input).toEqual(before); expect(terminalPolicy(input)).toEqual(result); }, ); test("direct opening rejection preserves the original working reference", () => { let input = inputFor(question); let seed = stateWithOption("Unrelated question?", "seed", "seed-option", "Seed option."); input.state.threads = Array.from( { length: MAX_THREADS }, (_, index) => ({ ...seed.threads[0]!, id: `seed-${index}` }), ); let context = prepareRemaining(input); expect(runRemainingTerminals(context)?.policyGate).toBe("direct question rejected"); expect(context.working).toBe(input.state); }); test("direct option rejection retains successful opening and earlier addition in working", () => { let input = inputFor(question); capEvents(input, MAX_EVENTS - 2); let before = structuredClone(input); let context = prepareRemaining(input); let result = runRemainingTerminals(context)!; expect(result.policyGate).toBe("direct option rejected"); expect(result.events).toEqual([]); expect(result.outcomes.map(outcome => outcome.status)).toEqual(["review", "review"]); expect(context.working.events).toHaveLength(MAX_EVENTS); expect(context.working.threads[0]?.contributions).toHaveLength(1); expect(context.working).not.toBe(input.state); expect(input).toEqual(before); }); test("quoted-option errors propagate while direct working retains earlier successes", () => { let input = inputFor(question); let context = prepareRemaining(input); let original = context.quotedOption!; context.quotedOption = (...args) => { if (args[1] === 1) throw new Error("quoted option failure"); return original(...args); }; expect(() => runRemainingTerminals(context)).toThrow("quoted option failure"); expect(context.working.events.map(event => event.type)).toEqual([ "thread.opened", "option.added", ]); expect(input.state.events).toEqual([]); }); test.each(["declarative", "editor"] as const)( "%s batch rejection leaves staged state local", kind => { let input = kind === "declarative" ? declarativeInput() : editorInput(); capEvents(input, MAX_EVENTS - 1); let before = structuredClone(input); let context = prepareRemaining(input); let result = runRemainingTerminals(context)!; expect(result.policyGate).toBe( kind === "declarative" ? "declarative options rejected" : "bare editor list rejected", ); expect(result.events).toEqual([]); expect(context.working).toBe(input.state); expect(input).toEqual(before); }, ); test.each(["declarative", "editor"] as const)( "%s quoted-option errors stay outside inference catches", kind => { let input = kind === "declarative" ? declarativeInput() : editorInput(); let context = prepareRemaining(input); let original = context.quotedOption!; context.quotedOption = (...args) => { if (args[1] === 1) throw new Error("quoted option failure"); return original(...args); }; expect(() => runRemainingTerminals(context)).toThrow("quoted option failure"); expect(context.working).toBe(input.state); }, ); test.each(["strong", "weak", "missing"] as const)("editor joint clarification is %s", strength => { let input = editorInput(); for (let candidate of input.candidates) { candidate.answers.role = { type: "choice", choice: "option", confidence: 0.65, probabilities: { option: 0.65, none: 0.35 }, }; candidate.answers.option = { type: "choice", choice: "new", confidence: 0.75, probabilities: { new: 0.75, none: 0.25 }, }; candidate.answers.new_option = { type: "noul", noul: 0.75 }; } if (strength !== "missing") { input.clarification = { list_kind: { type: "choice", choice: "four_distinct_options", confidence: 0.95, probabilities: { four_distinct_options: strength === "strong" ? 0.95 : 0.7, other: strength === "strong" ? 0.05 : 0.3, unclear: 0, }, }, ...Object.fromEntries( Array.from( { length: 4 }, (_, index) => [`c${index}_distinct_option`, { type: "noul", noul: 0.95 }], ), ), }; } let result = terminalPolicy(input); expect(result.policyGate).toBe( strength === "strong" ? "bare editor list accepted" : "bare editor list needs review", ); expect(result.events).toHaveLength(strength === "strong" ? 4 : 0); }); test("purpose acceptance validates without replacing context working", () => { let input = d01RecordedOpening(); let context = prepareRemaining(input); expect(runRemainingTerminals(context)?.policyGate).toBe( "owned purpose and final question accepted", ); expect(context.working).toBe(input.state); expect(input.state.threads).toEqual([]); }); test("purpose opening rejection continues without assigning working", () => { let input = d01RecordedOpening(); capEvents(input, MAX_EVENTS); let context = prepareRemaining(input); expect(runRemainingTerminals(context)).toBeUndefined(); expect(context.working).toBe(input.state); expect(context.directQuestion).toBe(false); expect(remainingPrefix(input)).toBeUndefined(); }); test("directQuestion survives continuation when bounds fail and later inputs change", () => { let input = inputFor("Should audit logs go in PostgreSQL or PostgreSQL?"); let context = prepareRemaining(input); expect(context.facts?.exactDirectAlternatives).toBe(true); expect(context.facts?.directBounds).toBe(false); expect(runRemainingTerminals(context)).toBeUndefined(); expect(context.directQuestion).toBe(true); context.working = stateWithOption("Other question?", "other", "other-option", "Other option."); context.first.new_question = { type: "noul", noul: 0 }; context.facts!.exactDirectAlternatives = false; expect(context.directQuestion).toBe(true); expect(remainingPrefix(input)).toBeUndefined(); }); test("remaining stages and cached options use the initially captured message", () => { let input = inputFor(question); let original = input.message; let context = prepareRemaining(input); input.message = { ...input.message, id: "changed-message", text: "Changed after initialization.", }; let result = runRemainingTerminals(context)!; expect(result.policyGate).toBe("direct alternatives accepted"); expect(result.events.map(event => "source" in event ? event.source?.messageId : undefined)) .toEqual(Array(3).fill(original.id)); expect(result.events[0]).toMatchObject({ question: original.text }); });