@webpresso/agent-kit 3.1.30 → 3.2.0

package/dist/esm/status/snapshot.js

@@ -1,11 +1,13 @@
 import path from "node:path";
 import { z } from "zod";
 import { evaluateApprovalReviewers } from "#lifecycle/audit.js";
+import { collectV2ReviewProvenance } from "#lifecycle/review-provenance.js";
 import { evaluateRequiredChecks } from "#mcp/tools/_shared/required-checks.js";
 import { redactText } from "#mcp/tools/_shared/redact.js";
 import { runCommand } from "#mcp/tools/_shared/run-command.js";
 import { readReviewAuthorityAtRef } from "#review/authority.js";
 import { resolveBlueprintRoot } from "#utils/blueprint-root.js";
+import { parseBlueprintDocumentRelativePath } from "#utils/document-paths.js";
 export const statusLevelSchema = z.enum(["ready", "blocked", "partial", "unknown"]);
 export const requiredCheckEvaluationSchema = z.object({
     total: z.number().int().nonnegative(),
@@ -80,6 +82,11 @@ export const wpStatusSnapshotSchema = z.object({
 });
 const DEFAULT_TIMEOUT_MS = 30_000;
 const DEFAULT_MAX_OUTPUT_BYTES = 64_000;
+// `gh pr view --json` includes the PR `body`, which alone can exceed the small
+// caller diagnostic budget (GitHub bodies run to tens of KB). Parse that JSON
+// against a generous semantic budget so mergeability/checks/blueprint-linkage
+// fields are never lost to truncation; diagnostics keep the small caller budget.
+const PR_VIEW_SEMANTIC_MAX_OUTPUT_BYTES = 1_048_576;
 const DISCLOSURE_FIELDS = [
     "Execution model(s)",
     "Planning/refinement model(s)",
@@ -115,8 +122,8 @@ async function probe(cwd, command, args, options = {}) {
         cwd,
         timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
     });
+    const maxOutputBytes = options.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
     if ("error" in outcome) {
-        const maxOutputBytes = options.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
         return {
             passed: false,
             semanticStdout: "",
@@ -125,11 +132,11 @@ async function probe(cwd, command, args, options = {}) {
             missingBinary: outcome.error.code === "ENOENT",
         };
     }
-    const maxOutputBytes = options.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
+    const semanticMaxOutputBytes = options.semanticMaxOutputBytes ?? maxOutputBytes;
     return {
         passed: outcome.exitCode === 0,
-        semanticStdout: clipBytes(outcome.stdout, maxOutputBytes),
-        semanticTruncated: Buffer.byteLength(outcome.stdout, "utf8") > maxOutputBytes,
+        semanticStdout: clipBytes(outcome.stdout, semanticMaxOutputBytes),
+        semanticTruncated: Buffer.byteLength(outcome.stdout, "utf8") > semanticMaxOutputBytes,
         stdout: clipDiagnostic(outcome.stdout, maxOutputBytes),
         stderr: clipDiagnostic(outcome.stderr, maxOutputBytes),
         exitCode: outcome.exitCode,
@@ -307,33 +314,29 @@ function selectBlueprintFile(projectRoot, pr) {
             const prefix = `${root}/`;
             if (!file.path.startsWith(prefix))
                 continue;
-            const segments = file.path.slice(prefix.length).split("/");
-            if (segments.length < 3 ||
-                segments.at(-1) !== "_overview.md" ||
-                segments.some((segment) => segment.length === 0 || segment === "." || segment === "..")) {
-                continue;
-            }
-            const stableSlug = segments.slice(1, -1).join("/");
-            if (stableSlug)
-                return [{ ...file, stableSlug }];
+            const parsed = parseBlueprintDocumentRelativePath(file.path.slice(prefix.length));
+            if (parsed)
+                return [{ ...file, stableSlug: parsed.slug }];
         }
         return [];
     });
     const priority = (file) => file.changeType === "ADDED" ? 0 : file.changeType === "RENAMED" ? 1 : 2;
     return candidates.toSorted((left, right) => priority(left) - priority(right))[0];
 }
-function resolveBlueprintEvidence(cwd, projectRoot, pr, targetHash) {
+function resolveBlueprintEvidence(projectRoot, pr, targetHash) {
     const blueprintFile = selectBlueprintFile(projectRoot, pr);
     if (!blueprintFile || !targetHash)
         return undefined;
     try {
-        const authority = readReviewAuthorityAtRef(cwd, targetHash, blueprintFile.stableSlug, "delivery");
+        const authority = readReviewAuthorityAtRef(projectRoot, targetHash, blueprintFile.stableSlug, "delivery");
         if (authority.blueprintPath !== blueprintFile.path)
             return undefined;
+        const approvals = collectV2ReviewProvenance(path.resolve(projectRoot, blueprintFile.path), "delivery", targetHash);
         return {
             path: blueprintFile.path,
             lifecycle: authority.lifecycle,
-            approvalsSatisfied: evaluateApprovalReviewers(authority.approvals.map((approval) => approval.reviewer)).satisfied,
+            approvalsSatisfied: evaluateApprovalReviewers(approvals.map((approval) => approval.reviewer))
+                .satisfied,
         };
     }
     catch {
@@ -582,7 +585,10 @@ export async function buildStatusSnapshot(options = {}) {
             "files",
         ].join(",");
         const [view, checksProbe] = await Promise.all([
-            probe(cwd, "gh", ["pr", "view", ...selector, "--json", fields], probeOptions),
+            probe(cwd, "gh", ["pr", "view", ...selector, "--json", fields], {
+                ...probeOptions,
+                semanticMaxOutputBytes: PR_VIEW_SEMANTIC_MAX_OUTPUT_BYTES,
+            }),
             probe(cwd, "gh", ["pr", "checks", ...selector, "--required", "--json", "name,state,bucket,link,description"], probeOptions),
         ]);
         pr = view.passed ? parseJsonObject(view.semanticStdout) : undefined;
@@ -599,7 +605,7 @@ export async function buildStatusSnapshot(options = {}) {
                 readGreptileComments(cwd, pr, probeOptions),
             ])
             : [{ complete: false, warning: "PR metadata unavailable." }, { comments: [] }];
-        const blueprint = resolveBlueprintEvidence(cwd, firstLine(topLevel.semanticStdout) ?? cwd, pr, localHead);
+        const blueprint = resolveBlueprintEvidence(firstLine(topLevel.semanticStdout) ?? cwd, pr, localHead);
         const readiness = evaluatePrReadiness({
             localHead,
             dirtyWorktree,
@@ -649,9 +655,14 @@ export async function buildStatusSnapshot(options = {}) {
             threadsComplete: threads.complete,
             greptile: classifyGreptile(checks ?? [], greptileComments.comments, stringField(pr?.headRefOid)),
         };
+        // `body` is fully consumed above (release-evidence + disclosure via
+        // `evaluatePrReadiness`, blueprint linkage via `resolveBlueprintEvidence`),
+        // so drop it from the emitted metadata to keep the payload from re-ballooning
+        // to the size that truncated the parse in the first place.
+        const { body: _body, ...metadataWithoutBody } = pr ?? {};
         context.pr = {
             selector: selector[0],
-            metadata: pr,
+            metadata: pr ? metadataWithoutBody : undefined,
             checks: readiness.checks
                 ? { ...readiness.checks, checks: [...readiness.checks.checks] }
                 : undefined,

package/dist/esm/test/duration-sequencer.d.ts

@@ -0,0 +1,20 @@
+import { BaseSequencer, type TestSpecification } from "vitest/node";
+export declare function weightFor(project: string, relativePath: string): number;
+interface WeightedSpec {
+    readonly spec: TestSpecification;
+    readonly weight: number;
+    readonly key: string;
+}
+/**
+ * Deterministic greedy LPT partition of `specs` into `count` bins. Files are
+ * sorted heaviest-first (ties broken by path so the order is stable across
+ * every shard job), then each is placed into the currently-lightest bin (ties
+ * broken by lowest bin index). Returns all bins in index order.
+ *
+ * Exported for the contract test; the sequencer only needs one bin.
+ */
+export declare function partitionByDuration(specs: readonly WeightedSpec[], count: number): readonly (readonly WeightedSpec[])[];
+export declare class DurationSequencer extends BaseSequencer {
+    shard(files: TestSpecification[]): Promise<TestSpecification[]>;
+}
+export {};

package/dist/esm/test/duration-sequencer.js

@@ -0,0 +1,54 @@
+import { relative } from "node:path";
+import { BaseSequencer } from "vitest/node";
+import rawSnapshot from "./shard-durations.json" with { type: "json" };
+const snapshot = rawSnapshot;
+// A generated snapshot always carries a positive defaultWeight; clamp to 1 only
+// to keep LPT well-defined if the JSON is ever hand-truncated to nothing.
+const DEFAULT_WEIGHT = snapshot.defaultWeight > 0 ? snapshot.defaultWeight : 1;
+export function weightFor(project, relativePath) {
+    return snapshot.durations[project]?.[relativePath] ?? DEFAULT_WEIGHT;
+}
+/**
+ * Deterministic greedy LPT partition of `specs` into `count` bins. Files are
+ * sorted heaviest-first (ties broken by path so the order is stable across
+ * every shard job), then each is placed into the currently-lightest bin (ties
+ * broken by lowest bin index). Returns all bins in index order.
+ *
+ * Exported for the contract test; the sequencer only needs one bin.
+ */
+export function partitionByDuration(specs, count) {
+    const bins = Array.from({ length: count }, () => []);
+    const loads = Array.from({ length: count }, () => 0);
+    const ordered = [...specs].sort((a, b) => b.weight !== a.weight ? b.weight - a.weight : a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
+    for (const item of ordered) {
+        let target = 0;
+        let targetLoad = loads[0] ?? 0;
+        for (let i = 1; i < count; i += 1) {
+            const load = loads[i] ?? 0;
+            if (load < targetLoad) {
+                target = i;
+                targetLoad = load;
+            }
+        }
+        // target is always in [0, count): bins/loads were sized to `count`.
+        (bins[target] ??= []).push(item);
+        loads[target] = targetLoad + item.weight;
+    }
+    return bins;
+}
+export class DurationSequencer extends BaseSequencer {
+    async shard(files) {
+        const { config } = this.ctx;
+        // No --shard (serial lane, local full runs): nothing to partition.
+        if (!config.shard)
+            return files;
+        const { index, count } = config.shard;
+        const weighted = files.map((spec) => {
+            const key = relative(config.root, spec.moduleId);
+            return { spec, key, weight: weightFor(spec.project.name, key) };
+        });
+        const bins = partitionByDuration(weighted, count);
+        // index is 1-based in [1, count]; the bin is always present.
+        return (bins[index - 1] ?? []).map((item) => item.spec);
+    }
+}