@a-company/paradigm 3.34.0 → 3.43.0

package/dist/{accept-orchestration-XXANWJVZ.js → accept-orchestration-ZUWQUHSK.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/add-VSPZ6FM4.js

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+import {
+  rebuildUniversityIndex,
+  saveNote,
+  saveQuiz
+} from "./chunk-GT5QGC2H.js";
+import "./chunk-ZXMDA7VB.js";
+
+// src/commands/university/add.ts
+import chalk from "chalk";
+import { execSync } from "child_process";
+import * as os from "os";
+function resolveAuthor() {
+  try {
+    return execSync("git config user.name", { encoding: "utf-8", timeout: 3e3 }).trim().toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").slice(0, 20) || "unknown";
+  } catch {
+    try {
+      return os.userInfo().username;
+    } catch {
+      return "unknown";
+    }
+  }
+}
+async function universityAddCommand(type, options) {
+  const rootDir = process.cwd();
+  if (!options.title) {
+    console.error(chalk.red("\n  Error: --title is required\n"));
+    process.exit(1);
+  }
+  const author = resolveAuthor();
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const slug = options.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
+  const tags = options.tags ? options.tags.split(",").map((t) => t.trim()) : [];
+  const symbols = options.symbols ? options.symbols.split(",").map((s) => s.trim()) : [];
+  if (type === "quiz") {
+    const id2 = `Q-${slug}`;
+    const quiz = {
+      id: id2,
+      title: options.title,
+      description: options.body || "",
+      author,
+      created: today,
+      updated: today,
+      tags,
+      symbols,
+      difficulty: options.difficulty || "beginner",
+      passThreshold: 0.7,
+      questions: []
+    };
+    saveQuiz(rootDir, quiz);
+    rebuildUniversityIndex(rootDir);
+    console.log(chalk.green(`
+  Created quiz: ${id2}`));
+    console.log(chalk.gray("  Add questions by editing the YAML file\n"));
+    return;
+  }
+  const prefix = type === "policy" ? "P" : "N";
+  const id = `${prefix}-${slug}`;
+  const frontmatter = {
+    id,
+    title: options.title,
+    type,
+    author,
+    created: today,
+    updated: today,
+    tags,
+    symbols,
+    difficulty: options.difficulty || "beginner",
+    estimatedMinutes: options.minutes ? parseInt(options.minutes, 10) : void 0,
+    prerequisites: []
+  };
+  saveNote(rootDir, frontmatter, options.body || "");
+  rebuildUniversityIndex(rootDir);
+  console.log(chalk.green(`
+  Created ${type}: ${id}`));
+  console.log(chalk.gray(`  Edit at .paradigm/university/content/${type === "policy" ? "policies" : "notes"}/${id}.md
+`));
+}
+export {
+  universityAddCommand
+};

package/dist/{aggregate-XHQ6GI3Z.js → aggregate-SV3VGEIL.js}

@@ -5,8 +5,8 @@ import {
   buildSymbolIndex,
   getSymbolCounts,
   parsePremiseFile
-} from "./chunk-CTF6RHKG.js";
-import "./chunk-VUSCJJ4A.js";
+} from "./chunk-ZGUAAVMA.js";
+import "./chunk-EDOAWN7J.js";
 import "./chunk-IRKUEJVW.js";
 import "./chunk-ZXMDA7VB.js";
 

