gentle-pi 2.0.0 → 2.1.1

package/runtime/native-review-cli.mjs

@@ -118,6 +118,7 @@ export const NATIVE_SDD_ARTIFACT_STATE = {
 
 
 
+
 
 
 	                                                       
@@ -372,6 +373,21 @@ export const NATIVE_REVIEW_CAPTURE_OUTCOME = ["passed", "verification_failed", "
 
 
 
+export const NATIVE_REVIEW_CONSENT_ANSWER = { GRANTED: "granted", DECLINED: "declined" }         ;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -560,7 +576,13 @@ const REVIEW_RISK_SUBJECT_BY_SIGNAL                                   = Object.f
 // an unmapped signal degrades to this rather than dropping the path entirely.
 const REVIEW_RISK_UNKNOWN_SIGNAL_SUBJECT = "a sensitive area";
 
-function nativeRiskEvidenceSubject(reason                         )         {
+
+
+
+
+
+
+function nativeRiskEvidenceSubject(reason                          )         {
 	const code = typeof reason.code === "string" ? reason.code : "";
 	if (code === "hot_path") {
 		const signal = typeof reason.signal === "string" ? reason.signal : "";
@@ -569,7 +591,7 @@ function nativeRiskEvidenceSubject(reason                         )         {
 	return REVIEW_RISK_SUBJECT_BY_CODE[code] ?? "";
 }
 
-function nativeRiskEvidencePhrase(reason                         )         {
+function nativeRiskEvidencePhrase(reason                          )         {
 	const path = typeof reason.path === "string" ? reason.path.trim() : "";
 	// An empty file is named first and described second. Every other subject
 	// reads "<what changed> in <path>", which for a file with no bytes would
@@ -582,7 +604,7 @@ function nativeRiskEvidencePhrase(reason                         )         {
 	return `${subject} in ${path}`;
 }
 
-export function nativeRiskEvidencePhrases(riskLevel        , reasons                                    )                    {
+export function nativeRiskEvidencePhrases(riskLevel        , reasons                                     )                    {
 	if (riskLevel !== "high" && riskLevel !== "medium") return [];
 	const phrases = reasons.map((reason) => nativeRiskEvidencePhrase(reason)).filter((phrase) => phrase !== "");
 	return riskLevel === "medium" ? [REVIEW_MEDIUM_RISK_REASON, ...phrases] : phrases;
@@ -1016,6 +1038,21 @@ function decodeNativeReviewStatus(value         )                           {
 	};
 }
 function isWindowsRepositoryPath(value        )          { return /^[A-Za-z]:[\\/]/.test(value) || /^\\\\/.test(value); }
+export function normalizeNativeReviewCwd(value        , platform                  = process.platform)         {
+	if (platform !== "win32") return value;
+	const gitBashDrive = /^\/([A-Za-z])(?:\/(.*))?$/.exec(value);
+	const windowsPath = gitBashDrive === null
+		? value
+		: `${gitBashDrive[1] .toUpperCase()}:/${gitBashDrive[2] ?? ""}`;
+	if (!isWindowsRepositoryPath(windowsPath)) return windowsPath;
+	const normalized = win32.normalize(windowsPath);
+	return normalized.replace(/^([a-z]):/, (_match, drive        ) => `${drive.toUpperCase()}:`);
+}
+async function canonicalNativeReviewCwd(value        )                  {
+	const normalized = normalizeNativeReviewCwd(value);
+	try { return await realpath(normalized); }
+	catch { return normalized; }
+}
 async function repositoryPathIdentity(value        )                  {
 	const windowsPath = isWindowsRepositoryPath(value);
 	try { return `filesystem:${windowsPath ? (await realpath(value)).toLowerCase() : await realpath(value)}`; }
@@ -1124,6 +1161,7 @@ function nativeError(code                       , operation
 
 
 
+
 export class NativeReviewCliV214 {
 	                 adapter                 ;
 	                 executable                         ;
@@ -1338,12 +1376,13 @@ export class NativeReviewCliV214 {
 	// and always pass `--scope clone` so Pi's own kill-switch command surface
 	// never mutates the operator's global gentle-ai state across other clones.
 	async reviewMode(request                         )                                  {
-		await this.verifyVersion(request.cwd, request.signal, ["mode"]);
+		const cwd = await canonicalNativeReviewCwd(request.cwd);
+		await this.verifyVersion(cwd, request.signal, ["mode"]);
 		const mutating = request.operation !== NATIVE_REVIEW_MODE_OPERATION.STATUS;
 		const { body } = await this.execute(
 			NATIVE_REVIEW_OPERATION.MODE,
-			request.cwd,
-			["review", "mode", request.operation, "--cwd", request.cwd, ...(mutating ? ["--scope", "clone"] : []), "--json"],
+			cwd,
+			["review", "mode", request.operation, "--cwd", cwd, ...(mutating ? ["--scope", "clone"] : []), "--json"],
 			mutating,
 			request.signal,
 		);
@@ -1618,12 +1657,13 @@ export class NativeReviewIntegrationError extends Error {
 }
 
 // Raised when negotiated START answers `consent/v2` (action:
-// "consent_required") instead of `start/v3`. Pi stays headless and never
-// sends `--consent relay`, so this is a blocking question surfaced to the
-// caller rather than answered on its behalf.
+// "consent_required") instead of `start/v3`. The provider has frozen no
+// authority yet: Pi must relay this complete candidate-scoped question and may
+// answer only through one of the exact invocations carried by the envelope.
 export class NativeReviewConsentRequiredError extends Error {
 	         consent                 ;
 	         launchAttempted = true;
+	         mutationOutcome = "none";
 	constructor(consent                 ) {
 		super(consent.headline);
 		this.name = "NativeReviewConsentRequiredError";
@@ -1631,6 +1671,117 @@ export class NativeReviewConsentRequiredError extends Error {
 	}
 }
 
+// Raised when the provider-issued consent invocation no longer matches the
+// binding Pi is answering for. Every one of these guards runs before the
+// provider is launched, so the failure is local and nothing was mutated. It
+// carries its own identity precisely so callers never report it as a provider
+// outage: an opaque `native-operation-failed` here sent issue #247 chasing a
+// missing `--cwd` that Pi does forward.
+export class NativeReviewConsentBindingError extends Error {
+	         reason        ;
+	         launchAttempted = false;
+	         mutationOutcome = "none";
+	constructor(reason        , message        ) {
+		super(message);
+		this.name = "NativeReviewConsentBindingError";
+		this.reason = reason;
+	}
+}
+
+function splitNativeConsentInvocation(invocation        )                    {
+	const words           = [];
+	let current = "";
+	let quote                       ;
+	let escaping = false;
+	let started = false;
+	for (const character of invocation.trim()) {
+		if (escaping) {
+			current += character;
+			escaping = false;
+			started = true;
+			continue;
+		}
+		if (character === "\\" && quote !== "'") {
+			escaping = true;
+			started = true;
+			continue;
+		}
+		if (quote !== undefined) {
+			if (character === quote) quote = undefined;
+			else current += character;
+			started = true;
+			continue;
+		}
+		if (character === "'" || character === '"') {
+			quote = character;
+			started = true;
+			continue;
+		}
+		if (/\s/.test(character)) {
+			if (started) {
+				words.push(current);
+				current = "";
+				started = false;
+			}
+			continue;
+		}
+		current += character;
+		started = true;
+	}
+	if (quote !== undefined || escaping) throw new TypeError("Native consent invocation has invalid quoting");
+	if (started) words.push(current);
+	return words;
+}
+
+function exactConsentOption(arguments_                   , name        )         {
+	const values           = [];
+	for (let index = 0; index < arguments_.length; index += 1) {
+		const token = arguments_[index] ;
+		if (token === name) {
+			const value = arguments_[index + 1];
+			if (value === undefined) throw new NativeReviewConsentBindingError("consent-invocation-option-invalid", `Native consent invocation ${name} is missing its value`);
+			values.push(value);
+			index += 1;
+		} else if (token.startsWith(`${name}=`)) values.push(token.slice(name.length + 1));
+	}
+	if (values.length !== 1) throw new NativeReviewConsentBindingError("consent-invocation-option-invalid", `Native consent invocation requires exactly one ${name}`);
+	return values[0] ;
+}
+
+function consentInvocationArguments(request                                  )                    {
+	const choice = request.consent.choices.find((candidate) => candidate.answer === request.answer);
+	if (choice === undefined) throw new NativeReviewConsentBindingError("consent-answer-unknown", "Native consent answer must be granted or declined");
+	const words = splitNativeConsentInvocation(choice.invocation);
+	if (words[0] !== "gentle-ai" || words[1] !== "review" || words[2] !== "start") throw new NativeReviewConsentBindingError("consent-invocation-not-start", "Native consent invocation is not a provider review START");
+	const arguments_ = words.slice(1);
+	if (exactConsentOption(arguments_, "--contract") !== REVIEW_INTEGRATION_CONTRACT) throw new NativeReviewConsentBindingError("consent-invocation-contract-changed", "Native consent invocation contract changed");
+	if (exactConsentOption(arguments_, "--cwd") !== request.cwd) throw new NativeReviewConsentBindingError("consent-invocation-cwd-changed", "Native consent invocation repository binding changed");
+	if (exactConsentOption(arguments_, "--target") !== request.consent.targetIdentity) throw new NativeReviewConsentBindingError("consent-invocation-target-changed", "Native consent invocation target binding changed");
+	if (exactConsentOption(arguments_, "--projection") !== request.consent.projection) throw new NativeReviewConsentBindingError("consent-invocation-projection-changed", "Native consent invocation projection binding changed");
+	if (exactConsentOption(arguments_, "--consent") !== request.answer || arguments_.at(-1) !== request.answer) throw new NativeReviewConsentBindingError("consent-invocation-answer-changed", "Native consent invocation answer binding changed");
+	return arguments_;
+}
+
+function decodeDeclinedConsentStart(value         , expected                                  )                                    {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new TypeError("Native declined consent result must be an object");
+	const body = value                           ;
+	if (body.operation !== "review/start" || body.action !== "declined" || body.consent !== "declined_this_candidate") throw new TypeError("Native declined consent result has an invalid identity");
+	if (body.target_identity !== expected.consent.targetIdentity || body.projection !== expected.consent.projection || body.risk_level !== expected.consent.riskLevel) throw new TypeError("Native declined consent result target binding changed");
+	if (body.lenses_required !== false || !Array.isArray(body.selected_lenses) || body.selected_lenses.length !== 0 || !Array.isArray(body.lens_bindings) || body.lens_bindings.length !== 0) throw new TypeError("Native declined consent result must create no review authority");
+	if (typeof body.changed_files !== "number" || !Number.isSafeInteger(body.changed_files) || body.changed_files < 0 || typeof body.changed_lines !== "number" || !Number.isSafeInteger(body.changed_lines) || body.changed_lines < 0) throw new TypeError("Native declined consent result has invalid change counts");
+	if (body.lineage_id !== "" || body.state !== "" || body.correction_budget !== 0) throw new TypeError("Native declined consent result cannot carry review authority");
+	return {
+		kind: "declined",
+		targetIdentity: expected.consent.targetIdentity,
+		projection: expected.consent.projection,
+		riskLevel: expected.consent.riskLevel,
+		changedFiles: body.changed_files,
+		changedLines: body.changed_lines,
+		consent: "declined_this_candidate",
+		raw: body,
+	};
+}
+
 
 const nativeCapabilitiesByDigest = new Map                                       ();
 
@@ -1820,41 +1971,40 @@ export class NativeReviewCliV216                            {
 		if (request.baseRef !== undefined && !isCanonicalProcessString(request.baseRef)) throw new TypeError("Native START baseRef must be a non-empty, trimmed, NUL-free string");
 		if (request.baseRef !== undefined && request.committedOnly !== true) throw new TypeError("Native START baseRef requires explicit committedOnly acknowledgement");
 		if (request.baseRef === undefined && request.committedOnly !== undefined) throw new TypeError("Native START committedOnly requires an explicit baseRef");
-		// A negotiated START requires exactly one --contract, --target, and
-		// --projection. The target is resolved here, from the same root START is
-		// about to run in, rather than threaded in by the caller: the caller's
-		// root and START's root differ whenever a candidate view is in play, and
-		// a target frozen from the wrong root would name a snapshot this START
-		// never inspects. targetStatus is read-only, so this costs one extra
-		// read and cannot create authority.
+		if (request.targetIdentity !== undefined && !/^sha256:[0-9a-f]{64}$/.test(request.targetIdentity)) throw new TypeError("Native START targetIdentity must be a canonical sha256 identity");
+		// The controller supplies the target it already projected from the
+		// authority workspace after proving its immutable actor view is identical.
+		// Direct adapter callers may omit it and retain the same-root projection.
 		const projection = request.projection ?? "workspace";
-		const target = await this.targetStatus({
+		const targetIdentity = request.targetIdentity ?? (await this.targetStatus({
 			cwd: request.cwd,
 			projection,
 			...(request.baseRef === undefined ? {} : { baseRef: request.baseRef }),
 			...(request.lineageId === undefined ? {} : { lineageId: request.lineageId }),
 			...(request.signal === undefined ? {} : { signal: request.signal }),
-		});
+		})).targetIdentity;
 		const execution = await this.negotiated(NATIVE_REVIEW_OPERATION.START, request.cwd, [
 			"review", "start", "--contract", REVIEW_INTEGRATION_CONTRACT, "--cwd", request.cwd,
-			"--target", target.targetIdentity, "--projection", projection,
+			"--target", targetIdentity, "--projection", projection,
 			...(request.baseRef === undefined ? [] : ["--base-ref", request.baseRef, "--committed-only"]),
 			...(request.lineageId === undefined ? [] : ["--lineage", request.lineageId]),
 			...(request.policyPath === undefined ? [] : ["--policy", request.policyPath]),
 			...(request.focus === undefined ? [] : ["--focus", request.focus]),
-			// A headless START that reviews without asking still succeeds; its
-			// consent notices are console output, never a failure signal.
-		], true, request.signal, REVIEW_CONSENT_NOTICES);
+			"--consent", "relay",
+		], true, request.signal);
 		// A negotiated v2 START may answer `consent/v2` (action:
 		// "consent_required") instead of `start/v3` when the provider needs an
-		// explicit answer it cannot infer. Discriminated BEFORE decode: the two
-		// envelopes share no required shape, and Pi never sends `--consent
-		// relay`, so this is always surfaced to the caller, never answered here.
+		// explicit answer it cannot infer. Discriminate before decode and surface
+		// the complete envelope; only the caller can map a human answer.
 		if (execution.body.action === "consent_required") {
-			throw new NativeReviewConsentRequiredError(decode(NATIVE_REVIEW_OPERATION.START, true, () => decodeReviewConsentV2(execution.body)));
+			const consent = decode(NATIVE_REVIEW_OPERATION.START, true, () => decodeReviewConsentV2(execution.body));
+			if (consent.targetIdentity !== targetIdentity || consent.projection !== projection) throw nativeError(NATIVE_REVIEW_ERROR_CODE.IDENTITY_MISMATCH, NATIVE_REVIEW_OPERATION.START, true, "native consent target binding mismatch");
+			throw new NativeReviewConsentRequiredError(consent);
 		}
 		const result = decode(NATIVE_REVIEW_OPERATION.START, true, () => decodeReviewStartV3(execution.body));
 		if (request.lineageId !== undefined && result.lineageId !== request.lineageId) throw nativeError(NATIVE_REVIEW_ERROR_CODE.IDENTITY_MISMATCH, NATIVE_REVIEW_OPERATION.START, true, "native start lineage mismatch");
+		const resultTarget = result.targetIdentity ?? result.repositoryContext?.targetIdentity;
+		if (resultTarget !== undefined && resultTarget !== targetIdentity) throw nativeError(NATIVE_REVIEW_ERROR_CODE.IDENTITY_MISMATCH, NATIVE_REVIEW_OPERATION.START, true, "native start target mismatch");
 		return {
 			lineageId: result.lineageId,
 			state: result.state                              ,
@@ -1883,6 +2033,36 @@ export class NativeReviewCliV216                            {
 		};
 	}
 
+	async answerConsent(request                                  )                                           {
+		const arguments_ = consentInvocationArguments(request);
+		const execution = await this.negotiated(NATIVE_REVIEW_OPERATION.START, request.cwd, arguments_, true, request.signal);
+		if (request.answer === NATIVE_REVIEW_CONSENT_ANSWER.DECLINED) {
+			return decode(NATIVE_REVIEW_OPERATION.START, true, () => decodeDeclinedConsentStart(execution.body, request));
+		}
+		const result = decode(NATIVE_REVIEW_OPERATION.START, true, () => decodeReviewStartV3(execution.body));
+		const answeredTarget = result.targetIdentity ?? result.repositoryContext?.targetIdentity;
+		if (answeredTarget !== request.consent.targetIdentity) throw nativeError(NATIVE_REVIEW_ERROR_CODE.IDENTITY_MISMATCH, NATIVE_REVIEW_OPERATION.START, true, "native consent answer target mismatch");
+		const lineageId = exactConsentOption(arguments_, "--lineage");
+		if (result.lineageId !== lineageId) throw nativeError(NATIVE_REVIEW_ERROR_CODE.IDENTITY_MISMATCH, NATIVE_REVIEW_OPERATION.START, true, "native consent answer lineage mismatch");
+		return { kind: "started", start: {
+			lineageId: result.lineageId,
+			state: result.state                              ,
+			riskLevel: result.riskLevel,
+			selectedLenses: result.selectedLenses,
+			changedFiles: result.changedFiles,
+			changedLines: result.changedLines,
+			correctionBudget: result.correctionBudget,
+			action: result.action                     ,
+			lensesRequired: result.lensesRequired,
+			riskReasons: result.riskReasons.map((reason) => ({ ...reason })),
+			...(() => {
+				const evidence = nativeRiskEvidencePhrases(result.riskLevel, result.riskReasons);
+				return evidence.length === 0 ? {} : { riskEvidence: evidence };
+			})(),
+			raw: result.raw,
+		} };
+	}
+
 	        async stageDocument(directory        , name        , document         )                  {
 		const path = join(directory, `${name}.json`);
 		await writeFile(path, JSON.stringify(document), { encoding: "utf8", mode: 0o600 });

package/runtime/review-integration-v2.mjs

@@ -1304,10 +1304,14 @@ export function decodeReviewConsentV2(value         )                  {
 	if (body.action !== "consent_required") throw new TypeError("consent.action must be consent_required");
 	if (body.blocking !== true) throw new TypeError("consent.blocking must be true");
 
+	const targetIdentity = sha256(body.target_identity, "consent.target_identity");
 	const choicesArray = body.choices;
 	if (!Array.isArray(choicesArray) || choicesArray.length !== 2) throw new TypeError("consent.choices must have exactly 2 items");
 	const granted = decodeConsentChoice(choicesArray[0], "consent.choices[0]", "granted");
 	const declined = decodeConsentChoice(choicesArray[1], "consent.choices[1]", "declined");
+	for (const choice of [granted, declined]) {
+		if (!choice.invocation.includes(` --target ${targetIdentity} `)) throw new TypeError(`consent choice ${choice.answer} invocation must bind consent.target_identity`);
+	}
 
 	const offPathSource = exactRecord(body.off_path, "consent.off_path", ["note", "command"]);
 	if (offPathSource.command !== "gentle-ai review mode disable") throw new TypeError("consent.off_path.command is unsupported");
@@ -1318,7 +1322,7 @@ export function decodeReviewConsentV2(value         )                  {
 		operation: "review.start",
 		action: "consent_required",
 		blocking: true,
-		targetIdentity: sha256(body.target_identity, "consent.target_identity"),
+		targetIdentity,
 		projection: enumeration(body.projection, REQUIRED_PROJECTIONS, "consent.projection"),
 		riskLevel: enumeration(body.risk_level, ["medium", "high"]         , "consent.risk_level"),
 		changedFiles: integer(body.changed_files, "consent.changed_files"),