@webpresso/agent-kit 0.21.0

package/dist/esm/blueprint/tech-debt/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * TechDebt schema module exports
+ *
+ * Re-exports all schemas and types for technical debt document validation
+ */
+export { extractCheckboxStatus, parseTechDebt, type RemediationStep, serializeTechDebt, type TechDebtItem, } from './parser.js';
+export { isCategory, isSeverity, isTechDebtStatus, type TechDebtQueryFilters, type TechDebtQueryResult, type TechDebtQuerySummary, type TechDebtRecord, type TechDebtSortField, type TechDebtSortOptions, } from './query-types.js';
+export { categorySchema, type ReviewCadence, reviewCadenceSchema, severitySchema, type TechDebtCategory, type TechDebtFrontmatter, type TechDebtSeverity, type TechDebtSlug, type TechDebtStatus, techDebtFrontmatterSchema, techDebtSlugSchema, techDebtStatusSchema, } from './schema.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/blueprint/tech-debt/index.js

@@ -0,0 +1,9 @@
+/**
+ * TechDebt schema module exports
+ *
+ * Re-exports all schemas and types for technical debt document validation
+ */
+export { extractCheckboxStatus, parseTechDebt, serializeTechDebt, } from './parser.js';
+export { isCategory, isSeverity, isTechDebtStatus, } from './query-types.js';
+export { categorySchema, reviewCadenceSchema, severitySchema, techDebtFrontmatterSchema, techDebtSlugSchema, techDebtStatusSchema, } from './schema.js';
+//# sourceMappingURL=index.js.map

package/dist/esm/blueprint/tech-debt/parser.d.ts

@@ -0,0 +1,56 @@
+/**
+ * TechDebt Parser
+ *
+ * Parses technical debt markdown files with validated frontmatter.
+ * Uses Zod schema for type-safe frontmatter validation.
+ *
+ * Key features:
+ * - Extracts hazard ID from H1 heading (# H-XXX: Title)
+ * - Extracts remediation steps from #### Step X: format
+ * - Computes checkbox completion status (Git-Native SSoT)
+ * - Validates frontmatter using techDebtFrontmatterSchema
+ */
+/**
+ * Extract checkbox status from a section
+ * Returns total count and checked count
+ */
+export declare function extractCheckboxStatus(section: string): {
+    total: number;
+    checked: number;
+};
+export interface RemediationStep {
+    id: string;
+    title: string;
+    checked: boolean;
+}
+export interface TechDebtItem {
+    slug: string;
+    hazardId: string | null;
+    title: string;
+    status: string;
+    severity: string;
+    category?: string;
+    reviewCadence?: string;
+    lastReviewed?: string;
+    nextReview: string;
+    basePriority: number;
+    linkedBlueprints?: string[];
+    diagrams: string[];
+    remediationSteps: RemediationStep[];
+    raw: string;
+}
+/**
+ * Parse a technical debt markdown document
+ *
+ * @param markdown - Full markdown content with frontmatter
+ * @param slug - Document slug (usually filename without extension)
+ * @returns Parsed TechDebtItem with all fields
+ * @throws ZodError if frontmatter validation fails
+ */
+export declare function parseTechDebt(markdown: string, slug: string): TechDebtItem;
+/**
+ * Serialize a TechDebtItem back to markdown
+ * Updates frontmatter fields while preserving content
+ */
+export declare function serializeTechDebt(item: TechDebtItem): string;
+//# sourceMappingURL=parser.d.ts.map

package/dist/esm/blueprint/tech-debt/parser.js

