gentle-pi 3.3.0 → 3.5.0

package/tests/native-review-capability-contract.test.ts

@@ -319,11 +319,26 @@ test("3.4.0 repeats 3.2.1 because the negotiated lane Pi consumes is unchanged",
 	assert.deepEqual(contract, NATIVE_CLI_CONTRACTS["3.2.1"] as Record<string, boolean>);
 });
 
+test("3.5.0 repeats 3.4.0 because the negotiated lane Pi consumes is unchanged", () => {
+	// Published v3.4.0 and v3.5.0 provider bundles are byte-identical at
+	// contract 1.2.0, both with archive SHA-256:
+	// 547b68e172cc87aa297309d61624e5fc2c24d407a494b53eeb5a2b053904352c.
+	// Both binaries advertise capabilities/v2.6; only build-identity fields
+	// differ. No review-integration schema changed between the tags. The v2
+	// preflight failure identity fix changes no closed START/STATUS field
+	// this row negotiates, so it repeats 3.4.0. riskEvidence and hint remain
+	// dark because neither is proven to reach Pi's negotiated START path.
+	const contract = NATIVE_CLI_CONTRACTS["3.5.0"] as Record<string, boolean>;
+	assert.equal(contract.riskEvidence, false);
+	assert.equal(contract.hint, false);
+	assert.deepEqual(contract, NATIVE_CLI_CONTRACTS["3.4.0"] as Record<string, boolean>);
+});
+
 test("no shipped version key was added beyond the pin bump", () => {
 	// Rows are promises to consumers, so a new key only ever appears in a
 	// dedicated commit alongside a pin bump, never as a side effect. v2.2.4 and
 	// v2.3.0 shipped upstream while Pi stayed on 2.2.3 and were never pinned,
 	// so they get no row: a row asserts ground truth measured against a binary
 	// Pi actually ran, and the table only has to be ascending, not gapless.
-	assert.deepEqual(Object.keys(NATIVE_CLI_CONTRACTS), [...DARK_VERSIONS, "2.2.0", "2.2.1", "2.2.2", "2.2.3", "2.4.0", "2.5.0-rc.3", "2.5.0", "2.6.0", "2.7.0", "2.8.0", "2.8.1", "2.8.2", "2.9.0", "2.9.1", "3.0.0", "3.0.1", "3.1.0", "3.2.1", "3.4.0"]);
+	assert.deepEqual(Object.keys(NATIVE_CLI_CONTRACTS), [...DARK_VERSIONS, "2.2.0", "2.2.1", "2.2.2", "2.2.3", "2.4.0", "2.5.0-rc.3", "2.5.0", "2.6.0", "2.7.0", "2.8.0", "2.8.1", "2.8.2", "2.9.0", "2.9.1", "3.0.0", "3.0.1", "3.1.0", "3.2.1", "3.4.0", "3.5.0"]);
 });

package/tests/native-review-parity.test.ts

@@ -344,6 +344,25 @@ function assertStaleConsentBinding(outcome: Record<string, unknown>, binding: un
 	assert.equal(outcome.next_action, "restart-for-fresh-consent");
 }
 
