@a-company/paradigm 3.34.0 → 3.44.0

package/dist/config-schema-3YNIFJCJ.js

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+import "./chunk-ZXMDA7VB.js";
+
+// src/core/config-schema.ts
+import { z } from "zod";
+import * as yaml from "js-yaml";
+var disciplineEnum = z.enum([
+  "web",
+  "backend",
+  "fullstack",
+  "api",
+  "cli",
+  "ml",
+  "mobile",
+  "game",
+  "embedded",
+  "devops",
+  "data",
+  "library",
+  "monorepo",
+  "custom"
+]);
+var agentProviderEnum = z.enum([
+  "auto",
+  "claude",
+  "claude-code",
+  "cursor-cli",
+  "claude-cli",
+  "manual"
+]);
+var symbolDefinitionSchema = z.object({
+  name: z.string(),
+  description: z.string(),
+  examples: z.array(z.string()).optional()
+}).passthrough();
+var tagBankSchema = z.object({
+  file: z.string().optional(),
+  "core-tags": z.array(z.string()).optional(),
+  "allow-suggestions": z.boolean().optional()
+}).passthrough();
+var agentGuidelinesSchema = z.object({
+  overview: z.string().optional(),
+  "how-to-use": z.array(z.string()).optional(),
+  "update-rules": z.array(z.string()).optional()
+}).passthrough();
+var loggingSchema = z.object({
+  enforce: z.boolean().optional(),
+  "default-level": z.enum(["debug", "info", "warn", "error"]).optional(),
+  "symbol-mapping": z.record(z.string(), z.string()).optional()
+}).passthrough();
+var purposeRequiredEntry = z.object({
+  pattern: z.string(),
+  depth: z.number().optional()
+});
+var limitsSchema = z.object({
+  toolCacheTtlMs: z.number().optional()
+}).passthrough();
+var aiAgentSchema = z.object({
+  model: z.string().optional(),
+  "context-window": z.number().optional()
+}).passthrough();
+var contextSchema = z.object({
+  enabled: z.boolean().optional(),
+  "index-file": z.string().optional(),
+  "docs-path": z.string().optional()
+}).passthrough();
+var probeSchema = z.object({
+  enabled: z.boolean().optional(),
+  "auto-include": z.boolean().optional()
+}).passthrough();
+var paradigmConfigSchema = z.object({
+  version: z.string(),
+  project: z.string(),
+  discipline: disciplineEnum.optional(),
+  "agent-provider": agentProviderEnum.optional(),
+  "agent-guidelines": agentGuidelinesSchema.optional(),
+  "symbol-system": z.record(z.string(), symbolDefinitionSchema).optional(),
+  "tag-bank": tagBankSchema.optional(),
+  component_types: z.record(z.string(), z.string()).optional(),
+  logging: loggingSchema.optional(),
+  "purpose-required": z.array(purposeRequiredEntry).optional(),
+  conventions: z.array(z.string()).optional(),
+  workspace: z.string().optional(),
+  limits: limitsSchema.optional(),
+  "ai-agent": aiAgentSchema.optional(),
+  context: contextSchema.optional(),
+  probe: probeSchema.optional(),
+  states: z.record(z.string(), z.unknown()).optional(),
+  "custom-symbols": z.record(z.string(), symbolDefinitionSchema).optional()
+}).passthrough();
+var KNOWN_TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
+  "version",
+  "project",
+  "discipline",
+  "agent-provider",
+  "agent-guidelines",
+  "symbol-system",
+  "tag-bank",
+  "component_types",
+  "logging",
+  "purpose-required",
+  "conventions",
+  "workspace",
+  "limits",
+  "ai-agent",
+  "context",
+  "probe",
+  "states",
+  "custom-symbols"
+]);
+function validateConfig(content) {
+  const warnings = [];
+  const errors = [];
+  let parsed;
+  try {
+    parsed = yaml.load(content);
+  } catch (e) {
+    return {
+      valid: false,
+      warnings: [],
+      errors: [`YAML parse error: ${e.message}`]
+    };
+  }
+  if (!parsed || typeof parsed !== "object") {
+    return {
+      valid: false,
+      warnings: [],
+      errors: ["Config must be a YAML object"]
+    };
+  }
+  for (const key of Object.keys(parsed)) {
+    if (!KNOWN_TOP_LEVEL_KEYS.has(key)) {
+      warnings.push(`Unrecognized config key: "${key}"`);
+    }
+  }
+  const result = paradigmConfigSchema.safeParse(parsed);
+  if (!result.success) {
+    for (const issue of result.error.issues) {
+      const path = issue.path.join(".");
+      errors.push(`${path}: ${issue.message}`);
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    warnings,
+    errors
+  };
+}
+export {
+  paradigmConfigSchema,
+  validateConfig
+};

package/dist/{constellation-LZ6XIKDT.js → constellation-FAGT45TU.js}

@@ -5,8 +5,8 @@ import {
   getAllSymbols,
   getSymbolCounts,
   getSymbolsByType
-} from "./chunk-CTF6RHKG.js";
-import "./chunk-VUSCJJ4A.js";
+} from "./chunk-ZGUAAVMA.js";
+import "./chunk-EDOAWN7J.js";
 import "./chunk-IRKUEJVW.js";
 import {
   log

package/dist/{context-audit-RI4R2WRH.js → context-audit-557EO6PK.js}

@@ -360,25 +360,35 @@ async function checkOrphanedSymbols(rootDir) {
       }
     }
   }
