@uluops/ops-mcp 0.2.1

package/dist/types/run-schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-schemas.d.ts","sourceRoot":"","sources":["../../src/types/run-schemas.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,iDAAiD;AACjD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;EAI9B,CAAC;AAOH,+DAA+D;AAC/D,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAwC0B,CAAC;AAEhE,8DAA8D;AAC9D,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOuB,CAAC;AAEzD,4EAA4E;AAC5E,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASpC,CAAC;AAEH,sFAAsF;AACtF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;EAOnC,CAAC"}

package/dist/types/run-schemas.js

@@ -0,0 +1,91 @@
+/**
+ * Shared Zod schemas for run-related tools (save_run, update_run, validate_run).
+ *
+ * Extracted to eliminate the ~80-line copy-paste block that previously lived
+ * in both save-run.ts and update-run.ts. Variants that need extra fields
+ * (e.g., `agent_name` on update_run records) `.extend()` the base schemas.
+ */
+import { z } from 'zod';
+import { AnalysisRecordTypeSchema, SeveritySchema } from './schemas.js';
+/** Per-category score breakdown for an agent. */
+export const CategoryScoreSchema = z.object({
+    name: z.string().describe('Category name'),
+    weight: z.number().int().min(1).describe('Category weight'),
+    score: z.number().int().min(0).describe('Points earned'),
+});
+const ExplorationSectionBase = z.object({
+    label: z.string().describe('Human-readable section title'),
+    summary: z.string().optional().describe('Brief section description'),
+});
+/** Discriminated union of exploration map section variants. */
+export const ExplorationSectionSchema = z.discriminatedUnion('type', [
+    ExplorationSectionBase.extend({
+        type: z.literal('inventory'),
+        items: z.array(z.record(z.unknown())).optional().describe('Inventory items'),
+        gaps: z.array(z.string()).optional().describe('Identified gaps'),
+    }).passthrough(),
+    ExplorationSectionBase.extend({
+        type: z.literal('topology'),
+        entities: z.array(z.record(z.unknown())).optional().describe('Entities in the topology'),
+        relationships: z.array(z.record(z.unknown())).optional().describe('Relationships between entities'),
+        clusters: z.array(z.record(z.unknown())).optional().describe('Entity clusters'),
+    }).passthrough(),
+    ExplorationSectionBase.extend({
+        type: z.literal('landscape'),
+        dimensions: z.array(z.string()).optional().describe('Landscape dimensions'),
+        findings: z.array(z.record(z.unknown())).optional().describe('Findings across dimensions'),
+    }).passthrough(),
+    ExplorationSectionBase.extend({
+        type: z.literal('classification'),
+        hierarchy: z.array(z.record(z.unknown())).optional().describe('Taxonomic hierarchy'),
+    }).passthrough(),
+    ExplorationSectionBase.extend({
+        type: z.literal('mapping'),
+        source_domain: z.string().optional().describe('Source domain name'),
+        target_domain: z.string().optional().describe('Target domain name'),
+        translations: z.array(z.record(z.unknown())).optional().describe('Source-to-target translations'),
+    }).passthrough(),
+    ExplorationSectionBase.extend({
+        type: z.literal('synthesis'),
+        patterns: z.array(z.record(z.unknown())).optional().describe('Discovered patterns'),
+        archetypes: z.array(z.record(z.unknown())).optional().describe('Identified archetypes'),
+    }).passthrough(),
+    ExplorationSectionBase.extend({
+        type: z.literal('limitation'),
+        blind_spots: z.array(z.record(z.unknown())).optional().describe('Framework blind spots'),
+    }).passthrough(),
+    ExplorationSectionBase.extend({
+        type: z.literal('agenda'),
+        questions: z.array(z.record(z.unknown())).optional().describe('Inquiry questions for downstream analysis'),
+    }).passthrough(),
+]).describe('Typed section — type determines available fields');
+/** A complete structural map emitted by an explorer agent. */
+export const ExplorationMapSchema = z.object({
+    metadata: z.object({
+        explorer_name: z.string().describe('Explorer agent name'),
+        framework: z.string().describe('Analytical framework (archimedes, bateson, meadows, etc.)'),
+        artifact_path: z.string().optional().describe('Path to analyzed artifact'),
+    }),
+    sections: z.array(ExplorationSectionSchema).max(50).describe('Typed structural sections'),
+}).describe('Structural mapping from an explorer agent');
+/** Analysis summary base — extend with agent_name for per-agent updates. */
+export const AnalysisSummaryBaseSchema = z.object({
+    decision: z.string().max(50).describe('Decision (VITAL, FLOWING, PASS, etc.)'),
+    score: z.number().min(0).max(100).optional().nullable().describe('Score. Omit for scoreless agents.'),
+    decision_vocabulary: z.string().max(100).optional().nullable().describe('e.g., VITAL/DECADENT'),
+    system_metrics: z.record(z.unknown()).optional().nullable().describe('Agent-type-specific metrics'),
+    category_scores: z.array(CategoryScoreSchema).optional().nullable().describe('Category score breakdown'),
+    epistemic_assessment: z.record(z.unknown()).optional().nullable().describe('Failure signature risk ratings'),
+    audit_implications: z.array(z.string()).optional().nullable().describe('Trajectory projections'),
+    exploration_maps: z.array(ExplorationMapSchema).optional().nullable().describe('Structural maps from explorer agents — inventories, topologies, claim extractions, etc.'),
+});
+/** Structured analysis record base — extend with agent_name for per-agent updates. */
+export const AnalysisRecordBaseSchema = z.object({
+    record_type: AnalysisRecordTypeSchema.describe('Record type (convention, tension, decay_vector, etc.)'),
+    record_id: z.string().max(20).describe('Agent-local ID (C-1, T-3, D-2)'),
+    title: z.string().max(500).describe('Human-readable title'),
+    classification: z.string().max(50).optional().nullable().describe('Type-specific classification (LIVING, CALCIFIED, IMMINENT, etc.)'),
+    severity: SeveritySchema.optional().nullable().describe('Severity when applicable'),
+    data: z.record(z.unknown()).describe('Full structured data for this record'),
+});
+//# sourceMappingURL=run-schemas.js.map

