supipowers 2.1.0 → 2.2.1

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

package/src/lsp/contracts.ts

@@ -4,32 +4,24 @@
 // ai/structured-output.ts to schema-check model output and by
 // ai/schema-text.ts to render the shape into the prompt.
 
-import { Type, type Static } from "@sinclair/typebox";
+import { z } from "zod/v4";
 
 const DIAGNOSTIC_SEVERITIES = ["error", "warning", "info", "hint"] as const;
 
-export const LspDiagnosticSchema = Type.Object(
-  {
-    severity: Type.Union(
-      DIAGNOSTIC_SEVERITIES.map((value) => Type.Literal(value)),
-    ),
-    message: Type.String(),
-    line: Type.Number(),
-    column: Type.Number(),
-  },
-  { additionalProperties: false },
-);
+export const LspDiagnosticSchema = z.object({
+  severity: z.enum(DIAGNOSTIC_SEVERITIES),
+  message: z.string(),
+  line: z.number(),
+  column: z.number(),
+}).strict();
 
-export const LspDiagnosticsResultSchema = Type.Object(
-  {
-    file: Type.String(),
-    diagnostics: Type.Array(LspDiagnosticSchema),
-  },
-  { additionalProperties: false },
-);
+export const LspDiagnosticsResultSchema = z.object({
+  file: z.string(),
+  diagnostics: z.array(LspDiagnosticSchema),
+}).strict();
 
-export const LspDiagnosticsResultsSchema = Type.Array(LspDiagnosticsResultSchema);
+export const LspDiagnosticsResultsSchema = z.array(LspDiagnosticsResultSchema);
 
-export type LspDiagnostic = Static<typeof LspDiagnosticSchema>;
-export type LspDiagnosticsResult = Static<typeof LspDiagnosticsResultSchema>;
-export type LspDiagnosticsResults = Static<typeof LspDiagnosticsResultsSchema>;
+export type LspDiagnostic = z.infer<typeof LspDiagnosticSchema>;
+export type LspDiagnosticsResult = z.infer<typeof LspDiagnosticsResultSchema>;
+export type LspDiagnosticsResults = z.infer<typeof LspDiagnosticsResultsSchema>;

package/src/planning/planning-ask-tool.ts