package/dist/assess-UHBDYIK7.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+import {
+  addAssessment,
+  loadLoreEntry
+} from "./chunk-QIOCFXDQ.js";
+import "./chunk-ZXMDA7VB.js";
+
+// src/commands/lore/assess.ts
+import chalk from "chalk";
+async function loreAssessCommand(id, verdict, options) {
+  const rootDir = process.cwd();
+  const validVerdicts = ["correct", "partial", "incorrect"];
+  if (!validVerdicts.includes(verdict)) {
+    console.error(chalk.red(`
+  Invalid verdict: "${verdict}". Must be one of: correct, partial, incorrect
+`));
+    process.exit(1);
+  }
+  const entry = await loadLoreEntry(rootDir, id);
+  if (!entry) {
+    console.error(chalk.red(`
+  Entry not found: ${id}
+`));
+    process.exit(1);
+  }
+  const success = await addAssessment(rootDir, id, {
+    verdict,
+    assessed_by: options.assessor || "unknown",
+    assessed_at: (/* @__PURE__ */ new Date()).toISOString(),
+    notes: options.notes
+  });
+  if (success) {
+    const verdictColors = {
+      correct: chalk.green,
+      partial: chalk.yellow,
+      incorrect: chalk.red
+    };
+    const colorFn = verdictColors[verdict] || chalk.white;
+    console.log(chalk.green(`
+  Assessment recorded for ${id}`));
+    console.log(`  Verdict: ${colorFn(verdict)}`);
+    if (entry.confidence != null) {
+      const impliedScore = verdict === "correct" ? 1 : verdict === "partial" ? 0.5 : 0;
+      const delta = impliedScore - entry.confidence;
+      const deltaStr = `${delta > 0 ? "+" : ""}${delta.toFixed(2)}`;
+      const deltaColor = Math.abs(delta) <= 0.1 ? chalk.green : Math.abs(delta) <= 0.3 ? chalk.yellow : chalk.red;
+      console.log(`  Confidence: ${entry.confidence.toFixed(2)} | Delta: ${deltaColor(deltaStr)}`);
+      if (delta > 0.1) {
+        console.log(chalk.gray("  Under-confident (outcome better than predicted)"));
+      } else if (delta < -0.1) {
+        console.log(chalk.gray("  Over-confident (outcome worse than predicted)"));
+      } else {
+        console.log(chalk.gray("  Well-calibrated"));
+      }
+    } else {
+      console.log(chalk.gray("  No confidence recorded \u2014 delta not computed"));
+    }
+    console.log();
+  } else {
+    console.error(chalk.red(`
+  Failed to assess entry: ${id}
+`));
+    process.exit(1);
+  }
+}
+export {
+  loreAssessCommand
+};

package/dist/{beacon-BTLQMYQL.js → beacon-3SJV4DAP.js}

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

