supipowers 2.2.0 → 2.2.2

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/harness/anti_slop/fallow-adapter.ts

@@ -25,6 +25,7 @@ import {
   type SlopBackendResult,
   type SlopFinding,
 } from "./backend.js";
+import { execCli } from "../../utils/exec-cli.js";
 
 const DEFAULT_TIMEOUT_MS = 60_000;
 
@@ -149,7 +150,7 @@ async function resolveInvocation(
   }
 
   try {
-    const probe = await platform.exec("npx", ["--no-install", "fallow", "--version"], { timeout: 5000 });
+    const probe = await execCli((cmd, args, opts) => platform.exec(cmd, args, opts), "npx", ["--no-install", "fallow", "--version"], { timeout: 5000 });
     if (probe.code === 0) {
       availabilityCache = { ok: true, via: "npx" };
       return { ok: true, cmd: "npx", baseArgs: ["--no-install", "fallow"], via: "npx" };
@@ -187,7 +188,7 @@ async function runFallow(
   const startedAt = Date.now();
   let result;
   try {
-    result = await platform.exec(invocation.cmd, args, {
+    result = await execCli((cmd, args, opts) => platform.exec(cmd, args, opts), invocation.cmd, args, {
       cwd: opts.cwd,
       timeout: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS,
     });
@@ -269,7 +270,7 @@ export class FallowAdapter implements SlopBackend {
     if (opts.subtree) args.push("--path", opts.subtree);
 
     try {
-      const result = await platform.exec(invocation.cmd, args, {
+      const result = await execCli((cmd, args, opts) => platform.exec(cmd, args, opts), invocation.cmd, args, {
         cwd: opts.cwd,
         timeout: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS,
       });

package/src/harness/command.ts

@@ -45,7 +45,6 @@ import {
 import { computeScore } from "./anti_slop/score.js";
 import {
   type BuildRunnerInput,
-  type HarnessPipelineProgressEvent,
   type PipelineRunOutcome,
   HARNESS_STAGE_ORDER,
   runHarnessPipelineUntilGate,
@@ -58,7 +57,7 @@ import { DEFAULT_HARNESS_CONFIG } from "./hooks/register.js";
 import { handlePrComment } from "./pr-comment/handler.js";
 import { runGitVerificationQa } from "./git-verify-qa.js";
 import { getHarnessSessionDir } from "./project-paths.js";
-import type { HarnessDesignSpec, HarnessGateMode, HarnessSession, HarnessStage } from "../types.js";
+import type { HarnessDesignSpec, HarnessGateMode, HarnessPipelineProgressEvent, HarnessSession, HarnessStage } from "../types.js";
 
 modelRegistry.register({
   id: "harness",
@@ -133,9 +132,11 @@ function createHarnessProgress(ctx: HarnessCommandContext) {
   let done = 0;
   let cur: HarnessStage | null = null;
   const completed: string[] = [];
+  let liveDetail: string | null = null;
 
   function refresh() {
-    const label = cur ? HARNESS_STAGE_LABELS[cur] : "Complete";
+    const baseLabel = cur ? HARNESS_STAGE_LABELS[cur] : "Complete";
+    const label = cur && liveDetail ? `${baseLabel} — ${liveDetail}` : baseLabel;
     const spinner = cur ? "\u25cc" : "\u2713";
     (ctx.ui as any).setStatus?.("supi-harness", `  ${spinner} harness: ${label} (${done}/${SO.length})`);
   }
@@ -147,22 +148,26 @@ function createHarnessProgress(ctx: HarnessCommandContext) {
         case "stage-started":
           cur = event.stage;
           break;
+        case "stage-progress":
+          cur = event.stage;
+          liveDetail = event.detail;
+          break;
         case "stage-completed": {
-          done += 1; cur = null;
+          done += 1; cur = null; liveDetail = null;
           const mark = "\u2713";
           completed.push(`${mark} ${HARNESS_STAGE_LABELS[event.stage]}: ${event.detail || "done"}`);
           break;
         }
         case "stage-skipped":
-          done += 1; cur = null;
+          done += 1; cur = null; liveDetail = null;
           completed.push(`\u2013 ${HARNESS_STAGE_LABELS[event.stage]}: skipped`);
           break;
         case "awaiting-user":
-          done += 1; cur = null;
+          done += 1; cur = null; liveDetail = null;
           completed.push(`\u25cb ${HARNESS_STAGE_LABELS[event.stage]}: ${event.detail || "awaiting review"}`);
           break;
         case "stage-failed": case "stage-blocked":
-          cur = null;
+          cur = null; liveDetail = null;
           completed.push(`\u2717 ${HARNESS_STAGE_LABELS[event.stage]}: ${event.detail || "failed"}`);
           break;
       }

package/src/harness/pipeline.ts

@@ -14,6 +14,7 @@ import * as path from "node:path";
 import type { Platform, PlatformPaths } from "../platform/types.js";
 import type {
   HarnessGateMode,
+  HarnessPipelineProgressEvent,
   HarnessStage,
   ModelConfig,
 } from "../types.js";
@@ -38,14 +39,6 @@ import { buildBackendAdapter } from "./anti_slop/backend-factory.js";
 import { DEFAULT_HARNESS_CONFIG } from "./hooks/register.js";
 import { getProjectStatePath } from "../workspace/state-paths.js";
 
-/** Progress event emitted by the pipeline driver for UI feedback. */
-export type HarnessPipelineProgressEvent =
-  | { type: "stage-started"; stage: HarnessStage }
-  | { type: "stage-skipped"; stage: HarnessStage }
-  | { type: "stage-completed"; stage: HarnessStage; detail?: string }
-  | { type: "stage-blocked"; stage: HarnessStage; detail: string }
-  | { type: "stage-failed"; stage: HarnessStage; detail: string }
-  | { type: "awaiting-user"; stage: HarnessStage; detail?: string };
 
 const STAGE_ORDER: readonly HarnessStage[] = [
   "discover",
@@ -301,6 +294,7 @@ export async function runHarnessPipelineUntilGate(
       sessionId: input.sessionId,
       modelConfig: input.modelConfig,
       gateMode: input.gates,
+      onProgress: (event) => input.onProgress?.(event),
     };
 
     const result = await runner.run(ctx);

package/src/harness/stage-runner.ts

@@ -21,6 +21,7 @@
 import type { Platform, PlatformPaths } from "../platform/types.js";
 import type {
   HarnessGateMode,
+  HarnessPipelineProgressEvent,
   HarnessStage,
   HarnessStageStatus,
   ModelConfig,
@@ -46,6 +47,8 @@ export interface HarnessStageRunnerContext {
   now?: () => string;
   /** Optional override for the agent session model. Tests use this to bypass resolution. */
   modelOverride?: { model: string; thinkingLevel: string | null };
+  /** Live progress sink for long-running stage internals such as subagent turns. */
+  onProgress?: (event: HarnessPipelineProgressEvent) => void;
 }
 
 export type HarnessStageRunStatus =

package/src/harness/stages/docs.ts

@@ -90,6 +90,7 @@ export interface DocsStageInput {
 }
 
 interface AgentSessionLike {
+  subscribe?: (handler: (event: unknown) => void) => () => void;
   prompt(text: string, opts?: { expandPromptTemplates?: boolean }): Promise<void>;
   dispose(): Promise<void>;
 }
@@ -536,6 +537,60 @@ async function orchestrateLayerSubagent(input: OrchestrateLayerInput): Promise<O
   }
 }
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function stringField(record: Record<string, unknown>, key: string): string | null {
+  const value = record[key];
+  return typeof value === "string" && value.trim().length > 0 ? value : null;
+}
+
+function nestedStringField(record: Record<string, unknown>, objectKey: string, fieldKey: string): string | null {
+  const nested = record[objectKey];
+  if (!isRecord(nested)) return null;
+  return stringField(nested, fieldKey);
+}
+
+function compactDetail(value: string, maxChars = 180): string {
+  const compact = value.replace(/\s+/g, " ").trim();
+  if (compact.length <= maxChars) return compact;
+  return `${compact.slice(0, maxChars - 1).trimEnd()}…`;
+}
+
+function summarizeAgentSessionEvent(event: unknown): string | null {
+  if (!isRecord(event)) return null;
+  const type = stringField(event, "type") ?? stringField(event, "kind") ?? stringField(event, "event");
+  const lowerType = type?.toLowerCase() ?? "";
+  const toolName =
+    stringField(event, "toolName") ??
+    stringField(event, "tool") ??
+    stringField(event, "name") ??
+    nestedStringField(event, "toolCall", "name") ??
+    nestedStringField(event, "tool_call", "name");
+  if (toolName && (lowerType.includes("tool") || lowerType.includes("call"))) {
+    return `tool ${compactDetail(toolName, 80)}`;
+  }
+
+  const text =
+    stringField(event, "text") ??
+    stringField(event, "delta") ??
+    stringField(event, "thought") ??
+    stringField(event, "content") ??
+    nestedStringField(event, "message", "text") ??
+    nestedStringField(event, "message", "content");
+  if (text) {
+    const prefix = lowerType.includes("thought") || lowerType.includes("reason")
+      ? "thought"
+      : lowerType.includes("tool")
+        ? "tool"
+        : "agent";
+    return `${prefix} ${compactDetail(text)}`;
+  }
+
+  return type ? compactDetail(type, 80) : null;
+}
+
 async function dispatchSubagent(input: {
   platform: Platform;
   ctx: HarnessStageRunnerContext;
@@ -548,7 +603,13 @@ async function dispatchSubagent(input: {
   const agentDisplayName = buildHarnessAgentDisplayName("docs", input.entry.layer.layer);
 
   let session: AgentSessionLike | null = null;
+  let unsubscribe: (() => void) | null = null;
   try {
+    input.ctx.onProgress?.({
+      type: "stage-progress",
+      stage: "docs",
+      detail: `${agentDisplayName}: starting attempt ${input.attempt}`,
+    });
     if (input.factory) {
       session = await input.factory(input.platform, {
         cwd: input.ctx.cwd,
@@ -562,7 +623,21 @@ async function dispatchSubagent(input: {
         agentDisplayName,
       });
     }
+    unsubscribe = session.subscribe?.((event) => {
+      const summary = summarizeAgentSessionEvent(event);
+      if (!summary) return;
+      input.ctx.onProgress?.({
+        type: "stage-progress",
+        stage: "docs",
+        detail: `${agentDisplayName}: ${summary}`,
+      });
+    }) ?? null;
     await session.prompt(input.assignment, { expandPromptTemplates: false });
+    input.ctx.onProgress?.({
+      type: "stage-progress",
+      stage: "docs",
+      detail: `${agentDisplayName}: attempt ${input.attempt} complete`,
+    });
   } catch (error) {
     return {
       ok: false,
@@ -571,6 +646,13 @@ async function dispatchSubagent(input: {
       ],
     };
   } finally {
+    if (unsubscribe) {
+      try {
+        unsubscribe();
+      } catch {
+        /* best-effort */
+      }
+    }
     if (session) {
       try {
         await session.dispose();

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);