@@ -129,11 +129,11 @@ function getAskRedirectReason(): string | null {
  */
 export function registerPlanningAskToolGuard(platform: Platform): void {
   platform.on("tool_call", (event) => {
-    if (event.toolName === "exit_plan_mode" && isPlanningActive()) {
+    if (event.toolName === "resolve" && isPlanApprovalResolveInput(event.input) && isPlanningActive()) {
       return {
         block: true,
         reason:
-          "Planning mode: /supi:plan uses a file-based approval hook. Do not call exit_plan_mode because it is OMP's native approval path and bypasses supipowers plan tracking.",
+          "Planning mode: /supi:plan uses a file-based approval hook. Do not call `resolve` with `extra.title` because it is OMP's native approval path and bypasses supipowers plan tracking.",
       };
     }
 
@@ -148,3 +148,14 @@ export function registerPlanningAskToolGuard(platform: Platform): void {
     };
   });
 }
+
+function isPlanApprovalResolveInput(input: unknown): boolean {
+  if (input === null || typeof input !== "object" || Array.isArray(input)) return false;
+  const candidate = input as { action?: unknown; extra?: unknown };
+  if (candidate.action !== "apply") return false;
+  const extra = candidate.extra;
+  return extra !== null
+    && typeof extra === "object"
+    && !Array.isArray(extra)
+    && typeof (extra as { title?: unknown }).title === "string";
+}

package/src/planning/spec.ts

@@ -8,35 +8,29 @@
 // Phase 3 exit gate: PlanSpec is the canonical planning artifact; markdown
 // is rendered from it via render-markdown.ts, not the other way around.
 
-import { Type, type Static } from "@sinclair/typebox";
+import { z } from "zod/v4";
 
 export const TASK_COMPLEXITY_VALUES = ["small", "medium", "large"] as const;
 
-export const PlanSpecTaskSchema = Type.Object(
-  {
-    id: Type.Integer({ minimum: 1 }),
-    name: Type.String({ minLength: 1 }),
-    description: Type.String(),
-    files: Type.Array(Type.String({ minLength: 1 })),
-    criteria: Type.String(),
-    complexity: Type.Union(TASK_COMPLEXITY_VALUES.map((v) => Type.Literal(v))),
-    model: Type.Optional(Type.String({ minLength: 1 })),
-  },
-  { additionalProperties: false },
-);
+export const PlanSpecTaskSchema = z.object({
+  id: z.number().int().min(1),
+  name: z.string().min(1),
+  description: z.string(),
+  files: z.array(z.string().min(1)),
+  criteria: z.string(),
+  complexity: z.enum(TASK_COMPLEXITY_VALUES),
+  model: z.string().min(1).optional(),
+}).strict();
 
-export const PlanSpecSchema = Type.Object(
-  {
-    name: Type.String({ minLength: 1 }),
-    /** ISO date string, e.g. "2026-04-17". Empty string is tolerated for
-     * legacy plans produced before the field was required. */
-    created: Type.String(),
-    tags: Type.Array(Type.String()),
-    context: Type.String(),
-    tasks: Type.Array(PlanSpecTaskSchema),
-  },
-  { additionalProperties: false },
-);
+export const PlanSpecSchema = z.object({
+  name: z.string().min(1),
+  /** ISO date string, e.g. "2026-04-17". Empty string is tolerated for
+   * legacy plans produced before the field was required. */
+  created: z.string(),
+  tags: z.array(z.string()),
+  context: z.string(),
+  tasks: z.array(PlanSpecTaskSchema),
+}).strict();
 
-export type PlanSpec = Static<typeof PlanSpecSchema>;
-export type PlanSpecTask = Static<typeof PlanSpecTaskSchema>;
+export type PlanSpec = z.infer<typeof PlanSpecSchema>;
+export type PlanSpecTask = z.infer<typeof PlanSpecTaskSchema>;

package/src/planning/system-prompt.ts

@@ -233,7 +233,7 @@ function buildPlanningCriticalBlock(options: PlanningSystemPromptOptions): strin
     "## Plan submission",
     "",
     "This is NOT native OMP plan mode.",
-    "You **MUST NOT** call `exit_plan_mode` or `ExitPlanMode` — that is OMP's native approval path and bypasses supipowers' file-based approval hook.",
+    "You **MUST NOT** call `resolve` with `extra.title` — that is OMP's native approval path and bypasses supipowers' file-based approval hook.",
     `You **MUST NOT** write plans to \`local://PLAN.md\` — that is OMP's native plan location and will not trigger the approval flow.`,
     `You **MUST** save the plan to \`${options.plansDir}/YYYY-MM-DD-<feature-name>.md\` using the Write tool.`,
     "After saving, tell the user the plan path, then **stop and yield your turn**.",

package/src/planning/validate.ts

@@ -5,7 +5,6 @@
 // Everyone converges on the same path so validation errors surface in one
 // consistent shape with field-level paths.
 
-import { Value } from "@sinclair/typebox/value";
 import { collectValidationErrors, formatValidationErrors } from "../ai/structured-output.js";
 import type { ValidationError } from "../types.js";
 import { PlanSpecSchema, type PlanSpec } from "./spec.js";
@@ -22,14 +21,12 @@ export interface PlanSpecValidationResult {
  * human-readable summary and `errors` lists every field-level issue.
  */
 export function validatePlanSpec(data: unknown): PlanSpecValidationResult {
-  if (Value.Check(PlanSpecSchema, data)) {
+  const errors = collectValidationErrors(PlanSpecSchema, data);
+  if (errors.length === 0) {
     return { output: data as PlanSpec, error: null, errors: [] };
   }
 
-  const errors = collectValidationErrors(PlanSpecSchema, data);
-  const error = errors.length > 0
-    ? formatValidationErrors(errors).join("; ")
-    : "Plan does not match the PlanSpec schema.";
+  const error = formatValidationErrors(errors).join("; ") || "Plan does not match the PlanSpec schema.";
   return { output: null, error, errors };
 }
 
@@ -37,7 +34,7 @@ export function validatePlanSpec(data: unknown): PlanSpecValidationResult {
  * Narrowing predicate for PlanSpec. Use when you do not need error detail.
  */
 export function isPlanSpec(value: unknown): value is PlanSpec {
-  return Value.Check(PlanSpecSchema, value);
+  return collectValidationErrors(PlanSpecSchema, value).length === 0;
 }
 
 

package/src/platform/progress.ts

@@ -58,6 +58,7 @@ export function createWorkflowProgress(ui: PlatformUI, options: WorkflowProgress
   let frame = 0;
   let statusActive = false;
   let timer: ReturnType<typeof setInterval> | null = null;
+  let disposed = false;
 
   function visibleSteps(): WorkflowStepState[] {
     return steps.filter((step) => !step.hidden);
@@ -92,6 +93,9 @@ export function createWorkflowProgress(ui: PlatformUI, options: WorkflowProgress
   }
 
   function refresh() {
+    if (disposed) {
+      return;
+    }
     frame++;
     ui.setWidget?.(widgetKey, () => new Text(renderWidgetText(), 0, 0));
     if (statusActive) {
@@ -100,6 +104,9 @@ export function createWorkflowProgress(ui: PlatformUI, options: WorkflowProgress
   }
 
   function startTimer() {
+    if (disposed) {
+      return;
+    }
     if (!timer) {
       timer = setInterval(refresh, 80);
     }
@@ -117,6 +124,9 @@ export function createWorkflowProgress(ui: PlatformUI, options: WorkflowProgress
   }
 
   function setStatus(stepKey: string, status: WorkflowStepStatus, detail?: string) {
+    if (disposed) {
+      return;
+    }
     const step = getStep(stepKey);
     if (!step) {
       return;
@@ -170,6 +180,7 @@ export function createWorkflowProgress(ui: PlatformUI, options: WorkflowProgress
       refresh();
     },
     dispose() {
+      disposed = true;
       stopTimer();
       ui.setStatus?.(options.statusKey, undefined);
       for (const key of options.clearStatusKeys ?? []) {

package/src/quality/contracts.ts

@@ -1,34 +1,26 @@
 // src/quality/contracts.ts
 //
-// TypeBox contracts for AI-driven quality-gate workflows. Embedded into
+// Zod contracts for AI-driven quality-gate workflows. Embedded into
 // prompts via ai/schema-text.ts and used by ai/structured-output.ts to
 // validate model output with retry-on-invalid feedback.
 
-import { Type, type Static } from "@sinclair/typebox";
+import { z } from "zod/v4";
 
 const ISSUE_SEVERITIES = ["error", "warning", "info"] as const;
 const RECOMMENDED_STATUSES = ["passed", "failed", "blocked"] as const;
 
-export const AiReviewIssueSchema = Type.Object(
-  {
-    severity: Type.Union(ISSUE_SEVERITIES.map((value) => Type.Literal(value))),
-    message: Type.String({ minLength: 1 }),
-    file: Type.Optional(Type.String()),
-    line: Type.Optional(Type.Number()),
-    detail: Type.Optional(Type.String()),
-  },
-  { additionalProperties: false },
-);
+export const AiReviewIssueSchema = z.object({
+  severity: z.enum(ISSUE_SEVERITIES),
+  message: z.string().min(1),
+  file: z.string().optional(),
+  line: z.number().optional(),
+  detail: z.string().optional(),
+}).strict();
 
-export const AiReviewOutputSchema = Type.Object(
-  {
-    summary: Type.String(),
-    issues: Type.Array(AiReviewIssueSchema),
-    recommendedStatus: Type.Union(
-      RECOMMENDED_STATUSES.map((value) => Type.Literal(value)),
-    ),
-  },
-  { additionalProperties: false },
-);
+export const AiReviewOutputSchema = z.object({
+  summary: z.string(),
+  issues: z.array(AiReviewIssueSchema),
+  recommendedStatus: z.enum(RECOMMENDED_STATUSES),
+}).strict();
 
-export type AiReviewOutput = Static<typeof AiReviewOutputSchema>;
+export type AiReviewOutput = z.infer<typeof AiReviewOutputSchema>;

package/src/quality/schemas.ts

@@ -1,79 +1,52 @@
-import { Type } from "@sinclair/typebox";
-import type { TSchema } from "@sinclair/typebox";
+import { z } from "zod/v4";
+import type { ZodType } from "zod/v4";
 import type { GateId } from "../types.js";
 
-export const LspDiagnosticsGateConfigSchema = Type.Object(
-  {
-    enabled: Type.Boolean(),
-  },
-  { additionalProperties: false },
-);
+export const LspDiagnosticsGateConfigSchema = z.object({
+  enabled: z.boolean(),
+}).strict();
 
-export const CommandGateRunTargetSchema = Type.Union([
-  Type.Object(
-    {
-      scope: Type.Literal("all-targets"),
-    },
-    { additionalProperties: false },
-  ),
-  Type.Object(
-    {
-      scope: Type.Literal("root"),
-    },
-    { additionalProperties: false },
-  ),
-  Type.Object(
-    {
-      scope: Type.Literal("all-workspaces"),
-    },
-    { additionalProperties: false },
-  ),
-  Type.Object(
-    {
-      scope: Type.Literal("workspace"),
-      relativeDir: Type.String({ minLength: 1 }),
-    },
-    { additionalProperties: false },
-  ),
+export const CommandGateRunTargetSchema = z.union([
+  z.object({
+    scope: z.literal("all-targets"),
+  }).strict(),
+  z.object({
+    scope: z.literal("root"),
+  }).strict(),
+  z.object({
+    scope: z.literal("all-workspaces"),
+  }).strict(),
+  z.object({
+    scope: z.literal("workspace"),
+    relativeDir: z.string().min(1),
+  }).strict(),
 ]);
 
-export const CommandGateRunSchema = Type.Object(
-  {
-    command: Type.String({ minLength: 1 }),
-    target: CommandGateRunTargetSchema,
-  },
-  { additionalProperties: false },
-);
+export const CommandGateRunSchema = z.object({
+  command: z.string().min(1),
+  target: CommandGateRunTargetSchema,
+}).strict();
 
-export const CommandGateConfigSchema = Type.Union([
-  Type.Object(
-    {
-      enabled: Type.Literal(false),
-    },
-    { additionalProperties: false },
-  ),
-  Type.Object(
-    {
-      enabled: Type.Literal(true),
-      runs: Type.Array(CommandGateRunSchema, { minItems: 1 }),
-    },
-    { additionalProperties: false },
-  ),
+export const CommandGateConfigSchema = z.union([
+  z.object({
+    enabled: z.literal(false),
+  }).strict(),
+  z.object({
+    enabled: z.literal(true),
+    runs: z.array(CommandGateRunSchema).min(1),
+  }).strict(),
 ]);
 
-export const QualityGatesSchema = Type.Object(
-  {
-    "lsp-diagnostics": Type.Optional(LspDiagnosticsGateConfigSchema),
-    lint: Type.Optional(CommandGateConfigSchema),
-    typecheck: Type.Optional(CommandGateConfigSchema),
-    format: Type.Optional(CommandGateConfigSchema),
-    "test-suite": Type.Optional(CommandGateConfigSchema),
-    build: Type.Optional(CommandGateConfigSchema),
-  },
-  { additionalProperties: false },
-);
+export const QualityGatesSchema = z.object({
+  "lsp-diagnostics": LspDiagnosticsGateConfigSchema.optional(),
+  lint: CommandGateConfigSchema.optional(),
+  typecheck: CommandGateConfigSchema.optional(),
+  format: CommandGateConfigSchema.optional(),
+  "test-suite": CommandGateConfigSchema.optional(),
+  build: CommandGateConfigSchema.optional(),
+}).strict();
 
-export const GATE_CONFIG_SCHEMAS: Record<GateId, TSchema> = {
+export const GATE_CONFIG_SCHEMAS: Record<GateId, ZodType> = {
   "lsp-diagnostics": LspDiagnosticsGateConfigSchema,
   lint: CommandGateConfigSchema,
   typecheck: CommandGateConfigSchema,

package/src/release/contracts.ts

@@ -15,49 +15,40 @@
 // hands validation errors back to the model rather than letting the
 // release command publish on malformed output.
 
-import { Type, type Static } from "@sinclair/typebox";
+import { z } from "zod/v4";
 
 // ── Release-note polish ───────────────────────────────────────
 
 export const RELEASE_NOTE_STATUSES = ["ok", "empty"] as const;
 export type ReleaseNoteStatus = (typeof RELEASE_NOTE_STATUSES)[number];
 
-export const ReleaseNotePolishOutputSchema = Type.Object(
-  {
-    title: Type.String({ minLength: 1 }),
-    body: Type.String(),
-    highlights: Type.Array(Type.String({ minLength: 1 })),
-    status: Type.Union(RELEASE_NOTE_STATUSES.map((value) => Type.Literal(value))),
-  },
-  { additionalProperties: false },
-);
+export const ReleaseNotePolishOutputSchema = z.object({
+  title: z.string().min(1),
+  body: z.string(),
+  highlights: z.array(z.string().min(1)),
+  status: z.enum(RELEASE_NOTE_STATUSES),
+}).strict();
 
-export type ReleaseNotePolishOutput = Static<typeof ReleaseNotePolishOutputSchema>;
+export type ReleaseNotePolishOutput = z.infer<typeof ReleaseNotePolishOutputSchema>;
 
 // ── Release doc-fix ───────────────────────────────────────────
 
 export const RELEASE_DOC_FIX_STATUSES = ["ok", "blocked"] as const;
 export type ReleaseDocFixStatus = (typeof RELEASE_DOC_FIX_STATUSES)[number];
 
-export const ReleaseDocFixEditSchema = Type.Object(
-  {
-    file: Type.String({ minLength: 1 }),
-    instructions: Type.String({ minLength: 1 }),
-  },
-  { additionalProperties: false },
-);
+export const ReleaseDocFixEditSchema = z.object({
+  file: z.string().min(1),
+  instructions: z.string().min(1),
+}).strict();
 
-export const ReleaseDocFixOutputSchema = Type.Object(
-  {
-    edits: Type.Array(ReleaseDocFixEditSchema),
-    summary: Type.String({ minLength: 1 }),
-    status: Type.Union(RELEASE_DOC_FIX_STATUSES.map((value) => Type.Literal(value))),
-  },
-  { additionalProperties: false },
-);
+export const ReleaseDocFixOutputSchema = z.object({
+  edits: z.array(ReleaseDocFixEditSchema),
+  summary: z.string().min(1),
+  status: z.enum(RELEASE_DOC_FIX_STATUSES),
+}).strict();
 
-export type ReleaseDocFixEdit = Static<typeof ReleaseDocFixEditSchema>;
-export type ReleaseDocFixOutput = Static<typeof ReleaseDocFixOutputSchema>;
+export type ReleaseDocFixEdit = z.infer<typeof ReleaseDocFixEditSchema>;
+export type ReleaseDocFixOutput = z.infer<typeof ReleaseDocFixOutputSchema>;
 
 /**
  * Render a polished release-note artifact as markdown suitable for