@a-company/paradigm 3.1.5 → 3.5.0

package/dist/{dist-NHJQVVUW.js → dist-Q6SAZI7X.js}

@@ -30,8 +30,8 @@ import {
   searchSymbols,
   serializePremiseFile,
   updateNodePosition
-} from "./chunk-5C4SGQKH.js";
-import "./chunk-PW2EXJQT.js";
+} from "./chunk-6P4IFIK2.js";
+import "./chunk-MRENOFTR.js";
 import "./chunk-IRKUEJVW.js";
 import "./chunk-MO4EEYFW.js";
 export {

package/dist/{dist-GPQ4LAY3.js → dist-YP2CO4TG.js}

@@ -7,36 +7,54 @@ import {
   PatternMatcher,
   PatternSuggester,
   Sentinel,
+  SentinelClient,
+  SentinelTransport,
   StatsCalculator,
   TimelineBuilder,
+  createSentinelClient,
+  createSentinelTransport,
   detectSymbols,
+  enableSentinel,
   generateConfig,
   loadAllSeedPatterns,
-  loadConfig,
   loadParadigmPatterns,
-  loadUniversalPatterns,
-  writeConfig
-} from "./chunk-4LGLU2LO.js";
+  loadUniversalPatterns
+} from "./chunk-2E2RTBSM.js";
 import {
-  SentinelStorage
-} from "./chunk-VZ7CXFRZ.js";
+  DEFAULT_AUTH_CONFIG,
+  DEFAULT_RATE_LIMIT_CONFIG,
+  DEFAULT_SERVER_CONFIG,
+  SentinelStorage,
+  loadConfig,
+  loadServerConfig,
+  writeConfig
+} from "./chunk-CRICL4FQ.js";
 import "./chunk-MO4EEYFW.js";
 export {
   ContextEnricher,
+  DEFAULT_AUTH_CONFIG,
+  DEFAULT_RATE_LIMIT_CONFIG,
+  DEFAULT_SERVER_CONFIG,
   FlowTracker,
   IncidentGrouper,
   PatternImporter,
   PatternMatcher,
   PatternSuggester,
   Sentinel,
+  SentinelClient,
   SentinelStorage,
+  SentinelTransport,
   StatsCalculator,
   TimelineBuilder,
+  createSentinelClient,
+  createSentinelTransport,
   detectSymbols,
+  enableSentinel,
   generateConfig,
   loadAllSeedPatterns,
   loadConfig,
   loadParadigmPatterns,
+  loadServerConfig,
   loadUniversalPatterns,
   writeConfig
 };

package/dist/{doctor-JBIV5PMN.js → doctor-TQYRF7KK.js}

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import {
   doctorCommand
-} from "./chunk-ZPN7MXRA.js";
-import "./chunk-YCLN7WXV.js";
+} from "./chunk-KFHK6EBI.js";
+import "./chunk-2QNZ6PVD.js";
 import "./chunk-4NCFWYGG.js";
 import "./chunk-YO6DVTL7.js";
 import "./chunk-MO4EEYFW.js";

package/dist/{edit-Y7XPYSMK.js → edit-EOMPXOG5.js}

@@ -2,7 +2,7 @@
 import {
   loadLoreEntry,
   updateLoreEntry
-} from "./chunk-MVXJVRFI.js";
+} from "./chunk-5TUAVVIG.js";
 import "./chunk-MO4EEYFW.js";
 
 // src/commands/lore/edit.ts

