pi-roundtable 0.19.2 → 0.21.0

package/src/core/testing/surface-contract.ts

@@ -3,8 +3,13 @@ import type { ChatSurface } from "../contract/surface.ts";
 import { parseChannelKey } from "../contract/surface.ts";
 import type { TurnProgress } from "../domain/progress.ts";
 import type { Approval } from "../interactions/prompts.ts";
+import type {
+	Questionnaire,
+	QuestionnaireAnswer,
+} from "../interactions/questionnaire.ts";
 import type { ChannelKey } from "../sessions.ts";
 import type { Speaker } from "../speakers.ts";
+import { QUESTIONNAIRE_CHECKS } from "./surface-contract-questionnaire.ts";
 import {
 	answeredOnlyByThem,
 	approval,
@@ -13,6 +18,7 @@ import {
 	namedApproverAnswers,
 	nextPrompt,
 	type Running,
+	runCheck,
 	scopeOf,
 	seen,
 	speakerOf,
@@ -44,6 +50,12 @@ export interface SurfaceContractSubject {
 	observations(): readonly SurfaceObservation[];
 	/** The person answers an open approval; without it the prompt checks are skipped. */
 	answer?(prompt: string, approved: boolean): Promise<void>;
+	/** The person answers an open questionnaire, as shaped for `asks`; without it those checks are skipped. */
+	answerQuestionnaire?(
+		prompt: string,
+		answer: QuestionnaireAnswer,
+		questionnaire: Questionnaire,
+	): Promise<void>;
 	/**
 	 * The person as the speaker of the turns that ask them, given to `surface.prompts` as the
 	 * scope `promptScope(speaker, visibility)`; default an owner-tier speaker. Every approval the
@@ -71,6 +83,12 @@ export interface SurfaceContractSubject {
 	 * named-approver checks are skipped.
 	 */
 	approver?: SurfaceContractAnswerer & { principalId: string };
+	/**
+	 * Set by a surface that honours `ApprovalOptions.speakerOnly` in a shared conversation, where
+	 * `owner` is on the network and could otherwise answer: the owner's answer to such an approval
+	 * settles nothing, the person's does. Without it, or without `owner`, the check is skipped.
+	 */
+	speakerOnly?: boolean;
 	/**
 	 * Set by a surface that serves only conversations private to one person, such as the web chat:
 	 * it has no shared conversation in which an approval is the named approvers', so it skips that
@@ -85,6 +103,12 @@ export interface SurfaceContractAnswerer {
 	/** They join the surface, once it has started. */
 	join?(): Promise<void>;
 	answer(prompt: string, approved: boolean): Promise<void>;
+	/** They answer an open questionnaire; without it its stranger check is skipped. */
+	answerQuestionnaire?(
+		prompt: string,
+		answer: QuestionnaireAnswer,
+		questionnaire: Questionnaire,
+	): Promise<void>;
 }
 
 /** One way the subject broke the contract. */
@@ -351,6 +375,23 @@ const CHECKS: readonly Check[] = [
 		run: (running) =>
 			answeredOnlyByThem(running, running.subject.owner, "private"),
 	},
+	{
+		name: "an approval that is the speaker's alone is not answered by an owner in a shared conversation",
+		applies: (subject) =>
+			subject.surface.prompts !== undefined &&
+			subject.answer !== undefined &&
+			subject.owner !== undefined &&
+			subject.speakerOnly === true &&
+			subject.privateOnly !== true,
+		run: (running) =>
+			answeredOnlyByThem(
+				running,
+				running.subject.owner,
+				"shared",
+				undefined,
+				true,
+			),
+	},
 	{
 		name: "a named approver answers an approval instead of the person; the person and another person cannot",
 		applies: (subject) =>
@@ -401,26 +442,9 @@ const CHECKS: readonly Check[] = [
 			);
 		},
 	},
+	...QUESTIONNAIRE_CHECKS,
 ];
 
-async function runCheck(
-	check: Check,
-	make: () => Promise<SurfaceContractSubject>,
-): Promise<"passed" | "skipped"> {
-	const subject = await make();
-	const running: Running = { subject, delivered: [] };
-	try {
-		if (check.applies && !check.applies(subject)) return "skipped";
-		await subject.surface.start((message) => running.delivered.push(message));
-		await subject.join?.();
-		await check.run(running);
-		return "passed";
-	} finally {
-		await subject.close?.();
-		await subject.surface.stop?.();
-	}
-}
-
 /**
  * Runs the chat surface contract on fresh subjects from `make`, one per check, and returns the
  * checks the surface broke. `describeSurfaceContract` registers the same checks as tests.
@@ -447,9 +471,11 @@ export async function checkSurfaceContract(
  * one its plugin withdraws (`ApprovalOptions.supersede`) as cancelled, ignores
  * another person's answer to the person's approval, and, in a private conversation, an owner's
  * too, and lets an approval above the person's tier there come back at once, shown to no one.
- * Where it can name approvers, an approval that does is answered by them, reported as the
+ * Where `speakerOnly` is declared, an approval that is the speaker's alone is not settled by an
+ * owner's answer in a shared conversation. Where it can name approvers, an approval that does is answered by them, reported as the
  * approver, and not by the person or another person, and a private conversation's is answered by
- * its person alone, whoever the call names besides them. Each
+ * its person alone, whoever the call names besides them. A subject that gives
+ * `answerQuestionnaire` must declare `asks`, and then questionnaires keep the same rules. Each
  * check gets a fresh subject from `make`; a check for an optional part the surface lacks passes.
  */
 export function describeSurfaceContract(

package/src/index.ts

@@ -195,6 +195,7 @@ export type {
 	ApprovalOptions,
 	ApprovedBy,
 	AskOption,
+	AskSupport,
 	LateAnswer,
 	OwnerAnswer,
 	OwnerPrompts,
@@ -202,8 +203,18 @@ export type {
 	PromptScope,
 	Prompts,
 	PromptWait,
+	Questionnaire,
+	QuestionnaireAnswer,
 } from "./core/interactions/prompts.ts";
 export { promptScope, withdrawalNote } from "./core/interactions/prompts.ts";
+export {
+	checkAnswer,
+	checkQuestionnaireAnswer,
+	QUESTIONNAIRE_LIMITS,
+	SINGLE_QUESTION,
+	shapeFor,
+	validateQuestionnaire,
+} from "./core/interactions/questionnaire.ts";
 export type { JudgeModel } from "./core/judging/model-judge.ts";
 export type { LogEntry, LogFn, Logger } from "./core/log.ts";
 export type { ThinkingLevel, ThinkingSetting } from "./core/models.ts";