@jphutchins/code-review 0.1.0-alpha.46 → 0.1.0-alpha.48

package/dist/index.js

@@ -33,6 +33,7 @@ var LineNumber = t.refinement(
 var Confidence = t.refinement(t.number, (n) => n >= 0 && n <= 1, "Confidence");
 var Likelihood = t.refinement(t.number, (n) => n >= 0 && n <= 1, "Likelihood");
 var FiniteNumber = t.refinement(t.number, (n) => Number.isFinite(n), "FiniteNumber");
+var NonNegativePrice = t.refinement(t.number, (n) => n >= 0, "NonNegativePrice");
 var SCHEMA_VERSION_RE = /^(0|[1-9]\d*)\.(\d+)\.(\d+)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
 var SchemaVersion = t.refinement(
   t.string,
@@ -170,6 +171,15 @@ var ConvergenceStrict = t.refinement(
   "ConvergenceStrict"
 );
 var ConvergenceCodec = t.exact(ConvergenceStrict);
+var LineDelta = t.refinement(
+  t.number,
+  (n) => Number.isInteger(n) && n >= 0,
+  "LineDelta"
+);
+var ChangeLinesCodec = t.exact(t.type({ added: LineDelta, removed: LineDelta }));
+var ChangeSizeCodec = t.exact(
+  t.partial({ code: ChangeLinesCodec, tests: ChangeLinesCodec, docs: ChangeLinesCodec })
+);
 var FindingsCodec = t.exact(
   t.intersection([
     t.type({
@@ -183,10 +193,20 @@ var FindingsCodec = t.exact(
       // Pipeline-stamped only (issue #150); see ScopeMetastasisCodec.
       scope_metastasis: ScopeMetastasisCodec,
       // Pipeline-stamped only (issue #174); see ConvergenceCodec.
-      convergence: ConvergenceCodec
+      convergence: ConvergenceCodec,
+      // Agent-written best-effort (issue #182); see ChangeSizeCodec.
+      change_size: ChangeSizeCodec
     })
   ])
 );
+var PIPELINE_STAMPED_FIELDS = /* @__PURE__ */ new Set([
+  "convergence",
+  "scope_metastasis"
+]);
+var RECOVERABLE_OPTIONAL_FIELDS = /* @__PURE__ */ new Set([
+  ...PIPELINE_STAMPED_FIELDS,
+  "change_size"
+]);
 var TriageCodec = t.type({
   safe: t.boolean,
   reasons: t.string
@@ -219,6 +239,11 @@ var ResultEnvelopeCodec = t.intersection([
     vendor_cost_usd: t.union([t.number, t.null]),
     route: t.string,
     effort: t.string,
+    // The ISO-8601 UTC instant the run completed (stamped by `adapt` when it built this envelope, issue
+    // #170). Cost recomputation prices a time-slotted model at THIS instant, so the same envelope prices
+    // to the same slot deterministically wherever it is re-rendered — not at each command's wall clock.
+    // Absent on a pre-#170 envelope (cost then falls back to the caller's instant).
+    generated_at: t.string,
     // The run produced a notice rather than a completed review (security-gate block, agent kill, no
     // recoverable findings). An empty `findings` array alone can't say this — a genuine clean review
     // is also empty — so the render suppresses "clean review" and the sticky precedence guard refuses
@@ -226,12 +251,44 @@ var ResultEnvelopeCodec = t.intersection([
     incomplete: t.boolean
   })
 ]);
-var ModelPricesCodec = t.type({
-  in: t.number,
-  out: t.number,
-  cache_read: t.number,
-  cache_write: t.number
+var FlatModelPricesShape = t.type({
+  in: NonNegativePrice,
+  out: NonNegativePrice,
+  cache_read: NonNegativePrice,
+  cache_write: NonNegativePrice
 });
+var FLAT_PRICE_KEYS = new Set(Object.keys(FlatModelPricesShape.props));
+var FlatModelPricesStrict = t.refinement(
+  FlatModelPricesShape,
+  (p) => Object.keys(p).every((k) => FLAT_PRICE_KEYS.has(k)),
+  "FlatModelPricesStrict"
+);
+var FlatModelPricesCodec = t.exact(FlatModelPricesStrict);
+var UTC_HHMM_RE = /^([01][0-9]|2[0-3]):[0-5][0-9]$/;
+var UtcHHMM = t.refinement(t.string, (s) => UTC_HHMM_RE.test(s), "UtcHHMM");
+var PriceSlotShape = t.intersection([
+  t.type({ utc_from: UtcHHMM, utc_to: UtcHHMM }),
+  FlatModelPricesShape
+]);
+var PRICE_SLOT_KEYS = /* @__PURE__ */ new Set(["utc_from", "utc_to", ...Object.keys(FlatModelPricesShape.props)]);
+var PriceSlotStrict = t.refinement(
+  PriceSlotShape,
+  (s) => Object.keys(s).every((k) => PRICE_SLOT_KEYS.has(k)),
+  "PriceSlotStrict"
+);
+var PriceSlotCodec = t.exact(PriceSlotStrict);
+var NonEmptyPriceSlots = t.refinement(
+  t.array(PriceSlotCodec),
+  (a) => a.length >= 1,
+  "NonEmptyPriceSlots"
+);
+var SlottedModelPricesStrict = t.refinement(
+  t.type({ slots: NonEmptyPriceSlots }),
+  (s) => Object.keys(s).every((k) => k === "slots"),
+  "SlottedModelPricesStrict"
+);
+var SlottedModelPricesCodec = t.exact(SlottedModelPricesStrict);
+var ModelPricesCodec = t.union([FlatModelPricesCodec, SlottedModelPricesCodec]);
 var PriceMapCodec = t.type({
   _updated: t.string,
   _unit: t.string,
@@ -265,35 +322,64 @@ var defaultWarn = (message) => {
   process.stderr.write(`${message}
 `);
 };
-var computeModelCost = (entry, prices, warn) => {
-  const p = prices.models[entry.model];
-  const cacheRead = entry.cache_read_tokens ?? 0;
-  const cacheWrite = entry.cache_write_tokens ?? 0;
-  if (!p) {
+var parseInstant = (iso) => {
+  if (iso === void 0) return void 0;
+  if (iso.includes("T") && !/(Z|[+-]\d{2}:?\d{2})$/.test(iso)) return void 0;
+  const d = new Date(iso);
+  return Number.isNaN(d.getTime()) ? void 0 : d;
+};
+var utcMinuteOfDay = (at) => at.getUTCHours() * 60 + at.getUTCMinutes();
+var hhmmToMinutes = (hhmm) => {
+  const [h, m] = hhmm.split(":");
+  return Number(h) * 60 + Number(m);
+};
+var hhmmOf = (minute) => `${String(Math.floor(minute / 60)).padStart(2, "0")}:${String(minute % 60).padStart(2, "0")}`;
+var slotCovers = (slot, minute) => {
+  const from = hhmmToMinutes(slot.utc_from);
+  const to = hhmmToMinutes(slot.utc_to);
+  return from < to ? minute >= from && minute < to : minute >= from || minute < to;
+};
+var resolveFlatPrices = (model, p, pricedAt, warn) => {
+  if (!("slots" in p)) return p;
+  if (pricedAt === void 0) {
     warn(
-      `code-review cost: unknown model "${entry.model}" \u2014 no entry in price map; cost for this model set to $0`
+      `code-review cost: model "${model}" has time-slotted prices but no run instant was supplied to select a slot; cost for this model set to $0`
     );
-    return {
-      model: entry.model,
-      inputTokens: entry.input_tokens,
-      outputTokens: entry.output_tokens,
-      cacheReadTokens: cacheRead,
-      cacheWriteTokens: cacheWrite,
-      costUSD: 0
-    };
+    return null;
   }
-  const costUSD = (entry.input_tokens * p.in + entry.output_tokens * p.out + cacheRead * p.cache_read + cacheWrite * p.cache_write) / 1e6;
-  return {
+  const minute = utcMinuteOfDay(pricedAt);
+  const covering = p.slots.filter((s) => slotCovers(s, minute));
+  if (covering.length === 1) return covering[0] ?? null;
+  warn(
+    `code-review cost: model "${model}" \u2014 ${String(covering.length)} price slots cover ${hhmmOf(minute)} UTC (expected exactly 1); a model's slots must partition the 24h day with no gap or overlap; cost for this model set to $0`
+  );
+  return null;
+};
+var computeModelCost = (entry, prices, pricedAt, warn) => {
+  const p = prices.models[entry.model];
+  const cacheRead = entry.cache_read_tokens ?? 0;
+  const cacheWrite = entry.cache_write_tokens ?? 0;
+  const zero = {
     model: entry.model,
     inputTokens: entry.input_tokens,
     outputTokens: entry.output_tokens,
     cacheReadTokens: cacheRead,
     cacheWriteTokens: cacheWrite,
-    costUSD
+    costUSD: 0
   };
+  if (!p) {
+    warn(
+      `code-review cost: unknown model "${entry.model}" \u2014 no entry in price map; cost for this model set to $0`
+    );
+    return zero;
+  }
+  const rate = resolveFlatPrices(entry.model, p, pricedAt, warn);
+  if (rate === null) return zero;
+  const costUSD = (entry.input_tokens * rate.in + entry.output_tokens * rate.out + cacheRead * rate.cache_read + cacheWrite * rate.cache_write) / 1e6;
+  return { ...zero, costUSD };
 };
-var computeCost = (models, prices, warn = defaultWarn) => {
-  const lines = models.map((entry) => computeModelCost(entry, prices, warn));
+var computeCost = (models, prices, pricedAt, warn = defaultWarn) => {
+  const lines = models.map((entry) => computeModelCost(entry, prices, pricedAt, warn));
   return {
     lines,
     totalInputTokens: lines.reduce((s, l) => s + l.inputTokens, 0),
@@ -477,13 +563,7 @@ var normalizeCodeCounts = (codes, priorCodes) => {
   if (typeof codes !== "object" || codes === null || Array.isArray(codes)) return void 0;
   const entries = Object.entries(codes).filter(
     (e) => typeof e[1] === "number" && Number.isSafeInteger(e[1]) && e[1] > 0
-  ).sort((a, b) => {
-    if (b[1] !== a[1]) return b[1] - a[1];
-    const aPrior = hasCode(priorCodes, a[0]) ? 1 : 0;
-    const bPrior = hasCode(priorCodes, b[0]) ? 1 : 0;
-    if (aPrior !== bPrior) return bPrior - aPrior;
-    return a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0;
-  });
+  );
   if (entries.length === 0) return void 0;
   const sorted = entries.sort((a, b) => {
     if (b[1] !== a[1]) return b[1] - a[1];
@@ -666,6 +746,23 @@ var priorBelowFloorNits = (priorDoc, floor = DEFAULT_NIT_VISIBILITY_FLOOR) => {
 };
 var convergenceBadge = (c) => c.converged ? `**Convergence** \u{1F3C1} ${formatScore(c.score)} \u2264 ${String(c.threshold)} \u2014 converged` : `**Convergence** \u{1F504} ${formatScore(c.score)} > ${String(c.threshold)} \u2014 iterating`;
 var convergenceSummary = (doc, threshold = DEFAULT_CONVERGENCE_THRESHOLD) => convergenceBadge(convergenceSignal(doc, threshold));
+var changeSizeSummary = (changeSize) => {
+  if (changeSize === void 0) return "";
+  const cell = (label, d) => d === void 0 ? null : `+${String(d.added)} / \u2212${String(d.removed)} ${label}`;
+  return [
+    cell("code", changeSize.code),
+    cell("tests", changeSize.tests),
+    cell("docs", changeSize.docs)
+  ].filter((c) => c !== null).join(" \xB7 ");
+};
+var nextRoundNumber = (priorTraj, priorConvRounds) => {
+  const last = (rounds) => rounds.length > 0 ? rounds[rounds.length - 1]?.round ?? rounds.length : 0;
+  return Math.max(last(priorTraj), last(priorConvRounds)) + 1;
+};
+var inProgressConvergence = (prior, runningRound) => {
+  const rounds = prior.rounds ?? [];
+  return rounds.length === 0 ? "" : `${roundsSummary(rounds, runningRound)} \u2192 \u23F3`;
+};
 var SURFACE_SCHEMA_VERSION = "0.8.0";
 var convergenceSignal = (doc, threshold = DEFAULT_CONVERGENCE_THRESHOLD) => {
   const score = convergenceScore(doc, threshold);
@@ -1131,7 +1228,8 @@ var render = (input) => {
   const usageAvailable = input.envelope !== null;
   const hasUsage = input.envelope !== null && input.envelope.models.length > 0;
   const incomplete = (input.incomplete ?? input.envelope?.incomplete ?? false) || isIncompleteFindings(input.findings);
-  const costReport = input.envelope ? computeCost(input.envelope.models, input.prices) : null;
+  const pricedAt = parseInstant(input.envelope?.generated_at) ?? input.pricedAt;
+  const costReport = input.envelope ? computeCost(input.envelope.models, input.prices, pricedAt) : null;
   const pricesProvided = input.pricesProvided ?? true;
   const route = input.route ?? input.envelope?.route ?? null;
   const effort = input.effort ?? input.envelope?.effort ?? null;
@@ -1154,6 +1252,10 @@ var render = (input) => {
     effort,
     modelNames,
     testReport: input.testReport ?? null,
+    // The agent's best-effort role split (issue #182) and the pipeline's deterministic cloc table; both
+    // chrome, gated to a completed review by the template's !incomplete block.
+    changeSummary: changeSizeSummary(input.findings.change_size),
+    clocDiff: input.clocDiff !== void 0 ? escapeFence(input.clocDiff) : null,
     reviewedSha: input.reviewedSha ?? "0000000000000000000000000000000000000000",
     postedAt: input.postedAt ?? "",
     severityCounts,
@@ -1170,7 +1272,6 @@ var render = (input) => {
     // (issue #174) — no separate signal or rounds marker rides beside it. post always supplies the
     // precomputed marker; the standalone `render` command falls back to encoding the doc here.
     findingsPointer: input.findingsPointer ?? findingsPointer(input.findings, input.jsonUrl),
-    roundsMarker: "",
     roundsSummary: roundsSummary(trajectory, input.roundCount),
     metastasisNote: advisoryAllowed ? metastasisNote(trajectory) : "",
     sameRootNotes: advisoryAllowed ? sameRootNotes : {},
@@ -1777,11 +1878,24 @@ var triageTable = [
 ];
 var pricesTable = [
   {
+    // Retained non-latest so `validate`/`print-schema --schema-version 0.1` still resolves (the
+    // keep-old-minors convention the findings table follows). The price map carries no version signal,
+    // and the schema is a single unversioned file, so both entries point at it; the codec's oneOf
+    // accepts a flat 0.1-era map unchanged.
     minor: "0.1",
     defaultVersion: "0.1.0",
     schemaFile: "prices.schema.json",
     codec: PriceMapCodec,
     normalize: identity,
+    latest: false
+  },
+  {
+    // v0.2.0 (issue #170): a model's value gained the time-slotted alternative (flat | { slots }).
+    minor: "0.2",
+    defaultVersion: "0.2.0",
+    schemaFile: "prices.schema.json",
+    codec: PriceMapCodec,
+    normalize: identity,
     latest: true
   }
 ];
@@ -1826,7 +1940,8 @@ var resolveFindings = (raw) => {
   return decoded._tag === "Left" ? { kind: "invalid-shape", errors: formatErrors(decoded.left) } : { kind: "ok", version, value: entry.normalize(decoded.right) };
 };
 var resolveSingleVersion = (kind, raw) => {
-  const entry = tableFor(kind)[0];
+  const table = tableFor(kind);
+  const entry = table.find((e) => e.latest) ?? table[0];
   if (!entry) throw new Error(`Registry invariant violated \u2014 no entry for "${kind}"`);
   const decoded = entry.codec.decode(raw);
   return decoded._tag === "Left" ? { kind: "invalid-shape", errors: formatErrors(decoded.left) } : { kind: "ok", version: entry.defaultVersion, value: entry.normalize(decoded.right) };
@@ -2055,7 +2170,6 @@ var checkLongSuggestions = (comments) => {
   });
   return { comments: adjusted, longFiles };
 };
-var PIPELINE_STAMPED_FIELDS = /* @__PURE__ */ new Set(["convergence", "scope_metastasis"]);
 var decodeFindings = (doc) => {
   const resolution = resolve("findings", doc);
   switch (resolution.kind) {
@@ -2076,14 +2190,14 @@ var loadFindings = (path) => {
     return { kind: "corrupt" };
   }
   const first = decodeFindings(raw);
-  if (first.kind === "invalid-shape" && typeof raw === "object" && raw !== null && !Array.isArray(raw) && Object.keys(raw).some((k) => PIPELINE_STAMPED_FIELDS.has(k))) {
+  if (first.kind === "invalid-shape" && typeof raw === "object" && raw !== null && !Array.isArray(raw) && Object.keys(raw).some((k) => RECOVERABLE_OPTIONAL_FIELDS.has(k))) {
     const stripped = Object.fromEntries(
-      Object.entries(raw).filter(([key2]) => !PIPELINE_STAMPED_FIELDS.has(key2))
+      Object.entries(raw).filter(([key2]) => !RECOVERABLE_OPTIONAL_FIELDS.has(key2))
     );
     const retry = decodeFindings(stripped);
     if (retry.kind === "ok") {
       process.stderr.write(
-        "Warning: the review draft carried an invalid pipeline-stamped field (convergence/scope_metastasis) \u2014 stripped it and used the rest; the pipeline re-stamps convergence\n"
+        "Warning: the review draft carried an invalid best-effort field (convergence/scope_metastasis/change_size) \u2014 stripped it and used the rest; the pipeline re-stamps convergence\n"
       );
       return retry;
     }
@@ -2133,6 +2247,19 @@ var loadTestReport = (path) => {
   }
   return decoded.right;
 };
+var loadClocDiff = (path) => {
+  let raw;
+  try {
+    raw = readFileSync(path, "utf-8");
+  } catch (err) {
+    process.stderr.write(
+      `Warning: could not read cloc diff at ${path}: ${errMsg(err)} \u2014 omitting the cloc collapsible
+`
+    );
+    return void 0;
+  }
+  return raw.trim() === "" ? void 0 : raw;
+};
 var parseHtmlUrl = (raw) => {
   const parsed = tryParseJson(raw);
   const htmlUrl = parsed.ok ? asRecord(parsed.value)?.["html_url"] : void 0;
@@ -2378,8 +2505,7 @@ var post = async (input, ghApi = runGhApi) => {
   const priorBody = existingSticky?.body ?? "";
   const priorTraj = priorTrajectory(priorDoc, priorBody);
   const priorConv = carriedConvergence(priorDoc, priorBody);
-  const lastRound = (rounds) => rounds.length > 0 ? rounds[rounds.length - 1]?.round ?? rounds.length : 0;
-  const priorRoundCount = Math.max(lastRound(priorTraj), lastRound(priorConv?.rounds ?? []));
+  const priorRoundCount = nextRoundNumber(priorTraj, priorConv?.rounds ?? []) - 1;
   const stampConvergence = (doc, conv) => ({
     ...doc,
     convergence: conv ?? void 0
@@ -2511,6 +2637,7 @@ ${dropNote}` : ""}`,
   const answeredDropNote = answeredReRaiseNote(verbatimReRaised, droppedCount) + (verbatimReRaised.length > 0 && findings.findings.length === 0 ? "\n> _The stop signal reflects the kept findings \u2014 this round carries none._" : "");
   const envelope = loadEnvelope(input.envelopePath);
   const testReport = input.testReportPath ? loadTestReport(input.testReportPath) : void 0;
+  const clocDiff = input.clocDiffPath ? loadClocDiff(input.clocDiffPath) : void 0;
   const effectiveRoute = input.route ?? envelope?.route;
   if (envelope === null) {
     const envelopelessIncomplete = isIncompleteFindings(findings);
@@ -2548,6 +2675,7 @@ ${dropNote}` : ""}`,
         roundCount: priorRoundCount,
         convergenceRound: false,
         testReport,
+        clocDiff,
         inlineDisposition: { kind: "no-envelope" },
         runUrl: input.runUrl,
         jsonUrl: input.jsonUrl,
@@ -2626,6 +2754,7 @@ ${dropNote}` : ""}`,
     reviewedSha: input.headSha,
     effort: input.effort,
     testReport,
+    clocDiff,
     severityCounts: currentCounts,
     sameRootNotes,
     answeredNotes: reRaisedNotes,
@@ -2639,7 +2768,8 @@ ${dropNote}` : ""}`,
     runUrl: input.runUrl,
     jsonUrl: input.jsonUrl,
     findingsPointer: findingsMarker,
-    postedAt: input.postedAt
+    postedAt: input.postedAt,
+    pricedAt: input.pricedAt
   };
   const longFilesNote = longFiles.length > 0 ? `
 
@@ -2724,12 +2854,22 @@ var bodyRefsRun = (body, runUrl) => {
   const runId = runIdFromUrl(runUrl);
   return runId === null ? body.includes(runUrl) : new RegExp(`/actions/runs/${runId}(?!\\d)`).test(body);
 };
-var announceBody = (headSha, runUrl, existingBody) => noticeBody(
-  `${DEFAULT_MARKER}
+var announceBody = (headSha, runUrl, existingBody) => {
+  const priorDoc = existingBody !== void 0 ? parseFindingsMarker(existingBody) : null;
+  const prior = existingBody !== void 0 ? carriedConvergence(priorDoc, existingBody) : null;
+  const progress = prior !== null ? inProgressConvergence(
+    prior,
+    nextRoundNumber(priorTrajectory(priorDoc, existingBody ?? ""), prior.rounds ?? [])
+  ) : "";
+  return noticeBody(
+    `${DEFAULT_MARKER}
 
-\u{1F504} **Code review in progress** for \`${headSha.slice(0, 7)}\` \u2014 see the [workflow run](${runUrl}) for progress; this comment is updated with the review when it completes.`,
-  existingBody
-);
+\u{1F504} **Code review in progress** for \`${headSha.slice(0, 7)}\` \u2014 see the [workflow run](${runUrl}) for progress; this comment is updated with the review when it completes.${progress ? `
+
+${progress}` : ""}`,
+    existingBody
+  );
+};
 var announce = async (input, ghApi = runGhApi) => {
   const candidates = await fetchPrCandidates(input.repo, input.headSha, ghApi);
   const resolution = resolvePr(candidates, input.headBranch);
@@ -3074,6 +3214,7 @@ var renderOutputs = (result) => {
 conclusion=${result.conclusion}
 diff_size=${String(result.diffSize)}
 stacked=${String(result.stacked)}
+base_sha=${result.baseSha}
 `;
   }
 };
@@ -3343,7 +3484,8 @@ var gather = async (input, ghApi = runGhApi, gitRun = runGit) => {
     pr: prNumber,
     conclusion: input.conclusion,
     diffSize: Buffer.byteLength(prDiff, "utf8"),
-    stacked
+    stacked,
+    baseSha: meta.base_sha
   };
 };
 
@@ -3576,10 +3718,16 @@ var nativeTelemetry = (native, meta) => resolveTelemetry(
 );
 var absentTelemetry = (meta) => resolveTelemetry({ models: [], turns: 0, durationMs: 0, vendorCostUsd: null }, meta);
 var buildEnvelope = (telemetry, native, agentFilePath, agentFileFallbackPath, seedUnrevised) => {
+  const generated_at = (/* @__PURE__ */ new Date()).toISOString();
   const outcome = findingsOutcome(native, agentFilePath, agentFileFallbackPath);
   switch (outcome.kind) {
     case "ok":
-      return { schema_version: outcome.version, findings: outcome.findings, ...telemetry };
+      return {
+        schema_version: outcome.version,
+        findings: outcome.findings,
+        generated_at,
+        ...telemetry
+      };
     case "telemetry-only": {
       const reason = seedUnrevised ? "the review agent did not write a review (its draft is still the pre-seeded sentinel)" : outcome.reason;
       return {
@@ -3588,6 +3736,7 @@ var buildEnvelope = (telemetry, native, agentFilePath, agentFileFallbackPath, se
 
 ${reason}`),
         incomplete: true,
+        generated_at,
         ...telemetry
       };
     }
@@ -3792,6 +3941,7 @@ var resolvePrices = (pricesArg) => {
   return { kind: "absent", path: bundledPath("schema", "prices.example.json") };
 };
 var TEST_REPORT_DESCRIPTION = 'Path to a JSON test summary: {"passed": number, "failed": number, "total": number, "failures"?: [{"name": string, "message"?: string}]}';
+var CLOC_DIFF_DESCRIPTION = "Path to a raw `cloc --git --diff <base> <head>` table, rendered verbatim in the sticky's cloc collapsible. Best-effort: an absent, unreadable, or empty file omits the collapsible.";
 var CONVERGENCE_THRESHOLD_DESCRIPTION = "Advisory convergence tolerance: the per-finding convergence score (each finding's severity floor + confidence-and-likelihood-weighted headroom; ceilings critical 4 \xB7 major 2 \xB7 minor 1 \xB7 nit 0) at or below which the sticky reads as converged. The floor values and the systemic-likelihood rule are documented in the README and the findings schema (default: 1)";
 var NIT_VISIBILITY_FLOOR_DESCRIPTION = "Nit visibility floor: nits whose confidence \xD7 likelihood falls below this are hidden from humans (no inline comment; a collapsed aside in the sticky) but kept in the machine blob as adjudicated. In [0, 1] (default: 0.25)";
 var renderCmd = defineCommand({
@@ -3834,6 +3984,10 @@ var renderCmd = defineCommand({
       type: "string",
       description: TEST_REPORT_DESCRIPTION
     },
+    "cloc-diff": {
+      type: "string",
+      description: CLOC_DIFF_DESCRIPTION
+    },
     "convergence-threshold": {
       type: "string",
       description: CONVERGENCE_THRESHOLD_DESCRIPTION
@@ -3851,6 +4005,7 @@ var renderCmd = defineCommand({
     const prices = decode(PriceMapCodec.decode(readJSON(priceResolution.path)), "prices");
     const template = readFileSync(templatePath, "utf-8");
     const testReport = args["test-report"] ? decode(TestSummaryCodec.decode(readJSON(args["test-report"])), "test report") : void 0;
+    const clocDiff = args["cloc-diff"] ? loadClocDiff(args["cloc-diff"]) : void 0;
     const route = args.route || envelope.route || null;
     const isRound = isConvergenceRound(route, envelope.incomplete === true || isIncompleteFindings(findings)) && isReviewVerdict(findings.verdict);
     const threshold = parseConvergenceThreshold(args["convergence-threshold"]);
@@ -3868,10 +4023,12 @@ var renderCmd = defineCommand({
       route: args.route,
       effort: args.effort,
       testReport,
+      clocDiff,
       convergenceThreshold: threshold,
       nitVisibilityFloor: parseNitVisibilityFloor(args["nit-visibility-floor"]),
       convergenceRound: isRound,
-      postedAt: formatUtc(/* @__PURE__ */ new Date())
+      postedAt: formatUtc(/* @__PURE__ */ new Date()),
+      pricedAt: /* @__PURE__ */ new Date()
     });
     process.stdout.write(output2);
   }
@@ -3936,7 +4093,11 @@ var costCmd = defineCommand({
   run: async ({ args }) => {
     const envelope = decode(ResultEnvelopeCodec.decode(readJSON(args.envelope)), "envelope");
     const prices = decode(PriceMapCodec.decode(readJSON(args.prices)), "prices");
-    const report = computeCost(envelope.models, prices);
+    const report = computeCost(
+      envelope.models,
+      prices,
+      parseInstant(envelope.generated_at) ?? /* @__PURE__ */ new Date()
+    );
     process.stdout.write(JSON.stringify(report, null, 2));
   }
 });
@@ -3967,7 +4128,11 @@ var checkCostCmd = defineCommand({
     const usage = sumTranscriptUsage(tree.entries);
     const priceResolution = resolvePrices(args.prices);
     const prices = decode(PriceMapCodec.decode(readJSON(priceResolution.path)), "prices");
-    const report = computeCost(usage.models, prices);
+    const report = computeCost(
+      usage.models,
+      prices,
+      usage.lastTsMs !== null ? new Date(usage.lastTsMs) : /* @__PURE__ */ new Date()
+    );
     process.stdout.write(
       `${JSON.stringify(
         {
@@ -4111,7 +4276,17 @@ var budgetHookCmd = defineCommand({
       const tree = transcriptPath ? readTranscriptTree(resolve$1(transcriptPath)) : void 0;
       const usage = tree ? sumTranscriptUsage(tree.entries) : void 0;
       const prices = args.prices ? tryReadPrices(args.prices) : null;
-      const spentUsd = prices !== null && usage ? computeCost(usage.models, prices).totalCostUSD : null;
+      const spentUsd = prices !== null && usage ? (
+        // Price at the transcript's last activity instant, not the wall clock (issue #170 review
+        // r2). Silent warn: this budget-steering cost is recomputed on EVERY tool event, so a
+        // misconfigured slot map would otherwise flood stderr; the final post's cost render warns.
+        computeCost(
+          usage.models,
+          prices,
+          usage.lastTsMs !== null ? new Date(usage.lastTsMs) : /* @__PURE__ */ new Date(),
+          () => void 0
+        ).totalCostUSD
+      ) : null;
       const wallMs = args.wall ? parseWallMs(args.wall) : null;
       const output2 = evaluateBudgetHook(input, {
         spentUsd,
@@ -4312,7 +4487,6 @@ ${printableSchema(schemaPath)}
   }
 });
 var isSurfaceStampedDoc = (doc) => typeof doc === "object" && doc !== null && !Array.isArray(doc) && doc["schema_version"] === SURFACE_SCHEMA_VERSION;
-var PIPELINE_STAMPED_FIELDS2 = /* @__PURE__ */ new Set(["scope_metastasis", "convergence"]);
 var withoutScopeMetastasis = (doc) => typeof doc === "object" && doc !== null && !Array.isArray(doc) ? Object.fromEntries(Object.entries(doc).filter(([key2]) => key2 !== "scope_metastasis")) : doc;
 var seedDraftCmd = defineCommand({
   meta: {
@@ -4457,12 +4631,12 @@ var seedDraftCmd = defineCommand({
         const schemaPath = args.schema ? resolve$1(args.schema) : schemaPathFor(kind, args["schema-version"]);
         const barePrior = typeof priorFindings === "object" && !Array.isArray(priorFindings) ? Object.fromEntries(
           Object.entries(priorFindings).filter(
-            ([key2]) => !PIPELINE_STAMPED_FIELDS2.has(key2)
+            ([key2]) => !RECOVERABLE_OPTIONAL_FIELDS.has(key2)
           )
         ) : priorFindings;
         const accepts = (doc) => validateAgainstSchema(doc, schemaPath).valid && resolve("findings", doc).kind === "ok";
         const seedDoc = accepts(priorFindings) ? priorFindings : accepts(barePrior) ? (process.stderr.write(
-          `Note: the in-force schema rejects the carried scope_metastasis entry \u2014 seeding the prior without it (issue #150 review r2)
+          `Note: the in-force schema rejects a carried recoverable field (scope_metastasis/convergence/change_size) \u2014 seeding the prior without it (issue #150 review r2 / #182 review r2)
 `
         ), barePrior) : null;
         if (seedDoc === null) return false;
@@ -4951,6 +5125,10 @@ var postCmd = defineCommand({
       type: "string",
       description: TEST_REPORT_DESCRIPTION
     },
+    "cloc-diff": {
+      type: "string",
+      description: CLOC_DIFF_DESCRIPTION
+    },
     "run-url": {
       type: "string",
       description: "Workflow run URL (transcript/traces), rendered as a link in the LLM Disclosure aside"
@@ -4984,11 +5162,13 @@ var postCmd = defineCommand({
       headBranch: args["head-branch"],
       effort: args.effort,
       testReportPath: args["test-report"],
+      clocDiffPath: args["cloc-diff"],
       runUrl: args["run-url"],
       jsonUrl: args["json-url"],
       convergenceThreshold: parseConvergenceThreshold(args["convergence-threshold"]),
       nitVisibilityFloor: parseNitVisibilityFloor(args["nit-visibility-floor"]),
-      postedAt: formatUtc(/* @__PURE__ */ new Date())
+      postedAt: formatUtc(/* @__PURE__ */ new Date()),
+      pricedAt: /* @__PURE__ */ new Date()
     });
   }
 });