supipowers 2.2.0 → 2.2.1

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

package/src/git/commit.ts

@@ -103,6 +103,8 @@ const COMMIT_STEPS = [
   { key: "ai-analysis", label: "AI analysis" },
   { key: "review-plan", label: "Review plan" },
   { key: "execute-commits", label: "Execute commits" },
+  { key: "push-commits", label: "Push commits" },
+  { key: "open-pr", label: "Open pull request" },
 ] as const;
 
 function createProgress(ctx: any) {
@@ -127,6 +129,9 @@ function createProgress(ctx: any) {
     skip(stepIndex: number, detail?: string) {
       progress.skip(COMMIT_STEPS[stepIndex]!.key, detail);
     },
+    fail(stepIndex: number, detail?: string) {
+      progress.fail(COMMIT_STEPS[stepIndex]!.key, detail);
+    },
     dispose() {
       progress.dispose();
     },
@@ -340,14 +345,11 @@ export async function analyzeAndCommit(
     }
 
     if (!plan) {
-      // Skip remaining tracked steps for the manual path
       progress.skip(5, "manual");
-      progress.skip(6, "manual");
-      progress.dispose();
       const reason = !platform.capabilities.agentSessions
         ? "no agent sessions"
         : agentReason;
-      return manualFallback(platform, ctx, cwd, fileList, platform.paths, agentAttempts, reason);
+      return manualFallback(platform, ctx, cwd, fileList, platform.paths, agentAttempts, progress, reason);
     }
 
     // 6. Present plan for approval
@@ -444,6 +446,7 @@ async function manualFallback(
   fileList: string[],
   paths: PlatformPaths,
   attempts: number,
+  progress: ReturnType<typeof createProgress>,
   reason?: string,
 ): Promise<CommitResult | null> {
   const exec = platform.exec.bind(platform);
@@ -467,27 +470,186 @@ async function manualFallback(
       ? `${reason} \u2014 enter a commit message manually`
       : "Enter a commit message manually",
   );
+  progress.activate(6, "manual");
 
   const message = await ctx.ui.input("Commit message (empty to abort)", {
     helpText: `${fileList.length} file(s) staged`,
   });
-
   if (!message?.trim()) {
     notifyInfo(ctx, "Commit cancelled", "No message provided");
+    progress.skip(6, "aborted");
     return null;
   }
 
   const commitResult = await commitStaged(exec, cwd, message);
   if (!commitResult.success) {
     notifyError(ctx, "Commit failed", commitResult.error);
+    progress.fail(6, "failed");
     return null;
   }
 
   notifySuccess(ctx, "Committed", message.split("\n")[0]);
+  progress.complete(6, "1 done");
+  await offerPostCommitActions(platform, ctx, cwd, progress);
   return { committed: 1, messages: [message] };
 }
 
 
+const PUSH_NO_OPTION = "No — keep commits local";
+const PR_NO_OPTION = "No — leave branch without a PR";
+const PR_YES_OPTION = "Yes — open a Pull Request";
+
+function pushYesOption(branch: string): string {
+  return `Yes — push to origin/${branch}`;
+}
+
+function isDefaultBranchName(branch: string): boolean {
+  return branch === "main" || branch === "master";
+}
+
+function formatCommandFailure(result: { stdout: string; stderr: string; code: number }): string {
+  return result.stderr.trim() || result.stdout.trim() || `exit code ${result.code}`;
+}
+
+async function readCurrentBranch(
+  exec: ExecFn,
+  ctx: any,
+  cwd: string,
+): Promise<string | null> {
+  const result = await exec("git", ["branch", "--show-current"], { cwd });
+  if (result.code !== 0) {
+    notifyError(ctx, "Could not determine current branch", formatCommandFailure(result));
+    return null;
+  }
+
+  return result.stdout.trim() || null;
+}
+
+async function pushCurrentBranch(
+  exec: ExecFn,
+  ctx: any,
+  cwd: string,
+  branch: string,
+): Promise<boolean> {
+  const result = await exec("git", ["push", "-u", "origin", branch], { cwd });
+  if (result.code !== 0) {
+    notifyError(ctx, "Push failed", formatCommandFailure(result));
+    return false;
+  }
+
+  notifySuccess(ctx, "Pushed", `origin/${branch}`);
+  return true;
+}
+
+async function createPullRequest(
+  exec: ExecFn,
+  ctx: any,
+  cwd: string,
+  branch: string,
+): Promise<boolean> {
+  const result = await exec("gh", ["pr", "create", "--fill", "--head", branch], { cwd });
+  if (result.code !== 0) {
+    notifyError(ctx, "Pull request failed", formatCommandFailure(result));
+    return false;
+  }
+
+  const detail = result.stdout.trim() || result.stderr.trim() || `Branch: ${branch}`;
+  notifySuccess(ctx, "Pull request opened", detail);
+  return true;
+}
+
+async function offerPostCommitActions(
+  platform: Platform,
+  ctx: any,
+  cwd: string,
+  progress: ReturnType<typeof createProgress>,
+): Promise<void> {
+  try {
+    const exec = platform.exec.bind(platform);
+    progress.activate(7, "detect branch");
+    const branch = await readCurrentBranch(exec, ctx, cwd);
+    if (!branch) {
+      progress.skip(7, "no branch");
+      progress.skip(8, "no branch");
+      return;
+    }
+
+    const yesPush = pushYesOption(branch);
+    progress.activate(7, "prompt");
+    const pushSelection = await ctx.ui.select("Push commits?", [
+      PUSH_NO_OPTION,
+      yesPush,
+    ], {
+      helpText: `Current branch: ${branch}`,
+    });
+
+    if (!pushSelection) {
+      progress.skip(7, "cancelled");
+      progress.skip(8, "cancelled");
+      return;
+    }
+
+    let pushed = false;
+    if (pushSelection === yesPush) {
+      progress.activate(7, `origin/${branch}`);
+      pushed = await pushCurrentBranch(exec, ctx, cwd, branch);
+      if (!pushed) {
+        progress.fail(7, "failed");
+        progress.skip(8, "push failed");
+        return;
+      }
+      progress.complete(7, `origin/${branch}`);
+    } else {
+      progress.skip(7, "kept local");
+    }
+
+    if (isDefaultBranchName(branch)) {
+      progress.skip(8, "default branch");
+      return;
+    }
+
+    progress.activate(8, "prompt");
+    const prSelection = await ctx.ui.select("Open a Pull Request?", [
+      PR_NO_OPTION,
+      PR_YES_OPTION,
+    ], {
+      helpText: pushed
+        ? `Branch: ${branch}`
+        : `Opening a PR will first push origin/${branch}.`,
+    });
+    if (!prSelection) {
+      progress.skip(8, "cancelled");
+      return;
+    }
+    if (prSelection !== PR_YES_OPTION) {
+      progress.skip(8, "not requested");
+      return;
+    }
+
+    if (!pushed) {
+      progress.activate(7, `origin/${branch}`);
+      pushed = await pushCurrentBranch(exec, ctx, cwd, branch);
+      if (!pushed) {
+        progress.fail(7, "failed");
+        progress.skip(8, "push failed");
+        return;
+      }
+      progress.complete(7, `origin/${branch}`);
+    }
+
+    progress.activate(8, "gh pr create");
+    if (!await createPullRequest(exec, ctx, cwd, branch)) {
+      progress.fail(8, "failed");
+      return;
+    }
+    progress.complete(8, "created");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    progress.fail(8, "error");
+    notifyError(ctx, "Post-commit action failed", message);
+  }
+}
+
 
 // ── Commit execution ───────────────────────────────────────
 
@@ -548,12 +710,12 @@ async function executeCommitPlan(
   await exec("git", ["read-tree", savedTree], { cwd });
 
   progress.complete(6, `${committedMessages.length} done`);
-  progress.dispose();
   notifySuccess(
     ctx,
     `${committedMessages.length} commit(s) created`,
     committedMessages.map((m) => m.split("\n")[0]).join(" | "),
   );
+  await offerPostCommitActions(platform, ctx, cwd, progress);
 
   return { committed: committedMessages.length, messages: committedMessages };
 }

package/src/lsp/capabilities.ts

@@ -11,7 +11,7 @@
 // treated as fail-closed: NO_LSP_SUPPORT (gate skips rather than pretending
 // it ran).
 
-import { Type, type Static } from "@sinclair/typebox";
+import { z } from "zod/v4";
 import {
   parseStructuredOutput,
   runWithOutputValidation,
@@ -20,18 +20,15 @@ import {
 import { renderSchemaText } from "../ai/schema-text.js";
 import type { GateExecutionContext } from "../types.js";
 
-export const LspCapabilitiesSchema = Type.Object(
-  {
-    diagnostics: Type.Boolean(),
-    references: Type.Boolean(),
-    definition: Type.Boolean(),
-    hover: Type.Boolean(),
-    rename: Type.Boolean(),
-  },
-  { additionalProperties: false },
-);
+export const LspCapabilitiesSchema = z.object({
+  diagnostics: z.boolean(),
+  references: z.boolean(),
+  definition: z.boolean(),
+  hover: z.boolean(),
+  rename: z.boolean(),
+}).strict();
 
-export type LspCapabilities = Static<typeof LspCapabilitiesSchema>;
+export type LspCapabilities = z.infer<typeof LspCapabilitiesSchema>;
 
 const SCHEMA_TEXT = renderSchemaText(LspCapabilitiesSchema);