supipowers 2.2.0 → 2.2.1

package/src/commands/fix-pr.ts

@@ -3,7 +3,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import type { Platform } from "../platform/types.js";
 import type { WorkspaceTarget } from "../types.js";
-import { buildWorkspaceTargetOptionLabel, parseTargetArg, selectWorkspaceTarget, stripCliArg, tokenizeCliArgs } from "../workspace/selector.js";
+import { buildWorkspaceTargetOptionLabel, parseTargetArg, stripCliArg, tokenizeCliArgs } from "../workspace/selector.js";
 import { resolvePackageManager } from "../workspace/package-manager.js";
 import { resolveRepoRoot } from "../workspace/repo-root.js";
 import { discoverWorkspaceTargets } from "../workspace/targets.js";
@@ -31,6 +31,45 @@ import { loadModelConfig } from "../config/model-config.js";
 import { detectBotReviewers } from "../fix-pr/bot-detector.js";
 import { runFixPrAssessment, groupAssessmentsIntoBatches } from "../fix-pr/assessment.js";
 import { updateFixPrSession } from "../storage/fix-pr-sessions.js";
+import { createWorkflowProgress } from "../platform/progress.js";
+
+
+const FIX_PR_ASSESSMENT_TIMEOUT_MS = 5 * 60 * 1_000;
+const FIX_PR_ASSESSMENT_COMMENTS_PER_BATCH = 12;
+
+const FIX_PR_STEPS = [
+  { key: "fetch-comments", label: "Fetch PR comments" },
+  { key: "select-target", label: "Select target" },
+  { key: "prepare-session", label: "Prepare session" },
+  { key: "llm-assessment", label: "LLM assessment" },
+  { key: "send-prompt", label: "Send fix prompt" },
+] as const;
+
+function createFixPrProgress(ctx: any) {
+  const progress = createWorkflowProgress(ctx.ui, {
+    title: "supi:fix-pr",
+    statusKey: "supi-fix-pr",
+    statusLabel: "Fixing PR...",
+    widgetKey: "supi-fix-pr",
+    clearStatusKeys: ["supi-model"],
+    steps: [...FIX_PR_STEPS],
+  });
+
+  return {
+    activate(stepIndex: number, detail?: string): void {
+      progress.activate(FIX_PR_STEPS[stepIndex]!.key, detail);
+    },
+    complete(stepIndex: number, detail?: string): void {
+      progress.complete(FIX_PR_STEPS[stepIndex]!.key, detail);
+    },
+    fail(stepIndex: number, detail?: string): void {
+      progress.fail(FIX_PR_STEPS[stepIndex]!.key, detail);
+    },
+    dispose(): void {
+      progress.dispose();
+    },
+  };
+}
 
 modelRegistry.register({
   id: "fix-pr",
@@ -47,6 +86,7 @@ modelRegistry.register({
   harnessRoleHint: "default",
 });
 
+
 function getScriptsDir(): string {
   return path.join(moduleDir(import.meta.url), "..", "fix-pr", "scripts");
 }
@@ -91,6 +131,12 @@ function formatUnscopedCommentCount(count: number): string {
   return `${formatCommentCount(count)} without file path`;
 }
 
+type FixPrSelectedTarget =
+  | { kind: "workspace"; target: WorkspaceTarget }
+  | { kind: "all"; target: WorkspaceTarget };
+
+const ALL_FIX_PR_TARGET_ID = "all";
+
 function buildCommentTargetOptions(
   targets: readonly WorkspaceTarget[],
   commentsByTargetId: ReadonlyMap<string, readonly PrComment[]>,
@@ -109,6 +155,43 @@ function buildCommentTargetOptions(
   });
 }
 
+function createAllCommentsTarget(repoRoot: string, packageManager: WorkspaceTarget["packageManager"]): WorkspaceTarget {
+  return {
+    id: ALL_FIX_PR_TARGET_ID,
+    name: "all",
+    kind: "workspace",
+    repoRoot,
+    packageDir: repoRoot,
+    manifestPath: path.join(repoRoot, "package.json"),
+    relativeDir: ALL_FIX_PR_TARGET_ID,
+    version: "0.0.0",
+    private: true,
+    packageManager,
+  };
+}
+
+function describeFixPrSelectedTarget(selected: FixPrSelectedTarget): string {
+  return selected.kind === "all" ? "all targets" : describeTarget(selected.target);
+}
+
+function getSelectedTargetComments(
+  selected: FixPrSelectedTarget,
+  commentsByTargetId: ReadonlyMap<string, readonly PrComment[]>,
+  unscopedComments: readonly PrComment[],
+): readonly PrComment[] {
+  if (selected.kind === "workspace") {
+    return commentsByTargetId.get(selected.target.id) ?? [];
+  }
+
+  const comments: PrComment[] = [];
+  for (const targetComments of commentsByTargetId.values()) {
+    comments.push(...targetComments);
+  }
+  comments.push(...unscopedComments);
+  return comments;
+}
+
+
 function countUnresolvedAssessments(assessment: FixPrAssessmentBatch): number {
   return assessment.assessments.filter((item: FixPrAssessmentBatch["assessments"][number]) => item.verdict !== "apply").length;
 }
@@ -211,14 +294,18 @@ export function registerFixPrCommand(platform: Platform): void {
         return;
       }
 
+      const progress = createFixPrProgress(ctx);
       const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "supi-fix-pr-"));
       try {
+        progress.activate(0, `PR #${prNumber}`);
         const fetchedCommentsPath = path.join(tempDir, "comments.jsonl");
         const fetchError = await fetchPrComments(platform, repo, prNumber, fetchedCommentsPath, repoRoot);
         if (fetchError) {
+          progress.fail(0, "failed");
           notifyError(ctx, "Failed to fetch PR comments", fetchError);
           return;
         }
+        progress.complete(0, `PR #${prNumber}`);
 
         const fetchedComments = fs.readFileSync(fetchedCommentsPath, "utf-8").trim();
         if (!fetchedComments) {
@@ -238,36 +325,74 @@ export function registerFixPrCommand(platform: Platform): void {
           clusteredComments.commentsByTargetId,
         );
 
-        if (targetOptions.length === 0) {
-          const detail = clusteredComments.unscopedComments.length > 0
-            ? `PR comments were fetched but only ${formatUnscopedCommentCount(clusteredComments.unscopedComments.length)} could not be assigned to a workspace target`
-            : "PR comments were fetched but could not be assigned to a package or root target";
-          notifyWarning(ctx, "No actionable comments found", detail);
+        const allTarget = createAllCommentsTarget(repoRoot, packageManager.id);
+        const allOption = {
+          target: allTarget,
+          changed: true,
+          label: buildWorkspaceTargetOptionLabel(
+            { target: allTarget, changed: true },
+            [formatCommentCount(parsedComments.length)],
+          ),
+        };
+
+        if (targetOptions.length === 0 && clusteredComments.unscopedComments.length === 0) {
+          notifyWarning(ctx, "No actionable comments found", "PR comments were fetched but could not be assigned to a package or root target");
           return;
         }
 
-        if (!requestedTarget && !ctx.hasUI && targetOptions.length > 1) {
-          notifyError(ctx, "Multiple comment targets found", buildAvailableTargetDetail(targetOptions, clusteredComments.unscopedComments.length));
-          return;
+        progress.activate(1, `${formatCommentCount(parsedComments.length)}`);
+        let selected: FixPrSelectedTarget | null = null;
+        if (requestedTarget === ALL_FIX_PR_TARGET_ID) {
+          selected = { kind: "all", target: allTarget };
+        } else if (requestedTarget) {
+          const target = targetOptions
+            .map((option) => option.target)
+            .find((optionTarget) => optionTarget.id === requestedTarget || optionTarget.name === requestedTarget);
+          selected = target ? { kind: "workspace", target } : null;
+        } else if (!ctx.hasUI) {
+          selected = { kind: "all", target: allTarget };
+        } else {
+          const labels = [
+            allOption.label,
+            ...targetOptions.map((option) => option.label ?? buildWorkspaceTargetOptionLabel(option)),
+          ];
+          const choice = await ctx.ui.select("Fix-PR target", labels, {
+            helpText: "Select all comments or one target to process for this run",
+          });
+          if (!choice) {
+            progress.fail(1, "cancelled");
+            return;
+          }
+          const selectedIndex = labels.indexOf(choice);
+          selected = selectedIndex === 0
+            ? { kind: "all", target: allTarget }
+            : targetOptions[selectedIndex - 1]
+              ? { kind: "workspace", target: targetOptions[selectedIndex - 1].target }
+              : null;
         }
 
-        const selectedTarget = await selectWorkspaceTarget(ctx, targetOptions, requestedTarget, {
-          title: "Fix-PR target",
-          helpText: "Select one target to process for this run",
-        });
-        if (!selectedTarget) {
+        if (!selected) {
           if (requestedTarget) {
             notifyError(ctx, "Target has no review comments", buildAvailableTargetDetail(targetOptions, clusteredComments.unscopedComments.length));
           }
+          progress.fail(1, "empty");
           return;
         }
+        progress.complete(1, describeFixPrSelectedTarget(selected));
 
-        const selectedComments = clusteredComments.commentsByTargetId.get(selectedTarget.id) ?? [];
+        const selectedTarget = selected.target;
+        const selectedComments = getSelectedTargetComments(
+          selected,
+          clusteredComments.commentsByTargetId,
+          clusteredComments.unscopedComments,
+        );
         if (selectedComments.length === 0) {
           notifyInfo(ctx, "No comments for selected target", `${selectedTarget.id} has no actionable comments in this PR snapshot`);
           return;
         }
 
+        progress.activate(2, `${formatCommentCount(selectedComments.length)}`);
+
         let activeSession = findActiveFixPrSession(platform.paths, selectedTarget, repo, prNumber);
         if (activeSession && ctx.hasUI) {
           const choice = await ctx.ui.select(
@@ -278,7 +403,10 @@ export function registerFixPrCommand(platform: Platform): void {
             ],
             { helpText: "Select session · Esc to cancel" },
           );
-          if (!choice) return;
+          if (!choice) {
+            progress.fail(2, "cancelled");
+            return;
+          }
           if (choice.startsWith("Start new")) activeSession = null;
         }
 
@@ -328,12 +456,17 @@ export function registerFixPrCommand(platform: Platform): void {
 
         const taskResolved = resolveModelForAction("task", modelRegistry, modelConfig, bridge);
         const taskModel = taskResolved.model ?? resolved.model ?? "claude-sonnet-4-6";
-        const deferredCommentsSummary = buildDeferredCommentsSummary(
-          targetOptions,
-          clusteredComments.commentsByTargetId,
-          selectedTarget,
-          clusteredComments.unscopedComments.length,
-        );
+        const deferredCommentsSummary = selected.kind === "all"
+          ? null
+          : buildDeferredCommentsSummary(
+            targetOptions,
+            clusteredComments.commentsByTargetId,
+            selectedTarget,
+            clusteredComments.unscopedComments.length,
+          );
+        progress.complete(2, activeSession ? `resume ${ledger.id}` : `new ${ledger.id}`);
+
+        progress.activate(3, `${formatCommentCount(selectedComments.length)}`);
 
         const assessmentResult = await runFixPrAssessment({
           createAgentSession: platform.createAgentSession,
@@ -342,17 +475,22 @@ export function registerFixPrCommand(platform: Platform): void {
           comments: selectedComments,
           repo,
           prNumber,
-          selectedTargetLabel: describeTarget(selectedTarget),
+          selectedTargetLabel: describeFixPrSelectedTarget(selected),
           model: resolved.model,
           thinkingLevel: resolved.thinkingLevel,
+          timeoutMs: FIX_PR_ASSESSMENT_TIMEOUT_MS,
+          maxCommentsPerBatch: FIX_PR_ASSESSMENT_COMMENTS_PER_BATCH,
         });
         if (assessmentResult.status === "blocked") {
+          progress.fail(3, "blocked");
           notifyError(ctx, "Fix-PR assessment failed", assessmentResult.error);
           return;
         }
+        progress.complete(3, `${formatCommentCount(assessmentResult.output.assessments.length)} assessed`);
         const assessment = assessmentResult.output;
         const unresolvedAssessmentCount = countUnresolvedAssessments(assessment);
         const workBatches = groupAssessmentsIntoBatches(assessment);
+        progress.activate(4, `${workBatches.length} batch${workBatches.length === 1 ? "" : "es"}`);
         ledger.assessment = assessment;
         updateFixPrSession(platform.paths, selectedTarget, ledger);
 
@@ -360,7 +498,7 @@ export function registerFixPrCommand(platform: Platform): void {
           notifyWarning(
             ctx,
             "Unresolved comments remain",
-            `${formatCommentCount(unresolvedAssessmentCount)} for ${describeTarget(selectedTarget)} still need rejection or investigation handling before this run can be considered complete.`,
+            `${formatCommentCount(unresolvedAssessmentCount)} for ${describeFixPrSelectedTarget(selected)} still need rejection or investigation handling before this run can be considered complete.`,
           );
         }
 
@@ -374,7 +512,7 @@ export function registerFixPrCommand(platform: Platform): void {
           iteration: ledger.iteration,
           skillContent,
           taskModel,
-          selectedTargetLabel: describeTarget(selectedTarget),
+          selectedTargetLabel: describeFixPrSelectedTarget(selected),
           deferredCommentsSummary,
           assessment,
           workBatches,
@@ -388,14 +526,16 @@ export function registerFixPrCommand(platform: Platform): void {
           },
           { deliverAs: "steer", triggerTurn: true },
         );
+        progress.complete(4, "sent");
 
-        const detailParts = [`${formatCommentCount(selectedComments.length)} for ${describeTarget(selectedTarget)}`];
+        const detailParts = [`${formatCommentCount(selectedComments.length)} for ${describeFixPrSelectedTarget(selected)}`];
         if (deferredCommentsSummary) {
           detailParts.push(`deferred: ${deferredCommentsSummary}`);
         }
         notifyInfo(ctx, `Fix-PR started: PR #${prNumber}`, `${detailParts.join(" | ")} | session ${ledger.id}`);
       } finally {
         fs.rmSync(tempDir, { recursive: true, force: true });
+        progress.dispose();
       }
     },
   });

package/src/config/schema.ts

@@ -1,176 +1,142 @@
-import type { TSchema } from "@sinclair/typebox";
-import { Type } from "@sinclair/typebox";
-import { Value } from "@sinclair/typebox/value";
+import { z } from "zod/v4";
+import type { ZodType } from "zod/v4";
 import type { SupipowersConfig } from "../types.js";
 import { QualityGatesSchema } from "../quality/schemas.js";
 import { UltraPlanConfigSchema } from "../ultraplan/contracts.js";
+import { collectSchemaValidationErrors } from "../ai/schema-validation.js";
 
 const TAG_FORMAT_PATTERN = "^(?:(?!\\$\\{version\\}).)*\\$\\{version\\}(?:(?!\\$\\{version\\}).)*$";
 
 
-export const ConfigSchema = Type.Object(
+export const ConfigSchema = z.object(
   {
-    version: Type.String(),
-    quality: Type.Object(
+    version: z.string(),
+    quality: z.object(
       {
         gates: QualityGatesSchema,
       },
-      { additionalProperties: false },
-    ),
-    lsp: Type.Object(
+    ).strict(),
+    lsp: z.object(
       {
-        setupGuide: Type.Boolean(),
+        setupGuide: z.boolean(),
       },
-      { additionalProperties: false },
-    ),
-    qa: Type.Object(
+    ).strict(),
+    qa: z.object(
       {
-        framework: Type.Union([Type.String(), Type.Null()]),
-        e2e: Type.Boolean(),
+        framework: z.string().nullable(),
+        e2e: z.boolean(),
       },
-      { additionalProperties: false },
-    ),
-    release: Type.Object(
+    ).strict(),
+    release: z.object(
       {
-        channels: Type.Array(Type.String()),
-        tagFormat: Type.String({ pattern: TAG_FORMAT_PATTERN }),
-        customChannels: Type.Optional(
-          Type.Record(
-            Type.String(),
-            Type.Object({
-              label: Type.String(),
-              publishCommand: Type.String(),
-              detectCommand: Type.Optional(Type.String()),
-            }),
-          ),
-        ),
+        channels: z.array(z.string()),
+        tagFormat: z.string().regex(new RegExp(TAG_FORMAT_PATTERN)),
+        customChannels: z.record(
+          z.string(),
+          z.object({
+            label: z.string(),
+            publishCommand: z.string(),
+            detectCommand: z.string().optional(),
+          }),
+        ).optional(),
       },
-      { additionalProperties: false },
-    ),
+    ).strict(),
     ultraplan: UltraPlanConfigSchema,
-    contextMode: Type.Object(
+    contextMode: z.object(
       {
-        enabled: Type.Boolean(),
-        compressionThreshold: Type.Number({ minimum: 1024 }),
-        blockHttpCommands: Type.Boolean(),
-        routingInstructions: Type.Boolean(),
-        eventTracking: Type.Boolean(),
-        compaction: Type.Boolean(),
-        llmSummarization: Type.Boolean(),
-        llmThreshold: Type.Number({ minimum: 4096 }),
-        enforceRouting: Type.Boolean(),
-        lazyTools: Type.Object(
+        enabled: z.boolean(),
+        compressionThreshold: z.number().min(1024),
+        blockHttpCommands: z.boolean(),
+        routingInstructions: z.boolean(),
+        eventTracking: z.boolean(),
+        compaction: z.boolean(),
+        llmSummarization: z.boolean(),
+        llmThreshold: z.number().min(4096),
+        enforceRouting: z.boolean(),
+        lazyTools: z.object(
           {
-            enabled: Type.Boolean(),
-            mode: Type.Union([
-              Type.Literal("conservative"),
-              Type.Literal("balanced"),
-              Type.Literal("aggressive"),
-            ]),
-            alwaysKeep: Type.Array(Type.String()),
-            commandAllowlist: Type.Record(Type.String(), Type.Array(Type.String())),
-            keywordTools: Type.Record(Type.String(), Type.Array(Type.String())),
+            enabled: z.boolean(),
+            mode: z.enum(["conservative", "balanced", "aggressive"]),
+            alwaysKeep: z.array(z.string()),
+            commandAllowlist: z.record(z.string(), z.array(z.string())),
+            keywordTools: z.record(z.string(), z.array(z.string())),
           },
-          { additionalProperties: false },
-        ),
-        processors: Type.Object(
+        ).strict(),
+        processors: z.object(
           {
-            enabled: Type.Boolean(),
-            disable: Type.Array(
-              Type.Union([
-                Type.Literal("git"),
-                Type.Literal("test"),
-                Type.Literal("lint"),
-                Type.Literal("build"),
-                Type.Literal("k8s"),
-                Type.Literal("docker"),
-                Type.Literal("log"),
-                Type.Literal("json"),
-              ]),
+            enabled: z.boolean(),
+            disable: z.array(
+              z.enum(["git", "test", "lint", "build", "k8s", "docker", "log", "json"]),
             ),
           },
-          { additionalProperties: false },
-        ),
-        cacheHandles: Type.Object(
+        ).strict(),
+        cacheHandles: z.object(
           {
-            enabled: Type.Boolean(),
-            spillThresholdBytes: Type.Number({ minimum: 1024 }),
-            previewBytes: Type.Number({ minimum: 256 }),
+            enabled: z.boolean(),
+            spillThresholdBytes: z.number().min(1024),
+            previewBytes: z.number().min(256),
           },
-          { additionalProperties: false },
-        ),
-        repomap: Type.Object(
+        ).strict(),
+        repomap: z.object(
           {
-            enabled: Type.Boolean(),
-            tokenBudget: Type.Number({ minimum: 100 }),
-            maxFiles: Type.Number({ minimum: 1 }),
+            enabled: z.boolean(),
+            tokenBudget: z.number().min(100),
+            maxFiles: z.number().min(1),
           },
-          { additionalProperties: false },
-        ),
-        memory: Type.Object(
+        ).strict(),
+        memory: z.object(
           {
-            enabled: Type.Boolean(),
-            byteBudget: Type.Number({ minimum: 256 }),
-            maxRows: Type.Number({ minimum: 1 }),
-            retentionDays: Type.Number({ minimum: 1 }),
-            focusChainCadence: Type.Integer({ minimum: 1 }),
+            enabled: z.boolean(),
+            byteBudget: z.number().min(256),
+            maxRows: z.number().min(1),
+            retentionDays: z.number().min(1),
+            focusChainCadence: z.number().int().min(1),
           },
-          { additionalProperties: false },
-        ),
+        ).strict(),
       },
-      { additionalProperties: false },
-    ),
-    mempalace: Type.Object(
+    ).strict(),
+    mempalace: z.object(
       {
-        enabled: Type.Boolean(),
-        packageVersion: Type.String({ minLength: 1 }),
-        managedVenvPath: Type.String({ minLength: 1 }),
-        palacePath: Type.String({ minLength: 1 }),
-        defaultWingStrategy: Type.Union([
-          Type.Literal("repo-name"),
-          Type.Literal("project-slug"),
-          Type.Literal("explicit"),
-        ]),
-        explicitWing: Type.Union([Type.String(), Type.Null()]),
-        defaultAgentName: Type.String({ minLength: 1 }),
-        autoSetup: Type.Boolean(),
-        hooks: Type.Object(
+        enabled: z.boolean(),
+        packageVersion: z.string().min(1),
+        managedVenvPath: z.string().min(1),
+        palacePath: z.string().min(1),
+        defaultWingStrategy: z.enum(["repo-name", "project-slug", "explicit"]),
+        explicitWing: z.string().nullable(),
+        defaultAgentName: z.string().min(1),
+        autoSetup: z.boolean(),
+        hooks: z.object(
           {
-            wakeUp: Type.Boolean(),
-            searchGuidance: Type.Boolean(),
-            autoSearchOnPrompt: Type.Boolean(),
-            compactionCheckpoint: Type.Boolean(),
-            shutdownDiary: Type.Boolean(),
+            wakeUp: z.boolean(),
+            searchGuidance: z.boolean(),
+            autoSearchOnPrompt: z.boolean(),
+            compactionCheckpoint: z.boolean(),
+            shutdownDiary: z.boolean(),
           },
-          { additionalProperties: false },
-        ),
-        budgets: Type.Object(
+        ).strict(),
+        budgets: z.object(
           {
-            wakeUpTokens: Type.Integer({ minimum: 1 }),
-            searchResultChars: Type.Integer({ minimum: 1 }),
-            listResultChars: Type.Integer({ minimum: 1 }),
-            diaryChars: Type.Integer({ minimum: 1 }),
-            autoSearchTokens: Type.Integer({ minimum: 1 }),
-            wakeUpInjectionEvery: Type.Integer({ minimum: 1 }),
-            autoSearchSimilarityFloor: Type.Number({ minimum: 0, maximum: 1 }),
-            autoSearchBm25Floor: Type.Number({ minimum: 0 }),
+            wakeUpTokens: z.number().int().min(1),
+            searchResultChars: z.number().int().min(1),
+            listResultChars: z.number().int().min(1),
+            diaryChars: z.number().int().min(1),
+            autoSearchTokens: z.number().int().min(1),
+            wakeUpInjectionEvery: z.number().int().min(1),
+            autoSearchSimilarityFloor: z.number().min(0).max(1),
+            autoSearchBm25Floor: z.number().min(0),
           },
-          { additionalProperties: false },
-        ),
-        timeouts: Type.Object(
+        ).strict(),
+        timeouts: z.object(
           {
-            setupMs: Type.Integer({ minimum: 1 }),
-            bridgeMs: Type.Integer({ minimum: 1 }),
-            hookMs: Type.Integer({ minimum: 1 }),
+            setupMs: z.number().int().min(1),
+            bridgeMs: z.number().int().min(1),
+            hookMs: z.number().int().min(1),
           },
-          { additionalProperties: false },
-        ),
+        ).strict(),
       },
-      { additionalProperties: false },
-    ), 
+    ).strict(),
   },
-  { additionalProperties: false },
-);
+).strict();
 
 export interface ConfigParseError {
   source: "global" | "root";
@@ -190,13 +156,10 @@ export interface InspectionLoadResult {
   validationErrors: ConfigValidationError[];
 }
 
-function normalizeErrorPath(path: string): string {
-  return path.replace(/^\//, "").replace(/\//g, ".") || "(root)";
-}
 
-function collectValidationErrors(schema: TSchema, data: unknown): ConfigValidationError[] {
-  return [...Value.Errors(schema, data)].map((error) => ({
-    path: normalizeErrorPath(error.path),
+function collectValidationErrors(schema: ZodType, data: unknown): ConfigValidationError[] {
+  return collectSchemaValidationErrors(schema, data).map((error) => ({
+    path: error.path,
     message: error.message,
   }));
 }

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