supipowers 2.1.0 → 2.2.1

package/src/docs/contracts.ts

@@ -5,7 +5,7 @@
 // retry loop (runWithOutputValidation) will hand validation errors back to
 // the model rather than letting a silent regex heuristic invent findings.
 
-import { Type, type Static } from "@sinclair/typebox";
+import { z } from "zod/v4"
 
 export const DOC_DRIFT_SEVERITIES = ["info", "warning", "error"] as const;
 export const DOC_DRIFT_STATUSES = ["ok", "drifted"] as const;
@@ -13,27 +13,17 @@ export const DOC_DRIFT_STATUSES = ["ok", "drifted"] as const;
 export type DocDriftSeverity = (typeof DOC_DRIFT_SEVERITIES)[number];
 export type DocDriftStatus = (typeof DOC_DRIFT_STATUSES)[number];
 
-export const DocDriftFindingSchema = Type.Object(
-  {
-    file: Type.String({ minLength: 1 }),
-    description: Type.String({ minLength: 1 }),
-    severity: Type.Union(
-      DOC_DRIFT_SEVERITIES.map((value) => Type.Literal(value)),
-    ),
-    relatedFiles: Type.Optional(Type.Array(Type.String({ minLength: 1 }))),
-  },
-  { additionalProperties: false },
-);
+export const DocDriftFindingSchema = z.object({
+  file: z.string().min(1),
+  description: z.string().min(1),
+  severity: z.enum(DOC_DRIFT_SEVERITIES),
+  relatedFiles: z.array(z.string().min(1)).optional(),
+}).strict();
 
-export const DocDriftOutputSchema = Type.Object(
-  {
-    findings: Type.Array(DocDriftFindingSchema),
-    status: Type.Union(
-      DOC_DRIFT_STATUSES.map((value) => Type.Literal(value)),
-    ),
-  },
-  { additionalProperties: false },
-);
+export const DocDriftOutputSchema = z.object({
+  findings: z.array(DocDriftFindingSchema),
+  status: z.enum(DOC_DRIFT_STATUSES),
+}).strict();
 
-export type DocDriftFinding = Static<typeof DocDriftFindingSchema>;
-export type DocDriftOutput = Static<typeof DocDriftOutputSchema>;
+export type DocDriftFinding = z.infer<typeof DocDriftFindingSchema>;
+export type DocDriftOutput = z.infer<typeof DocDriftOutputSchema>;

package/src/fix-pr/assessment.ts

@@ -29,6 +29,8 @@ export interface RunFixPrAssessmentInput {
   model?: string;
   thinkingLevel?: string | null;
   maxAttempts?: number;
+  timeoutMs?: number;
+  maxCommentsPerBatch?: number;
 }
 
 interface BuildAssessmentPromptArgs {
@@ -74,6 +76,19 @@ function buildAssessmentPrompt(args: BuildAssessmentPromptArgs): string {
   ].join("\n");
 }
 