-  const orphaned = [];
+  const hasOutgoingRefs = /* @__PURE__ */ new Set();
+  for (const cat of categories) {
+    const entries = index[cat];
+    if (!entries || typeof entries !== "object") continue;
+    for (const [, entry] of Object.entries(entries)) {
+      if (entry.symbol && entry.related && Array.isArray(entry.related) && entry.related.length > 0) {
+        hasOutgoingRefs.add(entry.symbol);
+      }
+    }
+  }
+  const isolated = [];
   for (const [symbol] of allSymbols) {
-    if (!referencedSymbols.has(symbol)) {
-      orphaned.push(symbol);
+    if (!referencedSymbols.has(symbol) && !hasOutgoingRefs.has(symbol)) {
+      isolated.push(symbol);
     }
   }
-  if (orphaned.length > 0) {
+  if (isolated.length > 0) {
     results.push({
       check: "orphaned-symbols",
       status: "advisory",
-      message: `${orphaned.length} symbol${orphaned.length > 1 ? "s" : ""} with zero cross-references`,
-      details: orphaned.slice(0, 20),
-      fix: "Add cross-references in .purpose files to connect orphaned symbols"
+      message: `${isolated.length} isolated symbol${isolated.length > 1 ? "s" : ""} (no connections to other symbols)`,
+      details: isolated.slice(0, 20),
+      fix: "Wire isolated symbols into features or remove them from .purpose files"
     });
   } else {
     results.push({
       check: "orphaned-symbols",
       status: "ok",
-      message: "All symbols have cross-references"
+      message: "All symbols are connected"
     });
   }
   return results;
@@ -524,6 +534,124 @@ async function checkInstructionVagueness(rootDir) {
   }
   return results;
 }
+async function checkConfigSchema(rootDir) {
+  const results = [];
+  const configPath = path.join(rootDir, ".paradigm", "config.yaml");
+  if (!fs.existsSync(configPath)) {
+    results.push({
+      check: "config-schema-validation",
+      status: "advisory",
+      message: "No .paradigm/config.yaml found"
+    });
+    return results;
+  }
+  try {
+    const content = fs.readFileSync(configPath, "utf8");
+    const { validateConfig } = await import("./config-schema-3YNIFJCJ.js");
+    const validation = validateConfig(content);
+    const details = [];
+    for (const err of validation.errors) {
+      details.push(`Error: ${err}`);
+    }
+    for (const warn of validation.warnings) {
+      details.push(`Warning: ${warn}`);
+    }
+    if (validation.errors.length > 0) {
+      results.push({
+        check: "config-schema-validation",
+        status: "error",
+        message: `${validation.errors.length} schema error${validation.errors.length > 1 ? "s" : ""} in config.yaml`,
+        details,
+        fix: "Fix invalid fields in .paradigm/config.yaml"
+      });
+    } else if (validation.warnings.length > 0) {
+      results.push({
+        check: "config-schema-validation",
+        status: "warn",
+        message: `${validation.warnings.length} unrecognized key${validation.warnings.length > 1 ? "s" : ""} in config.yaml`,
+        details,
+        fix: "Check for typos in .paradigm/config.yaml field names"
+      });
+    } else {
+      results.push({
+        check: "config-schema-validation",
+        status: "ok",
+        message: "config.yaml schema is valid"
+      });
+    }
+  } catch (e) {
+    results.push({
+      check: "config-schema-validation",
+      status: "error",
+      message: `Could not validate config.yaml: ${e.message}`
+    });
+  }
+  return results;
+}
+async function checkPurposeFileHealth(rootDir) {
+  const results = [];
+  const purposeFiles = [];
+  function findPurpose(dir) {
+    const skipDirs = /* @__PURE__ */ new Set(["node_modules", "dist", ".git", ".paradigm", "coverage", "build"]);
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (skipDirs.has(entry.name)) continue;
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          findPurpose(full);
+        } else if (entry.name === ".purpose") {
+          purposeFiles.push(full);
+        }
+      }
+    } catch {
+    }
+  }
+  findPurpose(rootDir);
+  if (purposeFiles.length === 0) {
+    results.push({
+      check: "purpose-file-health",
+      status: "ok",
+      message: "No .purpose files to check"
+    });
+    return results;
+  }
+  const oversized = [];
+  let maxLines = 0;
+  let maxFile = "";
+  for (const pf of purposeFiles) {
+    try {
+      const content = fs.readFileSync(pf, "utf8");
+      const lines = content.split("\n").length;
+      if (lines > maxLines) {
+        maxLines = lines;
+        maxFile = path.relative(rootDir, pf);
+      }
+      if (lines > 500) {
+        const severity = lines > 1e3 ? "!!" : "!";
+        oversized.push(`${severity} ${path.relative(rootDir, pf)} (${lines} lines)`);
+      }
+    } catch {
+      continue;
+    }
+  }
+  if (oversized.length > 0) {
+    results.push({
+      check: "purpose-file-health",
+      status: "warn",
+      message: `${oversized.length} oversized .purpose file${oversized.length > 1 ? "s" : ""} (largest: ${maxFile} at ${maxLines} lines)`,
+      details: oversized,
+      fix: "Split large .purpose files by component type or subdirectory"
+    });
+  } else {
+    results.push({
+      check: "purpose-file-health",
+      status: "ok",
+      message: `${purposeFiles.length} .purpose files, all under 500 lines`
+    });
+  }
+  return results;
+}
 async function runContextAudit(rootDir, _options) {
   const tracker = log.command("doctor:context-audit").start("Running context audit checks");
   const results = [];
@@ -534,6 +662,8 @@ async function runContextAudit(rootDir, _options) {
   results.push(...await checkOrphanedSymbols(rootDir));
   results.push(...await checkStalePortal(rootDir));
   results.push(...await checkInstructionVagueness(rootDir));
+  results.push(...await checkConfigSchema(rootDir));
+  results.push(...await checkPurposeFileHealth(rootDir));
   const errorCount = results.filter((r) => r.status === "error").length;
   const warnCount = results.filter((r) => r.status === "warn").length;
   const advisoryCount = results.filter((r) => r.status === "advisory").length;

package/dist/{cost-4SZM7OUS.js → cost-UD3WPEKZ.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   findPurposeFiles
-} from "./chunk-VUSCJJ4A.js";
+} from "./chunk-EDOAWN7J.js";
 import {
   findGateFiles
 } from "./chunk-IRKUEJVW.js";

package/dist/{delete-YTASL4SM.js → delete-RRK4RL6Y.js}

@@ -2,7 +2,7 @@
 import {
   deleteLoreEntry,
   loadLoreEntry
-} from "./chunk-BRILIG7Z.js";
+} from "./chunk-QIOCFXDQ.js";
 import "./chunk-ZXMDA7VB.js";
 
 // src/commands/lore/delete.ts