package/dist/calibration-WWHK73WU.js

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+import {
+  loadLoreEntries
+} from "./chunk-QIOCFXDQ.js";
+import "./chunk-ZXMDA7VB.js";
+
+// src/commands/lore/calibration.ts
+import chalk from "chalk";
+async function loreCalibrationCommand(options) {
+  const rootDir = process.cwd();
+  const entries = await loadLoreEntries(rootDir, {
+    symbol: options.symbol,
+    tag: options.tag,
+    author: options.author,
+    hasAssessment: true
+  });
+  if (entries.length === 0) {
+    if (options.json) {
+      console.log(JSON.stringify({ totalAssessed: 0, message: "No assessed entries found" }, null, 2));
+    } else {
+      console.log(chalk.gray("\n  No assessed lore entries found.\n"));
+      console.log(chalk.gray("  Use `paradigm lore assess <id> <correct|partial|incorrect>` to assess entries.\n"));
+    }
+    return;
+  }
+  const withConfidence = entries.filter((e) => e.confidence != null);
+  const totalAssessed = entries.length;
+  const totalWithConfidence = withConfidence.length;
+  const verdictBreakdown = { correct: 0, partial: 0, incorrect: 0 };
+  let totalImpliedScore = 0;
+  let totalConfidence = 0;
+  let totalAbsDelta = 0;
+  for (const e of entries) {
+    const v = e.assessment.verdict;
+    verdictBreakdown[v]++;
+    const implied = v === "correct" ? 1 : v === "partial" ? 0.5 : 0;
+    totalImpliedScore += implied;
+    if (e.confidence != null) {
+      totalConfidence += e.confidence;
+      totalAbsDelta += Math.abs(implied - e.confidence);
+    }
+  }
+  const accuracyRate = totalImpliedScore / totalAssessed;
+  const avgConfidence = totalWithConfidence > 0 ? totalConfidence / totalWithConfidence : null;
+  const calibrationScore = totalWithConfidence > 0 ? 1 - totalAbsDelta / totalWithConfidence : null;
+  let groups;
+  if (options.groupBy && totalAssessed > 0) {
+    const groupMap = /* @__PURE__ */ new Map();
+    for (const e of entries) {
+      let keys = [];
+      if (options.groupBy === "symbol") {
+        keys = e.symbols_touched || [];
+      } else if (options.groupBy === "tag") {
+        keys = e.tags || [];
+      } else if (options.groupBy === "type") {
+        keys = [e.type || "agent-session"];
+      }
+      for (const key of keys) {
+        if (!groupMap.has(key)) groupMap.set(key, []);
+        groupMap.get(key).push(e);
+      }
+    }
+    groups = Array.from(groupMap.entries()).map(([key, gEntries]) => {
+      const gWithConf = gEntries.filter((e) => e.confidence != null);
+      const gBreakdown = { correct: 0, partial: 0, incorrect: 0 };
+      let gImplied = 0;
+      let gConf = 0;
+      let gAbsDelta = 0;
+      for (const e of gEntries) {
+        const v = e.assessment.verdict;
+        gBreakdown[v]++;
+        const implied = v === "correct" ? 1 : v === "partial" ? 0.5 : 0;
+        gImplied += implied;
+        if (e.confidence != null) {
+          gConf += e.confidence;
+          gAbsDelta += Math.abs(implied - e.confidence);
+        }
+      }
+      return {
+        key,
+        total: gEntries.length,
+        accuracyRate: gImplied / gEntries.length,
+        avgConfidence: gWithConf.length > 0 ? gConf / gWithConf.length : null,
+        calibrationScore: gWithConf.length > 0 ? 1 - gAbsDelta / gWithConf.length : null,
+        verdictBreakdown: gBreakdown
+      };
+    }).sort((a, b) => b.total - a.total);
+  }
+  if (options.json) {
+    console.log(JSON.stringify({
+      totalAssessed,
+      totalWithConfidence,
+      accuracyRate: Math.round(accuracyRate * 1e3) / 1e3,
+      avgConfidence: avgConfidence != null ? Math.round(avgConfidence * 1e3) / 1e3 : null,
+      calibrationScore: calibrationScore != null ? Math.round(calibrationScore * 1e3) / 1e3 : null,
+      verdictBreakdown,
+      ...groups ? { groups } : {}
+    }, null, 2));
+    return;
+  }
+  const caveat = totalAssessed < 5 ? chalk.gray(`  (Low sample: N=${totalAssessed}. Stats may not be representative.)`) : totalAssessed < 15 ? chalk.gray(`  (Moderate sample: N=${totalAssessed}. Trends are directional.)`) : "";
+  console.log(chalk.magenta(`
+  Calibration Report (${totalAssessed} assessed entries)
+`));
+  if (caveat) console.log(caveat + "\n");
+  const total = totalAssessed;
+  console.log(chalk.white("  Verdicts:"));
+  console.log(`    ${chalk.green("correct")}:   ${verdictBreakdown.correct}/${total} (${(verdictBreakdown.correct / total * 100).toFixed(0)}%)`);
+  console.log(`    ${chalk.yellow("partial")}:   ${verdictBreakdown.partial}/${total} (${(verdictBreakdown.partial / total * 100).toFixed(0)}%)`);
+  console.log(`    ${chalk.red("incorrect")}: ${verdictBreakdown.incorrect}/${total} (${(verdictBreakdown.incorrect / total * 100).toFixed(0)}%)`);
+  console.log();
+  console.log(chalk.white("  Scores:"));
+  const accColor = accuracyRate >= 0.8 ? chalk.green : accuracyRate >= 0.5 ? chalk.yellow : chalk.red;
+  console.log(`    Accuracy rate:    ${accColor(accuracyRate.toFixed(3))}`);
+  if (avgConfidence != null) {
+    console.log(`    Avg confidence:   ${avgConfidence.toFixed(3)}`);
+  }
+  if (calibrationScore != null) {
+    const calColor = calibrationScore >= 0.9 ? chalk.green : calibrationScore >= 0.7 ? chalk.yellow : chalk.red;
+    console.log(`    Calibration:      ${calColor(calibrationScore.toFixed(3))} (1.0 = perfect)`);
+  }
+  console.log();
+  if (groups && groups.length > 0) {
+    console.log(chalk.white(`  By ${options.groupBy}:`));
+    for (const g of groups.slice(0, 15)) {
+      const gAccColor = g.accuracyRate >= 0.8 ? chalk.green : g.accuracyRate >= 0.5 ? chalk.yellow : chalk.red;
+      const calStr = g.calibrationScore != null ? ` cal:${g.calibrationScore.toFixed(2)}` : "";
+      console.log(`    ${chalk.cyan(g.key.padEnd(25))} ${gAccColor(`acc:${g.accuracyRate.toFixed(2)}`)}${calStr}  (${g.verdictBreakdown.correct}/${g.verdictBreakdown.partial}/${g.verdictBreakdown.incorrect}) N=${g.total}`);
+    }
+    console.log();
+  }
+}
+export {
+  loreCalibrationCommand
+};