package/dist/flow-7JUH6D4H.js

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+import "./chunk-HPC3JAUP.js";
+import {
+  log
+} from "./chunk-4NCFWYGG.js";
+import "./chunk-MO4EEYFW.js";
+
+// src/commands/flow.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import chalk from "chalk";
+
+// src/core/flow-validator.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "js-yaml";
+import { execSync } from "child_process";
+
+// src/core/flow-schema.ts
+function configToFlowDefinitions(config) {
+  return Object.entries(config.flows).map(([id, flow]) => ({
+    id,
+    ...flow
+  }));
+}
+
+// src/core/flow-validator.ts
+function loadFlowsConfig(rootDir) {
+  const flowsPath = path.join(rootDir, ".paradigm", "flows.yaml");
+  if (!fs.existsSync(flowsPath)) {
+    return null;
+  }
+  try {
+    const content = fs.readFileSync(flowsPath, "utf-8");
+    return yaml.load(content);
+  } catch {
+    return null;
+  }
+}
+function loadFlowsFromPurpose(rootDir) {
+  const flows = [];
+  try {
+    const result = execSync(
+      `find "${rootDir}" -name ".purpose" -not -path "*/node_modules/*" -not -path "*/.git/*" 2>/dev/null || true`,
+      { encoding: "utf-8" }
+    );
+    for (const purposePath of result.split("\n").filter(Boolean)) {
+      try {
+        const content = fs.readFileSync(purposePath, "utf-8");
+        const flowsMatch = content.match(/flows:\s*\n([\s\S]*?)(?=\n[a-z_]+:|$)/);
+        if (flowsMatch) {
+          const flowsYaml = yaml.load(`flows:
+${flowsMatch[1]}`);
+          if (flowsYaml && typeof flowsYaml === "object" && "flows" in flowsYaml) {
+            const flowsData = flowsYaml.flows;
+            for (const [id, flow] of Object.entries(flowsData)) {
+              flows.push({
+                id,
+                ...flow,
+                definedIn: path.relative(rootDir, purposePath)
+              });
+            }
+          }
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return flows;
+}
+function getAllFlows(rootDir) {
+  const flows = [];
+  const config = loadFlowsConfig(rootDir);
+  if (config) {
+    const configFlows = configToFlowDefinitions(config);
+    for (const flow of configFlows) {
+      flow.definedIn = ".paradigm/flows.yaml";
+      flows.push(flow);
+    }
+  }
+  const purposeFlows = loadFlowsFromPurpose(rootDir);
+  for (const flow of purposeFlows) {
+    if (!flows.some((f) => f.id === flow.id)) {
+      flows.push(flow);
+    }
+  }
+  return flows;
+}
+function generateMermaidDiagram(flow) {
+  const lines = [];
+  lines.push("```mermaid");
+  lines.push("flowchart TD");
+  lines.push(`  START([${escapeLabel(flow.trigger)}])`);
+  let prevId = "START";
+  for (let i = 0; i < flow.steps.length; i++) {
+    const step = flow.steps[i];
+    const nodeId = `S${i}`;
+    const label = escapeLabel(step.symbol);
+    switch (step.type) {
+      case "gate": {
+        const gateStep = step;
+        lines.push(`  ${nodeId}{${label}}`);
+        lines.push(`  ${prevId} --> ${nodeId}`);
+        if (gateStep.failResponse || step.errorSignal) {
+          const denyId = `DENY${i}`;
+          const denyLabel = gateStep.failResponse || step.errorSignal || "Denied";
+          lines.push(`  ${denyId}[/${escapeLabel(denyLabel)}/]`);
+          lines.push(`  ${nodeId} -->|deny| ${denyId}`);
+        }
+        break;
+      }
+      case "action":
+        lines.push(`  ${nodeId}[${label}]`);
+        lines.push(`  ${prevId} -->|${step.optional ? "optional" : "allow"}| ${nodeId}`);
+        break;
+      case "signal":
+        lines.push(`  ${nodeId}([${label}])`);
+        lines.push(`  ${prevId} --> ${nodeId}`);
+        break;
+    }
+    prevId = nodeId;
+  }
+  if (flow.successSignal) {
+    lines.push(`  SUCCESS([${escapeLabel(flow.successSignal)}])`);
+    lines.push(`  ${prevId} --> SUCCESS`);
+  }
+  lines.push("");
+  lines.push("  classDef gate fill:#f9d71c,stroke:#333,color:#000");
+  lines.push("  classDef action fill:#4a90d9,stroke:#333,color:#fff");
+  lines.push("  classDef signal fill:#50c878,stroke:#333,color:#fff");
+  for (let i = 0; i < flow.steps.length; i++) {
+    const step = flow.steps[i];
+    lines.push(`  class S${i} ${step.type}`);
+  }
+  lines.push("```");
+  return lines.join("\n");
+}
+function escapeLabel(text) {
+  return text.replace(/"/g, '\\"').replace(/[[\]{}()]/g, "");
+}
+
+// src/commands/flow.ts
+async function flowDiagramCommand(flowId, options) {
+  const rootDir = process.cwd();
+  const config = loadFlowsConfig(rootDir);
+  if (!config) {
+    console.log(chalk.red("\n\u274C No flows.yaml found"));
+    console.log(chalk.gray("Create .paradigm/flows.yaml to define flows.\n"));
+    process.exit(1);
+  }
+  const flows = getAllFlows(rootDir);
+  const normalizedId = flowId.startsWith("$") ? flowId : `$${flowId}`;
+  const flow = flows.find((f) => f.id === normalizedId || f.id === flowId);
+  if (!flow) {
+    console.log(chalk.red(`
+\u274C Flow not found: ${flowId}`));
+    console.log(chalk.gray(`
+Available flows:`));
+    for (const f of flows) {
+      console.log(chalk.gray(`  ${f.id} \u2014 ${f.name}`));
+    }
+    console.log("");
+    process.exit(1);
+  }
+  log.command("flow-diagram").info("Generating Mermaid diagram", { flowId: flow.id });
+  const diagram = generateMermaidDiagram(flow);
+  if (options.output) {
+    const outputPath = path2.resolve(rootDir, options.output);
+    fs2.writeFileSync(outputPath, diagram, "utf-8");
+    console.log(chalk.green(`
+\u2713 Diagram written to ${path2.relative(rootDir, outputPath)}
+`));
+  } else {
+    console.log("");
+    console.log(chalk.blue(`Flow: ${flow.name} (${flow.id})`));
+    console.log(chalk.gray(`Trigger: ${flow.trigger}`));
+    console.log("");
+    console.log(diagram);
+    console.log("");
+  }
+}
+export {
+  flowDiagramCommand
+};

package/dist/global-AXILUM5X.js

@@ -0,0 +1,136 @@
+#!/usr/bin/env node
+import {
+  log
+} from "./chunk-4NCFWYGG.js";
+import "./chunk-MO4EEYFW.js";
+
+// src/commands/global.ts
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+import ora from "ora";
+function parseDuration(duration) {
+  const match = duration.match(/^(\d+)(d|h|m)$/);
+  if (!match) return null;
+  const [, num, unit] = match;
+  const value = parseInt(num, 10);
+  switch (unit) {
+    case "d":
+      return value * 24 * 60 * 60 * 1e3;
+    case "h":
+      return value * 60 * 60 * 1e3;
+    case "m":
+      return value * 60 * 1e3;
+    default:
+      return null;
+  }
+}
+function findOldFiles(dir, cutoffMs) {
+  const results = [];
+  if (!fs.existsSync(dir)) return results;
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...findOldFiles(fullPath, cutoffMs));
+    } else if (entry.isFile()) {
+      try {
+        const stat = fs.statSync(fullPath);
+        const age = Date.now() - stat.mtimeMs;
+        if (age > cutoffMs) {
+          const days = Math.floor(age / (24 * 60 * 60 * 1e3));
+          results.push({ path: fullPath, age: `${days}d` });
+        }
+      } catch {
+      }
+    }
+  }
+  return results;
+}
+async function globalCleanCommand(options) {
+  const homeDir = process.env.HOME || process.env.USERPROFILE || "~";
+  const globalDir = path.join(homeDir, ".paradigm");
+  const spinner = ora();
+  if (!fs.existsSync(globalDir)) {
+    console.log(chalk.yellow("\nNo ~/.paradigm/ directory found.\n"));
+    return;
+  }
+  const durationStr = options.olderThan || "90d";
+  const durationMs = parseDuration(durationStr);
+  if (!durationMs) {
+    console.log(chalk.red(`
+Invalid duration: ${durationStr}`));
+    console.log(chalk.gray("Use format: 90d, 30d, 7d, 24h, etc.\n"));
+    process.exit(1);
+  }
+  console.log(chalk.blue(`
+Global Brain Rotation
+`));
+  console.log(chalk.gray(`  Scanning ~/.paradigm/ for files older than ${durationStr}...
+`));
+  spinner.start("Scanning...");
+  const cleanableDirs = ["wisdom", "lore", "history", "cache"];
+  const allOldFiles = [];
+  for (const sub of cleanableDirs) {
+    const subDir = path.join(globalDir, sub);
+    const oldFiles = findOldFiles(subDir, durationMs);
+    allOldFiles.push(...oldFiles);
+  }
+  spinner.stop();
+  if (allOldFiles.length === 0) {
+    console.log(chalk.green(`  No files older than ${durationStr} found.
+`));
+    return;
+  }
+  console.log(chalk.gray(`  Found ${allOldFiles.length} files older than ${durationStr}:
+`));
+  for (const file of allOldFiles.slice(0, 20)) {
+    const relPath = path.relative(globalDir, file.path);
+    console.log(chalk.gray(`    ${file.age} old - ${relPath}`));
+  }
+  if (allOldFiles.length > 20) {
+    console.log(chalk.gray(`    ... and ${allOldFiles.length - 20} more`));
+  }
+  if (options.dryRun) {
+    console.log(chalk.yellow(`
+  Dry run - no files deleted.
+`));
+    log.command("global-clean").info("Dry run completed", { count: allOldFiles.length, olderThan: durationStr });
+    return;
+  }
+  spinner.start(`Deleting ${allOldFiles.length} files...`);
+  let deleted = 0;
+  for (const file of allOldFiles) {
+    try {
+      fs.unlinkSync(file.path);
+      deleted++;
+    } catch {
+    }
+  }
+  spinner.succeed(`Deleted ${deleted} files older than ${durationStr}`);
+  for (const sub of cleanableDirs) {
+    const subDir = path.join(globalDir, sub);
+    cleanEmptyDirs(subDir);
+  }
+  console.log("");
+  log.command("global-clean").success("Global brain rotation completed", { deleted, olderThan: durationStr });
+}
+function cleanEmptyDirs(dir) {
+  if (!fs.existsSync(dir)) return;
+  const entries = fs.readdirSync(dir);
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry);
+    if (fs.statSync(fullPath).isDirectory()) {
+      cleanEmptyDirs(fullPath);
+    }
+  }
+  if (fs.readdirSync(dir).length === 0) {
+    try {
+      fs.rmdirSync(dir);
+    } catch {
+    }
+  }
+}
+export {
+  globalCleanCommand
+};