package/dist/{diff-T6YJSAAC.js → diff-IP5CIARP.js}

@@ -1,16 +1,16 @@
 #!/usr/bin/env node
 import {
   BackgroundOrchestrator
-} from "./chunk-3BGSDKWD.js";
-import "./chunk-6QC3YGB6.js";
-import "./chunk-J26YQVAK.js";
+} from "./chunk-QWA26UNO.js";
+import "./chunk-J4E6K5MG.js";
 import "./chunk-PBHIFAL4.js";
-import "./chunk-5SXMV4SP.js";
+import "./chunk-FS3WTUHY.js";
+import "./chunk-6QC3YGB6.js";
 import "./chunk-PMXRGPRQ.js";
 import "./chunk-MW5DMGBB.js";
 import "./chunk-5JGJACDU.js";
-import "./chunk-CTF6RHKG.js";
-import "./chunk-VUSCJJ4A.js";
+import "./chunk-ZGUAAVMA.js";
+import "./chunk-EDOAWN7J.js";
 import "./chunk-IRKUEJVW.js";
 import "./chunk-ZXMDA7VB.js";
 

package/dist/{dist-AG5JNIZU-HW2FWNTZ.js → dist-5QE2BB2B-X6DYVSUL.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import "./chunk-ZXMDA7VB.js";
 
-// ../sentinel/dist/dist-AG5JNIZU.js
+// ../sentinel/dist/dist-5QE2BB2B.js
 import * as fs4 from "fs";
 import { z as z2 } from "zod";
 import * as path3 from "path";
@@ -5578,6 +5578,12 @@ var Ze = Object.assign(Je, { glob: Je, globSync: ts, sync: Ui, globStream: Qe, s
 Ze.glob = Ze;
 var PurposeItemSchema = z.object({
   description: z.string(),
+  // Component type and hierarchy (v4)
+  type: z.string().optional(),
+  parent: z.string().optional(),
+  anchors: z.array(z.string()).optional(),
+  tags: z.array(z.string()).optional(),
+  // Standard fields
   endpoints: z.array(z.string()).optional(),
   tests: z.array(z.string()).optional(),
   rules: z.record(z.unknown()).optional(),
@@ -5589,7 +5595,6 @@ var PurposeItemSchema = z.object({
   states: z.array(z.string()).optional(),
   components: z.array(z.string()).optional(),
   // Extra fields preserved
-  tags: z.array(z.string()).optional(),
   location: z.string().optional(),
   locations: z.array(z.string()).optional(),
   uses: z.array(z.string()).optional(),
@@ -6401,6 +6406,7 @@ async function aggregateFromPremise(premiseFile, rootDir) {
         purposeFiles.push(...parsed.map((p) => p.filePath));
         const features = extractFeatures(parsed);
         for (const [id, { item, filePath }] of features) {
+          const featureTags = ["feature", ...item.tags || []];
           symbols.push(createSymbolEntry({
             id: `purpose-feature-${id}`,
             symbol: `#${id}`,
@@ -6409,7 +6415,10 @@ async function aggregateFromPremise(premiseFile, rootDir) {
             filePath,
             data: item,
             description: item.description,
-            tags: ["feature"]
+            tags: featureTags,
+            componentType: item.type,
+            parentSymbol: item.parent,
+            anchors: item.anchors?.map((a) => parseAnchorString(a))
           }));
         }
         const components = extractComponents(parsed);
@@ -6421,7 +6430,11 @@ async function aggregateFromPremise(premiseFile, rootDir) {
             source: "purpose",
             filePath,
             data: item,
-            description: item.description
+            description: item.description,
+            tags: item.tags,
+            componentType: item.type,
+            parentSymbol: item.parent,
+            anchors: item.anchors?.map((a) => parseAnchorString(a))
           }));
         }
         const gates = extractGates(parsed);
@@ -6587,12 +6600,27 @@ async function aggregateFromPremise(premiseFile, rootDir) {
     }));
   }
   resolveReferences(symbols);
+  const symbolFileMap = /* @__PURE__ */ new Map();
+  for (const sym of symbols) {
+    const files = symbolFileMap.get(sym.symbol) || [];
+    if (!files.includes(sym.filePath)) {
+      files.push(sym.filePath);
+    }
+    symbolFileMap.set(sym.symbol, files);
+  }
+  const duplicateSymbols = [];
+  for (const [symbol, files] of symbolFileMap) {
+    if (files.length > 1) {
+      duplicateSymbols.push({ symbol, files });
+    }
+  }
   return {
     symbols,
     purposeFiles,
     portalFiles,
     errors,
-    timestamp: Date.now()
+    timestamp: Date.now(),
+    ...duplicateSymbols.length > 0 ? { duplicateSymbols } : {}
   };
 }
 function createSymbolEntry(partial) {
@@ -6751,10 +6779,33 @@ function searchSymbols(index, query) {
     }
     if (entry.tags?.some((tag) => tag.toLowerCase().includes(lowerQuery))) {
       results.push(entry);
+      continue;
+    }
+    if (entry.componentType?.toLowerCase().includes(lowerQuery)) {
+      results.push(entry);
+      continue;
     }
   }
   return results;
 }
+function getComponentsByType(index, componentType) {
+  const components = getSymbolsByType(index, "component");
+  return components.filter((c) => c.componentType === componentType);
+}
+function getAllComponentTypes(index) {
+  const types = /* @__PURE__ */ new Set();
+  const components = getSymbolsByType(index, "component");
+  for (const comp of components) {
+    if (comp.componentType) {
+      types.add(comp.componentType);
+    }
+  }
+  return Array.from(types).sort();
+}
+function getChildComponents(index, parentSymbol) {
+  const components = getSymbolsByType(index, "component");
+  return components.filter((c) => c.parentSymbol === parentSymbol);
+}
 function getReferencesTo(index, symbol) {
   const entry = getSymbol(index, symbol);
   if (!entry) return [];
@@ -6838,9 +6889,12 @@ export {
   createSnapshot,
   createSymbolIndex,
   createSymbolString,
+  getAllComponentTypes,
   getAllSymbols,
   getAllTags,
   getAutocompleteSuggestions,
+  getChildComponents,
+  getComponentsByType,
   getDefaultPremiseContent,
   getReferencesFrom,
   getReferencesTo,

package/dist/{dist-IKBGY7FQ.js → dist-CM3MVWWW.js}

@@ -10,6 +10,7 @@ import {
   PatternImporter,
   PatternMatcher,
   PatternSuggester,
+  SYMPHONY_SCHEMA,
   Sentinel,
   SentinelClient,
   SentinelStorage,
@@ -27,7 +28,7 @@ import {
   loadServerConfig,
   loadUniversalPatterns,
   writeConfig
-} from "./chunk-BKMNLROM.js";
+} from "./chunk-ZDHLG5VP.js";
 export {
   ContextEnricher,
   DEFAULT_AUTH_CONFIG,
@@ -39,6 +40,7 @@ export {
   PatternImporter,
   PatternMatcher,
   PatternSuggester,
+  SYMPHONY_SCHEMA,
   Sentinel,
   SentinelClient,
   SentinelStorage,

package/dist/{dist-OH4DBV2O.js → dist-OGTSAZ55.js}

@@ -1044,12 +1044,27 @@ async function aggregateFromPremise(premiseFile, rootDir) {
     }));
   }
   resolveReferences(symbols);
+  const symbolFileMap = /* @__PURE__ */ new Map();
+  for (const sym of symbols) {
+    const files = symbolFileMap.get(sym.symbol) || [];
+    if (!files.includes(sym.filePath)) {
+      files.push(sym.filePath);
+    }
+    symbolFileMap.set(sym.symbol, files);
+  }
+  const duplicateSymbols = [];
+  for (const [symbol, files] of symbolFileMap) {
+    if (files.length > 1) {
+      duplicateSymbols.push({ symbol, files });
+    }
+  }
   return {
     symbols,
     purposeFiles,
     portalFiles,
     errors,
-    timestamp: Date.now()
+    timestamp: Date.now(),
+    ...duplicateSymbols.length > 0 ? { duplicateSymbols } : {}
   };
 }
 function createSymbolEntry(partial) {

package/dist/{dist-RMAIFRTW.js → dist-POMVY6WP.js}

@@ -3,7 +3,6 @@ import {
   ContextEnricher,
   FlowTracker,
   IncidentGrouper,
-  PARADIGM_SCHEMA,
   PatternImporter,
   PatternMatcher,
   PatternSuggester,
@@ -20,16 +19,18 @@ import {
   loadAllSeedPatterns,
   loadParadigmPatterns,
   loadUniversalPatterns
-} from "./chunk-3BAMPB6I.js";
+} from "./chunk-ZSYVKSY6.js";
 import {
   DEFAULT_AUTH_CONFIG,
   DEFAULT_RATE_LIMIT_CONFIG,
   DEFAULT_SERVER_CONFIG,
+  PARADIGM_SCHEMA,
+  SYMPHONY_SCHEMA,
   SentinelStorage,
   loadConfig,
   loadServerConfig,
   writeConfig
-} from "./chunk-R2SGQ22F.js";
+} from "./chunk-FKJUBQU3.js";
 import "./chunk-ZXMDA7VB.js";
 export {
   ContextEnricher,
@@ -42,6 +43,7 @@ export {
   PatternImporter,
   PatternMatcher,
   PatternSuggester,
+  SYMPHONY_SCHEMA,
   Sentinel,
   SentinelClient,
   SentinelStorage,

package/dist/{dist-QSBAGCZT.js → dist-UXWV4OKX.js}

@@ -33,8 +33,8 @@ import {
   searchSymbols,
   serializePremiseFile,
   updateNodePosition
-} from "./chunk-CTF6RHKG.js";
-import "./chunk-VUSCJJ4A.js";
+} from "./chunk-ZGUAAVMA.js";
+import "./chunk-EDOAWN7J.js";
 import "./chunk-IRKUEJVW.js";
 import "./chunk-ZXMDA7VB.js";
 export {

package/dist/{doctor-INBOLZC7.js → doctor-GKZJU7QG.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   doctorCommand
-} from "./chunk-C5ZE6WEX.js";
+} from "./chunk-2SKXFXIT.js";
 import "./chunk-KB4XJWE3.js";
 import "./chunk-YO6DVTL7.js";
 import "./chunk-4NCFWYGG.js";

package/dist/{edit-S7NZD7H7.js → edit-4CLNN5JG.js}

@@ -2,7 +2,7 @@
 import {
   loadLoreEntry,
   updateLoreEntry
-} from "./chunk-BRILIG7Z.js";
+} from "./chunk-QIOCFXDQ.js";
 import "./chunk-ZXMDA7VB.js";
 
 // src/commands/lore/edit.ts

package/dist/{graph-ERNQQQ7C.js → graph-YYUXI3F7.js}

@@ -3,7 +3,7 @@ import {
   cliBuildGraphState,
   graphCommand,
   graphGenerateCommand
-} from "./chunk-Z7W7HNRG.js";
+} from "./chunk-QDXI2DHR.js";
 import "./chunk-ZXMDA7VB.js";
 export {
   cliBuildGraphState,