package/dist/{chunk-C5ZE6WEX.js → chunk-2SKXFXIT.js}

@@ -423,6 +423,96 @@ async function doctorCommand(options = {}) {
         });
       }
     }
+    const universityDir = path.join(cwd, ".paradigm", "university");
+    if (fs.existsSync(universityDir)) {
+      try {
+        const contentDir = path.join(universityDir, "content");
+        let contentCount = 0;
+        let issues = 0;
+        if (fs.existsSync(contentDir)) {
+          for (const subdir of ["notes", "policies", "quizzes", "paths"]) {
+            const sd = path.join(contentDir, subdir);
+            if (fs.existsSync(sd)) {
+              contentCount += fs.readdirSync(sd).filter((f) => f.endsWith(".md") || f.endsWith(".yaml")).length;
+            }
+          }
+        }
+        if (contentCount === 0) {
+          results.push({
+            name: "University content",
+            status: "warn",
+            message: "University directory exists but no content found",
+            fix: 'Add content: paradigm university add note --title "Getting Started"'
+          });
+        } else {
+          const quizDir = path.join(contentDir, "quizzes");
+          if (fs.existsSync(quizDir)) {
+            for (const file of fs.readdirSync(quizDir).filter((f) => f.endsWith(".yaml"))) {
+              try {
+                const { parse } = await import("./dist-PSF5CP4I.js");
+                const quiz = parse(fs.readFileSync(path.join(quizDir, file), "utf8"));
+                if (quiz?.questions) {
+                  for (const q of quiz.questions) {
+                    if (q.choices && q.correct && !(q.correct in q.choices)) {
+                      issues++;
+                    }
+                  }
+                }
+              } catch {
+              }
+            }
+          }
+          const pathDir = path.join(contentDir, "paths");
+          if (fs.existsSync(pathDir)) {
+            for (const file of fs.readdirSync(pathDir).filter((f) => f.endsWith(".yaml"))) {
+              try {
+                const { parse } = await import("./dist-PSF5CP4I.js");
+                const lp = parse(fs.readFileSync(path.join(pathDir, file), "utf8"));
+                if (lp?.steps) {
+                  for (const step of lp.steps) {
+                    if (step.content && !step.content.startsWith("plsat:")) {
+                      let found = false;
+                      for (const sd of ["notes", "policies", "quizzes", "paths"]) {
+                        const sdPath = path.join(contentDir, sd);
+                        if (fs.existsSync(sdPath)) {
+                          const files = fs.readdirSync(sdPath);
+                          if (files.some((f) => f.startsWith(step.content))) {
+                            found = true;
+                            break;
+                          }
+                        }
+                      }
+                      if (!found) issues++;
+                    }
+                  }
+                }
+              } catch {
+              }
+            }
+          }
+          if (issues > 0) {
+            results.push({
+              name: "University content",
+              status: "warn",
+              message: `${contentCount} items, ${issues} issue${issues > 1 ? "s" : ""}`,
+              fix: "Run: paradigm university validate --deep"
+            });
+          } else {
+            results.push({
+              name: "University content",
+              status: "ok",
+              message: `${contentCount} content item${contentCount > 1 ? "s" : ""}`
+            });
+          }
+        }
+      } catch {
+        results.push({
+          name: "University content",
+          status: "warn",
+          message: "Could not read university directory"
+        });
+      }
+    }
     const hooksJsonPath = path.join(cwd, ".claude", "hooks.json");
     const pluginHooksPath = path.join(cwd, "plugins", "paradigm", "hooks.json");
     if (fs.existsSync(hooksJsonPath)) {
@@ -543,7 +633,7 @@ async function doctorCommand(options = {}) {
       }
     }
   }