package/dist/{habits-FA65W77Y.js → habits-CHP4EW5H.js}

@@ -162,17 +162,93 @@ var seed_habits_default = [
       }
     },
     enabled: true
+  },
+  {
+    id: "commit-message-symbols",
+    name: "Commit Message Format",
+    description: "Commit messages should follow type(#symbol): format and include a Symbols: trailer",
+    category: "documentation",
+    trigger: "on-commit",
+    severity: "advisory",
+    check: {
+      type: "commit-message-format",
+      params: {
+        messagePatterns: ["^(feat|fix|refactor|chore|docs|test|style|perf|ci|build)\\(", "Symbols:"]
+      }
+    },
+    enabled: true
+  },
+  {
+    id: "flow-coverage-for-multi-component",
+    name: "Flow Coverage",
+    description: "Changes spanning 3+ components should have a documented $flow",
+    category: "documentation",
+    trigger: "postflight",
+    severity: "advisory",
+    check: {
+      type: "flow-coverage",
+      params: {
+        minSteps: 3
+      }
+    },
+    enabled: true
+  },
+  {
+    id: "context-session-awareness",
+    name: "Context Awareness",
+    description: "Use session recovery or context check tools for session continuity",
+    category: "discovery",
+    trigger: "preflight",
+    severity: "advisory",
+    check: {
+      type: "context-checked",
+      params: {
+        contextTools: ["paradigm_context_check", "paradigm_session_recover", "paradigm_session_checkpoint"]
+      }
+    },
+    enabled: true
+  },
+  {
+    id: "aspect-anchors-valid",
+    name: "Aspect Anchors Valid",
+    description: "Aspects touched during the session should have their code anchors validated",
+    category: "verification",
+    trigger: "postflight",
+    severity: "advisory",
+    check: {
+      type: "aspect-anchored",
+      params: {
+        checkAnchors: true
+      }
+    },
+    enabled: true
   }
 ];
 
 // src/core/habits/loader.ts
 var SEED_HABITS = seed_habits_default;