@@ -0,0 +1,133 @@
+/**
+ * TechDebt Parser
+ *
+ * Parses technical debt markdown files with validated frontmatter.
+ * Uses Zod schema for type-safe frontmatter validation.
+ *
+ * Key features:
+ * - Extracts hazard ID from H1 heading (# H-XXX: Title)
+ * - Extracts remediation steps from #### Step X: format
+ * - Computes checkbox completion status (Git-Native SSoT)
+ * - Validates frontmatter using techDebtFrontmatterSchema
+ */
+import matter from 'gray-matter';
+import { extractCodeBlocks } from '#markdown/helpers';
+import { techDebtFrontmatterSchema } from './schema.js';
+/**
+ * Parse markdown with frontmatter and validate against a Zod schema.
+ * Throws ZodError if validation fails.
+ */
+function parseWithSchema(markdown, schema) {
+    const { data: rawData, content } = matter(markdown);
+    const data = schema.parse(rawData);
+    return { data, content };
+}
+/**
+ * Extract checkbox status from a section
+ * Returns total count and checked count
+ */
+export function extractCheckboxStatus(section) {
+    const checkboxRegex = /^- \[([ x])\]/gm;
+    const matches = Array.from(section.matchAll(checkboxRegex));
+    const total = matches.length;
+    const checked = matches.filter((m) => m[1] === 'x').length;
+    return { total, checked };
+}
+/**
+ * Extract hazard ID from first H1 heading
+ * Format: # H-001: Title
+ * Returns: "H-001" or null if not found
+ */
+function extractHazardId(content) {
+    const hazardMatch = content.match(/^#\s+H-(\d+):/m);
+    if (!hazardMatch?.[1])
+        return null;
+    return `H-${hazardMatch[1]}`;
+}
+/**
+ * Extract title from first H1 heading
+ * Format: # H-001: Title → "Title"
+ * Or: # Title → "Title"
+ */
+function extractTitle(content) {
+    const h1Match = content.match(/^#\s+(?:H-\d+:\s*)?(.+)$/m);
+    return (h1Match?.[1] ?? 'Untitled').trim();
+}
+/**
+ * Extract remediation steps from markdown
+ * Format: #### Step X: Title
+ * Checkbox status is extracted from content under each step
+ */
+function extractRemediationSteps(content) {
+    const stepRegex = /^####\s+Step\s+(\d+):\s*(.+)$/gm;
+    const matches = Array.from(content.matchAll(stepRegex));
+    if (!matches.length) {
+        return [];
+    }
+    return matches.map((match, index) => {
+        const id = match[1] ?? '';
+        const stepStart = match.index ?? 0;
+        const nextStepIndex = matches[index + 1]?.index ?? content.length;
+        // Extract section between this step and next step (or end of content)
+        const stepSection = content.slice(stepStart, nextStepIndex);
+        const { checked: checkedCount } = extractCheckboxStatus(stepSection);
+        return {
+            id,
+            title: (match[2] ?? '').trim(),
+            checked: checkedCount > 0, // Step is checked if any of its checkboxes are checked
+        };
+    });
+}
+/**
+ * Parse a technical debt markdown document
+ *
+ * @param markdown - Full markdown content with frontmatter
+ * @param slug - Document slug (usually filename without extension)
+ * @returns Parsed TechDebtItem with all fields
+ * @throws ZodError if frontmatter validation fails
+ */
+export function parseTechDebt(markdown, slug) {
+    // Parse and validate frontmatter using Zod schema
+    // This throws ZodError if frontmatter is invalid
+    const { data, content } = parseWithSchema(markdown, techDebtFrontmatterSchema);
+    const hazardId = extractHazardId(content);
+    const title = extractTitle(content);
+    const diagrams = extractCodeBlocks(content, 'mermaid');
+    const remediationSteps = extractRemediationSteps(content);
+    // Convert date fields to string format for consistency
+    const lastReviewed = data.last_reviewed instanceof Date
+        ? (data.last_reviewed.toISOString().split('T')[0] ?? '')
+        : String(data.last_reviewed ?? '');
+    return {
+        slug,
+        hazardId,
+        title,
+        status: data.status,
+        severity: data.severity,
+        category: data.category,
+        reviewCadence: data.review_cadence,
+        lastReviewed,
+        nextReview: data.nextReview, // Computed by Zod transform
+        basePriority: data.basePriority, // Computed by Zod transform
+        linkedBlueprints: data.linked_blueprints,
+        diagrams,
+        remediationSteps,
+        raw: markdown,
+    };
+}
+/**
+ * Serialize a TechDebtItem back to markdown
+ * Updates frontmatter fields while preserving content
+ */
+export function serializeTechDebt(item) {
+    const { data, content } = matter(item.raw);
+    // Update mutable frontmatter fields
+    if (item.status)
+        data.status = item.status;
+    if (item.lastReviewed)
+        data.last_reviewed = item.lastReviewed;
+    // Remove computed fields (they are regenerated on parse)
+    const { nextReview: _nextReview, basePriority: _basePriority, ...cleanedData } = data;
+    return matter.stringify(content, cleanedData);
+}
+//# sourceMappingURL=parser.js.map

package/dist/esm/blueprint/tech-debt/query-types.d.ts

@@ -0,0 +1,130 @@
+/**
+ * TechDebt Query Types for Service Layer
+ *
+ * These types extend the base tech debt schema with query-specific fields
+ * for filtering, sorting, and summarizing technical debt records.
+ *
+ * Follows the pattern established in blueprint/query-types.ts.
+ */
+import { type TechDebtCategory, type TechDebtSeverity, type TechDebtStatus } from './schema.js';
+/**
+ * Freshness score for a tech debt document
+ * Tracks how recently the debt was reviewed
+ */
+export interface FreshnessScore {
+    score: number;
+    daysSinceUpdate: number;
+    status: 'fresh' | 'aging' | 'stale' | 'critical';
+}
+/**
+ * Summary view of a tech debt record for list displays.
+ * Contains essential fields for quick overview.
+ */
+export interface TechDebtQuerySummary {
+    /** Unique identifier derived from document filename */
+    slug: string;
+    /** Human-readable title extracted from document */
+    title: string;
+    /** Current debt status (accepted, needs-remediation, monitoring, resolved) */
+    status: TechDebtStatus;
+    /** Severity level (critical, high, medium, low) */
+    severity: TechDebtSeverity;
+    /** Type of technical debt */
+    category?: TechDebtCategory;
+    /** Computed priority score (higher = more urgent) */
+    priorityScore: number;
+    /** ISO date string for next scheduled review */
+    nextReview?: string;
+}
+/**
+ * Extended tech debt record with query-specific fields.
+ * Used for detailed queries and tech debt dashboards.
+ */
+export interface TechDebtRecord extends TechDebtQuerySummary {
+    /** Parent group derived from path (e.g., "testing"), null if top-level */
+    group: string | null;
+    /** Full file path to the tech debt markdown document */
+    path: string;
+    /** Date when the debt was last reviewed */
+    lastReviewed?: Date;
+    /** Calculated freshness score based on review status and last review date */
+    freshness: FreshnessScore;
+    /** Array of blueprint slugs that reference this tech debt */
+    linkedBlueprints: string[];
+}
+/**
+ * Query filters for tech debt searches.
+ * All fields are optional; multiple values use OR logic within a field.
+ */
+export interface TechDebtQueryFilters {
+    /** Filter by debt status (single or multiple values) */
+    status?: TechDebtStatus | TechDebtStatus[];
+    /** Filter by severity level (single or multiple values) */
+    severity?: TechDebtSeverity | TechDebtSeverity[];
+    /** Filter by category (single or multiple values) */
+    category?: TechDebtCategory | TechDebtCategory[];
+    /** Filter for overdue items (next_review < now) */
+    overdue?: boolean;
+    /** Filter for stale items only (not reviewed in N days) */
+    staleDays?: number;
+}
+/**
+ * Available fields for sorting tech debt results.
+ */
+export type TechDebtSortField = 'priorityScore' | 'nextReview' | 'lastReviewed' | 'slug' | 'severity';
+/**
+ * Sort direction for query results.
+ */
+export type SortDirection = 'asc' | 'desc';
+/**
+ * Sorting options for tech debt queries.
+ */
+export interface TechDebtSortOptions {
+    /** Field to sort by */
+    field: TechDebtSortField;
+    /** Sort direction (ascending or descending) */
+    direction: SortDirection;
+}
+/**
+ * Query result with tech debt records and aggregate summary.
+ * Provides both the filtered results and useful statistics.
+ */
+export interface TechDebtQueryResult {
+    /** List of matching tech debt records */
+    items: TechDebtRecord[];
+    /** Aggregate summary of the query results */
+    summary: {
+        /** Total number of matching items */
+        total: number;
+        /** Count of items by status */
+        byStatus: Record<string, number>;
+        /** Count of items by severity */
+        bySeverity: Record<string, number>;
+        /** Number of overdue items (past next_review date) */
+        overdueCount: number;
+        /** Average priority score across all items */
+        avgPriority: number;
+    };
+}
+/**
+ * Type guard to check if a string is a valid TechDebtStatus.
+ * Derives valid values from the Zod schema to ensure single source of truth.
+ * @param value - The string to check
+ * @returns True if the value is a valid TechDebtStatus
+ */
+export declare function isTechDebtStatus(value: string): value is TechDebtStatus;
+/**
+ * Type guard to check if a string is a valid Severity.
+ * Derives valid values from the Zod schema to ensure single source of truth.
+ * @param value - The string to check
+ * @returns True if the value is a valid Severity
+ */
+export declare function isSeverity(value: string): value is TechDebtSeverity;
+/**
+ * Type guard to check if a string is a valid TechDebtCategory.
+ * Derives valid values from the Zod schema to ensure single source of truth.
+ * @param value - The string to check
+ * @returns True if the value is a valid TechDebtCategory
+ */
+export declare function isCategory(value: string): value is TechDebtCategory;
+//# sourceMappingURL=query-types.d.ts.map

package/dist/esm/blueprint/tech-debt/query-types.js

@@ -0,0 +1,37 @@
+/**
+ * TechDebt Query Types for Service Layer
+ *
+ * These types extend the base tech debt schema with query-specific fields
+ * for filtering, sorting, and summarizing technical debt records.
+ *
+ * Follows the pattern established in blueprint/query-types.ts.
+ */
+import { categorySchema, severitySchema, techDebtStatusSchema, } from './schema.js';
+/**
+ * Type guard to check if a string is a valid TechDebtStatus.
+ * Derives valid values from the Zod schema to ensure single source of truth.
+ * @param value - The string to check
+ * @returns True if the value is a valid TechDebtStatus
+ */
+export function isTechDebtStatus(value) {
+    return techDebtStatusSchema.options.includes(value);
+}
+/**
+ * Type guard to check if a string is a valid Severity.
+ * Derives valid values from the Zod schema to ensure single source of truth.
+ * @param value - The string to check
+ * @returns True if the value is a valid Severity
+ */
+export function isSeverity(value) {
+    return severitySchema.options.includes(value);
+}
+/**
+ * Type guard to check if a string is a valid TechDebtCategory.
+ * Derives valid values from the Zod schema to ensure single source of truth.
+ * @param value - The string to check
+ * @returns True if the value is a valid TechDebtCategory
+ */
+export function isCategory(value) {
+    return categorySchema.options.includes(value);
+}
+//# sourceMappingURL=query-types.js.map

package/dist/esm/blueprint/tech-debt/schema.d.ts

@@ -0,0 +1,151 @@
+/**
+ * Zod schema for TechDebt frontmatter validation
+ *
+ * This schema defines the structure and validation rules for tech debt documents.
+ * Using Zod v4 features:
+ * - Branded types for type-safe slugs
+ * - Transform functions for computed fields (nextReview, basePriority)
+ * - Refinements for cross-field validation
+ * - Enum schemas for constrained string values
+ *
+ * Follows the Agentic Context Standard for technical debt tracking.
+ */
+import { z } from 'zod';
+/**
+ * Valid tech debt status values
+ * Maps to lifecycle: needs-remediation → monitoring → resolved
+ * 'accepted' = acknowledged debt that won't be fixed immediately
+ */
+export declare const techDebtStatusSchema: z.ZodEnum<{
+    accepted: "accepted";
+    "needs-remediation": "needs-remediation";
+    monitoring: "monitoring";
+    resolved: "resolved";
+}>;
+/**
+ * Valid severity levels
+ * Used to compute base priority score
+ */
+export declare const severitySchema: z.ZodEnum<{
+    low: "low";
+    medium: "medium";
+    high: "high";
+    critical: "critical";
+}>;
+/**
+ * Valid debt categories
+ * Categories align with common technical debt types
+ */
+export declare const categorySchema: z.ZodEnum<{
+    complexity: "complexity";
+    testing: "testing";
+    mutation: "mutation";
+    duplication: "duplication";
+    dependency: "dependency";
+    security: "security";
+    documentation: "documentation";
+}>;
+/**
+ * Valid review cadence intervals
+ * Determines how often debt should be reviewed
+ */
+export declare const reviewCadenceSchema: z.ZodEnum<{
+    weekly: "weekly";
+    biweekly: "biweekly";
+    monthly: "monthly";
+    quarterly: "quarterly";
+}>;
+/**
+ * Branded slug type for type-safe TechDebt identification
+ * Ensures slugs are non-empty strings with compile-time type safety
+ */
+export declare const techDebtSlugSchema: z.core.$ZodBranded<z.ZodString, "TechDebtSlug", "out">;
+/**
+ * TechDebt frontmatter schema with transforms and refinements
+ *
+ * Required fields:
+ * - type: Always 'tech-debt'
+ * - status: Current debt status
+ * - severity: Severity level (affects priority)
+ * - category: Type of technical debt
+ * - review_cadence: How often to review
+ * - last_reviewed: Last review date (ISO format YYYY-MM-DD)
+ *
+ * Optional fields:
+ * - created: Date debt was first identified
+ * - linked_blueprints: Array of blueprint slugs referencing this debt
+ * - affected_modules: Array of affected module/package names
+ *
+ * Computed fields (added by transform):
+ * - nextReview: Calculated from last_reviewed + review_cadence
+ * - basePriority: Score derived from severity (10-40)
+ */
+export declare const techDebtFrontmatterSchema: z.ZodPipe<z.ZodObject<{
+    type: z.ZodLiteral<"tech-debt">;
+    status: z.ZodEnum<{
+        accepted: "accepted";
+        "needs-remediation": "needs-remediation";
+        monitoring: "monitoring";
+        resolved: "resolved";
+    }>;
+    severity: z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        critical: "critical";
+    }>;
+    category: z.ZodEnum<{
+        complexity: "complexity";
+        testing: "testing";
+        mutation: "mutation";
+        duplication: "duplication";
+        dependency: "dependency";
+        security: "security";
+        documentation: "documentation";
+    }>;
+    review_cadence: z.ZodEnum<{
+        weekly: "weekly";
+        biweekly: "biweekly";
+        monthly: "monthly";
+        quarterly: "quarterly";
+    }>;
+    last_reviewed: z.ZodUnion<readonly [z.ZodString, z.ZodDate]>;
+    created: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodDate]>>;
+    linked_blueprints: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    affected_modules: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    auto_filed_hash: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodTransform<{
+    nextReview: string;
+    basePriority: number;
+    type: "tech-debt";
+    status: "accepted" | "needs-remediation" | "monitoring" | "resolved";
+    severity: "low" | "medium" | "high" | "critical";
+    category: "complexity" | "testing" | "mutation" | "duplication" | "dependency" | "security" | "documentation";
+    review_cadence: "weekly" | "biweekly" | "monthly" | "quarterly";
+    last_reviewed: string | Date;
+    linked_blueprints: string[];
+    affected_modules: string[];
+    created?: string | Date | undefined;
+    auto_filed_hash?: string | undefined;
+}, {
+    type: "tech-debt";
+    status: "accepted" | "needs-remediation" | "monitoring" | "resolved";
+    severity: "low" | "medium" | "high" | "critical";
+    category: "complexity" | "testing" | "mutation" | "duplication" | "dependency" | "security" | "documentation";
+    review_cadence: "weekly" | "biweekly" | "monthly" | "quarterly";
+    last_reviewed: string | Date;
+    linked_blueprints: string[];
+    affected_modules: string[];
+    created?: string | Date | undefined;
+    auto_filed_hash?: string | undefined;
+}>>;
+/**
+ * Infer TypeScript types from schemas
+ */
+export type TechDebtFrontmatter = z.infer<typeof techDebtFrontmatterSchema>;
+export type TechDebtStatus = z.infer<typeof techDebtStatusSchema>;
+export type TechDebtSeverity = z.infer<typeof severitySchema>;
+export type TechDebtCategory = z.infer<typeof categorySchema>;
+export type ReviewCadence = z.infer<typeof reviewCadenceSchema>;
+export type TechDebtSlug = z.infer<typeof techDebtSlugSchema>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/esm/blueprint/tech-debt/schema.js

@@ -0,0 +1,145 @@
+/**
+ * Zod schema for TechDebt frontmatter validation
+ *
+ * This schema defines the structure and validation rules for tech debt documents.
+ * Using Zod v4 features:
+ * - Branded types for type-safe slugs
+ * - Transform functions for computed fields (nextReview, basePriority)
+ * - Refinements for cross-field validation
+ * - Enum schemas for constrained string values
+ *
+ * Follows the Agentic Context Standard for technical debt tracking.
+ */
+import { z } from 'zod';
+/**
+ * Valid tech debt status values
+ * Maps to lifecycle: needs-remediation → monitoring → resolved
+ * 'accepted' = acknowledged debt that won't be fixed immediately
+ */
+export const techDebtStatusSchema = z.enum([
+    'accepted',
+    'needs-remediation',
+    'monitoring',
+    'resolved',
+]);
+/**
+ * Valid severity levels
+ * Used to compute base priority score
+ */
+export const severitySchema = z.enum(['critical', 'high', 'medium', 'low']);
+/**
+ * Valid debt categories
+ * Categories align with common technical debt types
+ */
+export const categorySchema = z.enum([
+    'complexity',
+    'testing',
+    'mutation',
+    'duplication',
+    'dependency',
+    'security',
+    'documentation',
+]);
+/**
+ * Valid review cadence intervals
+ * Determines how often debt should be reviewed
+ */
+export const reviewCadenceSchema = z.enum(['weekly', 'biweekly', 'monthly', 'quarterly']);
+/**
+ * Branded slug type for type-safe TechDebt identification
+ * Ensures slugs are non-empty strings with compile-time type safety
+ */
+export const techDebtSlugSchema = z.string().min(1).brand();
+/**
+ * Compute next review date based on last review and cadence
+ * @param lastReviewed - ISO date string of last review
+ * @param cadence - Review frequency
+ * @returns ISO date string for next scheduled review
+ */
+function computeNextReview(lastReviewed, cadence) {
+    const lastDate = new Date(lastReviewed);
+    // Map cadence to days
+    const daysMap = {
+        weekly: 7,
+        biweekly: 14,
+        monthly: 30,
+        quarterly: 90,
+    };
+    const days = daysMap[cadence];
+    // Use UTC arithmetic to avoid timezone/DST off-by-one when the input is an ISO date string
+    const nextDate = new Date(Date.UTC(lastDate.getUTCFullYear(), lastDate.getUTCMonth(), lastDate.getUTCDate() + days));
+    return nextDate.toISOString().slice(0, 10);
+}
+/**
+ * Compute base priority score from severity level
+ * Used in priority scoring algorithm
+ */
+function computeBasePriority(severity) {
+    const scoreMap = {
+        critical: 40,
+        high: 30,
+        medium: 20,
+        low: 10,
+    };
+    return scoreMap[severity];
+}
+/**
+ * TechDebt frontmatter schema with transforms and refinements
+ *
+ * Required fields:
+ * - type: Always 'tech-debt'
+ * - status: Current debt status
+ * - severity: Severity level (affects priority)
+ * - category: Type of technical debt
+ * - review_cadence: How often to review
+ * - last_reviewed: Last review date (ISO format YYYY-MM-DD)
+ *
+ * Optional fields:
+ * - created: Date debt was first identified
+ * - linked_blueprints: Array of blueprint slugs referencing this debt
+ * - affected_modules: Array of affected module/package names
+ *
+ * Computed fields (added by transform):
+ * - nextReview: Calculated from last_reviewed + review_cadence
+ * - basePriority: Score derived from severity (10-40)
+ */
+export const techDebtFrontmatterSchema = z
+    .object({
+    type: z.literal('tech-debt'),
+    status: techDebtStatusSchema,
+    severity: severitySchema,
+    category: categorySchema,
+    review_cadence: reviewCadenceSchema,
+    // Date fields - support both string and Date for flexibility
+    last_reviewed: z.union([z.string(), z.date()]),
+    created: z.union([z.string(), z.date()]).optional(),
+    // Cross-references
+    linked_blueprints: z
+        .array(z.string())
+        .optional()
+        .default(() => []),
+    affected_modules: z
+        .array(z.string())
+        .optional()
+        .default(() => []),
+    // Auto-filing: content-hash idempotency key set by `wp tech-debt new --from-audit`
+    auto_filed_hash: z.string().optional(),
+})
+    .transform((data) => ({
+    ...data,
+    // Compute next review date at parse time
+    nextReview: computeNextReview(data.last_reviewed, data.review_cadence),
+    // Compute base priority score at parse time
+    basePriority: computeBasePriority(data.severity),
+}))
+    .refine((data) => {
+    // Critical severity must have weekly cadence for timely attention
+    if (data.severity === 'critical' && data.review_cadence !== 'weekly') {
+        return false;
+    }
+    return true;
+}, {
+    message: 'Critical severity technical debt must have weekly review cadence',
+    path: ['review_cadence'],
+});
+//# sourceMappingURL=schema.js.map