@usepipr/runtime 0.4.1 → 0.4.2

package/dist/{commands-0cyQHxpm.d.mts → commands-DtdTtej_.d.mts}

@@ -299,13 +299,15 @@ declare const priorReviewStateSchema: z.ZodObject<{
   selectedTasks: z.ZodArray<z.ZodString>;
   findings: z.ZodArray<z.ZodObject<{
     id: z.ZodString;
+    anchorFingerprint: z.ZodOptional<z.ZodString>;
+    issueFingerprint: z.ZodOptional<z.ZodString>;
     status: z.ZodEnum<{
       open: "open";
       resolved: "resolved";
     }>;
     path: z.ZodString;
     rangeId: z.ZodString;
-    side: z.ZodType<ReviewSide, unknown, z.core.$ZodTypeInternals<ReviewSide, unknown>>;
+    side: z.ZodType<import("@usepipr/sdk").ReviewSide, unknown, z.core.$ZodTypeInternals<import("@usepipr/sdk").ReviewSide, unknown>>;
     startLine: z.ZodNumber;
     endLine: z.ZodNumber;
     firstSeenHeadSha: z.ZodString;
@@ -433,6 +435,8 @@ declare const publicationPlanSchema: z.ZodObject<{
     selectedTasks: z.ZodArray<z.ZodString>;
     findings: z.ZodArray<z.ZodObject<{
       id: z.ZodString;
+      anchorFingerprint: z.ZodOptional<z.ZodString>;
+      issueFingerprint: z.ZodOptional<z.ZodString>;
       status: z.ZodEnum<{
         open: "open";
         resolved: "resolved";
@@ -844,4 +848,4 @@ declare function runHostRunCommand(options: HostRunCommandOptions): Promise<Host
 declare function runHostRunCommandWithDependencies(options: HostRunCommandDependencyOptions): Promise<HostRunCommandResult>;
 //#endregion
 export { DiffManifest as A, RuntimeLogSink as C, PublicationResult as D, PublicationError as E, RuntimeSettings as F, OfficialInitAdapter as I, supportedOfficialInitAdapters as L, PlatformInfo as M, ProviderConfig as N, ChangeRequestEventContext as O, RepositoryRef as P, RuntimeLogRecord as S, RepositoryPermission as T, piBuiltinToolNames as _, runInspectCommand as a, piThinkingLevels as b, DryRunCommandOptions as c, HostRunCommandResult as d, InitCommandOptions as f, RuntimeCommandOptions as g, LocalReviewCommandResult as h, runInitCommand as i, PiprConfig as j, ChangeRequestRef as k, DryRunCommandResult as l, LocalReviewCommandOptions as m, runHostRunCommand as n, runLocalReviewCommand as o, InspectCommandResult as p, runHostRunCommandWithDependencies as r, runValidateCommand as s, runDryRunCommand as t, HostRunCommandOptions as u, piReadOnlyToolNames as v, CodeHostAdapter as w, SecretRedactor as x, piRequiredCliFlags as y };
-//# sourceMappingURL=commands-0cyQHxpm.d.mts.map
+//# sourceMappingURL=commands-DtdTtej_.d.mts.map

package/dist/commands-DtdTtej_.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands-DtdTtej_.d.mts","names":[],"sources":["../src/config/init.ts","../src/types.ts","../src/config/project.ts","../src/review/prior-state.ts","../src/review/comment.ts","../src/review/publication-result.ts","../src/hosts/types.ts","../src/shared/logging.ts","../src/shared/secret-redaction.ts","../src/pi/contract.ts","../src/review/task/task-output.ts","../src/review/task/task-runtime.ts","../src/host-run/types.ts","../src/host-run/commands.ts"],"mappings":";;;;KAuBY;EACV;EACA;EACA;;cAGW;KAOD,8BAA8B;;;cCJpC,sBAAoB,EAAA;;;;;;;;;;;;;;cAyBpB,kBAAgB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwBhB,uBAAqB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAMrB,oBAAkB,EAAA;;;;cAKlB,qBAAmB,EAAA;;;;cAKnB,2BAAyB,EAAA,uBAAA,EAAA;;;;;;;;;;;;;;;;;;;;cAkCzB,wBAAsB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAYtB,iCAA+B,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsE/B,uBAAqB,EAAA;;;;;;;;cAMrB,8BAA4B,EAAA;;;;;;;KAEtB,iBAAiB,EAAE,aAAa;KAGhC,aAAa,EAAE,aAAa;KAC5B,kBAAkB,EAAE,aAAa;KACjC,eAAe,EAAE,aAAa;KAC9B,gBAAgB,EAAE,aAAa;KAC/B,sBAAsB,EAAE,aAAa;KACrC,mBAAmB,EAAE,aAAa;KAClC,4BAA4B,EAAE,aAAa;KAE3C,kBAAkB,EAAE,aAAa;KACjC,yBAAyB,EAAE,aAAa;;;KCjNxC;EACV;EACA;EACA;EACA;EACA,QAAQ;IAAQ;IAAc;;EAC9B,UAAU;IAAQ;IAAiB;IAAc;;EACjD;EACA;;;;cCSW,wBAAsB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KASvB,mBAAmB,EAAE,aAAa;;;cCXxC,6BAA2B,EAAA;;;;;;;;;;;;;KAuCrB,wBAAwB,EAAE,aAAa;KACvC,qBAAqB;cAS3B,oBAAkB,EAAA;;;;;;;;;;;;KAYZ,eAAe,EAAE,aAAa;cAEpC,2BAAyB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;KAenB,sBAAsB,EAAE,aAAa;cAE3C,uBAAqB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAUf,kBAAkB,EAAE,aAAa;;;KC/HjC;EACV;IACE;IACA;;EAEF;IACE;IACA;IACA;;EAEF,UAAU;IACR;IACA;;;;cAKS,yBAAyB;WAGzB,QAAQ,KAAK;cADtB,iBACS,QAAQ,KAAK;;;;KCXd;EACV;EACA,KAAK,OAAO;EACZ;;KAGU;KAEA;EACV;EACA;EACA;EACA,YAAY;EACZ;EACA,WAAW;EACX;EACA;EACA;EACA;;KAGU;EACV;EACA,IAAI;;KAGM;EACV;EACA;EACA,iBAAiB;EACjB;EACA;EACA;EACA,UAAU;IACR,IAAI;IACJ;IACA;;;KAIQ;EACV;EACA;EACA;EACA,YAAY;EACZ;EACA,WAAW;EACX,kBAAkB;EAClB;EACA;EACA;;KAGU;EACN;EAAiB;;EACjB;EAAwB,QAAQ;;EAChC;EAAyB,SAAS;;EAClC;EAA8B,OAAO;;KAE/B;EACV,YAAY;EACZ,aAAa;EACb,QAAQ;EACR;EACA;EACA;EACA;;KAGU,uBAAuB;KAEvB;KAEA;EACV,IAAI;EACJ;;KAGU;EACV,WAAW,SAAS,wBAAwB,QAAQ;EACpD,kBAAkB;IAChB,YAAY;IACZ;IACA;IACA;IACA;IACA;MACE,QAAQ;;KAGF;EACV,wBAAwB;IACtB,QAAQ;IACR;MACE,QAAQ;;KAGF;EACV,mBAAmB;IACjB;IACA,QAAQ;MACN;EACJ,8BAA8B;IAAW;IAAiB,MAAM,OAAO;;;KAG7D;EACV,QAAQ;IACN,MAAM;IACN,QAAQ;MACN,QAAQ;EACZ,wBAAwB;IACtB,QAAQ;IACR,iBAAiB;IACjB;IACA;MACE,QAAQ;EACZ,sBAAsB;IACpB,QAAQ;IACR,SAAS;IACT;MACE;IAAU;;;KAGJ;EACV,sBAAsB;IACpB,QAAQ;MACN,QAAQ;EACZ,sBAAsB;IACpB,QAAQ;MACN;EACJ,0BAA0B;IACxB,QAAQ;MACN,QAAQ;;KAGF;EACV,YAAY,QAAQ;EACpB,OAAO;IACL,QAAQ;IACR;IACA,OAAO;IACP;IACA,SAAS;MACP,QAAQ;;KAGF;EACV;EACA;EACA;EACA;EACA;EACA;;KAGU;EACV;EACA,cAAc;EACd,QAAQ;EACR,WAAW;EACX,aAAa;EACb,cAAc;EACd,WAAW;EACX,WAAW;;;;KC5KD;EACV,IAAI,QAAQ;EACZ,MAAM,GAAG,cAAc,WAAW,QAAQ,KAAK,QAAQ;;KAG7C;EACV,OAAO;EACP;EACA,QAAQ;EACR;;KAQU,yBAAyB;KAsBzB;;;KCzCA;EACV;EACA;;KAGU;EACV,UAAU;EACV,OAAO,gBAAgB;;;;cCLZ;cACA;cACA;cAEA;;;KCqBD;KAEA;EACV;EACA,YAAY;EACZ;;;;KCqDG;EACH,UAAU;EACV,cAAc;EACd,YAAY;EACZ;;KAGU,uBACP;EACC;EACA,QAAQ;EACR,WAAW;EACX,iBAAiB;EACjB;EACA,qBAAqB;EACrB;MAED;EACC;EACA;EACA,QAAQ;EACR,WAAW;EACX,iBAAiB;EACjB;EACA,qBAAqB;EACrB;MAED;EACC;EACA;IACE;IACA;IACA,WAAW;IACX;;EAEF;EACA;EACA;EACA;EACA;;;;KCpHM;EACV;EACA;EACA,MAAM,OAAO;EACb;;KAGU,qBAAqB;EAC/B;EACA;EACA;EACA;;KAGU,uBAAuB;EACjC;EACA;;KAGU,wBAAwB;EAClC;EACA;EACA;EACA,UAAU;;KAGA,kCAAkC;EAC5C;EACA,cAAc;EACd,iBAAiB;;KAGP;EACV,KAAK;EACL,KAAK;EACL,MAAM;;KAGI,4BAA4B;EACtC;EACA;EACA;EACA,UAAU;EACV,UAAU;;KAGA;EACV;EACA,OAAO;EACP;;KAGU,uBAAuB;EACjC;;KAGU,2BAA2B;EACrC;EACA;;KAGU,+BAA+B,QAAQ;EAAuB;;KAE9D;EAEN;EACA;;EAGA;EACA,OAAO;EACP;;EAGA;EACA,OAAO;EACP;EACA;EACA;;EAGA;EACA,OAAO;EACP;EACA;EACA,QAAQ;EACR,aAAa;;EAGb;EACA,OAAO;EACP;EACA;EACA;IACE;;EAEF,aAAa;;EAGb;EACA,OAAO;EACP;EACA;;KAuBM,wBAAwB;;;;iBCvFd,eACpB,SAAS,qBACR,QAAQ;;iBAYW,mBACpB,SAAS,wBACR,QAAQ;;iBAUW,kBACpB,SAAS,wBACR,QAAQ;;iBASW,iBACpB,SAAS,uBACR,QAAQ;;iBAoBW,sBACpB,SAAS,4BACR,QAAQ;;iBA2EW,kBACpB,SAAS,wBACR,QAAQ;iBAOW,kCACpB,SAAS,kCACR,QAAQ"}

package/dist/{commands-46Q2ZDt0.mjs → commands-EZV-Icbs.mjs}

@@ -1,5 +1,5 @@
 import { c as resolveReadAtRefRequest, d as isRecord, l as unavailableReadAtRefResult, n as boundedLineSlice, r as parseManifestPath, u as createDiffRangeIndex } from "./runtime-tools-core-D8_WsbL_.mjs";
-import { a as officialInitRecipeWorkflowEnvSecrets, i as officialInitRecipeFiles, r as officialInitRecipeConfigTs, t as renderOfficialGithubWorkflow } from "./official-github-workflow-Cx-Yhh86.mjs";
+import { a as officialInitRecipeWorkflowEnvSecrets, i as officialInitRecipeFiles, r as officialInitRecipeConfigTs, t as renderOfficialGithubWorkflow } from "./official-github-workflow-BuZs6bOx.mjs";
 import { t as isPublishableSuggestedFixSelection } from "./suggested-fix-publication-policy-B5Wwuudp.mjs";
 import { createRequire } from "node:module";
 import { chmod, chown, cp, lstat, mkdir, mkdtemp, readdir, rm } from "node:fs/promises";
@@ -597,7 +597,7 @@ function compareStableSemver(left, right) {
 }
 //#endregion
 //#region src/shared/version.ts
-const runtimeVersion = "0.4.1";
+const runtimeVersion = "0.4.2";
 //#endregion
 //#region src/config/version-compat.ts
 async function resolveConfigVersionCompatibility(options) {
@@ -939,8 +939,8 @@ const supportedOfficialInitAdapters = [
 	"azure-devops",
 	"bitbucket"
 ];
-const defaultGitLabImageRef = "ghcr.io/somus/pipr:v0.4.1";
-const defaultSdkVersion = "0.4.1";
+const defaultGitLabImageRef = "ghcr.io/somus/pipr:v0.4.2";
+const defaultSdkVersion = "0.4.2";
 function resolveOfficialInitAdapters(adapters) {
 	if (adapters === void 0) return ["github"];
 	if (adapters.length === 0) return [];
@@ -3837,6 +3837,146 @@ function findingFingerprint(finding) {
 	return new Bun.CryptoHasher("sha256").update(basis).digest("hex").slice(0, 16);
 }
 //#endregion
+//#region src/review/agent/review-schema.ts
+const reviewFindingPropertyNames = [
+	"body",
+	"path",
+	"rangeId",
+	"side",
+	"startLine",
+	"endLine"
+];
+const completeReviewFindingPropertyMask = (1 << reviewFindingPropertyNames.length) - 1;
+const unresolvedSchemaReference = Symbol("unresolvedSchemaReference");
+const singleSchemaKeywords = [
+	"additionalItems",
+	"additionalProperties",
+	"contains",
+	"else",
+	"if",
+	"items",
+	"then",
+	"unevaluatedProperties"
+];
+const schemaArrayKeywords = [
+	"allOf",
+	"anyOf",
+	"oneOf",
+	"prefixItems"
+];
+const schemaMapKeywords = [
+	"dependentSchemas",
+	"patternProperties",
+	"properties"
+];
+const alternativeSchemaKeywords = ["anyOf", "oneOf"];
+function schemaContainsReviewFinding(value) {
+	if (!isRecord(value)) return false;
+	return reachableSchemaContainsReviewFinding(value, value, /* @__PURE__ */ new Set());
+}
+function reachableSchemaContainsReviewFinding(schema, rootSchema, visited) {
+	if (Array.isArray(schema)) return schema.some((child) => reachableSchemaContainsReviewFinding(child, rootSchema, visited));
+	if (!isRecord(schema) || visited.has(schema)) return false;
+	visited.add(schema);
+	return schemaObjectPropertyMasks(schema, rootSchema, /* @__PURE__ */ new Set()).has(completeReviewFindingPropertyMask) || reachableChildSchemas(schema, rootSchema).some((child) => reachableSchemaContainsReviewFinding(child, rootSchema, visited));
+}
+function reachableChildSchemas(schema, rootSchema) {
+	const referencedSchema = resolveLocalSchemaReference(rootSchema, schema.$ref);
+	return [
+		...referencedSchema === void 0 ? [] : [referencedSchema],
+		...singleSchemaKeywords.map((keyword) => schema[keyword]),
+		...schemaArrayKeywords.flatMap((keyword) => Array.isArray(schema[keyword]) ? schema[keyword] : []),
+		...schemaMapKeywords.flatMap((keyword) => {
+			const children = schema[keyword];
+			return isRecord(children) ? Object.values(children) : [];
+		})
+	];
+}
+function schemaObjectPropertyMasks(schema, rootSchema, visited) {
+	if (schema === true || visited.has(schema)) return /* @__PURE__ */ new Set([0]);
+	if (!isRecord(schema) || !schemaAllowsObject(schema, rootSchema, /* @__PURE__ */ new Set())) return /* @__PURE__ */ new Set();
+	visited.add(schema);
+	const conjunctiveMasks = conjunctiveSchemas(schema, rootSchema).reduce((masks, child) => combinePropertyMasks(masks, schemaObjectPropertyMasks(child, rootSchema, new Set(visited))), /* @__PURE__ */ new Set([reviewFindingPropertyMask(schema)]));
+	return alternativeSchemaGroups(schema).reduce((masks, alternatives) => combinePropertyMasks(masks, alternativePropertyMasks(alternatives, rootSchema, visited)), conjunctiveMasks);
+}
+function conjunctiveSchemas(schema, rootSchema) {
+	const referencedSchema = resolveLocalSchemaReference(rootSchema, schema.$ref);
+	const allOf = Array.isArray(schema.allOf) ? schema.allOf : [];
+	return referencedSchema === void 0 ? allOf : [referencedSchema, ...allOf];
+}
+function alternativeSchemaGroups(schema) {
+	return alternativeSchemaKeywords.map((keyword) => schema[keyword]).filter((alternatives) => Array.isArray(alternatives));
+}
+function alternativePropertyMasks(alternatives, rootSchema, visited) {
+	return new Set(alternatives.flatMap((child) => [...schemaObjectPropertyMasks(child, rootSchema, new Set(visited))]));
+}
+function reviewFindingPropertyMask(schema) {
+	let mask = 0;
+	const properties = isRecord(schema.properties) ? schema.properties : {};
+	const patternProperties = isRecord(schema.patternProperties) ? schema.patternProperties : {};
+	const propertyPatterns = Object.keys(patternProperties).flatMap((pattern) => {
+		try {
+			return [new RegExp(pattern)];
+		} catch {
+			return [];
+		}
+	});
+	const required = new Set(Array.isArray(schema.required) ? schema.required.filter((propertyName) => typeof propertyName === "string") : []);
+	for (const [index, propertyName] of reviewFindingPropertyNames.entries()) if (propertyName in properties || required.has(propertyName) || propertyPatterns.some((pattern) => pattern.test(propertyName))) mask |= 1 << index;
+	return mask;
+}
+function combinePropertyMasks(left, right) {
+	const combined = /* @__PURE__ */ new Set();
+	for (const leftMask of left) for (const rightMask of right) {
+		combined.add(leftMask | rightMask);
+		if (combined.has(completeReviewFindingPropertyMask)) return /* @__PURE__ */ new Set([completeReviewFindingPropertyMask]);
+	}
+	return combined;
+}
+function schemaAllowsObject(schema, rootSchema, visited) {
+	if (schema === false) return false;
+	if (schema === true || !isRecord(schema) || visited.has(schema)) return true;
+	visited.add(schema);
+	return directSchemaAllowsObject(schema) && conjunctiveSchemas(schema, rootSchema).every((child) => schemaAllowsObject(child, rootSchema, new Set(visited))) && alternativeSchemaGroups(schema).every((alternatives) => alternatives.some((child) => schemaAllowsObject(child, rootSchema, new Set(visited))));
+}
+function directSchemaAllowsObject(schema) {
+	const type = schema.type;
+	if (typeof type === "string") return type === "object";
+	if (Array.isArray(type) && !type.includes("object")) return false;
+	if ("const" in schema && !isRecord(schema.const)) return false;
+	return !Array.isArray(schema.enum) || schema.enum.some(isRecord);
+}
+function resolveLocalSchemaReference(rootSchema, reference) {
+	if (reference === "#") return rootSchema;
+	if (typeof reference !== "string" || !reference.startsWith("#/")) return;
+	let current = rootSchema;
+	for (const encodedSegment of reference.slice(2).split("/")) {
+		const segment = decodePointerSegment(encodedSegment);
+		if (segment === void 0) return;
+		current = resolvePointerSegment(current, segment);
+		if (current === unresolvedSchemaReference) return;
+	}
+	return current;
+}
+function decodePointerSegment(encodedSegment) {
+	try {
+		return decodeURIComponent(encodedSegment).replaceAll("~1", "/").replaceAll("~0", "~");
+	} catch {
+		return;
+	}
+}
+function resolvePointerSegment(current, segment) {
+	if (Array.isArray(current)) return resolveArrayPointerSegment(current, segment);
+	if (!isRecord(current) || !(segment in current)) return unresolvedSchemaReference;
+	return current[segment];
+}
+function resolveArrayPointerSegment(current, segment) {
+	if (!/^(0|[1-9]\d*)$/.test(segment)) return unresolvedSchemaReference;
+	const index = Number(segment);
+	if (!Number.isSafeInteger(index) || index >= current.length) return unresolvedSchemaReference;
+	return current[index];
+}
+//#endregion
 //#region src/review/agent/agent-prompt.ts
 async function renderAgentPrompt(options) {
 	const prompt = await renderAgentDefinitionPrompt(options.agent, options.input, options.agentRunContext.prompt);
@@ -3893,12 +4033,12 @@ function outputPrompt(schema) {
 	]);
 	if (schema.id === reviewResultSchemaId) {
 		lines.splice(2, 0, `Example:\n${JSON.stringify(reviewSchemaExample$1(), null, 2)}`, ...suggestedFixRules);
-		lines.push("For inlineFindings, use only fields shown in the schema. Each finding's path, rangeId, and side must identify one Diff Manifest commentable range, and its startLine and endLine must select a valid span within that range. If no valid span applies, omit the finding.", ...inlineSelectionPromptLines(), `For inlineFindings.body, write the exact inline comment body. Use one short paragraph, at most two sentences, and at most 700 characters. Treat 700 as a hard ceiling, not a target; prefer 250-450 characters when possible.`);
+		lines.push("For inlineFindings, use only fields shown in the schema. Each finding's path, rangeId, and side must identify one Diff Manifest commentable range, and its startLine and endLine must select a valid span within that range. If no valid span applies, omit the finding.", ...inlineSelectionPromptLines(), "For inlineFindings.body, write the exact inline comment body.");
 	} else if (schemaMentionsField(schema.jsonSchema, "suggestedFix")) lines.splice(2, 0, ...suggestedFixRules);
 	return lines.join("\n\n");
 }
 function customInlineSelectionPrompt(schema, diffManifest) {
-	if (!diffManifest || schema.id === reviewResultSchemaId) return;
+	if (!diffManifest || schema.id === reviewResultSchemaId || !schemaContainsReviewFinding(schema.jsonSchema)) return;
 	return promptSection("Inline Review Selection Policy", inlineSelectionPromptLines().join("\n"));
 }
 function inlineSelectionPromptLines() {
@@ -3922,16 +4062,16 @@ function schemaMentionsField(value, fieldName) {
 	return Object.entries(value).some(([key, child]) => key === fieldName || schemaMentionsField(child, fieldName));
 }
 function reviewPolicyPrompt(schema) {
-	if (schema.id !== reviewResultSchemaId) return;
+	if (schema.id !== reviewResultSchemaId && !schemaContainsReviewFinding(schema.jsonSchema)) return;
 	return promptSection("Review Policy", [
 		"Review only changed behavior.",
 		"Report only actionable defects, security risks, regressions, or meaningful test gaps.",
 		"Before emitting a finding, verify that the changed code introduces or exposes the issue, repository evidence supports it, and the impact is concrete. If any part is uncertain, omit it.",
 		"When changed behavior crosses a function, type, API, configuration, or data boundary, inspect relevant callers, callees, and tests before deciding whether the change is defective or intentionally coordinated.",
-		"Put each actionable issue in inlineFindings. Do not leave actionable defects or test gaps only in the summary.",
-		"Base the summary only on changed behavior and evidence available in the Diff Manifest or read tools. Do not claim tests or checks ran, passed, or failed unless their output is present.",
-		"Inline finding bodies are final code-review comments, not analysis notes.",
-		`State the concrete defect and user-visible or runtime impact directly. Keep each body to one short paragraph, at most two sentences, and at most 700 characters.`,
+		"Put each actionable issue in the schema's finding collection. Do not leave actionable defects or test gaps only in the summary.",
+		"When the output includes a summary, base it only on changed behavior and evidence available in the Diff Manifest or read tools. Do not claim tests or checks ran, passed, or failed unless their output is present.",
+		"Finding bodies must be publication-ready review prose, not analysis notes.",
+		`State the concrete defect and user-visible or runtime impact directly. Keep each body to one short paragraph, at most two sentences, and at most 700 characters. Treat 700 as a hard ceiling, not a target; prefer 250-450 characters when possible.`,
 		"Do not include step-by-step reasoning, broad context, praise, restated diff, alternatives, or code snippets unless they are necessary to identify the defect.",
 		"Never copy a secret-looking literal from changed code into the review summary, inline finding body, or suggestedFix. Describe only the secret kind and location.",
 		"Omit speculative, style-only, broad refactor, external-fact, and out-of-diff findings.",
@@ -3950,14 +4090,15 @@ function pathScopePrompt(paths) {
 	].join("\n");
 }
 function priorFindingsPrompt(state) {
-	const openFindings = state?.findings.filter((finding) => finding.status === "open") ?? [];
-	if (openFindings.length === 0) return;
+	const findings = state?.findings.filter((finding) => finding.status === "open") ?? [];
+	if (findings.length === 0) return;
 	return [
 		"Prior pipr findings:",
 		JSON.stringify({
 			reviewedHeadSha: state?.reviewedHeadSha,
-			findings: openFindings.map((finding) => ({
+			findings: findings.map((finding) => ({
 				id: finding.id,
+				status: finding.status,
 				path: finding.path,
 				rangeId: finding.rangeId,
 				side: finding.side,
@@ -4446,6 +4587,8 @@ const findingIdSchema = z.string().min(1).regex(/^[A-Za-z0-9_.-]+$/);
 const priorFindingStatusSchema = z.enum(["open", "resolved"]);
 const priorFindingRecordSchema = z.strictObject({
 	id: findingIdSchema,
+	anchorFingerprint: z.string().regex(/^[a-f0-9]{64}$/).optional(),
+	issueFingerprint: z.string().regex(/^[a-f0-9]{64}$/).optional(),
 	status: priorFindingStatusSchema,
 	path: z.string().min(1),
 	rangeId: z.string().min(1),
@@ -4469,33 +4612,23 @@ function buildPriorReviewState(options) {
 	const nextFindings = /* @__PURE__ */ new Map();
 	const usedPriorIds = /* @__PURE__ */ new Set();
 	const stats = accumulateReviewStats(scopedPriorState?.stats, options.stats);
-	for (const finding of options.findings) {
-		const id = selectFindingId({
+	const findings = options.findings.map((item) => item.finding);
+	const fingerprintCounts = countFindingFingerprints(options.findings);
+	for (const { finding, anchorFingerprint, issueFingerprint, previousPath } of options.findings) {
+		const record = buildFindingRecord({
 			finding,
-			findings: options.findings,
+			findings,
 			priorFindings,
-			usedPriorIds
+			usedPriorIds,
+			reviewedHeadSha: options.reviewedHeadSha,
+			anchorFingerprint,
+			issueFingerprint,
+			previousPath,
+			fingerprintCounts
 		});
-		const prior = priorFindings.get(id);
-		if (prior) usedPriorIds.add(prior.id);
-		const record = {
-			id,
-			status: "open",
-			path: finding.path,
-			rangeId: finding.rangeId,
-			side: finding.side,
-			startLine: finding.startLine,
-			endLine: finding.endLine,
-			firstSeenHeadSha: prior?.firstSeenHeadSha ?? options.reviewedHeadSha,
-			lastSeenHeadSha: options.reviewedHeadSha,
-			...prior?.lastCommentedHeadSha ? { lastCommentedHeadSha: prior.lastCommentedHeadSha } : {}
-		};
-		nextFindings.set(id, record);
-	}
-	for (const prior of priorFindings.values()) {
-		if (nextFindings.has(prior.id)) continue;
-		nextFindings.set(prior.id, prior);
+		nextFindings.set(record.id, record);
 	}
+	addHistoricalFindings(nextFindings, priorFindings.values());
 	return {
 		version: 1,
 		reviewedHeadSha: options.reviewedHeadSha,
@@ -4504,6 +4637,57 @@ function buildPriorReviewState(options) {
 		...stats ? { stats } : {}
 	};
 }
+function buildFindingRecord(options) {
+	const selection = selectPriorFindingRecord(options);
+	const prior = options.priorFindings.get(selection.id);
+	markPriorFindingUsed(options.usedPriorIds, prior);
+	return {
+		id: selection.id,
+		...findingIdentity(options.anchorFingerprint, options.issueFingerprint),
+		status: selection.status,
+		path: options.finding.path,
+		rangeId: options.finding.rangeId,
+		side: options.finding.side,
+		startLine: options.finding.startLine,
+		endLine: options.finding.endLine,
+		...findingHistory(prior, options.reviewedHeadSha)
+	};
+}
+function selectPriorFindingRecord(options) {
+	const resolvedMatch = matchResolvedFindingRecord([...options.priorFindings.values()], options.finding, options.anchorFingerprint, options.issueFingerprint, options.fingerprintCounts, options.previousPath);
+	if (resolvedMatch) return {
+		id: resolvedMatch.id,
+		status: "resolved"
+	};
+	return {
+		id: selectFindingId({
+			finding: options.finding,
+			findings: options.findings,
+			priorFindings: options.priorFindings,
+			usedPriorIds: options.usedPriorIds
+		}),
+		status: "open"
+	};
+}
+function markPriorFindingUsed(usedPriorIds, prior) {
+	if (prior) usedPriorIds.add(prior.id);
+}
+function findingIdentity(anchorFingerprint, issueFingerprint) {
+	return {
+		...anchorFingerprint ? { anchorFingerprint } : {},
+		...issueFingerprint ? { issueFingerprint } : {}
+	};
+}
+function findingHistory(prior, reviewedHeadSha) {
+	return {
+		firstSeenHeadSha: prior?.firstSeenHeadSha ?? reviewedHeadSha,
+		lastSeenHeadSha: reviewedHeadSha,
+		...prior?.lastCommentedHeadSha ? { lastCommentedHeadSha: prior.lastCommentedHeadSha } : {}
+	};
+}
+function addHistoricalFindings(findings, historicalFindings) {
+	for (const finding of historicalFindings) if (!findings.has(finding.id)) findings.set(finding.id, finding);
+}
 function resolvePriorFindings(state, findingIds) {
 	const resolved = new Set(findingIds);
 	return {
@@ -4523,6 +4707,22 @@ function matchFindingRecord(state, finding) {
 	if (deterministic) return deterministic;
 	return findOpenOverlappingFinding(state.findings, finding);
 }
+function matchResolvedFindingRecord(records, finding, anchorFingerprint, issueFingerprint, currentFingerprintCounts, previousPath) {
+	if (!anchorFingerprint || !issueFingerprint || (currentFingerprintCounts?.get(findingFingerprintKey(finding.path, anchorFingerprint, issueFingerprint)) ?? 1) !== 1) return;
+	const candidates = records.filter((record) => record.anchorFingerprint === anchorFingerprint && record.issueFingerprint === issueFingerprint && (record.path === finding.path || record.path === previousPath));
+	return candidates.length === 1 && candidates[0]?.status === "resolved" ? candidates[0] : void 0;
+}
+function countFindingFingerprints(findings) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const { finding, anchorFingerprint, issueFingerprint } of findings) if (anchorFingerprint && issueFingerprint) {
+		const key = findingFingerprintKey(finding.path, anchorFingerprint, issueFingerprint);
+		counts.set(key, (counts.get(key) ?? 0) + 1);
+	}
+	return counts;
+}
+function findingFingerprintKey(path, anchorFingerprint, issueFingerprint) {
+	return `${path}\0${anchorFingerprint}\0${issueFingerprint}`;
+}
 function renderMainCommentMarker(options) {
 	return `<!-- ${options.marker} change=${options.changeNumber} version=1 state=${encodeReviewState({
 		...options.reviewState,
@@ -4587,6 +4787,20 @@ function applyResolvedFindingMarkers(state, commentBodies) {
 		}))
 	};
 }
+function applyNativeThreadResolutions(state, resolutions) {
+	const resolutionByFinding = new Map(resolutions.map((resolution) => [`${resolution.findingId}:${resolution.findingHeadSha}`, resolution.resolved]));
+	return {
+		...state,
+		findings: state.findings.map((finding) => {
+			if (!finding.lastCommentedHeadSha) return finding;
+			const resolved = resolutionByFinding.get(`${finding.id}:${finding.lastCommentedHeadSha}`);
+			return resolved === void 0 ? finding : {
+				...finding,
+				status: resolved ? "resolved" : "open"
+			};
+		})
+	};
+}
 function extractVerifierResponseMarkers(commentBodies) {
 	return new Set(extractMarkerRecords(commentBodies, verifierResponseMarkerPrefix).map((record) => record.marker));
 }
@@ -4782,7 +4996,7 @@ function publicationPlanForHostCapabilities(plan, capabilities) {
 }
 function buildPublicationPlan(options) {
 	const reviewState = options.reviewState ?? buildPriorReviewState({
-		findings: options.inlineItems.map((item) => item.finding),
+		findings: options.inlineItems.map((item) => ({ finding: item.finding })),
 		reviewedHeadSha: options.metadata.reviewedHeadSha,
 		selectedTasks: options.metadata.selectedTasks
 	});
@@ -4827,10 +5041,12 @@ function preparePublishableInlineFindings(options) {
 }
 function prepareInlinePublicationItemsForPublishableFindings(options) {
 	const seenFindingIds = /* @__PURE__ */ new Set();
-	return inlinePublicationItemsSchema.parse(options.publishableFindings.flatMap(({ finding: publishableFinding, range, previousPath }) => {
+	const fingerprintCounts = countFindingFingerprints(options.publishableFindings);
+	return inlinePublicationItemsSchema.parse(options.publishableFindings.flatMap(({ finding: publishableFinding, range, previousPath, anchorFingerprint, issueFingerprint }) => {
 		const findingId = findingIdFor(publishableFinding, options.reviewState);
 		const stateRecord = options.reviewState ? matchFindingRecord(options.reviewState, publishableFinding) : void 0;
-		if (seenFindingIds.has(findingId) || stateRecord?.lastCommentedHeadSha === options.reviewedHeadSha) return [];
+		const resolvedRecord = options.reviewState ? matchResolvedFindingRecord(options.reviewState.findings, publishableFinding, anchorFingerprint, issueFingerprint, fingerprintCounts, previousPath) : void 0;
+		if (seenFindingIds.has(findingId) || resolvedRecord !== void 0 || stateRecord?.lastCommentedHeadSha === options.reviewedHeadSha) return [];
 		seenFindingIds.add(findingId);
 		const marker = inlineFindingMarker(findingId, options.reviewedHeadSha);
 		return [inlinePublicationItemSchema.parse({
@@ -4977,10 +5193,17 @@ function buildCommentPublishingPlan(options) {
 	const publishableInlineFindings = preparePublishableInlineFindings({
 		validated: options.validated,
 		manifest: options.manifest
+	}).map((item) => {
+		const fingerprint = selectedCodeFingerprint(item.finding, item.range);
+		return fingerprint ? {
+			...item,
+			anchorFingerprint: fingerprint,
+			issueFingerprint: findingIssueFingerprint(item.finding)
+		} : item;
 	});
 	const reviewState = buildPriorReviewState({
 		priorState: options.priorReviewState,
-		findings: publishableInlineFindings.map((item) => item.finding),
+		findings: publishableInlineFindings,
 		reviewedHeadSha: options.event.change.head.sha,
 		selectedTasks: options.metadata.selectedTasks,
 		stats: options.metadata.stats
@@ -5011,6 +5234,20 @@ function buildCommentPublishingPlan(options) {
 		inlineCommentDrafts: publicationPlan.inlineItems
 	};
 }
+function selectedCodeFingerprint(finding, range) {
+	if (range.preview === void 0) return;
+	const lines = range.preview.replaceAll("\r\n", "\n").replaceAll("\r", "\n").split("\n");
+	const startOffset = finding.startLine - range.startLine;
+	const endOffset = finding.endLine - range.startLine + 1;
+	if (startOffset < 0 || endOffset > lines.length) return;
+	const selected = lines.slice(startOffset, endOffset).map((line) => line.trimEnd()).join("\n");
+	return new Bun.CryptoHasher("sha256").update(selected).digest("hex");
+}
+function findingIssueFingerprint(finding) {
+	const identity = finding.body.normalize("NFKC").toLowerCase().replace(/<[^>]*>/g, " ").replace(/\[([^\]]+)\]\([^)]*\)/g, "$1").replace(/[^\p{L}\p{N}_]+/gu, " ").trim().replace(/\s+/g, " ") || finding.body.normalize("NFKC").toLowerCase().trim();
+	if (!identity) return;
+	return new Bun.CryptoHasher("sha256").update(identity).digest("hex");
+}
 //#endregion
 //#region src/review/publication-redaction.ts
 function redactReviewPublication(options) {
@@ -6417,8 +6654,17 @@ async function loadAzureDevOpsPriorReviewState(options) {
 	const state = extractPriorReviewState(await loadAzureDevOpsPriorMainComment(options), options.change.change.number);
 	if (!state) return void 0;
 	const owner = await authenticatedAzureOwner(options.client);
-	const bodies = ownedThreadComments(await options.client.listThreads(azureCoordinates$1(options.change).repositoryId, options.change.change.number), owner.uniqueName).map((comment) => comment.content);
-	return applyResolvedFindingMarkers(applyInlineFindingMarkers(state, bodies), bodies);
+	const threads = await options.client.listThreads(azureCoordinates$1(options.change).repositoryId, options.change.change.number);
+	const bodies = ownedThreadComments(threads, owner.uniqueName).map((comment) => comment.content);
+	return applyNativeThreadResolutions(applyResolvedFindingMarkers(applyInlineFindingMarkers(state, bodies), bodies), threads.flatMap((thread) => {
+		const root = thread.comments[0];
+		const marker = root ? extractInlineFindingMarkerRecords([root.content])[0] : void 0;
+		return root && marker && root.author?.uniqueName === owner.uniqueName ? [{
+			findingId: marker.id,
+			findingHeadSha: marker.head,
+			resolved: isResolved(thread)
+		}] : [];
+	}));
 }
 async function loadAzureDevOpsPriorMainComment(options) {
 	const owner = await authenticatedAzureOwner(options.client);
@@ -7027,7 +7273,14 @@ async function loadBitbucketPriorReviewState(options) {
 	const state = extractPriorReviewState(body ? normalizeBitbucketMarkdown(body) : void 0, options.change.change.number);
 	if (!state) return void 0;
 	const bodies = comments.map((comment) => normalizeBitbucketMarkdown(comment.content.raw));
-	return applyResolvedFindingMarkers(applyInlineFindingMarkers(state, bodies), bodies);
+	return applyNativeThreadResolutions(applyResolvedFindingMarkers(applyInlineFindingMarkers(state, bodies), bodies), comments.flatMap((comment) => {
+		const marker = !comment.parent ? extractInlineFindingMarkerRecords([normalizeBitbucketMarkdown(comment.content.raw)])[0] : void 0;
+		return marker ? [{
+			findingId: marker.id,
+			findingHeadSha: marker.head,
+			resolved: comment.resolution !== void 0
+		}] : [];
+	}));
 }
 async function loadBitbucketPriorMainComment(options) {
 	const body = (await loadBitbucketOwnedComments(options)).find((comment) => normalizeBitbucketMarkdown(comment.content.raw).includes(mainMarker$1(options.change.change.number)))?.content.raw;
@@ -7893,23 +8146,20 @@ async function loadGitHubPriorReviewState(options) {
 		ownerLogin
 	}), options.change.change.number);
 	if (!state) return;
-	const inlineBodies = (await options.client.listReviewComments({
-		repo: options.change.repository.slug,
-		pullRequestNumber: options.change.change.number
-	})).filter((comment) => comment.authorLogin === ownerLogin).map((comment) => comment.body ?? "");
-	return applyResolvedFindingMarkers(applyInlineFindingMarkers(state, inlineBodies), inlineBodies);
+	const { ownerComments, threadByCommentId } = await loadOwnedReviewThreads(options, ownerLogin);
+	const inlineBodies = ownerComments.map((comment) => comment.body ?? "");
+	return applyNativeThreadResolutions(applyResolvedFindingMarkers(applyInlineFindingMarkers(state, inlineBodies), inlineBodies), ownerComments.flatMap((comment) => {
+		const marker = extractInlineFindingMarkerRecords([comment.body ?? ""])[0];
+		const thread = threadByCommentId.get(comment.id);
+		return marker && thread ? [{
+			findingId: marker.id,
+			findingHeadSha: marker.head,
+			resolved: thread.isResolved
+		}] : [];
+	}));
 }
 async function loadGitHubInlineThreadContexts(options) {
-	const ownerLogin = await options.client.getAuthenticatedUserLogin();
-	const comments = await options.client.listReviewComments({
-		repo: options.change.repository.slug,
-		pullRequestNumber: options.change.change.number
-	});
-	const ownerComments = comments.filter((comment) => comment.authorLogin === ownerLogin);
-	const threadByCommentId = reviewThreadByCommentId(await options.client.listReviewThreads({
-		repo: options.change.repository.slug,
-		pullRequestNumber: options.change.change.number
-	}));
+	const { comments, ownerComments, threadByCommentId } = await loadOwnedReviewThreads(options, await options.client.getAuthenticatedUserLogin());
 	const commentById = new Map(comments.map((comment) => [comment.id, comment]));
 	return ownerComments.flatMap((comment) => {
 		const marker = extractInlineFindingMarkerRecords([comment.body ?? ""])[0];
@@ -7933,6 +8183,19 @@ async function loadGitHubInlineThreadContexts(options) {
 		}];
 	});
 }
+async function loadOwnedReviewThreads(options, ownerLogin) {
+	const coordinates = {
+		repo: options.change.repository.slug,
+		pullRequestNumber: options.change.change.number
+	};
+	const comments = await options.client.listReviewComments(coordinates);
+	const threads = await options.client.listReviewThreads(coordinates);
+	return {
+		comments,
+		ownerComments: comments.filter((comment) => comment.authorLogin === ownerLogin),
+		threadByCommentId: reviewThreadByCommentId(threads)
+	};
+}
 async function loadGitHubPriorMainComment(options) {
 	const ownerLogin = options.ownerLogin ?? await options.client.getAuthenticatedUserLogin();
 	return findMainComment(await options.client.listIssueComments({
@@ -8723,8 +8986,17 @@ async function loadGitLabPriorReviewState(options) {
 	const state = extractPriorReviewState(await loadGitLabPriorMainComment(options), options.change.change.number);
 	if (!state) return void 0;
 	const owner = await options.client.currentUser();
-	const bodies = discussionNotes(await options.client.listDiscussions(gitLabCoordinates$1(options.change).projectId, options.change.change.number)).filter((note) => note.author?.username === owner.username).map((note) => note.body);
-	return applyResolvedFindingMarkers(applyInlineFindingMarkers(state, bodies), bodies);
+	const discussions = await options.client.listDiscussions(gitLabCoordinates$1(options.change).projectId, options.change.change.number);
+	const bodies = discussionNotes(discussions).filter((note) => note.author?.username === owner.username).map((note) => note.body);
+	return applyNativeThreadResolutions(applyResolvedFindingMarkers(applyInlineFindingMarkers(state, bodies), bodies), discussions.flatMap((discussion) => {
+		const root = discussion.notes[0];
+		const marker = root ? extractInlineFindingMarkerRecords([root.body])[0] : void 0;
+		return root && marker && root.author?.username === owner.username ? [{
+			findingId: marker.id,
+			findingHeadSha: marker.head,
+			resolved: root.resolved ?? false
+		}] : [];
+	}));
 }
 async function loadGitLabPriorMainComment(options) {
 	const owner = await options.client.currentUser();
@@ -9982,4 +10254,4 @@ async function runHostRunCommandWithDependencies(options) {
 //#endregion
 export { piReadOnlyToolNames as _, runInspectCommand as a, createGitHubHostAdapter as c, createGitLabClient as d, createBitbucketClient as f, piBuiltinToolNames as g, supportedOfficialInitAdapters as h, runInitCommand as i, PublicationError as l, azureOrganizationFromUrl as m, runHostRunCommand as n, runLocalReviewCommand as o, createAzureDevOpsClient as p, runHostRunCommandWithDependencies as r, runValidateCommand as s, runDryRunCommand as t, createKnownSecretRedactor as u, piRequiredCliFlags as v, piThinkingLevels as y };
 
-//# sourceMappingURL=commands-46Q2ZDt0.mjs.map
+//# sourceMappingURL=commands-EZV-Icbs.mjs.map