-var HABITS_CACHE_TTL_MS = 30 * 1e3;
+var DEFAULT_HABITS_CACHE_TTL_MS = 30 * 1e3;
+function getHabitsCacheTtl(rootDir) {
+  try {
+    const configPath = path.join(rootDir, ".paradigm", "config.yaml");
+    if (fs.existsSync(configPath)) {
+      const content = fs.readFileSync(configPath, "utf8");
+      const config = yaml.load(content);
+      const limits = config?.limits;
+      if (limits?.habitsCacheTtlMs && typeof limits.habitsCacheTtlMs === "number") {
+        return limits.habitsCacheTtlMs;
+      }
+    }
+  } catch {
+  }
+  return DEFAULT_HABITS_CACHE_TTL_MS;
+}
 var habitsCache = /* @__PURE__ */ new Map();
 function loadHabits(rootDir) {
   const absoluteRoot = path.resolve(rootDir);
   const cached = habitsCache.get(absoluteRoot);
-  if (cached && Date.now() - cached.loadedAt < HABITS_CACHE_TTL_MS) {
+  const ttl = getHabitsCacheTtl(absoluteRoot);
+  if (cached && Date.now() - cached.loadedAt < ttl) {
     return cached.habits;
   }
   const habits = loadHabitsFresh(absoluteRoot);
@@ -294,6 +370,14 @@ function evaluateHabit(habit, context) {
       return evaluateFileModified(habit, context);
     case "git-clean":
       return evaluateGitClean(habit, context);
+    case "commit-message-format":
+      return evaluateCommitMessageFormat(habit, context);
+    case "flow-coverage":
+      return evaluateFlowCoverage(habit, context);
+    case "context-checked":
+      return evaluateContextChecked(habit, context);
+    case "aspect-anchored":
+      return evaluateAspectAnchored(habit, context);
     default:
       return {
         habit,
@@ -550,6 +634,148 @@ function evaluateGitClean(habit, context) {
     reason: "Uncommitted changes in working tree"
   };
 }
+function evaluateCommitMessageFormat(habit, context) {
+  if (!context.commitMessage) {
+    return {
+      habit,
+      result: "followed",
+      reason: "No commit message to check (not a commit trigger)"
+    };
+  }
+  const patterns = habit.check.params.messagePatterns || [
+    "^(feat|fix|refactor|chore|docs|test|style|perf|ci|build)\\(",
+    "Symbols:"
+  ];
+  const matchedPatterns = patterns.filter(
+    (p) => new RegExp(p, "m").test(context.commitMessage)
+  );
+  if (matchedPatterns.length === patterns.length) {
+    return {
+      habit,
+      result: "followed",
+      reason: "Commit message matches all required patterns",
+      evidence: matchedPatterns
+    };
+  }
+  if (matchedPatterns.length > 0) {
+    const missing = patterns.filter(
+      (p) => !new RegExp(p, "m").test(context.commitMessage)
+    );
+    return {
+      habit,
+      result: "partial",
+      reason: `Commit message matches ${matchedPatterns.length}/${patterns.length} patterns. Missing: ${missing.join(", ")}`
+    };
+  }
+  return {
+    habit,
+    result: "skipped",
+    reason: "Commit message does not match required format patterns"
+  };
+}
+function evaluateFlowCoverage(habit, context) {
+  const componentSymbols = context.symbolsTouched.filter(
+    (s) => s.startsWith("#")
+  );
+  if (componentSymbols.length < 3) {
+    return {
+      habit,
+      result: "followed",
+      reason: "Fewer than 3 components touched \u2014 flow not required"
+    };
+  }
+  if (context.hasFlowCoverage) {
+    return {
+      habit,
+      result: "followed",
+      reason: "Flow coverage exists for multi-component changes"
+    };
+  }
+  const flowTools = [
+    "paradigm_flow_validate",
+    "paradigm_flows_affected",
+    "paradigm_purpose_add_flow"
+  ];
+  const calledFlowTools = flowTools.filter(
+    (t) => context.toolsCalled.includes(t)
+  );
+  if (calledFlowTools.length > 0) {
+    return {
+      habit,
+      result: "followed",
+      reason: `Flow tools called: ${calledFlowTools.join(", ")}`,
+      evidence: calledFlowTools
+    };
+  }
+  return {
+    habit,
+    result: "skipped",
+    reason: `${componentSymbols.length} components touched without flow coverage or flow tools called`,
+    evidence: componentSymbols.slice(0, 5)
+  };
+}
+function evaluateContextChecked(habit, context) {
+  const contextTools = habit.check.params.contextTools || [
+    "paradigm_context_check",
+    "paradigm_session_recover",
+    "paradigm_session_checkpoint"
+  ];
+  const calledTools = contextTools.filter(
+    (t) => context.toolsCalled.includes(t)
+  );
+  if (calledTools.length > 0) {
+    return {
+      habit,
+      result: "followed",
+      reason: `Context tools called: ${calledTools.join(", ")}`,
+      evidence: calledTools
+    };
+  }
+  if (context.filesModified.length === 0 && context.symbolsTouched.length === 0) {
+    return {
+      habit,
+      result: "followed",
+      reason: "No modifications made, context check not applicable"
+    };
+  }
+  return {
+    habit,
+    result: "skipped",
+    reason: "No context/session tools called during session"
+  };
+}
+function evaluateAspectAnchored(habit, context) {
+  const aspectSymbols = context.symbolsTouched.filter(
+    (s) => s.startsWith("~")
+  );
+  if (aspectSymbols.length === 0) {
+    return {
+      habit,
+      result: "followed",
+      reason: "No aspects touched"
+    };
+  }
+  if (context.aspectAnchorsValid === true) {
+    return {
+      habit,
+      result: "followed",
+      reason: "Aspect anchors validated and valid"
+    };
+  }
+  if (context.toolsCalled.includes("paradigm_aspect_check")) {
+    return {
+      habit,
+      result: "followed",
+      reason: "paradigm_aspect_check was called to validate anchors"
+    };
+  }
+  return {
+    habit,
+    result: "skipped",
+    reason: `${aspectSymbols.length} aspect(s) touched without anchor validation`,
+    evidence: aspectSymbols.slice(0, 5)
+  };
+}
 function buildEvaluationContext(params) {
   return {
     toolsCalled: params.toolsCalled || [],
@@ -559,7 +785,10 @@ function buildEvaluationContext(params) {
     hasPortalRoutes: params.hasPortalRoutes || false,
     taskAddsRoutes: params.taskAddsRoutes || false,
     taskDescription: params.taskDescription,
-    gitClean: params.gitClean
+    gitClean: params.gitClean,
+    commitMessage: params.commitMessage,
+    hasFlowCoverage: params.hasFlowCoverage,
+    aspectAnchorsValid: params.aspectAnchorsValid
   };
 }
 
@@ -682,7 +911,7 @@ async function habitsStatusCommand(options) {
   const enabled = getEnabledHabits(habits);
   let practiceData = null;
   try {
-    const { SentinelStorage } = await import("./dist-GPQ4LAY3.js");
+    const { SentinelStorage } = await import("./dist-YP2CO4TG.js");
     const sentinelDir = path3.join(rootDir, ".paradigm", "sentinel");
     if (fs2.existsSync(sentinelDir)) {
       const storage = new SentinelStorage(sentinelDir);
@@ -1050,7 +1279,7 @@ async function habitsCheckCommand(options) {
     try {
       const sentinelDir = path3.join(rootDir, ".paradigm", "sentinel");
       if (fs2.existsSync(sentinelDir)) {
-        const { SentinelStorage } = await import("./dist-GPQ4LAY3.js");
+        const { SentinelStorage } = await import("./dist-YP2CO4TG.js");
         const storage = new SentinelStorage(sentinelDir);
         for (const e of evaluation.evaluations) {
           storage.recordPracticeEvent({