package/dist/types/run-schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-schemas.js","sourceRoot":"","sources":["../../src/types/run-schemas.ts"],"names":[],"mappings":"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"}

package/dist/types/schemas.d.ts

@@ -0,0 +1,288 @@
+/**
+ * Shared Zod schemas for common enums and types
+ *
+ * Centralizes repeated enum definitions to ensure consistency
+ * across all tool schemas.
+ */
+import { z } from 'zod';
+/**
+ * Issue priority levels
+ * - critical: Must fix before shipping
+ * - suggested: Should fix, but not blocking
+ * - backlog: Technical debt for later
+ */
+export declare const PrioritySchema: z.ZodEnum<["critical", "high", "suggested", "backlog"]>;
+export type Priority = z.infer<typeof PrioritySchema>;
+/**
+ * Issue priority with 'all' option for queries
+ */
+export declare const PriorityFilterSchema: z.ZodEnum<["critical", "high", "suggested", "backlog", "all"]>;
+export type PriorityFilter = z.infer<typeof PriorityFilterSchema>;
+/**
+ * Issue severity levels
+ */
+export declare const SeveritySchema: z.ZodEnum<["critical", "high", "medium", "low", "info"]>;
+export type Severity = z.infer<typeof SeveritySchema>;
+/**
+ * Issue status values
+ * - open: Active issue
+ * - completed: Fixed and verified
+ * - deferred: Postponed for later
+ * - wontfix: Not planning to address
+ * - merged: Combined with another issue
+ * - false-positive: Not a real issue (misidentified by agent)
+ */
+export declare const IssueStatusSchema: z.ZodEnum<["open", "completed", "deferred", "wontfix", "merged", "false-positive", "observation"]>;
+export type IssueStatus = z.infer<typeof IssueStatusSchema>;
+/**
+ * Issue status with 'all' option for queries
+ */
+export declare const IssueStatusFilterSchema: z.ZodEnum<["open", "completed", "deferred", "wontfix", "merged", "false-positive", "observation", "all"]>;
+export type IssueStatusFilter = z.infer<typeof IssueStatusFilterSchema>;
+/**
+ * Failure taxonomy domains
+ * - STR: Structural issues (syntax, formatting)
+ * - SEM: Semantic issues (logic, correctness)
+ * - PRA: Pragmatic issues (usability, clarity)
+ * - EPI: Epistemic issues (knowledge, assumptions)
+ */
+export declare const FailureDomainSchema: z.ZodEnum<["STR", "SEM", "PRA", "EPI"]>;
+export type FailureDomain = z.infer<typeof FailureDomainSchema>;
+/**
+ * Classification confidence levels
+ */
+export declare const ConfidenceSchema: z.ZodEnum<["high", "medium", "low"]>;
+export type Confidence = z.infer<typeof ConfidenceSchema>;
+/**
+ * Classification source
+ */
+export declare const ClassifierSchema: z.ZodEnum<["agent", "classifier", "human"]>;
+export type Classifier = z.infer<typeof ClassifierSchema>;
+/**
+ * Analysis record type vocabulary.
+ * Must stay in sync with ANALYSIS_RECORD_TYPES in
+ * ops-uluops-api/src/business-objects/analysis-record.ts
+ *
+ * TODO: Move this vocabulary to the database (e.g., a `record_types` lookup table)
+ * so it can be shared across services without code duplication. This becomes
+ * necessary when multiple services need to validate record types independently.
+ */
+export declare const ANALYSIS_RECORD_TYPES: readonly ["category_breakdown", "criterion_deduction", "auto_fail_check", "convention", "power_map", "tension", "tension_health", "stagnation", "four_cause", "essential_property", "naming_chain", "ritual", "evidence_claim", "causal_claim", "is_ought_violation", "habitual_assumption", "theory", "corroboration", "untested_assumption", "bold_conjecture", "participation_gap", "shadow", "hierarchy_inversion", "form_extraction", "confidence_basis", "examination_debt", "intervention_chain", "reversal", "emptiness", "control_paradox", "stress_concentration", "lever_point", "displacement", "fulcrum", "center_of_gravity", "commitment", "contradiction", "inquiry_question", "definitional_stability", "decay_vector", "tension_trajectory", "cascade_layer", "capability_emergence", "artifact", "completion_criterion", "improvement", "evidence_finding"];
+export declare const AnalysisRecordTypeSchema: z.ZodEnum<["category_breakdown", "criterion_deduction", "auto_fail_check", "convention", "power_map", "tension", "tension_health", "stagnation", "four_cause", "essential_property", "naming_chain", "ritual", "evidence_claim", "causal_claim", "is_ought_violation", "habitual_assumption", "theory", "corroboration", "untested_assumption", "bold_conjecture", "participation_gap", "shadow", "hierarchy_inversion", "form_extraction", "confidence_basis", "examination_debt", "intervention_chain", "reversal", "emptiness", "control_paradox", "stress_concentration", "lever_point", "displacement", "fulcrum", "center_of_gravity", "commitment", "contradiction", "inquiry_question", "definitional_stability", "decay_vector", "tension_trajectory", "cascade_layer", "capability_emergence", "artifact", "completion_criterion", "improvement", "evidence_finding"]>;
+export type AnalysisRecordType = z.infer<typeof AnalysisRecordTypeSchema>;
+/**
+ * Note types for issue annotations
+ */
+export declare const NoteTypeSchema: z.ZodEnum<["context", "resolution", "blocker"]>;
+export type NoteType = z.infer<typeof NoteTypeSchema>;
+/**
+ * Issue merge strategies
+ */
+export declare const MergeStrategySchema: z.ZodEnum<["keep_target", "keep_highest_priority"]>;
+export type MergeStrategy = z.infer<typeof MergeStrategySchema>;
+/**
+ * Issue type classification
+ * Accepts domain-specific types (e.g., "deficiency" for legal domains)
+ * in addition to universal types (feature, bug, refactor, config, docs, infra, security, test).
+ * The API resolves domain types to universal types before storage.
+ */
+export declare const IssueTypeSchema: z.ZodString;
+export type IssueType = string;
+/**
+ * File path schema with client-side validation
+ *
+ * Validates paths to prevent:
+ * - Path traversal attacks (../)
+ * - Null byte injection
+ * - Excessively long paths
+ *
+ * Note: The backend API performs authoritative validation;
+ * this is defense-in-depth.
+ */
+export declare const FilePathSchema: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+/**
+ * Token usage metrics for agent runs
+ *
+ * Base schema requires input_tokens and output_tokens.
+ * Extended fields (cache_creation, cache_read, total_effective) are optional.
+ */
+export declare const TokenUsageSchema: z.ZodObject<{
+    input_tokens: z.ZodNumber;
+    output_tokens: z.ZodNumber;
+    cache_creation: z.ZodOptional<z.ZodNumber>;
+    cache_creation_tokens: z.ZodOptional<z.ZodNumber>;
+    cache_read: z.ZodOptional<z.ZodNumber>;
+    cache_read_tokens: z.ZodOptional<z.ZodNumber>;
+    total_effective: z.ZodOptional<z.ZodNumber>;
+    total_effective_tokens: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    input_tokens: number;
+    output_tokens: number;
+    cache_creation?: number | undefined;
+    cache_creation_tokens?: number | undefined;
+    cache_read?: number | undefined;
+    cache_read_tokens?: number | undefined;
+    total_effective?: number | undefined;
+    total_effective_tokens?: number | undefined;
+}, {
+    input_tokens: number;
+    output_tokens: number;
+    cache_creation?: number | undefined;
+    cache_creation_tokens?: number | undefined;
+    cache_read?: number | undefined;
+    cache_read_tokens?: number | undefined;
+    total_effective?: number | undefined;
+    total_effective_tokens?: number | undefined;
+}>;
+export type TokenUsage = z.infer<typeof TokenUsageSchema>;
+/**
+ * Agent result schema for validation runs
+ */
+export declare const AgentResultSchema: z.ZodObject<{
+    name: z.ZodString;
+    score: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    max_score: z.ZodOptional<z.ZodNumber>;
+    decision: z.ZodString;
+    definition_version: z.ZodOptional<z.ZodString>;
+    summary: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    tokens: z.ZodOptional<z.ZodObject<{
+        input_tokens: z.ZodNumber;
+        output_tokens: z.ZodNumber;
+        cache_creation: z.ZodOptional<z.ZodNumber>;
+        cache_creation_tokens: z.ZodOptional<z.ZodNumber>;
+        cache_read: z.ZodOptional<z.ZodNumber>;
+        cache_read_tokens: z.ZodOptional<z.ZodNumber>;
+        total_effective: z.ZodOptional<z.ZodNumber>;
+        total_effective_tokens: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        input_tokens: number;
+        output_tokens: number;
+        cache_creation?: number | undefined;
+        cache_creation_tokens?: number | undefined;
+        cache_read?: number | undefined;
+        cache_read_tokens?: number | undefined;
+        total_effective?: number | undefined;
+        total_effective_tokens?: number | undefined;
+    }, {
+        input_tokens: number;
+        output_tokens: number;
+        cache_creation?: number | undefined;
+        cache_creation_tokens?: number | undefined;
+        cache_read?: number | undefined;
+        cache_read_tokens?: number | undefined;
+        total_effective?: number | undefined;
+        total_effective_tokens?: number | undefined;
+    }>>;
+    duration_ms: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    decision: string;
+    score?: number | null | undefined;
+    max_score?: number | undefined;
+    definition_version?: string | undefined;
+    summary?: string | undefined;
+    model?: string | undefined;
+    tokens?: {
+        input_tokens: number;
+        output_tokens: number;
+        cache_creation?: number | undefined;
+        cache_creation_tokens?: number | undefined;
+        cache_read?: number | undefined;
+        cache_read_tokens?: number | undefined;
+        total_effective?: number | undefined;
+        total_effective_tokens?: number | undefined;
+    } | undefined;
+    duration_ms?: number | undefined;
+}, {
+    name: string;
+    decision: string;
+    score?: number | null | undefined;
+    max_score?: number | undefined;
+    definition_version?: string | undefined;
+    summary?: string | undefined;
+    model?: string | undefined;
+    tokens?: {
+        input_tokens: number;
+        output_tokens: number;
+        cache_creation?: number | undefined;
+        cache_creation_tokens?: number | undefined;
+        cache_read?: number | undefined;
+        cache_read_tokens?: number | undefined;
+        total_effective?: number | undefined;
+        total_effective_tokens?: number | undefined;
+    } | undefined;
+    duration_ms?: number | undefined;
+}>;
+export type AgentResult = z.infer<typeof AgentResultSchema>;
+/**
+ * Recommendation/issue schema for validation findings
+ */
+export declare const RecommendationSchema: z.ZodObject<{
+    agent: z.ZodString;
+    title: z.ZodString;
+    priority: z.ZodEnum<["critical", "high", "suggested", "backlog"]>;
+    type: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    file_path: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
+    line_number: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    category: z.ZodOptional<z.ZodString>;
+    severity: z.ZodOptional<z.ZodEnum<["critical", "high", "medium", "low", "info"]>>;
+    failure_code: z.ZodOptional<z.ZodString>;
+    failure_domain: z.ZodOptional<z.ZodEnum<["STR", "SEM", "PRA", "EPI"]>>;
+    failure_mode: z.ZodOptional<z.ZodString>;
+    classification_confidence: z.ZodOptional<z.ZodEnum<["high", "medium", "low"]>>;
+    classified_by: z.ZodOptional<z.ZodEnum<["agent", "classifier", "human"]>>;
+    secondary_failure_codes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    taxonomy_version: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    agent: string;
+    title: string;
+    priority: "critical" | "high" | "suggested" | "backlog";
+    type?: string | undefined;
+    description?: string | undefined;
+    file_path?: string | undefined;
+    line_number?: number | null | undefined;
+    category?: string | undefined;
+    severity?: "info" | "critical" | "high" | "medium" | "low" | undefined;
+    failure_code?: string | undefined;
+    failure_domain?: "STR" | "SEM" | "PRA" | "EPI" | undefined;
+    failure_mode?: string | undefined;
+    classification_confidence?: "high" | "medium" | "low" | undefined;
+    classified_by?: "agent" | "classifier" | "human" | undefined;
+    secondary_failure_codes?: string[] | undefined;
+    taxonomy_version?: string | undefined;
+}, {
+    agent: string;
+    title: string;
+    priority: "critical" | "high" | "suggested" | "backlog";
+    type?: string | undefined;
+    description?: string | undefined;
+    file_path?: string | undefined;
+    line_number?: number | null | undefined;
+    category?: string | undefined;
+    severity?: "info" | "critical" | "high" | "medium" | "low" | undefined;
+    failure_code?: string | undefined;
+    failure_domain?: "STR" | "SEM" | "PRA" | "EPI" | undefined;
+    failure_mode?: string | undefined;
+    classification_confidence?: "high" | "medium" | "low" | undefined;
+    classified_by?: "agent" | "classifier" | "human" | undefined;
+    secondary_failure_codes?: string[] | undefined;
+    taxonomy_version?: string | undefined;
+}>;
+export type Recommendation = z.infer<typeof RecommendationSchema>;
+/**
+ * Summary statistics schema for validation runs
+ */
+export declare const ValidationSummarySchema: z.ZodObject<{
+    all_gates_passed: z.ZodOptional<z.ZodBoolean>;
+    average_score: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    all_gates_passed?: boolean | undefined;
+    average_score?: number | undefined;
+}, {
+    all_gates_passed?: boolean | undefined;
+    average_score?: number | undefined;
+}>;
+export type ValidationSummary = z.infer<typeof ValidationSummarySchema>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/types/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/types/schemas.ts"],"names":[],"mappings":"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"}

