@pmelab/gtd 49.0.0 → 50.0.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "gtd",
-  "version": "49.0.0",
+  "version": "50.0.0",
   "description": "Drive the gtd loop inside Claude Code: agent turns run as subagents, gtd decides every beat",
   "author": {
     "name": "Philipp Melab"

package/README.md

@@ -538,32 +538,37 @@ noted in steps 3 and 4 below.
    commit) and what was **dropped as noise**. A review with a chunk pointing at
    no code, or a note left out, is refused (`review-pointers`). A pointer note
    the reviewer opens with `Risk:` is fixed before you see the review
-   (`build.review.fix.risks.fixing`), then the review is written again. On
-   `refactor-first` the refactor slice gets a review of its own first, composed
-   by gtd from its lap's notes, before the feature is built; see
-   [the naive pass](#the-naive-pass). **Every note needs exactly one tick before
-   `gtd land` accepts the review** (`answer-completeness`; an open `- H:` thread
-   waiting on the agent is the one exception). Fix as suggested joins the nit
-   batch below, unjudged; won't fix drops the note and records it as
-   `Gtd-Mark: wontfix=<title>` on the gate's commit; your own answer is judged
-   like a note. A note you answered is left out of the fresh review after a nit
-   fix. Land with every note answered and nothing else changed to approve, or
-   write what is wrong — disagreeing with a fix or a drop means writing a note
-   of your own. Approving ends the process (at the refactor review, it moves on
-   to the feature); feedback is judged note by note, each as `edit`, `question`,
-   `nit` or `praise`. An `edit` sends the process back to step 2 for re-derived
-   requirements — the built criteria keep their IDs (reworded in place when
-   their behaviour changes) and new behaviour gets new ones — then the
-   implementation is amended to meet them, with no new naive pass or seam judge,
-   every criterion's coverage is judged again, the quality lap runs, and you
-   review again. At the refactor review an `edit` re-derives the refactor
-   instead. A `question` is answered inline under your note and the process
-   stops at the review again — no new plan. A `nit` is fixed in one batch, the
-   suite must go green (a red one gets fix turns first), then a fresh review of
-   the change stops at the review again. `praise` is dropped; a round of only
-   praise signs off. When a round mixes them, questions are answered and nits
-   fixed first, then the edits are planned — risk: the planning lap may redo nit
-   fixes it touches.
+   (`build.review.fix.risks.fixing`), then the review is written again. **What
+   matters most comes first:** a judge (`build.review.ranking`) rates every
+   chunk on the four severity questions below, and the review lists `critical`
+   chunks first (security, then one-way doors), then `should`, then `could`,
+   each led by its tier and reason (`_critical: security, one-way door_`) — the
+   phone shows it on the chunk's card. A chunk the judge is unsure of, or whose
+   evidence the budget cut, is `critical`. On `refactor-first` the refactor
+   slice gets a review of its own first, composed by gtd from its lap's notes,
+   before the feature is built; see [the naive pass](#the-naive-pass). **Every
+   note needs exactly one tick before `gtd land` accepts the review**
+   (`answer-completeness`; an open `- H:` thread waiting on the agent is the one
+   exception). Fix as suggested joins the nit batch below, unjudged; won't fix
+   drops the note and records it as `Gtd-Mark: wontfix=<title>` on the gate's
+   commit; your own answer is judged like a note. A note you answered is left
+   out of the fresh review after a nit fix. Land with every note answered and
+   nothing else changed to approve, or write what is wrong — disagreeing with a
+   fix or a drop means writing a note of your own. Approving ends the process
+   (at the refactor review, it moves on to the feature); feedback is judged note
+   by note, each as `edit`, `question`, `nit` or `praise`. An `edit` sends the
+   process back to step 2 for re-derived requirements — the built criteria keep
+   their IDs (reworded in place when their behaviour changes) and new behaviour
+   gets new ones — then the implementation is amended to meet them, with no new
+   naive pass or seam judge, every criterion's coverage is judged again, the
+   quality lap runs, and you review again. At the refactor review an `edit`
+   re-derives the refactor instead. A `question` is answered inline under your
+   note and the process stops at the review again — no new plan. A `nit` is
+   fixed in one batch, the suite must go green (a red one gets fix turns first),
+   then a fresh review of the change stops at the review again. `praise` is
+   dropped; a round of only praise signs off. When a round mixes them, questions
+   are answered and nits fixed first, then the edits are planned — risk: the
+   planning lap may redo nit fixes it touches.
 
    Each `edit` note also gets a severity tier from four judge questions
    (security, reversibility, blast radius, new concept). Every tier is

package/dist/chunks/{reserved-CYZ1bSBy.mjs → reserved-CdOzKFVX.mjs}

@@ -1,5 +1,5 @@
 import { accessFor, agent, answered, changesSince, check, codeThreads, defineWorkflow, displayPath, env, head, human, judge, mark, numeric, quote, read, refuse, scope, skillsFor, start, vars } from "../flows.mjs";
-import { d as ANSWER_FIX, f as ANSWER_LEAD, m as reviewChunks, p as ANSWER_WONT_FIX, y as FREE_TEXT_PLACEHOLDER } from "./steering-BXwjmocB.mjs";
+import { b as FREE_TEXT_PLACEHOLDER, d as ANSWER_FIX, f as ANSWER_LEAD, m as reviewChunks, p as ANSWER_WONT_FIX, v as severityLine } from "./steering-DtUVUz9l.mjs";
 import { gate as gate$1, healthy as healthy$1, lensScopes, lensesOf, removedAssertions } from "../workflow-kit.mjs";
 import { c as String$, g as standardSchemaV1, h as optionalWith, l as Struct, n as Boolean$, s as Number$ } from "./Schema-C6fLlQzx.mjs";
 //#region src/workflows/shared/registry.ts
@@ -641,6 +641,56 @@ const withWalkthrough = (review, report) => {
 	const body = lines.join("\n").trimEnd();
 	return summary.length === 0 ? `${body}\n` : `${body}\n\n${summary.join("\n\n")}\n`;
 };
+const chunkBlocks = (review) => {
+	const lines = review.split("\n");
+	const chunks = reviewChunks(review);
+	return {
+		head: lines.slice(0, chunks[0]?.line ?? lines.length),
+		blocks: chunks.map((c, i) => ({
+			title: c.title,
+			lines: lines.slice(c.line, chunks[i + 1]?.line ?? lines.length)
+		}))
+	};
+};
+const isBlank = (line) => line !== void 0 && line.trim() === "";
+/** \`review\` with every chunk's severity line removed, so a re-review is ranked afresh. */
+const unranked = (review) => {
+	const drop = new Set(reviewChunks(review).flatMap((c) => c.severityLine ?? []));
+	if (drop.size === 0) return review;
+	const lines = review.split("\n");
+	return lines.filter((_, i) => !drop.has(i) && !(drop.has(i - 1) && isBlank(lines[i]))).join("\n");
+};
+const chunkTexts = (review) => new Map(chunkBlocks(review).blocks.map((b) => [b.title, b.lines.join("\n").trim()]));
+const trimBlankLines = (lines) => {
+	let start = 0;
+	let end = lines.length;
+	while (start < end && isBlank(lines[start])) start++;
+	while (end > start && isBlank(lines[end - 1])) end--;
+	return lines.slice(start, end);
+};
+/**
+* \`review\` with the \`ranked\` chunks first, in their order, each led by its
+* severity line; every other chunk follows in place.
+*/
+const rankedReview = (review, ranked) => {
+	const { head, blocks } = chunkBlocks(review);
+	const place = new Map(ranked.map((r, k) => [r.title, k]));
+	const labels = new Map(ranked.map((r) => [r.title, r.label]));
+	const order = (i) => place.get(blocks[i].title) ?? ranked.length;
+	const chunk = (i) => {
+		const { title, lines } = blocks[i];
+		const label = labels.get(title);
+		const heading = /^ {0,3}-+\s*$/.test(lines[1] ?? "") ? 2 : 1;
+		const body = trimBlankLines(lines.slice(heading)).join("\n");
+		return [
+			lines.slice(0, heading).join("\n"),
+			...label === void 0 ? [] : [severityLine(label)],
+			...body === "" ? [] : [body]
+		].join("\n\n");
+	};
+	const sorted = blocks.map((_, i) => i).sort((x, y) => order(x) - order(y) || x - y);
+	return `${[head.join("\n").trim(), ...sorted.map(chunk)].filter((p) => p !== "").join("\n\n")}\n`;
+};
 /**
 * \`.gtd/REVIEW.md\` as gtd writes it: one chunk per note, each ending in its
 * answer boxes, then the fixed and noise lists. Chunk titles are made unique —
@@ -1195,6 +1245,13 @@ const wrapItem = (item) => {
 	} else line = line === "" ? word : `${line} ${word}`;
 	return [...out, line];
 };
+const reviewRankingMessage = () => `Ranking each chunk of the review before the human reads it. Run
+\`gtd judge answer\` and pipe, per chunk \`C<n>\`: \`C<n>.security\`
+(yes/no), \`C<n>.reversibility\` (one-way/two-way),
+\`C<n>.blastRadius\` (local/module/contract) and \`C<n>.newConcept\`
+(yes/no) — or land without a verdict, which lists every chunk as
+critical.
+`;
 const buildReviewTriageMessage = () => `Judging each note the human added to \`.gtd/REVIEW.md\` (a line note, a
 footnote, or prose under a chunk) with one verdict: \`edit\` (a change
 request), \`question\`, \`nit\` (a small fix needing no re-plan) or
@@ -2074,4 +2131,4 @@ const steering = {
 	[REVIEW]: "review"
 };
 //#endregion
-export { naivePassPrompt as $, reviewQuality as A, conflictBody as At, coverageQuestion as B, flipProblems as Bt, collecting as C, walkthroughBlock as Ct, fixRisks as D, envDefaults as Dt, fixQuality as E, defaults as Et, builderSystem as F, parseStandards as Ft, designTriagePrompt as G, criterionLine as H, requireFlag as Ht, clearCriteriaMessage as I, renderStandards as It, handOffAwaitReviewMessage as J, finisherSystem as K, clearCriteriaQuestion as L, standardKey as Lt, agentWithSkills as M, conflictTitle as Mt, buildReviewCollectingPrompt as N, isConflictTitle as Nt, planner as O, testFileGlobs as Ot, buildReviewTriageMessage as P, oneLine as Pt, naiveApplyFailure as Q, composedReview as R, flagMentions as Rt, coder as S, unwindFailure as St, fixNits as T, withWalkthrough as Tt, designGateAnswerMessage as U, coveringPrompt as V, registryEntry as Vt, designSystem as W, implementBuildingPrompt as X, idleMessage as Y, implementFixPrompt as Z, REQUIREMENTS as _, slicingPrompt as _t, flagModeOn as a, refactorDroppedRefusal as at, answerReviewQuestions as b, uncoveredMessage as bt, baseline as c, refactorRules as ct, healthy as d, reviewFeedbackFixPrompt as dt, normaliseCriteriaScript as et, FEEDBACK as f, reviewGateBlockedMessage as ft, REFACTOR_NOTE as g, seamSteerMessage as gt, REFACTOR as h, seamByHandMessage as ht, skills as i, refactorBuildingPrompt as it, reviewing as j, conflictFor as jt, reviewMissing as k, STANDARDS as kt, gate as l, reviewEditNotesCapture as lt, QUALITY as m, reviewerSystem as mt, summary as n, qualityFindingsFile as nt, flagShipped as o, refactorFixPrompt as ot, HANDOFF as p, reviewNotesCapture as pt, fixReviewNotesPrompt as q, access as r, qualityTriageMessage as rt, shipped as s, refactorNotePrompt as st, steering as t, oversizedMessage as tt, guarded as u, reviewEditsCapture as ut, REVIEW as v, startGateBlockedMessage as vt, fixCheck as w, withLapFindings as wt, awaitReview as x, unwindFailedMessage as xt, SLICES as y, titledNotes as yt, coverageMessage as z, flagReferences as zt };
+export { naiveApplyFailure as $, reviewQuality as A, defaults as At, coverageMessage as B, renderStandards as Bt, collecting as C, uncoveredMessage as Ct, fixRisks as D, walkthroughBlock as Dt, fixQuality as E, unwindFailure as Et, builderSystem as F, conflictFor as Ft, designSystem as G, registryEntry as Gt, coveringPrompt as H, flagMentions as Ht, chunkTexts as I, conflictTitle as It, fixReviewNotesPrompt as J, designTriagePrompt as K, requireFlag as Kt, clearCriteriaMessage as L, isConflictTitle as Lt, agentWithSkills as M, testFileGlobs as Mt, buildReviewCollectingPrompt as N, STANDARDS as Nt, planner as O, withLapFindings as Ot, buildReviewTriageMessage as P, conflictBody as Pt, implementFixPrompt as Q, clearCriteriaQuestion as R, oneLine as Rt, coder as S, titledNotes as St, fixNits as T, unwindFailedMessage as Tt, criterionLine as U, flagReferences as Ut, coverageQuestion as V, standardKey as Vt, designGateAnswerMessage as W, flipProblems as Wt, idleMessage as X, handOffAwaitReviewMessage as Y, implementBuildingPrompt as Z, REQUIREMENTS as _, reviewerSystem as _t, flagModeOn as a, rankedReview as at, answerReviewQuestions as b, slicingPrompt as bt, baseline as c, refactorFixPrompt as ct, healthy as d, reviewEditNotesCapture as dt, naivePassPrompt as et, FEEDBACK as f, reviewEditsCapture as ft, REFACTOR_NOTE as g, reviewRankingMessage as gt, REFACTOR as h, reviewNotesCapture as ht, skills as i, qualityTriageMessage as it, reviewing as j, envDefaults as jt, reviewMissing as k, withWalkthrough as kt, gate as l, refactorNotePrompt as lt, QUALITY as m, reviewGateBlockedMessage as mt, summary as n, oversizedMessage as nt, flagShipped as o, refactorBuildingPrompt as ot, HANDOFF as p, reviewFeedbackFixPrompt as pt, finisherSystem as q, access as r, qualityFindingsFile as rt, shipped as s, refactorDroppedRefusal as st, steering as t, normaliseCriteriaScript as tt, guarded as u, refactorRules as ut, REVIEW as v, seamByHandMessage as vt, fixCheck as w, unranked as wt, awaitReview as x, startGateBlockedMessage as xt, SLICES as y, seamSteerMessage as yt, composedReview as z, parseStandards as zt };

package/dist/chunks/{review-BewyJflS.mjs → review-BChXEl2Y.mjs}

@@ -1,8 +1,8 @@
 import { answered, changesSince, head, judge, numeric, read, refuse, requireRevert, restoreScript, run, showScript, vars, writeScript } from "../flows.mjs";
-import { _ as reviewRisks, m as reviewChunks } from "./steering-BXwjmocB.mjs";
+import { _ as reviewRisks, m as reviewChunks } from "./steering-DtUVUz9l.mjs";
 import { removedAssertions, review } from "../workflow-kit.mjs";
-import { At as conflictBody, C as collecting, Ct as walkthroughBlock, D as fixRisks, Ft as parseStandards, It as renderStandards, Lt as standardKey, Mt as conflictTitle, Nt as isConflictTitle, P as buildReviewTriageMessage, Pt as oneLine, R as composedReview, T as fixNits, Tt as withWalkthrough, b as answerReviewQuestions, d as healthy, j as reviewing, jt as conflictFor, k as reviewMissing, kt as STANDARDS, lt as reviewEditNotesCapture, pt as reviewNotesCapture, u as guarded, ut as reviewEditsCapture, v as REVIEW, w as fixCheck, x as awaitReview, yt as titledNotes } from "./reserved-CYZ1bSBy.mjs";
-import { i as isOptionalObject, n as closeReview, o as tail, s as NO_FINDINGS } from "./tail-C1Oi2YEy.mjs";
+import { Bt as renderStandards, C as collecting, D as fixRisks, Dt as walkthroughBlock, Ft as conflictFor, I as chunkTexts, It as conflictTitle, Lt as isConflictTitle, Nt as STANDARDS, P as buildReviewTriageMessage, Pt as conflictBody, Rt as oneLine, St as titledNotes, T as fixNits, Vt as standardKey, at as rankedReview, b as answerReviewQuestions, d as healthy, dt as reviewEditNotesCapture, ft as reviewEditsCapture, gt as reviewRankingMessage, ht as reviewNotesCapture, j as reviewing, k as reviewMissing, kt as withWalkthrough, u as guarded, v as REVIEW, w as fixCheck, wt as unranked, x as awaitReview, z as composedReview, zt as parseStandards } from "./reserved-CdOzKFVX.mjs";
+import { i as isOptionalObject, n as closeReview, o as tail, s as NO_FINDINGS } from "./tail-DRM2eC1z.mjs";
 //#region src/workflows/shared/learn.ts
 const SUMMARY_MAX = 200;
 const BANNER = /^_(?:The fixer left this unresolved\.|A fix turn removed this while renaming another finding — check whether it was fixed\.|No detail given\.)_\s*/;
@@ -205,7 +205,8 @@ const severityOf = (note, judgment, minP) => {
 	if (critical.length > 0) return {
 		tier: "critical",
 		reason: `critical: ${critical.join(", ")}`,
-		rank: rank()
+		rank: rank(),
+		...a("security") === "yes" ? { security: true } : {}
 	};
 	const should = [...a("blastRadius") === "contract" ? ["contract"] : [], ...a("newConcept") === "yes" ? ["new concept"] : []];
 	if (should.length > 0) return {
@@ -219,29 +220,30 @@ const severityOf = (note, judgment, minP) => {
 		rank: 2
 	};
 };
-const severityQuestions = (note) => [
+/** `asks` names the change in full, `change` refers back to it. */
+const severityQuestions = (id, asks, change) => [
 	{
-		id: `${note.id}.security`,
+		id: `${id}.security`,
 		primitive: "noul",
-		instructions: `Does the change the human asks for in note "${note.id}" (on "${note.anchor}") touch security — authentication, authorisation, secrets, untrusted input or data exposure?`,
+		instructions: `Does ${asks} touch security — authentication, authorisation, secrets, untrusted input or data exposure?`,
 		criteria: "yes: it changes or could weaken a security property. no: it does not."
 	},
 	{
-		id: `${note.id}.reversibility`,
+		id: `${id}.reversibility`,
 		primitive: "choice",
-		instructions: `Once the change in note "${note.id}" ships, can it be undone without breaking anyone who already depends on it?`,
+		instructions: `Once ${change} ships, can it be undone without breaking anyone who already depends on it?`,
 		criteria: "one-way: a published API, file format, persisted data, protocol or other contract that cannot be taken back. two-way: can be reverted freely."
 	},
 	{
-		id: `${note.id}.blastRadius`,
+		id: `${id}.blastRadius`,
 		primitive: "choice",
-		instructions: `How far does the change in note "${note.id}" reach?`,
+		instructions: `How far does ${change} reach?`,
 		criteria: "local: one function or file. module: a whole module or several files. contract: a public interface other code or users depend on."
 	},
 	{
-		id: `${note.id}.newConcept`,
+		id: `${id}.newConcept`,
 		primitive: "noul",
-		instructions: `Does the change in note "${note.id}" introduce a concept new to this codebase — a new abstraction, entity or term? Judge from the evidence, never a glossary; reusing or extending an existing concept is not new.`,
+		instructions: `Does ${change} introduce a concept new to this codebase — a new abstraction, entity or term? Judge from the evidence, never a glossary; reusing or extending an existing concept is not new.`,
 		criteria: "yes: a genuinely new concept. no: reuses or extends an existing one."
 	}
 ];
@@ -258,7 +260,7 @@ const triage = (severities) => async (notes) => {
 		answers: {},
 		truncated: []
 	} : await judge("review.triage", {
-		questions: asked.flatMap((n) => [verdictQuestion(n), ...severityQuestions(n)]),
+		questions: asked.flatMap((n) => [verdictQuestion(n), ...severityQuestions(n.id, `the change the human asks for in note "${n.id}" (on "${n.anchor}")`, `the change in note "${n.id}"`)]),
 		evidence: Object.fromEntries(asked.map((n) => [n.id, `Anchor: ${n.anchor}\nReviewer's text: ${n.before}\nHuman's text: ${n.text}`])),
 		message: buildReviewTriageMessage(),
 		label: "Judging each note"
@@ -274,6 +276,67 @@ const triage = (severities) => async (notes) => {
 		return [n.id, "edit"];
 	}));
 };
+/** Review order: security, one-way doors, the judge unsure, then should, then could. */
+const chunkKey = (s) => s.tier === "could" ? 4 : s.tier === "should" ? 3 : s.security === true ? 0 : s.rank === 0 ? 1 : 2;
+/** A chunk's text, then the code each of its pointers covers: a bare path the whole file. */
+const chunkEvidence = (text, files) => [text, ...files.map(({ path, line, rangeEnd }) => {
+	const where = `${path}${line === void 0 ? "" : `#${line}${rangeEnd === void 0 ? "" : `-${rangeEnd}`}`}`;
+	const lines = read(path.replace(/^\.\//, ""))?.split("\n");
+	if (lines === void 0) return `${where}: no longer exists`;
+	return `${where}:\n${(line === void 0 ? lines : lines.slice(line - 1, rangeEnd ?? line)).join("\n")}`;
+})].join("\n\n");
+const bytes = (text) => new TextEncoder().encode(text).length;
+/** Fills each batch while the budget's even share still holds its widest evidence, so nothing is cut that fits alone. */
+const batched = (items, budget) => {
+	const batches = [];
+	let batch = [];
+	let widest = 0;
+	for (const item of items) {
+		const size = bytes(item.evidence);
+		if (batch.length > 0 && Math.floor(budget / (batch.length + 1)) < Math.max(widest, size)) {
+			batches.push(batch);
+			batch = [];
+			widest = 0;
+		}
+		batch.push(item);
+		widest = Math.max(widest, size);
+	}
+	return batch.length === 0 ? batches : [...batches, batch];
+};
+/**
+* Rates every chunk the reviewer wrote — a walkthrough chunk or a carried
+* finding — and sorts \`full\` by it, each chunk led by its tier and reason.
+* gtd's summary chunks are not rated and stay last.
+*/
+const ranked = async (review, full) => {
+	const texts = chunkTexts(full);
+	const chunks = reviewChunks(review).map((c, i) => ({
+		id: `C${i + 1}`,
+		title: c.title,
+		evidence: chunkEvidence(texts.get(c.title) ?? "", c.files)
+	}));
+	if (chunks.length === 0) return full;
+	const minP = numeric(vars.reviewSeverityMinP, Infinity);
+	const batches = batched(chunks, numeric(vars.judgeBudgetBytes, 32768));
+	const severities = /* @__PURE__ */ new Map();
+	for (const [i, batch] of batches.entries()) {
+		const judgment = await judge("review.ranking", {
+			questions: batch.flatMap((c) => severityQuestions(c.id, `the change review chunk "${c.id}" ("${c.title}") walks through`, `the change in review chunk "${c.id}"`)),
+			evidence: Object.fromEntries(batch.map((c) => [c.id, c.evidence])),
+			message: reviewRankingMessage(),
+			label: batches.length === 1 ? "Ranking the review" : `Ranking the review (${i + 1}/${batches.length})`
+		});
+		for (const c of batch) severities.set(c.id, severityOf(c, judgment, minP));
+	}
+	return rankedReview(full, chunks.map((c, i) => ({
+		c,
+		i,
+		s: severities.get(c.id)
+	})).sort((x, y) => chunkKey(x.s) - chunkKey(y.s) || x.i - y.i).map(({ c, s }) => ({
+		title: c.title,
+		label: s.reason
+	})));
+};
 const isCode = (path) => path !== ".gtd" && !path.startsWith(".gtd/");
 const composedOf = (base, report, nitFix, answered) => ({
 	...report,
@@ -325,12 +388,13 @@ const requirePointers = (review, notes, codeChanged) => {
 const walkthrough = async (base, report, lap, carry) => {
 	const notes = titledNotes(report);
 	await reviewing(base, carry, lap, walkthroughBlock(notes, report.nitFix));
-	const review = read(REVIEW);
-	if (review === void 0) return;
-	requirePointers(review, notes, changesSince(base).some((c) => isCode(c.path)));
-	const full = withWalkthrough(review, report);
-	if (full !== review) await run("review.carrying", writeScript(REVIEW, full), {
-		label: "Adding the quality lap's findings",
+	const written = read(REVIEW);
+	if (written === void 0) return;
+	const review = unranked(written);
+	requirePointers(written, notes, changesSince(base).some((c) => isCode(c.path)));
+	const full = await ranked(review, withWalkthrough(review, report));
+	if (full !== written) await run("review.carrying", writeScript(REVIEW, full), {
+		label: "Ordering the review and adding the quality lap's findings",
 		file: REVIEW,
 		base
 	});

package/dist/chunks/{steering-BXwjmocB.mjs → steering-DtUVUz9l.mjs}

@@ -15089,6 +15089,9 @@ const qaDescriptor = {
 const ANSWER_LEAD = "Tick exactly one:";
 const ANSWER_FIX = "fix as suggested";
 const ANSWER_WONT_FIX = "won't fix";
+/** A chunk's leading `_critical: security_` paragraph: the tier gtd ranked it with, and why. */
+const SEVERITY_LINE_RE = /^_((?:critical|should|could)(?::[^_\n]*)?)_$/;
+const severityLine = (label) => `_${label}_`;
 /**
 * The canonical sample. Every detail here is load-bearing for the formatter
 * round-trip: both footnote bodies exceed 80 characters so a reflow actually
@@ -15379,12 +15382,26 @@ const answerListOf = (content, body) => {
 		})
 	};
 };
+/** A leading severity line is the chunk's tier, never its prose. */
+const splitSeverity = (content, run) => {
+	const first = run[0];
+	const label = first?.type === "paragraph" ? SEVERITY_LINE_RE.exec(sourceText(content, first).trim())?.[1] : void 0;
+	if (label === void 0) return { leadingRun: run };
+	return {
+		severity: {
+			label,
+			line: toLspPosition(first.position.start).line
+		},
+		leadingRun: run.slice(1)
+	};
+};
 /** Splits one chunk's body nodes into its file pointers (hunk pointers are task items, collected recursively at ANY nesting depth via `taskItems` — a nested hunk is the same kind of hunk as a top-level one) and description prose. The description is the chunk's own leading run and never a node that contains a hunk pointer: it stops at the first node whose `taskItems` include a real pointer (at any depth — a blockquote wrapping a pointer list stops it just as a top-level list would). Every node kind in what's left before that point contributes — a `footnoteDefinition` is the one exception, excluded by `blockNodesOfRun` itself (it's a note, never document content). */
 const parseChunkBody = (content, lines, title, body) => {
 	const answer = answerListOf(content, body);
 	const isAnswer = (n) => answer !== void 0 && (n === answer.list || n === body[answer.lead]);
 	const firstPointerIndex = body.findIndex((n) => !isAnswer(n) && taskItems(n).some((item) => hasPointerToken(content, item)));
-	const leadingRun = (firstPointerIndex === -1 ? body : body.slice(0, firstPointerIndex)).filter((n) => !isAnswer(n));
+	const run = (firstPointerIndex === -1 ? body : body.slice(0, firstPointerIndex)).filter((n) => !isAnswer(n));
+	const { severity, leadingRun } = splitSeverity(content, run);
 	const descriptionNodes = blockNodesOfRun(content, leadingRun);
 	const descriptionInline = collapseImages(blockRunInline(content, leadingRun));
 	const description = leadingRun.filter((n) => n.type !== "footnoteDefinition").map((n) => sourceText(content, n)).join(" ").trim();
@@ -15403,6 +15420,7 @@ const parseChunkBody = (content, lines, title, body) => {
 		files,
 		errors,
 		...answer === void 0 ? {} : { answers: answer.options },
+		...severity === void 0 ? {} : { severity },
 		boxed: body.some((n) => !isAnswer(n) && taskItems(n).length > 0)
 	};
 };
@@ -15439,7 +15457,7 @@ const parseChangesets = (tree, content, lines) => {
 	const errors = [];
 	for (const { heading, headingLine, body } of splitChunks(tree)) {
 		const title = headingText$1(content, heading);
-		const { description, descriptionNodes, descriptionInline, files, answers, boxed, errors: bodyErrors } = parseChunkBody(content, lines, title, body);
+		const { description, descriptionNodes, descriptionInline, files, answers, severity, boxed, errors: bodyErrors } = parseChunkBody(content, lines, title, body);
 		errors.push(...bodyErrors);
 		if (files.length === 0 && boxed) errors.push({
 			message: `Chunk "${title}" has no file pointers`,
@@ -15453,7 +15471,8 @@ const parseChangesets = (tree, content, lines) => {
 			descriptionInline,
 			files,
 			headingLine,
-			...answers === void 0 ? {} : { answers }
+			...answers === void 0 ? {} : { answers },
+			...severity === void 0 ? {} : { severity }
 		});
 	}
 	if (changesets.length === 0) errors.push({ message: "REVIEW.md has no '##' chunks" });
@@ -15754,6 +15773,7 @@ const reviewView = (content) => {
 			detail: chunk.description,
 			detailInline: chunk.descriptionInline,
 			body: chunk.descriptionNodes,
+			...chunk.severity === void 0 ? {} : { status: chunk.severity.label },
 			anchor: {
 				kind: "chunk",
 				index: chunkIndex
@@ -15901,15 +15921,19 @@ const reviewDescriptor = {
 	openThreads: openThreadsOf
 };
 const pointerLabel = (f) => `${f.path}${f.line === void 0 ? "" : `#${f.line}${f.rangeEnd === void 0 ? "" : `-${f.rangeEnd}`}`}`;
-const chunkNote = (chunk, prior) => chunk.description === (prior?.description ?? "") || prior === void 0 && chunk.answers !== void 0 ? [] : [{
-	line: chunk.headingLine,
-	note: {
-		kind: "chunk",
-		anchor: chunk.title,
-		before: prior?.description ?? "",
-		text: chunk.description
-	}
-}];
+const chunkProse = (chunk, retiered) => [chunk?.description ?? "", retiered && chunk?.severity !== void 0 ? severityLine(chunk.severity.label) : ""].filter((p) => p !== "").join("\n\n");
+const chunkNote = (chunk, prior) => {
+	const retiered = chunk.severity !== void 0 && chunk.severity.label !== prior?.severity?.label;
+	return chunkProse(chunk, retiered) === chunkProse(prior, retiered) || prior === void 0 && chunk.answers !== void 0 ? [] : [{
+		line: chunk.headingLine,
+		note: {
+			kind: "chunk",
+			anchor: chunk.title,
+			before: chunkProse(prior, retiered),
+			text: chunkProse(chunk, retiered)
+		}
+	}];
+};
 const pointerNotes = (chunk, prior) => chunk.files.flatMap((file) => {
 	const label = pointerLabel(file);
 	const was = prior?.files.find((f) => pointerLabel(f) === label);
@@ -16023,7 +16047,13 @@ const reviewDecisions = (before, after) => {
 const reviewChunks = (content) => parseReviewDoc(content).changesets.map((c) => ({
 	title: c.title,
 	line: c.headingLine,
-	pointers: c.files.length
+	pointers: c.files.length,
+	...c.severity === void 0 ? {} : { severityLine: c.severity.line },
+	files: c.files.map((f) => ({
+		path: f.path,
+		...f.line === void 0 ? {} : { line: f.line },
+		...f.rangeEnd === void 0 ? {} : { rangeEnd: f.rangeEnd }
+	}))
 }));
 //#endregion
 //#region src/steering/Edits.ts
@@ -16393,4 +16423,4 @@ const viewOf = (format, content) => ({
 /** Every OPEN thread — last entry is the agent's — as `{ name, line, firstMe }` (0-based line). `[]` for a format with no thread concept. */
 const openThreads = (format, content) => format.openThreads?.(content) ?? [];
 //#endregion
-export { formatFinding as A, openThreadFindings as C, getParseCount as D, parseThreadsWithFindings as E, headingSectionBodies as O, THREAD_REPLY_ACTION_TITLE as S, parseThreads as T, reviewRisks as _, unansweredQuestions as a, isAnswered as b, stripCodeThreads as c, ANSWER_FIX as d, ANSWER_LEAD as f, reviewNotes as g, reviewDecisions as h, steeringFormatOrFreeForm as i, headingSections as k, freeFormFormat as l, reviewChunks as m, openThreads as n, viewOf as o, ANSWER_WONT_FIX as p, steeringFormatFor as r, parseCodeThreads as s, BUILT_IN_MODE_NAMES as t, applySteeringEdits as u, unansweredNotes as v, parseFootnotes as w, FOOTNOTE_ACTION_TITLE as x, FREE_TEXT_PLACEHOLDER as y };
+export { headingSections as A, THREAD_REPLY_ACTION_TITLE as C, parseThreadsWithFindings as D, parseThreads as E, getParseCount as O, FOOTNOTE_ACTION_TITLE as S, parseFootnotes as T, reviewRisks as _, unansweredQuestions as a, FREE_TEXT_PLACEHOLDER as b, stripCodeThreads as c, ANSWER_FIX as d, ANSWER_LEAD as f, reviewNotes as g, reviewDecisions as h, steeringFormatOrFreeForm as i, formatFinding as j, headingSectionBodies as k, freeFormFormat as l, reviewChunks as m, openThreads as n, viewOf as o, ANSWER_WONT_FIX as p, steeringFormatFor as r, parseCodeThreads as s, BUILT_IN_MODE_NAMES as t, applySteeringEdits as u, severityLine as v, openThreadFindings as w, isAnswered as x, unansweredNotes as y };

package/dist/chunks/{tail-C1Oi2YEy.mjs → tail-DRM2eC1z.mjs}

@@ -1,6 +1,6 @@
 import { answered, head, judge, mark, numeric, read, refuse, removeScript, run, scope, sectionBodies, showScript, vars, writeScript } from "../flows.mjs";
 import { lensEntriesOf, lensOf, qualityLap, reviewToHandOff } from "../workflow-kit.mjs";
-import { A as reviewQuality, D as fixRisks, E as fixQuality, J as handOffAwaitReviewMessage, d as healthy, j as reviewing, k as reviewMissing, m as QUALITY, nt as qualityFindingsFile, rt as qualityTriageMessage, u as guarded, v as REVIEW, w as fixCheck, wt as withLapFindings, x as awaitReview } from "./reserved-CYZ1bSBy.mjs";
+import { A as reviewQuality, D as fixRisks, E as fixQuality, Ot as withLapFindings, Y as handOffAwaitReviewMessage, d as healthy, it as qualityTriageMessage, j as reviewing, k as reviewMissing, m as QUALITY, rt as qualityFindingsFile, u as guarded, v as REVIEW, w as fixCheck, x as awaitReview } from "./reserved-CdOzKFVX.mjs";
 //#region src/workflows/shared/lenses.ts
 const NO_FINDINGS = {
 	notes: [],