+test("synthetic default-ON status reaches review consent without changing RDD mode", async (t) => {
+	const cwd = repository(t);
+	const fixture = consentNative(cwd);
+	const operations: string[] = [];
+	fixture.native.reviewMode = async ({ operation }) => {
+		operations.push(operation);
+		return {
+			operation: "status",
+			scope: "clone",
+			status: { global: "", cloneLocal: "", effective: "on", source: "default" },
+		};
+	};
+	await beginConsent(parityRuntime(fixture.native), cwd);
+	assert.equal(fixture.starts.count, 1, "default ON must not skip native review START");
+	assert.ok(operations.length > 0);
+	assert.ok(operations.every((operation) => operation === "status"), "automation must only read RDD mode");
+	assert.deepEqual(fixture.answers, [], "default ON does not grant candidate consent");
+});
+
 test("review-mode gate retains every off-source continuation and fails closed on native errors", async () => {
 	for (const [source, expected] of [
 		["clone_local", /clear this clone-local override/],

package/tests/package-manifest.test.ts

@@ -142,7 +142,6 @@ test("package verification names the native review runtime boundary and packaged
 
 test("npm publication is bound to the exact package tag and triggering commit", () => {
 	const workflow = readFileSync(join(PACKAGE_ROOT, ".github", "workflows", "publish.yml"), "utf8");
-	const releaseSkill = readFileSync(join(PACKAGE_ROOT, "skills", "release", "SKILL.md"), "utf8");
 	const packageJson = readPackageJson();
 	const dispatchBlock = workflow.match(
 		/^ {2}workflow_dispatch:\n([\s\S]*?)^\npermissions:/m,
@@ -189,16 +188,6 @@ test("npm publication is bound to the exact package tag and triggering commit",
 	);
 	assert.match(workflow, /npm publish --provenance --access public/);
 	assert.doesNotMatch(workflow, /pnpm publish|--no-git-checks|NODE_AUTH_TOKEN/);
-
-	assert.match(releaseSkill, /tag="v\$\{version\}"/);
-	assert.match(releaseSkill, /release_sha="\$\(git rev-parse 'origin\/main\^\{commit\}'\)"/);
-	assert.match(releaseSkill, /git rev-parse "\$\{tag\}\^\{commit\}"/);
-	assert.match(releaseSkill, /git fetch --no-tags origin "refs\/tags\/\$\{tag\}"/);
-	assert.match(releaseSkill, /gh release create "\$\{tag\}"[\s\S]*--verify-tag/);
-	assert.match(releaseSkill, /--ref main/);
-	assert.match(releaseSkill, /-f tag="\$\{tag\}"/);
-	assert.match(releaseSkill, /trusted OIDC with provenance/);
-	assert.doesNotMatch(releaseSkill, /--ref "\$\{tag\}"|-f dist-tag=/);
 });
 
 test("Pi delivery relay is absent from the packaged extension", () => {
@@ -309,20 +298,20 @@ test("package manifest installs pi-pretty through a wrapper without bundling nat
 	);
 });
 
-test("package verification binds the published Gentle AI v3.4.0 runtime pin", () => {
+test("package verification binds the published Gentle AI v3.5.0 runtime pin", () => {
 	const installer = readFileSync(join(PACKAGE_ROOT, "scripts", "gentle-ai-installer.mjs"), "utf8");
 	const binary = readFileSync(join(PACKAGE_ROOT, "lib", "gentle-ai-binary.ts"), "utf8");
 	const verifier = readFileSync(join(PACKAGE_ROOT, "scripts", "verify-package-files.mjs"), "utf8");
 
-	assert.match(installer, /INSTALLER_VERSION = "3\.4\.0"/);
+	assert.match(installer, /INSTALLER_VERSION = "3\.5\.0"/);
 	assert.match(installer, /GENTLE_AI_WINDOWS_SOURCE_PACKAGE.*GENTLE_AI_WINDOWS_SOURCE_MODULE/);
-	assert.match(installer, /GENTLE_AI_WINDOWS_SOURCE_MODULE_CHECKSUM = "h1:bQOM\+Xa3WN5\+idTagEk15rgEEQQWVhZvq8BPF\/FHtSs="/);
+	assert.match(installer, /GENTLE_AI_WINDOWS_SOURCE_MODULE_CHECKSUM = "h1:3y\+Nb7CtgGB3ne3bSNxkzV6j19etkOnGDXIiuv7tMp8="/);
 	assert.match(installer, /GOTOOLCHAIN: "local"/);
 	assert.match(installer, /GOSUMDB: "sum\.golang\.org"/);
 	assert.match(binary, /GENTLE_AI_VERSION = INSTALLER_VERSION/);
 	assert.match(binary, /GO_SUMDB_SOURCE_BUILD/);
 	assert.match(binary, /GENTLE_AI_WINDOWS_SOURCE_MODULE_CHECKSUM/);
-	assert.match(verifier, /v3\.4\.0/);
+	assert.match(verifier, /v3\.5\.0/);
 });
 
 
@@ -1574,9 +1563,9 @@ test("pi-pretty wrapper uses cached ESM loading for compiled and pnpm symlink in
 	assert.match(wrapper, /quietToolsEnabled/);
 });
 
-test("Gentle Shell v3.3.0 package and runtime stop before publication", () => {
+test("Gentle Shell v3.5.0 package and runtime stop before publication", () => {
 	const packageJson = readPackageJson();
-	assert.equal(packageJson.version, "3.3.0", "the release manifest must remain explicitly pinned to v3.3.0");
+	assert.equal(packageJson.version, "3.5.0", "the release manifest must remain explicitly pinned to v3.5.0");
 	assert.equal(
 		packageJson.scripts?.test,
 		"node --experimental-strip-types --test tests/*.test.ts && pnpm run check:provider-contract && pnpm run test:harness",

package/tests/questionnaire-schema.test.ts

@@ -0,0 +1,274 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { Value } from "typebox/value";
+import {
+	CUSTOM_ROW_LABEL,
+	MAX_HEADER_LENGTH,
+	MAX_LABEL_LENGTH,
+	MAX_OPTIONS,
+	MAX_QUESTIONS,
+	MIN_OPTIONS,
+	QuestionParamsSchema,
+	type OptionData,
+	type QuestionParams,
+} from "../lib/questionnaire/schema.ts";
+import { validateQuestionnaire, type QuestionnaireError } from "../lib/questionnaire/validate.ts";
+
+const H = "Header";
+const option = (label: string, preview?: string): OptionData =>
+	preview === undefined ? { label, description: `${label} description` } : { label, description: `${label} description`, preview };
+
+const question = (
+	text: string,
+	options: OptionData[],
+	overrides: { header?: string; multiSelect?: boolean } = {},
+) => ({
+	question: text,
+	header: overrides.header ?? H,
+	options,
+	...(overrides.multiSelect === undefined ? {} : { multiSelect: overrides.multiSelect }),
+});
+
+const params = (questions: ReturnType<typeof question>[]): QuestionParams => ({ questions });
+const valid = (): ReturnType<typeof question>[] => [question("First?", [option("Alpha"), option("Beta")])];
+
+interface Case {
+	name: string;
+	input: ReturnType<typeof params>;
+	expected: QuestionnaireError | undefined;
+}
+
+function makeCases(): Case[] {
+	return [
+		{ name: "accepts a minimal valid questionnaire", input: params(valid()), expected: undefined },
+		{
+			name: "accepts exactly one question with two options",
+			input: params([question("Solo?", [option("A"), option("B")])]),
+			expected: undefined,
+		},
+		{
+			name: "accepts exactly four questions and four options",
+			input: params([
+				question("Q1", [option("A1"), option("B1"), option("C1"), option("D1")]),
+				question("Q2", [option("A2"), option("B2")]),
+				question("Q3", [option("A3"), option("B3")]),
+				question("Q4", [option("A4"), option("B4")]),
+			]),
+			expected: undefined,
+		},
+		{
+			name: "accepts a header at the 16 character limit",
+			input: params([question("Long header?", [option("A"), option("B")], { header: "x".repeat(MAX_HEADER_LENGTH) })]),
+			expected: undefined,
+		},
+		{
+			name: "accepts a label at the 60 character limit",
+			input: params([question("Long label?", [option("y".repeat(MAX_LABEL_LENGTH)), option("B")])]),
+			expected: undefined,
+		},
+		{
+			name: "rejects an empty question list",
+			input: params([]),
+			expected: { code: "no_questions", message: "At least one question is required." },
+		},
+		{
+			name: "rejects a question with empty options",
+			input: params([question("Empty?", [])]),
+			expected: {
+				code: "empty_options",
+				message: "Question 1 must declare at least one option.",
+				questionIndex: 0,
+			},
+		},
+		{
+			name: "rejects a single option below the minimum",
+			input: params([question("One?", [option("Only")])]),
+			expected: {
+				code: "option_count",
+				message: "Question 1 must have between 2 and 4 options, received 1.",
+				questionIndex: 0,
+				count: 1,
+			},
+		},
+		{
+			name: "rejects five options above the maximum",
+			input: params([question("Five?", [option("A"), option("B"), option("C"), option("D"), option("E")])]),
+			expected: {
+				code: "option_count",
+				message: "Question 1 must have between 2 and 4 options, received 5.",
+				questionIndex: 0,
+				count: 5,
+			},
+		},
+		{
+			name: "rejects more than four questions",
+			input: params([
+				question("Q1", [option("A1"), option("B1")]),
+				question("Q2", [option("A2"), option("B2")]),
+				question("Q3", [option("A3"), option("B3")]),
+				question("Q4", [option("A4"), option("B4")]),
+				question("Q5", [option("A5"), option("B5")]),
+			]),
+			expected: {
+				code: "too_many_questions",
+				message: "A questionnaire accepts at most 4 questions, received 5.",
+				count: 5,
+			},
+		},
+		{
+			name: "rejects duplicate question text",
+			input: params([
+				question("Same?", [option("A1"), option("B1")]),
+				question("Same?", [option("A2"), option("B2")]),
+			]),
+			expected: {
+				code: "duplicate_question",
+				message: "Question 2 duplicates an earlier question text.",
+				questionIndex: 1,
+			},
+		},
+		{
+			name: "rejects a duplicate option label within one question",
+			input: params([question("Dupe?", [option("Alpha"), option("Alpha")])]),
+			expected: {
+				code: "duplicate_option_label",
+				message: 'Question 1 option 2 duplicates the label "Alpha".',
+				questionIndex: 0,
+				optionIndex: 1,
+				label: "Alpha",
+			},
+		},
+		{
+			name: "rejects a label over the 60 character limit",
+			input: params([question("Too long?", [option("z".repeat(MAX_LABEL_LENGTH + 1)), option("B")])]),
+			expected: {
+				code: "label_too_long",
+				message: "Question 1 option 1 label exceeds 60 characters.",
+				questionIndex: 0,
+				optionIndex: 0,
+				length: MAX_LABEL_LENGTH + 1,
+			},
+		},
+		{
+			name: "rejects a header over the 16 character limit",
+			input: params([question("Header too long?", [option("A"), option("B")], { header: "x".repeat(MAX_HEADER_LENGTH + 1) })]),
+			expected: {
+				code: "header_too_long",
+				message: "Question 1 header exceeds 16 characters.",
+				questionIndex: 0,
+				length: MAX_HEADER_LENGTH + 1,
+			},
+		},
+		{
+			name: "rejects the reserved Other label",
+			input: params([question("Reserved?", [option("Other"), option("B")])]),
+			expected: {
+				code: "reserved_label",
+				message: 'Question 1 option 1 uses the reserved label "Other".',
+				questionIndex: 0,
+				optionIndex: 0,
+				label: "Other",
+			},
+		},
+		{
+			name: "rejects the reserved custom-row label",
+			input: params([question("Reserved?", [option(CUSTOM_ROW_LABEL), option("B")])]),
+			expected: {
+				code: "reserved_label",
+				message: `Question 1 option 1 uses the reserved label "${CUSTOM_ROW_LABEL}".`,
+				questionIndex: 0,
+				optionIndex: 0,
+				label: CUSTOM_ROW_LABEL,
+			},
+		},
+		{
+			name: "does not treat a reserved label with different casing as reserved",
+			input: params([question("Case?", [option("other"), option("type something.")])]),
+			expected: undefined,
+		},
+		{
+			name: "reports a duplicated question before its duplicated option label",
+			input: params([
+				question("Same?", [option("A"), option("B")]),
+				question("Same?", [option("A"), option("B")]),
+			]),
+			expected: {
+				code: "duplicate_question",
+				message: "Question 2 duplicates an earlier question text.",
+				questionIndex: 1,
+			},
+		},
+	];
+}
+
+test("validateQuestionnaire reports the first violation for each guard", () => {
+	for (const testCase of makeCases()) {
+		const actual = validateQuestionnaire(testCase.input);
+		assert.deepEqual(actual, testCase.expected, testCase.name);
+	}
+});
+
+test("schema constants expose the documented limits", () => {
+	assert.equal(MAX_QUESTIONS, 4);
+	assert.equal(MIN_OPTIONS, 2);
+	assert.equal(MAX_OPTIONS, 4);
+	assert.equal(MAX_HEADER_LENGTH, 16);
+	assert.equal(MAX_LABEL_LENGTH, 60);
+	assert.equal(CUSTOM_ROW_LABEL, "Type something.");
+});
+
+test("QuestionParamsSchema pins the questionnaire parameter shape", () => {
+	const root = QuestionParamsSchema as unknown as {
+		additionalProperties?: boolean;
+		properties?: {
+			questions?: {
+				minItems?: number;
+				maxItems?: number;
+				items?: {
+					additionalProperties?: boolean;
+					properties?: Record<string, unknown>;
+					required?: string[];
+				};
+			};
+		};
+	};
+	const questions = root.properties?.questions;
+	const questionSchema = questions?.items;
+	const questionProperties = questionSchema?.properties ?? {};
+
+	assert.equal(root.additionalProperties, false);
+	assert.equal(questions?.minItems, 1);
+	assert.equal(questions?.maxItems, MAX_QUESTIONS);
+	assert.equal(questionSchema?.additionalProperties, false);
+	assert.deepEqual([...(questionSchema?.required ?? [])].sort(), ["header", "options", "question"]);
+	assert.deepEqual(Object.keys(questionProperties).sort(), ["header", "multiSelect", "options", "question"]);
+});
+
+test("schema rejects malformed questionnaire parameters", () => {
+	const validParams = params(valid());
+	assert.equal(Value.Check(QuestionParamsSchema, validParams), true);
+
+	const invalidCases: Array<[string, unknown]> = [
+		["missing questions", {}],
+		["empty questions", { questions: [] }],
+		["five questions", params([
+			question("Q1", [option("A1"), option("B1")]),
+			question("Q2", [option("A2"), option("B2")]),
+			question("Q3", [option("A3"), option("B3")]),
+			question("Q4", [option("A4"), option("B4")]),
+			question("Q5", [option("A5"), option("B5")]),
+		])],
+		["one option", params([question("One?", [option("Only")])])],
+		["label over the limit", params([question("Long?", [option("z".repeat(MAX_LABEL_LENGTH + 1)), option("B")])])],
+		["header over the limit", params([question("Long?", [option("A"), option("B")], { header: "x".repeat(MAX_HEADER_LENGTH + 1) })])],
+		["unknown root property", { questions: valid(), extra: true }],
+	];
+	for (const [name, subject] of invalidCases) {
+		assert.equal(Value.Check(QuestionParamsSchema, subject), false, name);
+	}
+});
+
+test("schema accepts multiSelect and preview as optional fields", () => {
+	const withOptionals = params([question("Options?", [option("A", "Preview A"), option("B")], { multiSelect: true })]);
+	assert.equal(Value.Check(QuestionParamsSchema, withOptionals), true);
+});