package/dist/types/schemas.js

@@ -0,0 +1,218 @@
+/**
+ * Shared Zod schemas for common enums and types
+ *
+ * Centralizes repeated enum definitions to ensure consistency
+ * across all tool schemas.
+ */
+import { z } from 'zod';
+/**
+ * Issue priority levels
+ * - critical: Must fix before shipping
+ * - suggested: Should fix, but not blocking
+ * - backlog: Technical debt for later
+ */
+export const PrioritySchema = z.enum(['critical', 'high', 'suggested', 'backlog']);
+/**
+ * Issue priority with 'all' option for queries
+ */
+export const PriorityFilterSchema = z.enum(['critical', 'high', 'suggested', 'backlog', 'all']);
+/**
+ * Issue severity levels
+ */
+export const SeveritySchema = z.enum(['critical', 'high', 'medium', 'low', 'info']);
+/**
+ * Issue status values
+ * - open: Active issue
+ * - completed: Fixed and verified
+ * - deferred: Postponed for later
+ * - wontfix: Not planning to address
+ * - merged: Combined with another issue
+ * - false-positive: Not a real issue (misidentified by agent)
+ */
+export const IssueStatusSchema = z.enum(['open', 'completed', 'deferred', 'wontfix', 'merged', 'false-positive', 'observation']);
+/**
+ * Issue status with 'all' option for queries
+ */
+export const IssueStatusFilterSchema = z.enum(['open', 'completed', 'deferred', 'wontfix', 'merged', 'false-positive', 'observation', 'all']);
+/**
+ * Failure taxonomy domains
+ * - STR: Structural issues (syntax, formatting)
+ * - SEM: Semantic issues (logic, correctness)
+ * - PRA: Pragmatic issues (usability, clarity)
+ * - EPI: Epistemic issues (knowledge, assumptions)
+ */
+export const FailureDomainSchema = z.enum(['STR', 'SEM', 'PRA', 'EPI']);
+/**
+ * Classification confidence levels
+ */
+export const ConfidenceSchema = z.enum(['high', 'medium', 'low']);
+/**
+ * Classification source
+ */
+export const ClassifierSchema = z.enum(['agent', 'classifier', 'human']);
+/**
+ * Analysis record type vocabulary.
+ * Must stay in sync with ANALYSIS_RECORD_TYPES in
+ * ops-uluops-api/src/business-objects/analysis-record.ts
+ *
+ * TODO: Move this vocabulary to the database (e.g., a `record_types` lookup table)
+ * so it can be shared across services without code duplication. This becomes
+ * necessary when multiple services need to validate record types independently.
+ */
+export const ANALYSIS_RECORD_TYPES = [
+    // Validator
+    'category_breakdown', 'criterion_deduction', 'auto_fail_check',
+    // Analyst — Nietzsche
+    'convention', 'power_map',
+    // Analyst — Heraclitus
+    'tension', 'tension_health', 'stagnation',
+    // Analyst — Aristotle
+    'four_cause', 'essential_property',
+    // Analyst — Confucius
+    'naming_chain', 'ritual',
+    // Analyst — Hume
+    'evidence_claim', 'causal_claim', 'is_ought_violation', 'habitual_assumption',
+    // Analyst — Popper
+    'theory', 'corroboration', 'untested_assumption', 'bold_conjecture',
+    // Analyst — Plato
+    'participation_gap', 'shadow', 'hierarchy_inversion', 'form_extraction',
+    // Analyst — Socrates
+    'confidence_basis', 'examination_debt',
+    // Analyst — Laozi
+    'intervention_chain', 'reversal', 'emptiness', 'control_paradox',
+    // Analyst — Archimedes
+    'stress_concentration', 'lever_point', 'displacement', 'fulcrum', 'center_of_gravity',
+    // Explorer
+    'commitment', 'contradiction', 'inquiry_question', 'definitional_stability',
+    // Forecaster
+    'decay_vector', 'tension_trajectory', 'cascade_layer', 'capability_emergence',
+    // Executor
+    'artifact', 'completion_criterion',
+    // Generator
+    'improvement', 'evidence_finding',
+];
+export const AnalysisRecordTypeSchema = z.enum(ANALYSIS_RECORD_TYPES);
+/**
+ * Note types for issue annotations
+ */
+export const NoteTypeSchema = z.enum(['context', 'resolution', 'blocker']);
+/**
+ * Issue merge strategies
+ */
+export const MergeStrategySchema = z.enum(['keep_target', 'keep_highest_priority']);
+/**
+ * Issue type classification
+ * Accepts domain-specific types (e.g., "deficiency" for legal domains)
+ * in addition to universal types (feature, bug, refactor, config, docs, infra, security, test).
+ * The API resolves domain types to universal types before storage.
+ */
+export const IssueTypeSchema = z.string().max(50);
+/**
+ * File path schema with client-side validation
+ *
+ * Validates paths to prevent:
+ * - Path traversal attacks (../)
+ * - Null byte injection
+ * - Excessively long paths
+ *
+ * Note: The backend API performs authoritative validation;
+ * this is defense-in-depth.
+ */
+export const FilePathSchema = z
+    .string()
+    .max(1000, 'File path exceeds maximum length of 1000 characters')
+    .refine((path) => !path.includes('\0'), 'File path cannot contain null bytes')
+    .refine((path) => !path.includes('../') && !path.includes('..\\'), 'File path cannot contain path traversal sequences');
+/**
+ * Token usage metrics for agent runs
+ *
+ * Base schema requires input_tokens and output_tokens.
+ * Extended fields (cache_creation, cache_read, total_effective) are optional.
+ */
+export const TokenUsageSchema = z
+    .object({
+    input_tokens: z.number().int().nonnegative().describe('Input tokens consumed'),
+    output_tokens: z.number().int().nonnegative().describe('Output tokens generated'),
+    cache_creation: z.number().int().nonnegative().optional().describe('Cache creation tokens'),
+    cache_creation_tokens: z
+        .number()
+        .int()
+        .nonnegative()
+        .optional()
+        .describe('Cache creation tokens (alias)'),
+    cache_read: z.number().int().nonnegative().optional().describe('Cache read tokens'),
+    cache_read_tokens: z
+        .number()
+        .int()
+        .nonnegative()
+        .optional()
+        .describe('Cache read tokens (alias)'),
+    total_effective: z.number().int().nonnegative().optional().describe('Total effective tokens'),
+    total_effective_tokens: z
+        .number()
+        .int()
+        .nonnegative()
+        .optional()
+        .describe('Total effective tokens (alias)'),
+})
+    .describe('Token usage metrics for an agent run');
+/**
+ * Agent result schema for validation runs
+ */
+export const AgentResultSchema = z
+    .object({
+    name: z.string().min(1).describe('Agent name (e.g., code-validator, test-architect)'),
+    score: z.number().optional().nullable().describe('Agent score (0-100). Omit for generator/executor agents that do not produce scores.'),
+    max_score: z.number().optional().describe('Maximum possible score'),
+    decision: z.string().describe('Agent decision (e.g., PASS, FAIL, CLEAR, BEWITCHED)'),
+    definition_version: z.string().max(50).optional().describe('Definition version for version-aware analytics'),
+    summary: z.string().optional().describe('Brief human-readable summary of agent result'),
+    model: z.string().optional().describe('Model used (e.g., sonnet, opus)'),
+    tokens: TokenUsageSchema.optional().describe('Token usage metrics'),
+    duration_ms: z
+        .number()
+        .int()
+        .nonnegative()
+        .optional()
+        .describe('Execution duration in milliseconds'),
+})
+    .describe('Results from a single agent');
+/**
+ * Recommendation/issue schema for validation findings
+ */
+export const RecommendationSchema = z
+    .object({
+    agent: z.string().min(1).describe('Source agent name'),
+    title: z.string().min(1).describe('Issue title'),
+    priority: PrioritySchema.describe('Issue priority'),
+    type: IssueTypeSchema.optional().describe('Issue type. Universal types: feature, bug, refactor, config, docs, infra, security, test. Domain-specific types (e.g., "deficiency", "ambiguity" for legal) are also accepted and resolved by the API.'),
+    description: z.string().optional().describe('Detailed description'),
+    file_path: FilePathSchema.optional().describe('File path where issue was found'),
+    line_number: z.number().int().nonnegative().optional().nullable().describe('Line number in file'),
+    category: z.string().optional().describe('Issue category'),
+    severity: SeveritySchema.optional().describe('Issue severity'),
+    failure_code: z
+        .string()
+        .regex(/^(STR|SEM|PRA|EPI)-[A-Z]{3}\/[CHMLI]$/, {
+        message: 'Must match pattern DOMAIN-MODE/SEVERITY (e.g., SEM-VAL/H, STR-OMI/M)',
+    })
+        .optional()
+        .describe('Failure taxonomy code (e.g., SEM-VAL/H)'),
+    failure_domain: FailureDomainSchema.optional().describe('Failure domain'),
+    failure_mode: z.string().optional().describe('Failure mode identifier'),
+    classification_confidence: ConfidenceSchema.optional().describe('Classification confidence'),
+    classified_by: ClassifierSchema.optional().describe('Classification source'),
+    secondary_failure_codes: z.array(z.string()).optional().describe('Secondary failure codes'),
+    taxonomy_version: z.string().optional().describe('Taxonomy version used'),
+})
+    .describe('A single issue or recommendation from validation');
+/**
+ * Summary statistics schema for validation runs
+ */
+export const ValidationSummarySchema = z
+    .object({
+    all_gates_passed: z.boolean().optional().describe('Whether all validation gates passed'),
+    average_score: z.number().optional().describe('Average score across all agents'),
+})
+    .describe('Summary statistics for the validation run');
+//# sourceMappingURL=schemas.js.map

package/dist/types/schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.js","sourceRoot":"","sources":["../../src/types/schemas.ts"],"names":[],"mappings":"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"}