-  const { runContextAudit } = await import("./context-audit-RI4R2WRH.js");
+  const { runContextAudit } = await import("./context-audit-557EO6PK.js");
   const contextResults = await runContextAudit(cwd, { quiet });
   let contextErrorCount = 0;
   let contextWarnCount = 0;

package/dist/{chunk-S5TDFT5Q.js → chunk-7COU5S2Z.js}

@@ -5,10 +5,10 @@ import {
 } from "./chunk-36TKPM5Z.js";
 import {
   aggregateFromDirectory
-} from "./chunk-CTF6RHKG.js";
+} from "./chunk-ZGUAAVMA.js";
 import {
   cliBuildGraphState
-} from "./chunk-Z7W7HNRG.js";
+} from "./chunk-QDXI2DHR.js";
 
 // src/commands/scan/navigator.ts
 import * as fs from "fs";

package/dist/{chunk-3BAMPB6I.js → chunk-7WEKMZ46.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   SentinelStorage
-} from "./chunk-R2SGQ22F.js";
+} from "./chunk-YW5OCVKB.js";
 
 // ../sentinel/dist/chunk-VQ3SIN7S.js
 import { v4 as uuidv4 } from "uuid";
@@ -2578,150 +2578,6 @@ var PatternImporter = class {
     };
   }
 };