+function chunkComments(comments: readonly PrComment[], maxCommentsPerBatch: number): PrComment[][] {
+  if (maxCommentsPerBatch <= 0 || comments.length <= maxCommentsPerBatch) {
+    return [[...comments]];
+  }
+
+  const chunks: PrComment[][] = [];
+  for (let index = 0; index < comments.length; index += maxCommentsPerBatch) {
+    chunks.push(comments.slice(index, index + maxCommentsPerBatch));
+  }
+  return chunks;
+}
+
+
 /**
  * Run a schema-backed assessment over a cluster of PR comments.
  *
@@ -93,30 +108,54 @@ export async function runFixPrAssessment(
   }
 
   const schemaText = renderSchemaText(FixPrAssessmentBatchSchema);
-  const prompt = buildAssessmentPrompt({
-    schemaText,
-    comments: input.comments,
-    repo: input.repo,
-    prNumber: input.prNumber,
-    selectedTargetLabel: input.selectedTargetLabel,
-  });
-
-  return runWithOutputValidation<FixPrAssessmentBatch>(
-    input.createAgentSession as any,
-    {
-      cwd: input.cwd,
-      prompt,
-      schema: schemaText,
-      parse: (raw) =>
-        parseStructuredOutput<FixPrAssessmentBatch>(raw, FixPrAssessmentBatchSchema),
-      model: input.model,
-      thinkingLevel: input.thinkingLevel ?? null,
-      maxAttempts: input.maxAttempts,
-      reliability: input.paths
-        ? { paths: input.paths, cwd: input.cwd, command: "fix-pr", operation: "assessment" }
-        : undefined,
-    },
-  );
+  const maxCommentsPerBatch = input.maxCommentsPerBatch ?? input.comments.length;
+  const commentChunks = chunkComments(input.comments, maxCommentsPerBatch);
+  const assessments: FixPrAssessmentBatch["assessments"] = [];
+  const rawOutputs: string[] = [];
+  let attempts = 0;
+
+  for (const comments of commentChunks) {
+    const prompt = buildAssessmentPrompt({
+      schemaText,
+      comments,
+      repo: input.repo,
+      prNumber: input.prNumber,
+      selectedTargetLabel: input.selectedTargetLabel,
+    });
+
+    const result = await runWithOutputValidation<FixPrAssessmentBatch>(
+      input.createAgentSession as any,
+      {
+        cwd: input.cwd,
+        prompt,
+        schema: schemaText,
+        parse: (raw) =>
+          parseStructuredOutput<FixPrAssessmentBatch>(raw, FixPrAssessmentBatchSchema),
+        model: input.model,
+        thinkingLevel: input.thinkingLevel ?? null,
+        maxAttempts: input.maxAttempts,
+        timeoutMs: input.timeoutMs,
+        reliability: input.paths
+          ? { paths: input.paths, cwd: input.cwd, command: "fix-pr", operation: "assessment" }
+          : undefined,
+      },
+    );
+
+    attempts += result.attempts;
+    if (result.status === "blocked") {
+      return { ...result, attempts };
+    }
+
+    rawOutputs.push(result.rawOutput);
+    assessments.push(...result.output.assessments);
+  }
+
+  return {
+    status: "ok",
+    output: { assessments },
+    rawOutput: rawOutputs.join("\n"),
+    attempts,
+  };
 }
 
 /**

package/src/fix-pr/contracts.ts

@@ -5,35 +5,27 @@
 // against FixPrAssessmentBatchSchema; downstream work batches are derived
 // from this validated artifact, not from ad-hoc orchestration prose.
 
-import { Type, type Static } from "@sinclair/typebox";
+import { z } from "zod/v4"
 
 export const FIX_PR_ASSESSMENT_VERDICTS = ["apply", "reject", "investigate"] as const;
 export type FixPrAssessmentVerdict = (typeof FIX_PR_ASSESSMENT_VERDICTS)[number];
 
-export const FixPrCommentAssessmentSchema = Type.Object(
-  {
-    commentId: Type.Integer(),
-    verdict: Type.Union(
-      FIX_PR_ASSESSMENT_VERDICTS.map((value) => Type.Literal(value)),
-    ),
-    rationale: Type.String({ minLength: 1 }),
-    affectedFiles: Type.Array(Type.String({ minLength: 1 })),
-    rippleEffects: Type.Array(Type.String({ minLength: 1 })),
-    verificationPlan: Type.String({ minLength: 1 }),
-  },
-  { additionalProperties: false },
-);
+export const FixPrCommentAssessmentSchema = z.object({
+  commentId: z.number().int(),
+  verdict: z.enum(FIX_PR_ASSESSMENT_VERDICTS),
+  rationale: z.string().min(1),
+  affectedFiles: z.array(z.string().min(1)),
+  rippleEffects: z.array(z.string().min(1)),
+  verificationPlan: z.string().min(1),
+}).strict();
 
-export const FixPrAssessmentBatchSchema = Type.Object(
-  {
-    assessments: Type.Array(FixPrCommentAssessmentSchema),
-    summary: Type.Optional(Type.String()),
-  },
-  { additionalProperties: false },
-);
+export const FixPrAssessmentBatchSchema = z.object({
+  assessments: z.array(FixPrCommentAssessmentSchema),
+  summary: z.string().optional(),
+}).strict();
 
-export type FixPrCommentAssessment = Static<typeof FixPrCommentAssessmentSchema>;
-export type FixPrAssessmentBatch = Static<typeof FixPrAssessmentBatchSchema>;
+export type FixPrCommentAssessment = z.infer<typeof FixPrCommentAssessmentSchema>;
+export type FixPrAssessmentBatch = z.infer<typeof FixPrAssessmentBatchSchema>;
 
 /**
  * A deterministic execution unit derived from a validated FixPrAssessmentBatch.

package/src/fix-pr/fetch-comments.ts

@@ -11,6 +11,30 @@ const INLINE_COMMENTS_JQ =
 const REVIEW_COMMENTS_JQ =
   '.[] | select(.body != null and .body != "") | {id, path: null, line: null, body, user: .user.login, userType: .user.type, createdAt: .submitted_at, updatedAt: .submitted_at, inReplyToId: null, diffHunk: null, state}';
 
+
+const RESOLVED_REVIEW_THREAD_COMMENT_IDS_QUERY = `
+query($owner: String!, $name: String!, $number: Int!, $endCursor: String) {
+  repository(owner: $owner, name: $name) {
+    pullRequest(number: $number) {
+      reviewThreads(first: 100, after: $endCursor) {
+        nodes {
+          isResolved
+          comments(first: 100) {
+            nodes {
+              databaseId
+            }
+          }
+        }
+        pageInfo {
+          hasNextPage
+          endCursor
+        }
+      }
+    }
+  }
+}
+`;
+
 export interface ClusteredPrComments<TTarget extends WorkspaceTarget = WorkspaceTarget> {
   allComments: PrComment[];
   commentsByTargetId: Map<string, PrComment[]>;
@@ -27,6 +51,30 @@ function appendComment(commentsByTargetId: Map<string, PrComment[]>, targetId: s
   commentsByTargetId.set(targetId, [comment]);
 }
 
+
+function parseRepoOwnerAndName(repo: string): { owner: string; name: string } | null {
+  const separator = repo.indexOf("/");
+  if (separator <= 0 || separator === repo.length - 1) {
+    return null;
+  }
+
+  return {
+    owner: repo.slice(0, separator),
+    name: repo.slice(separator + 1),
+  };
+}
+
+function parseResolvedCommentIds(output: string): Set<number> {
+  const ids = new Set<number>();
+  for (const line of output.split(/\r?\n/)) {
+    const id = Number.parseInt(line.trim(), 10);
+    if (Number.isInteger(id)) {
+      ids.add(id);
+    }
+  }
+  return ids;
+}
+
 export function parsePrCommentsJsonl(content: string): PrComment[] {
   return content
     .split(/\r?\n/)
@@ -49,6 +97,68 @@ export function stringifyPrCommentsJsonl(comments: readonly PrComment[]): string
   return `${comments.map((comment) => JSON.stringify(comment)).join("\n")}\n`;
 }
 
+async function fetchResolvedReviewThreadCommentIds(
+  platform: Platform,
+  repo: string,
+  prNumber: number,
+  cwd: string,
+): Promise<Set<number> | string> {
+  const repoParts = parseRepoOwnerAndName(repo);
+  if (!repoParts) {
+    return `Invalid repository name: ${repo}`;
+  }
+
+  const result = await platform.exec(
+    "gh",
+    [
+      "api",
+      "graphql",
+      "--paginate",
+      "-f",
+      `query=${RESOLVED_REVIEW_THREAD_COMMENT_IDS_QUERY}`,
+      "-F",
+      `owner=${repoParts.owner}`,
+      "-F",
+      `name=${repoParts.name}`,
+      "-F",
+      `number=${prNumber}`,
+      "--jq",
+      ".data.repository.pullRequest.reviewThreads.nodes[] | select(.isResolved == true) | .comments.nodes[].databaseId",
+    ],
+    { cwd },
+  );
+
+  if (result.code !== 0) {
+    return result.stderr || "gh api graphql failed while fetching resolved review threads";
+  }
+
+  return parseResolvedCommentIds(result.stdout);
+}
+
+function filterResolvedComments(content: string, resolvedCommentIds: ReadonlySet<number>): string {
+  if (!content.trim() || resolvedCommentIds.size === 0) {
+    return content;
+  }
+
+  const unresolvedLines = content
+    .split(/\r?\n/)
+    .filter((line) => {
+      const trimmed = line.trim();
+      if (!trimmed) {
+        return false;
+      }
+      try {
+        const comment = JSON.parse(trimmed) as Pick<PrComment, "id">;
+        return !resolvedCommentIds.has(comment.id);
+      } catch {
+        return true;
+      }
+    });
+
+  return unresolvedLines.length > 0 ? `${unresolvedLines.join("\n")}\n` : "";
+}
+
+
 export function clusterPrCommentsByTarget<TTarget extends WorkspaceTarget>(
   targets: readonly TTarget[],
   comments: readonly PrComment[],
@@ -143,4 +253,13 @@ export async function fetchPrComments(
   if (inlineResult.code !== 0 && reviewResult.code !== 0) {
     return inlineResult.stderr || reviewResult.stderr || "gh api calls failed";
   }
+
+  const resolvedCommentIds = await fetchResolvedReviewThreadCommentIds(platform, repo, prNumber, cwd);
+  if (typeof resolvedCommentIds === "string") {
+    return resolvedCommentIds;
+  }
+
+  if (resolvedCommentIds.size > 0) {
+    fs.writeFileSync(outputPath, filterResolvedComments(fs.readFileSync(outputPath, "utf-8"), resolvedCommentIds));
+  }
 }

package/src/fix-pr/prompt-builder.ts

@@ -177,26 +177,37 @@ export function buildFixPrOrchestratorPrompt(options: FixPrPromptOptions): strin
   sections.push(buildReplyInstructions(config), "");
 
   sections.push(
-    "## Step 6: Push and Check for New Comments",
+    "## Step 6: Push, Monitor CI, and Check for New Comments",
     "",
-    `1. Stage and commit: \`git add -A && git commit -m \"fix: address PR review comments (iteration ${iteration})\"\``,
+    `1. Stage and commit: \`git add -A && git commit -m "fix: address PR review comments (iteration ${iteration})"\``,
     "2. Push: `git push`",
   );
 
   if (reviewer.type !== "none" && reviewer.triggerMethod) {
     sections.push(
-      `3. Trigger re-review: \`bun \"${scriptsDir}/trigger-review.ts\" \"${repo}\" ${prNumber} \"${reviewer.type}\" \"${reviewer.triggerMethod}\"\``,
+      `3. Trigger re-review: \`bun "${scriptsDir}/trigger-review.ts" "${repo}" ${prNumber} "${reviewer.type}" "${reviewer.triggerMethod}"\``,
+      `4. While the reviewer runs, start the green pipeline: invoke OMP \`/green\` if available; otherwise run \`gh pr checks ${prNumber} --repo ${repo} --watch\`.`,
+      "   - If CI turns red, stop waiting for review comments and focus on CI.",
+      "   - Diagnose the failed check from its logs, fix the root cause, push again, then restart green monitoring.",
+      "5. Run the wait-and-check runner:",
+    );
+  } else {
+    sections.push(
+      `3. Start the green pipeline: invoke OMP \`/green\` if available; otherwise run \`gh pr checks ${prNumber} --repo ${repo} --watch\`.`,
+      "   - If CI turns red, focus on CI before considering the PR complete.",
+      "   - Diagnose the failed check from its logs, fix the root cause, push again, then restart green monitoring.",
+      "4. Run the wait-and-check runner:",
     );
   }
 
   sections.push(
-    `${reviewer.type !== "none" ? "4" : "3"}. Run the wait-and-check runner:`,
     "```text",
-    `bun \"${scriptsDir}/wait-and-check.ts\" \"${sessionDir}\" ${delay} ${iteration + 1} \"${repo}\" ${prNumber}`,
+    `bun "${scriptsDir}/wait-and-check.ts" "${sessionDir}" ${delay} ${iteration + 1} "${repo}" ${prNumber}`,
     "```",
-    `${reviewer.type !== "none" ? "5" : "4"}. Read the last line of output:`,
-    `   - If \`hasNewComments: true\` and iteration < ${maxIter}: process the new comments (go back to Step 1)`,
-    `   - If \`hasNewComments: false\` or iteration >= ${maxIter}: report done`,
+    `${reviewer.type !== "none" ? "6" : "5"}. Read the last line of output:`,
+    `   - If \`hasNewComments: true\` and iteration < ${maxIter}: process the new comments (go back to Step 1), then repeat push, green monitoring, and final validation`,
+    `   - If \`hasNewComments: false\` or iteration >= ${maxIter}: continue only after CI is green`,
+    `${reviewer.type !== "none" ? "7" : "6"}. Full validation is mandatory at the end: run \`bun ci\` locally after comments are handled and CI is green. Do not report done until both remote CI and local full validation are green.`,
     "",
   );
 

package/src/git/commit-contract.ts

@@ -6,30 +6,24 @@
 // (every staged file appears in exactly one commit) is a runtime rule that
 // can't live in the schema — see validateCommitPlanCoverage.
 
-import { type Static, Type } from "@sinclair/typebox";
+import { z } from "zod/v4"
 import { VALID_COMMIT_TYPES } from "../release/commit-types.js";
 import type { ValidationError } from "../types.js";
 
-export const CommitGroupSchema = Type.Object(
-  {
-    type: Type.Union(VALID_COMMIT_TYPES.map((value) => Type.Literal(value))),
-    scope: Type.Union([Type.String(), Type.Null()]),
-    summary: Type.String({ minLength: 1 }),
-    details: Type.Array(Type.String()),
-    files: Type.Array(Type.String({ minLength: 1 }), { minItems: 1 }),
-  },
-  { additionalProperties: false },
-);
+export const CommitGroupSchema = z.object({
+  type: z.enum(VALID_COMMIT_TYPES),
+  scope: z.string().nullable(),
+  summary: z.string().min(1),
+  details: z.array(z.string()),
+  files: z.array(z.string().min(1)).min(1),
+}).strict();
 
-export const CommitPlanSchema = Type.Object(
-  {
-    commits: Type.Array(CommitGroupSchema, { minItems: 1 }),
-  },
-  { additionalProperties: false },
-);
+export const CommitPlanSchema = z.object({
+  commits: z.array(CommitGroupSchema).min(1),
+}).strict();
 
-export type CommitGroup = Static<typeof CommitGroupSchema>;
-export type CommitPlan = Static<typeof CommitPlanSchema>;
+export type CommitGroup = z.infer<typeof CommitGroupSchema>;
+export type CommitPlan = z.infer<typeof CommitPlanSchema>;
 
 /**
  * Verify every staged file appears in exactly one commit and that no commit