-var PARADIGM_SCHEMA = {
-  id: "paradigm-logger",
-  version: "1.0.0",
-  name: "Paradigm Logger",
-  description: "Structured logs from @a-company/paradigm-logger with symbolic context",
-  scope: {
-    field: "correlationId",
-    type: "string",
-    label: "Correlation",
-    ordering: "independent",
-    sessionField: "sessionId"
-  },
-  eventTypes: [
-    {
-      type: "log:debug",
-      category: "logs",
-      label: "Debug Log",
-      severity: "debug",
-      frequency: "high",
-      fields: [
-        { name: "symbol", type: "string", indexed: true, display: true },
-        { name: "symbolType", type: "string", indexed: true, display: true },
-        { name: "message", type: "string", display: true },
-        { name: "service", type: "string", indexed: true, display: true },
-        { name: "durationMs", type: "number", display: true }
-      ]
-    },
-    {
-      type: "log:info",
-      category: "logs",
-      label: "Info Log",
-      severity: "info",
-      frequency: "high",
-      fields: [
-        { name: "symbol", type: "string", indexed: true, display: true },
-        { name: "symbolType", type: "string", indexed: true, display: true },
-        { name: "message", type: "string", display: true },
-        { name: "service", type: "string", indexed: true, display: true },
-        { name: "durationMs", type: "number", display: true }
-      ]
-    },
-    {
-      type: "log:warn",
-      category: "logs",
-      label: "Warning Log",
-      severity: "warn",
-      frequency: "medium",
-      fields: [
-        { name: "symbol", type: "string", indexed: true, display: true },
-        { name: "symbolType", type: "string", indexed: true, display: true },
-        { name: "message", type: "string", display: true },
-        { name: "service", type: "string", indexed: true, display: true }
-      ]
-    },
-    {
-      type: "log:error",
-      category: "logs",
-      label: "Error Log",
-      severity: "error",
-      frequency: "low",
-      fields: [
-        { name: "symbol", type: "string", indexed: true, display: true },
-        { name: "symbolType", type: "string", indexed: true, display: true },
-        { name: "message", type: "string", display: true },
-        { name: "service", type: "string", indexed: true, display: true }
-      ]
-    },
-    {
-      type: "metric:counter",
-      category: "metrics",
-      label: "Counter Metric",
-      severity: "info",
-      frequency: "high",
-      fields: [
-        { name: "name", type: "string", indexed: true, display: true },
-        { name: "value", type: "number", display: true },
-        { name: "tags", type: "object" }
-      ]
-    },
-    {
-      type: "metric:gauge",
-      category: "metrics",
-      label: "Gauge Metric",
-      severity: "info",
-      frequency: "medium",
-      fields: [
-        { name: "name", type: "string", indexed: true, display: true },
-        { name: "value", type: "number", display: true },
-        { name: "tags", type: "object" }
-      ]
-    },
-    {
-      type: "metric:histogram",
-      category: "metrics",
-      label: "Histogram Metric",
-      severity: "info",
-      frequency: "medium",
-      fields: [
-        { name: "name", type: "string", indexed: true, display: true },
-        { name: "value", type: "number", display: true },
-        { name: "tags", type: "object" }
-      ]
-    },
-    {
-      type: "trace:span",
-      category: "traces",
-      label: "Trace Span",
-      severity: "info",
-      frequency: "medium",
-      fields: [
-        { name: "traceId", type: "string", indexed: true, display: true },
-        { name: "spanId", type: "string", indexed: true },
-        { name: "operation", type: "string", display: true },
-        { name: "durationMs", type: "number", display: true },
-        { name: "status", type: "string", display: true }
-      ]
-    },
-    {
-      type: "incident:recorded",
-      category: "incidents",
-      label: "Incident Recorded",
-      severity: "error",
-      frequency: "low",
-      fields: [
-        { name: "incidentId", type: "string", indexed: true, display: true },
-        { name: "errorMessage", type: "string", display: true },
-        { name: "symbols", type: "object" },
-        { name: "environment", type: "string", display: true }
-      ]
-    }
-  ],
-  visualization: {
-    defaultView: "table",
-    categoryColors: {
-      logs: "#3b82f6",
-      metrics: "#22c55e",
-      traces: "#a855f7",
-      incidents: "#ef4444"
-    },
-    summaryFields: ["symbol", "message", "service"],
-    defaultExcluded: ["log:debug"]
-  },
-  tags: ["builtin", "paradigm"]
-};
 
 export {
   SentinelClient,
@@ -2742,6 +2598,5 @@ export {
   StatsCalculator,
   ContextEnricher,
   PatternSuggester,
-  PatternImporter,
-  PARADIGM_SCHEMA
+  PatternImporter
 };

package/dist/{chunk-H4TVBJD4.js → chunk-AKIMFN6I.js}

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 import {
   indexCommand
-} from "./chunk-S5TDFT5Q.js";
+} from "./chunk-7COU5S2Z.js";
 import {
   getDefaultPremiseContent
-} from "./chunk-CTF6RHKG.js";
+} from "./chunk-ZGUAAVMA.js";
 import {
   getDefaultPurposeContent
-} from "./chunk-VUSCJJ4A.js";
+} from "./chunk-EDOAWN7J.js";
 import {
   STACK_PRESETS,
   detectDiscipline,