@a-company/paradigm 3.9.0 → 3.11.0

package/dist/chunk-F6EJKLF4.js

@@ -0,0 +1,4971 @@
+#!/usr/bin/env node
+
+// ../paradigm-mcp/src/tools/reindex.ts
+import * as fs8 from "fs";
+import * as path9 from "path";
+import * as yaml7 from "js-yaml";
+
+// ../paradigm-mcp/node_modules/.pnpm/@a-company+premise-core@0.2.0_typescript@5.9.3/node_modules/@a-company/premise-core/dist/index.js
+import * as yaml3 from "js-yaml";
+import { z as z2 } from "zod";
+import * as path3 from "path";
+
+// ../paradigm-mcp/node_modules/.pnpm/@a-company+purpose-core@3.5.0_typescript@5.9.3/node_modules/@a-company/purpose-core/dist/index.js
+import * as fs from "fs";
+import * as yaml from "js-yaml";
+import { z } from "zod";
+import * as path from "path";
+import { glob } from "glob";
+var PurposeItemSchema = z.object({
+  description: z.string(),
+  endpoints: z.array(z.string()).optional(),
+  tests: z.array(z.string()).optional(),
+  rules: z.record(z.unknown()).optional(),
+  aspects: z.array(z.string()).optional(),
+  // Symbol reference arrays
+  flows: z.array(z.string()).optional(),
+  gates: z.array(z.string()).optional(),
+  signals: z.array(z.string()).optional(),
+  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(),
+  "used-by": z.array(z.string()).optional(),
+  "used-for": z.array(z.string()).optional(),
+  exports: z.array(z.string()).optional(),
+  status: z.string().optional(),
+  properties: z.record(z.unknown()).optional(),
+  handles: z.array(z.string()).optional()
+}).passthrough();
+var PurposeItemArraySchema = PurposeItemSchema.extend({
+  id: z.string()
+});
+var SignalDefinitionObjectSchema = z.object({
+  description: z.string().optional(),
+  category: z.string().optional(),
+  severity: z.enum(["info", "warn", "error"]).optional(),
+  emitters: z.array(z.string()).optional(),
+  related: z.array(z.string()).optional(),
+  data: z.record(z.unknown()).optional()
+});
+var SignalDefinitionSchema = z.union([
+  SignalDefinitionObjectSchema,
+  z.string().transform((desc) => ({ description: desc }))
+]);
+var RelationshipObjectSchema = z.object({
+  from: z.string(),
+  to: z.string(),
+  type: z.string(),
+  description: z.string().optional()
+});
+var RelationshipSchema = z.union([RelationshipObjectSchema, z.string()]);
+var FlowStepObjectSchema = z.object({
+  component: z.string(),
+  action: z.string(),
+  description: z.string().optional()
+});
+var FlowStepSchema = z.union([FlowStepObjectSchema, z.string()]);
+var FlowWithStepsSchema = z.object({
+  name: z.string(),
+  description: z.string().optional(),
+  steps: z.array(FlowStepSchema)
+});
+var FlowDefinitionSchema = z.object({
+  description: z.string().optional(),
+  gates: z.array(z.string()).optional(),
+  signals: z.array(z.string()).optional(),
+  components: z.array(z.string()).optional(),
+  steps: z.array(FlowStepSchema).optional()
+});
+var GateDefinitionSchema = z.object({
+  description: z.string().optional(),
+  requires: z.array(z.string()).optional(),
+  keys: z.array(z.string()).optional(),
+  signals: z.array(z.string()).optional()
+});
+var StateDefinitionSchema = z.object({
+  description: z.string().optional(),
+  default: z.unknown().optional(),
+  type: z.string().optional()
+});
+var AspectDefinitionSchema = z.object({
+  description: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+  anchors: z.array(z.string()).optional(),
+  "applies-to": z.array(z.string()).optional(),
+  enforcement: z.string().optional()
+});
+var ReferenceSchema = z.object({
+  target: z.string(),
+  type: z.string(),
+  path: z.string()
+});
+var PurposeFileSchema = z.object({
+  version: z.string().optional(),
+  description: z.string().optional(),
+  apiSpec: z.string().optional(),
+  context: z.array(z.string()).optional(),
+  rules: z.record(z.unknown()).optional(),
+  // Support both array format [{ id, description }] and record format { id: { description } }
+  features: z.union([
+    z.array(PurposeItemArraySchema),
+    z.record(PurposeItemSchema)
+  ]).optional(),
+  components: z.union([
+    z.array(PurposeItemArraySchema),
+    z.record(PurposeItemSchema)
+  ]).optional(),
+  gates: z.record(GateDefinitionSchema).optional(),
+  states: z.record(StateDefinitionSchema).optional(),
+  signals: z.record(SignalDefinitionSchema).optional(),
+  aspects: z.record(AspectDefinitionSchema).optional(),
+  relationships: z.array(RelationshipSchema).optional(),
+  // Support both array format and record format for flows
+  flows: z.union([
+    z.array(FlowWithStepsSchema),
+    z.record(FlowDefinitionSchema)
+  ]).optional(),
+  references: z.array(ReferenceSchema).optional()
+});
+function parsePurposeFile(filePath) {
+  const result = parsePurposeFileDetailed(filePath);
+  return { data: result.data, errors: result.errors };
+}
+function parsePurposeFileDetailed(filePath) {
+  const errors = [];
+  const detailedErrors = [];
+  let rawContent;
+  try {
+    rawContent = fs.readFileSync(filePath, "utf8");
+  } catch (e) {
+    const error = `Cannot read file: ${e.message}`;
+    errors.push(error);
+    detailedErrors.push({ message: error, type: "file" });
+    return { data: null, errors, detailedErrors, rawContent: void 0, isYamlValid: false };
+  }
+  const processedContent = rawContent.replace(/^([#~!$^][\w-]+):/gm, '"$1":').replace(/^(\s*-\s+)([!#][\w-]+)$/gm, '$1"$2"');
+  let data = null;
+  try {
+    data = yaml.load(processedContent);
+  } catch (e) {
+    const yamlError = e;
+    const line = yamlError.mark?.line ? yamlError.mark.line + 1 : void 0;
+    const message = `YAML syntax error: ${yamlError.reason || e.message}`;
+    errors.push(`${message}${line ? ` (line ${line})` : ""}`);
+    detailedErrors.push({
+      message,
+      line,
+      type: "yaml"
+    });
+    return { data: null, errors, detailedErrors, rawContent, isYamlValid: false };
+  }
+  if (data === null || data === void 0) {
+    return {
+      data: {},
+      errors: [],
+      detailedErrors: [],
+      rawContent,
+      isYamlValid: true
+    };
+  }
+  if (typeof data === "object" && data !== null) {
+    const obj = data;
+    const prefixMap = {
+      "#": "components",
+      "$": "flows",
+      "^": "gates",
+      "!": "signals",
+      "~": "aspects"
+    };
+    for (const key of Object.keys(obj)) {
+      const prefix = key[0];
+      const target = prefixMap[prefix];
+      if (!target || key.length < 2) continue;
+      const id = key.slice(1);
+      const value = obj[key];
+      if (typeof value !== "object" || value === null) continue;
+      const dict = obj[target] || {};
+      if (!(target in obj)) obj[target] = dict;
+      if (!(id in dict)) dict[id] = value;
+      delete obj[key];
+    }
+  }
+  const parseResult = PurposeFileSchema.safeParse(data);
+  if (!parseResult.success) {
+    for (const issue of parseResult.error.issues) {
+      const path22 = issue.path.join(".");
+      const message = issue.message;
+      errors.push(`Schema error at ${path22 || "/"}: ${message}`);
+      detailedErrors.push({
+        message,
+        path: path22 || "/",
+        type: "schema"
+      });
+    }
+    return { data, errors, detailedErrors, rawContent, isYamlValid: true };
+  }
+  return { data: parseResult.data, errors: [], detailedErrors: [], rawContent, isYamlValid: true };
+}
+function serializePurposeFile(data) {
+  return yaml.dump(data, {
+    indent: 2,
+    lineWidth: -1,
+    noRefs: true,
+    sortKeys: false
+  });
+}
+function normalizeItemsToEntries(items) {
+  if (!items) return [];
+  if (Array.isArray(items)) {
+    return items.map((item) => [item.id, item]);
+  } else {
+    return Object.entries(items);
+  }
+}
+async function findPurposeFiles(rootDir) {
+  const absoluteRoot = path.resolve(rootDir);
+  const files = await glob("**/.purpose", {
+    cwd: absoluteRoot,
+    absolute: true,
+    ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**"]
+  });
+  return files.sort((a, b) => {
+    const depthA = a.split(path.sep).length;
+    const depthB = b.split(path.sep).length;
+    return depthA - depthB;
+  });
+}
+async function getAllPurposeFiles(rootDir) {
+  const files = await findPurposeFiles(rootDir);
+  const parsed = [];
+  for (const filePath of files) {
+    const { data, errors } = parsePurposeFile(filePath);
+    if (data) {
+      parsed.push({ filePath, data });
+      if (errors.length > 0) {
+        console.warn(`Warnings parsing ${filePath}:`, errors);
+      }
+    }
+  }
+  return parsed;
+}
+function extractFeatures(parsedFiles) {
+  const features = /* @__PURE__ */ new Map();
+  for (const { filePath, data } of parsedFiles) {
+    const entries = normalizeItemsToEntries(data.features);
+    for (const [id, item] of entries) {
+      features.set(id, { item, filePath });
+    }
+  }
+  return features;
+}
+function extractComponents(parsedFiles) {
+  const components = /* @__PURE__ */ new Map();
+  for (const { filePath, data } of parsedFiles) {
+    const entries = normalizeItemsToEntries(data.components);
+    for (const [id, item] of entries) {
+      components.set(id, { item, filePath });
+    }
+  }
+  return components;
+}
+function extractGates(parsedFiles) {
+  const gates = /* @__PURE__ */ new Map();
+  for (const { filePath, data } of parsedFiles) {
+    if (data.gates) {
+      for (const [id, item] of Object.entries(data.gates)) {
+        gates.set(id, { item, filePath });
+      }
+    }
+  }
+  return gates;
+}
+function extractStates(parsedFiles) {
+  const states = /* @__PURE__ */ new Map();
+  for (const { filePath, data } of parsedFiles) {
+    if (data.states) {
+      for (const [id, item] of Object.entries(data.states)) {
+        states.set(id, { item, filePath });
+      }
+    }
+  }
+  return states;
+}
+function extractFlows(parsedFiles) {
+  const flows = /* @__PURE__ */ new Map();
+  for (const { filePath, data } of parsedFiles) {
+    if (data.flows) {
+      if (Array.isArray(data.flows)) {
+        for (const flow of data.flows) {
+          flows.set(flow.name, {
+            item: {
+              id: flow.name,
+              description: flow.description,
+              steps: flow.steps
+            },
+            filePath
+          });
+        }
+      } else {
+        for (const [id, flowDef] of Object.entries(data.flows)) {
+          flows.set(id, {
+            item: {
+              id,
+              description: flowDef.description,
+              gates: flowDef.gates,
+              signals: flowDef.signals,
+              components: flowDef.components,
+              steps: flowDef.steps
+            },
+            filePath
+          });
+        }
+      }
+    }
+  }
+  return flows;
+}
+function extractSignals(parsedFiles) {
+  const signals = /* @__PURE__ */ new Map();
+  for (const { filePath, data } of parsedFiles) {
+    if (data.signals) {
+      for (const [id, item] of Object.entries(data.signals)) {
+        signals.set(id, { item, filePath });
+      }
+    }
+  }
+  return signals;
+}
+function extractAspects(parsedFiles) {
+  const aspects = /* @__PURE__ */ new Map();
+  for (const { filePath, data } of parsedFiles) {
+    if (data.aspects) {
+      for (const [id, item] of Object.entries(data.aspects)) {
+        aspects.set(id, { item, filePath });
+      }
+    }
+  }
+  return aspects;
+}
+function extractSymbolReferences(parsedFiles) {
+  const refs = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const { filePath, data } of parsedFiles) {
+    const featureEntries = normalizeItemsToEntries(data.features);
+    for (const [id, item] of featureEntries) {
+      extractRefsFromItem(`#${id}`, item, filePath, refs, seen);
+    }
+    const componentEntries = normalizeItemsToEntries(data.components);
+    for (const [id, item] of componentEntries) {
+      extractRefsFromItem(`#${id}`, item, filePath, refs, seen);
+    }
+  }
+  return refs;
+}
+function extractRefsFromItem(sourceSymbol, item, filePath, refs, seen) {
+  if (item.flows) {
+    for (const flow of item.flows) {
+      const symbol = flow.startsWith("$") ? flow : `$${flow}`;
+      if (!seen.has(symbol)) {
+        seen.add(symbol);
+        refs.push({ symbol, type: "flow", sourceSymbol, filePath });
+      }
+    }
+  }
+  if (item.gates) {
+    for (const gate of item.gates) {
+      const symbol = gate.startsWith("^") ? gate : `^${gate}`;
+      if (!seen.has(symbol)) {
+        seen.add(symbol);
+        refs.push({ symbol, type: "gate", sourceSymbol, filePath });
+      }
+    }
+  }
+  if (item.signals) {
+    for (const signal of item.signals) {
+      const symbol = signal.startsWith("!") ? signal : `!${signal}`;
+      if (!seen.has(symbol)) {
+        seen.add(symbol);
+        refs.push({ symbol, type: "signal", sourceSymbol, filePath });
+      }
+    }
+  }
+  if (item.states) {
+    for (const state of item.states) {
+      const symbol = state.startsWith("#") ? state : state.startsWith("%") ? `#${state.slice(1)}` : `#${state}`;
+      if (!seen.has(symbol)) {
+        seen.add(symbol);
+        refs.push({ symbol, type: "component", sourceSymbol, filePath });
+      }
+    }
+  }
+  if (item.components) {
+    for (const comp of item.components) {
+      const symbol = comp.startsWith("#") ? comp : `#${comp}`;
+      if (!seen.has(symbol)) {
+        seen.add(symbol);
+        refs.push({ symbol, type: "component", sourceSymbol, filePath });
+      }
+    }
+  }
+  if (item.aspects) {
+    for (const aspect of item.aspects) {
+      const symbol = aspect.startsWith("~") ? aspect : `~${aspect}`;
+      if (!seen.has(symbol)) {
+        seen.add(symbol);
+        refs.push({ symbol, type: "aspect", sourceSymbol, filePath });
+      }
+    }
+  }
+  if (item.description) {
+    const descRefs = extractSymbolsFromText(item.description);
+    for (const { symbol, type } of descRefs) {
+      if (!seen.has(symbol)) {
+        seen.add(symbol);
+        refs.push({ symbol, type, sourceSymbol, filePath });
+      }
+    }
+  }
+}
+var SYMBOL_BLOCKLIST = /* @__PURE__ */ new Set([
+  "$lib",
+  "$env",
+  "$app",
+  "$service-worker",
+  "$virtual",
+  "$schema",
+  "$ref",
+  "$id",
+  "$type"
+]);
+function extractSymbolsFromText(text) {
+  const results = [];
+  const pattern = /([$^!#~%])([a-zA-Z][a-zA-Z0-9._-]*)/g;
+  let match;
+  while ((match = pattern.exec(text)) !== null) {
+    const prefix = match[1];
+    const id = match[2];
+    let symbol;
+    let type;
+    switch (prefix) {
+      case "#":
+        type = "component";
+        symbol = `#${id}`;
+        break;
+      case "$":
+        type = "flow";
+        symbol = `$${id}`;
+        break;
+      case "^":
+        type = "gate";
+        symbol = `^${id}`;
+        break;
+      case "!":
+        type = "signal";
+        symbol = `!${id}`;
+        break;
+      case "~":
+        type = "aspect";
+        symbol = `~${id}`;
+        break;
+      // Legacy: %state → #component
+      case "%":
+        type = "component";
+        symbol = `#${id}`;
+        break;
+      default:
+        continue;
+    }
+    if (SYMBOL_BLOCKLIST.has(symbol)) continue;
+    results.push({ symbol, type });
+  }
+  return results;
+}
+function normalizeToEntries(items) {
+  if (!items) return [];
+  if (Array.isArray(items)) {
+    return items.map((item) => [item.id, item]);
+  } else {
+    return Object.entries(items);
+  }
+}
+function getItemIds(items) {
+  if (!items) return [];
+  if (Array.isArray(items)) {
+    return items.map((item) => item.id);
+  } else {
+    return Object.keys(items);
+  }
+}
+function validatePurposeFile(data, filePath) {
+  const issues = [];
+  const prefix = filePath ? `${filePath}: ` : "";
+  const featureEntries = normalizeToEntries(data.features);
+  for (const [id, feature] of featureEntries) {
+    validatePurposeItem(id, feature, "feature", prefix, issues);
+  }
+  const componentEntries = normalizeToEntries(data.components);
+  for (const [id, component] of componentEntries) {
+    validatePurposeItem(id, component, "component", prefix, issues);
+  }
+  if (data.relationships) {
+    const allIds = /* @__PURE__ */ new Set([
+      ...getItemIds(data.features),
+      ...getItemIds(data.components)
+    ]);
+    for (const rel of data.relationships) {
+      if (typeof rel === "string" || !rel || !rel.from || !rel.to) {
+        continue;
+      }
+      const fromId = rel.from.replace(/^[@#$%~^!?]/, "");
+      if (!allIds.has(fromId) && !rel.from.includes(".")) {
+        issues.push({
+          type: "warning",
+          message: `${prefix}Relationship references unknown source: "${rel.from}"`,
+          path: "relationships"
+        });
+      }
+      const toId = rel.to.replace(/^[@#$%~^!?]/, "");
+      if (!allIds.has(toId) && !rel.to.includes(".")) {
+        issues.push({
+          type: "warning",
+          message: `${prefix}Relationship references unknown target: "${rel.to}"`,
+          path: "relationships"
+        });
+      }
+    }
+  }
+  if (data.flows) {
+    const componentIds = new Set(getItemIds(data.components));
+    if (Array.isArray(data.flows)) {
+      for (const flow of data.flows) {
+        if (!flow || typeof flow !== "object") continue;
+        if (!flow.name) {
+          issues.push({
+            type: "error",
+            message: `${prefix}Flow missing required "name" field`,
+            path: "flows"
+          });
+        }
+        if (flow.steps && Array.isArray(flow.steps)) {
+          for (const step of flow.steps) {
+            if (typeof step === "string" || !step || !step.component) continue;
+            const componentId = step.component.replace(/^#/, "");
+            if (!componentIds.has(componentId)) {
+              issues.push({
+                type: "warning",
+                message: `${prefix}Flow "${flow.name}" references unknown component: "${step.component}"`,
+                path: `flows.${flow.name}`
+              });
+            }
+          }
+        }
+      }
+    } else {
+      for (const [flowId, flowDef] of Object.entries(data.flows)) {
+        if (!flowDef || typeof flowDef !== "object") continue;
+        if (flowDef.steps && Array.isArray(flowDef.steps)) {
+          for (const step of flowDef.steps) {
+            if (typeof step === "string" || !step || !step.component) continue;
+            const componentId = step.component.replace(/^#/, "");
+            if (!componentIds.has(componentId)) {
+              issues.push({
+                type: "warning",
+                message: `${prefix}Flow "${flowId}" references unknown component: "${step.component}"`,
+                path: `flows.${flowId}`
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+  return {
+    valid: issues.filter((i) => i.type === "error").length === 0,
+    issues
+  };
+}
+function validatePurposeItem(id, item, itemType, prefix, issues) {
+  const path22 = `${itemType}s.${id}`;
+  if (!/^[a-zA-Z][a-zA-Z0-9-]*$/.test(id)) {
+    issues.push({
+      type: "warning",
+      message: `${prefix}${itemType} ID "${id}" should use alphanumeric characters and hyphens`,
+      path: path22
+    });
+  }
+  if (!item.description || item.description.trim() === "") {
+    issues.push({
+      type: "warning",
+      message: `${prefix}${itemType} "${id}" has no description`,
+      path: path22
+    });
+  }
+  if (item.endpoints) {
+    for (const endpoint of item.endpoints) {
+      if (!/^(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\s+\//.test(endpoint)) {
+        issues.push({
+          type: "warning",
+          message: `${prefix}Endpoint "${endpoint}" in ${itemType} "${id}" may not be in standard format (e.g., "GET /api/users")`,
+          path: `${path22}.endpoints`
+        });
+      }
+    }
+  }
+}
+
+// ../paradigm-mcp/node_modules/.pnpm/@a-company+portal-core@0.1.0/node_modules/@a-company/portal-core/dist/index.js
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as yaml2 from "js-yaml";
+import { glob as glob2 } from "glob";
+var DEFAULT_DEV_SETTINGS = {
+  visualizerPort: 42195,
+  // Marathon: 42.195km
+  watcherPort: 42196,
+  // Marathon + 1
+  autoConnect: true
+};
+async function parseGateConfig(configPath) {
+  const absolutePath = path2.resolve(configPath);
+  const rootDir = path2.dirname(absolutePath);
+  if (!fs2.existsSync(absolutePath)) {
+    throw new Error(`Gate config not found: ${absolutePath}`);
+  }
+  const content = fs2.readFileSync(absolutePath, "utf8");
+  const config = yaml2.load(content);
+  if (!config.version) {
+    throw new Error('Gate config missing required "version" field');
+  }
+  const gates = [];
+  const configAny = config;
+  const gatesSource = config.gates || configAny.portals;
+  if (gatesSource) {
+    for (const [id, gateDef] of Object.entries(gatesSource)) {
+      gates.push(normalizeGate(id, gateDef));
+    }
+  }
+  if (config.include) {
+    for (const pattern of config.include) {
+      const fullPattern = path2.join(rootDir, pattern);
+      const files = await glob2(fullPattern.replace(/\\/g, "/"));
+      for (const file of files) {
+        const additionalGates = await parseGateFile(file);
+        gates.push(...additionalGates);
+      }
+    }
+  }
+  const flows = [];
+  if (config.flows) {
+    for (const [id, flowDef] of Object.entries(config.flows)) {
+      flows.push(normalizeFlow(id, flowDef));
+    }
+  }
+  return {
+    version: config.version,
+    gates,
+    flows,
+    settings: {
+      dev: {
+        ...DEFAULT_DEV_SETTINGS,
+        ...config.settings?.dev
+      }
+    }
+  };
+}
+async function parseGateFile(filePath) {
+  const content = fs2.readFileSync(filePath, "utf8");
+  const data = yaml2.load(content);
+  if (data.id) {
+    return [normalizeGate(data.id, data)];
+  }
+  if (data.gates) {
+    const gates = [];
+    for (const [id, gateDef] of Object.entries(data.gates)) {
+      gates.push(normalizeGate(id, gateDef));
+    }
+    return gates;
+  }
+  return [];
+}
+function normalizeGate(id, def) {
+  const locks = [];
+  if (def.locks) {
+    for (const lockDef of def.locks) {
+      locks.push(normalizeLock(lockDef));
+    }
+  }
+  const prizes = [];
+  if (def.prizes) {
+    for (const prizeDef of def.prizes) {
+      prizes.push(normalizePrize(prizeDef));
+    }
+  }
+  return {
+    id,
+    description: def.description,
+    locks,
+    prizes,
+    position: def.position
+  };
+}
+function normalizeLock(def) {
+  const lockDef = def;
+  const keys = [];
+  if (lockDef.keys) {
+    for (const keyDef of lockDef.keys) {
+      if (typeof keyDef === "string") {
+        keys.push({ expression: keyDef });
+      } else if (keyDef.expression) {
+        const k = keyDef;
+        keys.push({
+          expression: k.expression,
+          description: k.description
+        });
+      }
+    }
+  }
+  return {
+    id: lockDef.id,
+    description: lockDef.description,
+    keys,
+    mode: lockDef.mode || "all"
+  };
+}
+function normalizePrize(def) {
+  const prizeDef = def;
+  return {
+    id: prizeDef.id,
+    oneTime: prizeDef.oneTime ?? false,
+    metadata: prizeDef.metadata
+  };
+}
+function normalizeFlow(id, def) {
+  return {
+    id,
+    description: def.description,
+    gates: def.gates || [],
+    forkable: def.forkable
+  };
+}
+async function findGateFiles(rootDir) {
+  const absoluteRoot = path2.resolve(rootDir);
+  const files = await glob2("**/portal.yaml", {
+    cwd: absoluteRoot,
+    absolute: true,
+    ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**"]
+  });
+  return files;
+}
+
+// ../paradigm-mcp/node_modules/.pnpm/@a-company+premise-core@0.2.0_typescript@5.9.3/node_modules/@a-company/premise-core/dist/index.js
+var PositionSchema = z2.object({
+  x: z2.number(),
+  y: z2.number()
+});
+var ViewportSchema = z2.object({
+  x: z2.number(),
+  y: z2.number(),
+  zoom: z2.number()
+});
+var PremiseSourceConfigSchema = z2.object({
+  path: z2.string(),
+  include: z2.array(z2.string()).optional(),
+  exclude: z2.array(z2.string()).optional()
+});
+var PremiseNodeSchema = z2.object({
+  id: z2.string(),
+  symbol: z2.string(),
+  type: z2.enum(["feature", "component", "flow", "state", "aspect", "gate", "signal", "idea"]),
+  content: z2.string().optional(),
+  position: PositionSchema,
+  tags: z2.array(z2.string()).optional(),
+  created: z2.string(),
+  modified: z2.string().optional()
+});
+var PremiseConnectionSchema = z2.object({
+  from: z2.string(),
+  to: z2.string(),
+  label: z2.string().optional(),
+  type: z2.string().optional()
+});
+var PremiseGroupSchema = z2.object({
+  id: z2.string(),
+  name: z2.string(),
+  nodes: z2.array(z2.string()),
+  color: z2.string().optional()
+});
+var PremiseLayoutSchema = z2.object({
+  viewport: ViewportSchema,
+  groups: z2.array(PremiseGroupSchema).optional()
+});
+var PremiseSnapshotStateSchema = z2.object({
+  nodes: z2.array(PremiseNodeSchema),
+  connections: z2.array(PremiseConnectionSchema),
+  layout: PremiseLayoutSchema
+});
+var PremiseSnapshotSchema = z2.object({
+  id: z2.string(),
+  name: z2.string(),
+  timestamp: z2.string(),
+  description: z2.string().optional(),
+  state: PremiseSnapshotStateSchema
+});
+var PremiseFileSchema = z2.object({
+  version: z2.string(),
+  metadata: z2.object({
+    name: z2.string(),
+    created: z2.string(),
+    modified: z2.string()
+  }),
+  sources: z2.object({
+    purpose: z2.array(PremiseSourceConfigSchema).optional(),
+    portal: z2.array(PremiseSourceConfigSchema).optional()
+  }),
+  nodes: z2.array(PremiseNodeSchema),
+  connections: z2.array(PremiseConnectionSchema),
+  layout: PremiseLayoutSchema,
+  snapshots: z2.array(PremiseSnapshotSchema).optional()
+});
+async function aggregateFromPremise(premiseFile, rootDir) {
+  const symbols = [];
+  const errors = [];
+  const purposeFiles = [];
+  const portalFiles = [];
+  if (premiseFile.sources.purpose) {
+    for (const source of premiseFile.sources.purpose) {
+      const sourcePath = path3.resolve(rootDir, source.path);
+      try {
+        const parsed = await getAllPurposeFiles(sourcePath);
+        purposeFiles.push(...parsed.map((p) => p.filePath));
+        const features = extractFeatures(parsed);
+        for (const [id, { item, filePath }] of features) {
+          symbols.push(createSymbolEntry({
+            id: `purpose-feature-${id}`,
+            symbol: `#${id}`,
+            type: "component",
+            source: "purpose",
+            filePath,
+            data: item,
+            description: item.description,
+            tags: ["feature"]
+          }));
+        }
+        const components = extractComponents(parsed);
+        for (const [id, { item, filePath }] of components) {
+          symbols.push(createSymbolEntry({
+            id: `purpose-component-${id}`,
+            symbol: `#${id}`,
+            type: "component",
+            source: "purpose",
+            filePath,
+            data: item,
+            description: item.description
+          }));
+        }
+        const gates = extractGates(parsed);
+        for (const [id, { item, filePath }] of gates) {
+          symbols.push(createSymbolEntry({
+            id: `purpose-gate-${id}`,
+            symbol: `^${id}`,
+            type: "gate",
+            source: "purpose",
+            filePath,
+            data: item,
+            description: item.description
+          }));
+        }
+        const states = extractStates(parsed);
+        for (const [id, { item, filePath }] of states) {
+          symbols.push(createSymbolEntry({
+            id: `purpose-state-${id}`,
+            symbol: `#${id}`,
+            type: "component",
+            source: "purpose",
+            filePath,
+            data: item,
+            description: item.description,
+            tags: ["state"]
+          }));
+        }
+        const flows = extractFlows(parsed);
+        for (const [id, { item, filePath }] of flows) {
+          symbols.push(createSymbolEntry({
+            id: `purpose-flow-${id}`,
+            symbol: `$${id}`,
+            type: "flow",
+            source: "purpose",
+            filePath,
+            data: item,
+            description: item.description
+          }));
+        }
+        const signals = extractSignals(parsed);
+        for (const [id, { item, filePath }] of signals) {
+          symbols.push(createSymbolEntry({
+            id: `purpose-signal-${id}`,
+            symbol: `!${id}`,
+            type: "signal",
+            source: "purpose",
+            filePath,
+            data: item,
+            description: item.description
+          }));
+        }
+        const aspects = extractAspects(parsed);
+        for (const [id, { item, filePath }] of aspects) {
+          symbols.push(createSymbolEntry({
+            id: `purpose-aspect-${id}`,
+            symbol: `~${id}`,
+            type: "aspect",
+            source: "purpose",
+            filePath,
+            data: item,
+            description: item.description,
+            anchors: item.anchors?.map((a) => parseAnchorString(a)),
+            appliesTo: item["applies-to"]
+          }));
+        }
+        const symbolRefs = extractSymbolReferences(parsed);
+        const existingSymbols = new Set(symbols.map((s) => s.symbol));
+        for (const ref of symbolRefs) {
+          if (!existingSymbols.has(ref.symbol)) {
+            existingSymbols.add(ref.symbol);
+            symbols.push(createSymbolEntry({
+              id: `purpose-ref-${ref.type}-${ref.symbol.slice(1)}`,
+              symbol: ref.symbol,
+              type: ref.type,
+              source: "purpose",
+              filePath: ref.filePath,
+              data: { referencedFrom: ref.sourceSymbol },
+              description: `Referenced from ${ref.sourceSymbol}`
+            }));
+          }
+        }
+      } catch (e) {
+        errors.push({
+          source: "purpose",
+          filePath: sourcePath,
+          message: e.message
+        });
+      }
+    }
+  }
+  if (premiseFile.sources.portal) {
+    for (const source of premiseFile.sources.portal) {
+      const sourcePath = path3.resolve(rootDir, source.path);
+      try {
+        let gateConfig;
+        if (sourcePath.endsWith(".yaml") || sourcePath.endsWith(".yml")) {
+          gateConfig = await parseGateConfig(sourcePath);
+          portalFiles.push(sourcePath);
+        } else {
+          const files = await findGateFiles(sourcePath);
+          portalFiles.push(...files);
+          if (files.length > 0) {
+            gateConfig = await parseGateConfig(files[0]);
+            for (let i = 1; i < files.length; i++) {
+              const additional = await parseGateConfig(files[i]);
+              gateConfig.gates.push(...additional.gates);
+              gateConfig.flows.push(...additional.flows);
+            }
+          } else {
+            continue;
+          }
+        }
+        for (const gate of gateConfig.gates) {
+          symbols.push(createGateSymbol(gate, sourcePath));
+          for (const prize of gate.prizes) {
+            symbols.push(createSymbolEntry({
+              id: `gate-signal-${gate.id}-${prize.id}`,
+              symbol: `!${prize.id}`,
+              type: "signal",
+              source: "portal",
+              filePath: sourcePath,
+              data: prize,
+              description: `Signal from gate ${gate.id}`
+            }));
+          }
+        }
+        for (const flow of gateConfig.flows) {
+          symbols.push(createFlowSymbol(flow, sourcePath));
+        }
+      } catch (e) {
+        errors.push({
+          source: "portal",
+          filePath: sourcePath,
+          message: e.message
+        });
+      }
+    }
+  }
+  for (const node of premiseFile.nodes) {
+    const hasIdeaTag = node.tags?.includes("idea");
+    if (!node.content && !hasIdeaTag) {
+      const existing = symbols.find((s) => s.symbol === node.symbol);
+      if (existing) {
+        existing.position = node.position;
+        existing.tags = node.tags;
+        continue;
+      }
+    }
+    symbols.push(createSymbolEntry({
+      id: node.id,
+      symbol: node.symbol,
+      type: node.type,
+      source: "premise",
+      filePath: ".premise",
+      data: node,
+      description: node.content,
+      position: node.position,
+      tags: node.tags,
+      created: node.created,
+      modified: node.modified
+    }));
+  }
+  resolveReferences(symbols);
+  return {
+    symbols,
+    purposeFiles,
+    portalFiles,
+    errors,
+    timestamp: Date.now()
+  };
+}
+function createSymbolEntry(partial) {
+  return {
+    ...partial,
+    data: partial.data ?? null,
+    references: partial.references ?? [],
+    referencedBy: partial.referencedBy ?? []
+  };
+}
+function createGateSymbol(gate, filePath) {
+  return createSymbolEntry({
+    id: `gate-${gate.id}`,
+    symbol: `^${gate.id}`,
+    type: "gate",
+    source: "portal",
+    filePath,
+    data: gate,
+    description: gate.description,
+    position: gate.position
+  });
+}
+function createFlowSymbol(flow, filePath) {
+  return createSymbolEntry({
+    id: `gate-flow-${flow.id}`,
+    symbol: `$${flow.id}`,
+    type: "flow",
+    source: "portal",
+    filePath,
+    data: flow,
+    description: flow.description
+  });
+}
+function parseAnchorString(raw) {
+  const colonIndex = raw.lastIndexOf(":");
+  if (colonIndex === -1 || colonIndex === raw.length - 1) {
+    return { path: raw, lines: 0, raw };
+  }
+  const afterColon = raw.slice(colonIndex + 1);
+  const filePath = raw.slice(0, colonIndex);
+  if (!/^[\d,\- ]+$/.test(afterColon)) {
+    return { path: raw, lines: 0, raw };
+  }
+  if (afterColon.includes("-")) {
+    const [start, end] = afterColon.split("-").map(Number);
+    return { path: filePath, lines: [start, end], raw };
+  } else if (afterColon.includes(",")) {
+    const lines = afterColon.split(",").map(Number);
+    return { path: filePath, lines, raw };
+  } else {
+    return { path: filePath, lines: Number(afterColon), raw };
+  }
+}
+var SYMBOL_BLOCKLIST2 = /* @__PURE__ */ new Set([
+  "$lib",
+  "$env",
+  "$app",
+  "$service-worker",
+  "$virtual",
+  "$schema",
+  "$ref",
+  "$id",
+  "$type"
+]);
+function resolveReferences(symbols) {
+  const symbolMap = new Map(symbols.map((s) => [s.symbol, s]));
+  for (const symbol of symbols) {
+    const dataStr = JSON.stringify(symbol.data);
+    const refPattern = /(?:\?[@#$%~^!]|[@#$%~^!?])[a-zA-Z][\w-]*/g;
+    const matches = (dataStr.match(refPattern) || []).filter((m) => !SYMBOL_BLOCKLIST2.has(m));
+    for (const match of matches) {
+      if (match !== symbol.symbol && symbolMap.has(match)) {
+        if (!symbol.references.includes(match)) {
+          symbol.references.push(match);
+        }
+        const target = symbolMap.get(match);
+        if (target && !target.referencedBy.includes(symbol.symbol)) {
+          target.referencedBy.push(symbol.symbol);
+        }
+      }
+    }
+  }
+}
+async function aggregateFromDirectory(rootDir) {
+  const premiseFile = {
+    version: "1.0.0",
+    metadata: {
+      name: path3.basename(rootDir),
+      created: (/* @__PURE__ */ new Date()).toISOString(),
+      modified: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    sources: {
+      purpose: [{ path: "./" }],
+      portal: [{ path: "./" }]
+    },
+    nodes: [],
+    connections: [],
+    layout: {
+      viewport: { x: 0, y: 0, zoom: 1 }
+    }
+  };
+  return aggregateFromPremise(premiseFile, rootDir);
+}
+function createSymbolIndex() {
+  return {
+    entries: /* @__PURE__ */ new Map(),
+    byType: /* @__PURE__ */ new Map(),
+    bySource: /* @__PURE__ */ new Map(),
+    timestamp: 0
+  };
+}
+function buildSymbolIndex(result) {
+  const index = createSymbolIndex();
+  index.timestamp = result.timestamp;
+  for (const symbol of result.symbols) {
+    index.entries.set(symbol.id, symbol);
+    if (!index.byType.has(symbol.type)) {
+      index.byType.set(symbol.type, []);
+    }
+    index.byType.get(symbol.type).push(symbol);
+    if (!index.bySource.has(symbol.source)) {
+      index.bySource.set(symbol.source, []);
+    }
+    index.bySource.get(symbol.source).push(symbol);
+  }
+  return index;
+}
+function getSymbol(index, symbol) {
+  for (const entry of index.entries.values()) {
+    if (entry.symbol === symbol) {
+      return entry;
+    }
+  }
+  return void 0;
+}
+function getSymbolsByType(index, type) {
+  return index.byType.get(type) || [];
+}
+function searchSymbols(index, query) {
+  const lowerQuery = query.toLowerCase();
+  const results = [];
+  for (const entry of index.entries.values()) {
+    if (entry.symbol.toLowerCase().includes(lowerQuery)) {
+      results.push(entry);
+      continue;
+    }
+    if (entry.description?.toLowerCase().includes(lowerQuery)) {
+      results.push(entry);
+      continue;
+    }
+    if (entry.tags?.some((tag) => tag.toLowerCase().includes(lowerQuery))) {
+      results.push(entry);
+    }
+  }
+  return results;
+}
+function getReferencesTo(index, symbol) {
+  const entry = getSymbol(index, symbol);
+  if (!entry) return [];
+  return entry.referencedBy.map((ref) => getSymbol(index, ref)).filter((e) => e !== void 0);
+}
+function getReferencesFrom(index, symbol) {
+  const entry = getSymbol(index, symbol);
+  if (!entry) return [];
+  return entry.references.map((ref) => getSymbol(index, ref)).filter((e) => e !== void 0);
+}
+function getSymbolCounts(index) {
+  const counts = {
+    component: 0,
+    flow: 0,
+    gate: 0,
+    signal: 0,
+    aspect: 0
+  };
+  for (const [type, symbols] of index.byType) {
+    if (type in counts) {
+      counts[type] = symbols.length;
+    }
+  }
+  return counts;
+}
+function getAllSymbols(index) {
+  return Array.from(index.entries.values());
+}
+
+// ../paradigm-mcp/node_modules/.pnpm/@a-company+probe-core@3.5.0/node_modules/@a-company/probe-core/dist/generator.js
+var PARADIGM_VERSION = "0.1.0";
+var SCHEMA_VERSION = "1.0.0";
+function generateScanIndex(input, options) {
+  const index = {
+    $meta: createMeta(options.projectName, input),
+    components: {},
+    features: {},
+    flows: {},
+    state: {},
+    gates: {},
+    signals: {},
+    aspects: {},
+    screens: {},
+    symbolMap: {}
+  };
+  for (const symbol of input.symbols) {
+    processSymbol(symbol, index, options);
+  }
+  if (options.screenDefinitions) {
+    for (const [screenId, def] of Object.entries(options.screenDefinitions)) {
+      if (!index.screens[screenId]) {
+        index.screens[screenId] = {
+          id: screenId,
+          name: formatName(screenId),
+          route: def.route,
+          path: "",
+          // Will be resolved if found
+          components: def.components,
+          features: def.features
+        };
+      }
+    }
+  }
+  buildScreenReferences(index);
+  return index;
+}
+function createMeta(projectName, input) {
+  return {
+    version: SCHEMA_VERSION,
+    project: projectName,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    paradigmVersion: PARADIGM_VERSION,
+    sources: {
+      purposeFiles: input.purposeFiles.length,
+      portalFiles: input.portalFiles.length,
+      premiseFiles: input.symbols.filter((s) => s.source === "premise").length > 0 ? 1 : 0
+    }
+  };
+}
+function processSymbol(symbol, index, options) {
+  const { type } = symbol;
+  switch (type) {
+    case "component":
+      addComponent(symbol, index, options);
+      break;
+    case "feature":
+      addFeature(symbol, index, options);
+      break;
+    case "flow":
+      addFlow(symbol, index);
+      break;
+    case "state":
+      addState(symbol, index);
+      break;
+    case "gate":
+      addGate(symbol, index);
+      break;
+    case "signal":
+      addSignal(symbol, index);
+      break;
+    case "aspect":
+      addAspect(symbol, index);
+      break;
+    default:
+      break;
+  }
+}
+function addComponent(symbol, index, options) {
+  const id = extractId(symbol.symbol);
+  const visualTags = inferVisualTags(id, symbol.data, options.visualTagMappings);
+  const element = {
+    id,
+    name: formatName(id),
+    symbol: symbol.symbol,
+    category: "components",
+    path: symbol.filePath,
+    description: symbol.description,
+    visualTags,
+    related: symbol.references
+  };
+  index.components[id] = element;
+  index.symbolMap[symbol.symbol] = { category: "components", id };
+}
+function addFeature(symbol, index, options) {
+  const id = extractId(symbol.symbol);
+  const visualTags = inferVisualTags(id, symbol.data, options.visualTagMappings);
+  const element = {
+    id,
+    name: formatName(id),
+    symbol: symbol.symbol,
+    category: "features",
+    path: symbol.filePath,
+    description: symbol.description,
+    visualTags,
+    related: symbol.references
+  };
+  index.features[id] = element;
+  index.symbolMap[symbol.symbol] = { category: "features", id };
+}
+function addFlow(symbol, index) {
+  const id = extractId(symbol.symbol);
+  const data = symbol.data;
+  const steps = [];
+  if (data?.steps) {
+    for (let i = 0; i < data.steps.length; i++) {
+      const step = data.steps[i];
+      steps.push({
+        id: `${id}-step-${i}`,
+        name: step.action || `Step ${i + 1}`,
+        target: step.component,
+        description: step.description,
+        order: i
+      });
+    }
+  }
+  const flow = {
+    id,
+    name: formatName(id),
+    symbol: symbol.symbol,
+    path: symbol.filePath,
+    description: symbol.description,
+    steps
+  };
+  index.flows[id] = flow;
+  index.symbolMap[symbol.symbol] = { category: "flows", id };
+}
+function addState(symbol, index) {
+  const id = extractId(symbol.symbol);
+  const state = {
+    id,
+    name: formatName(id),
+    symbol: symbol.symbol,
+    path: symbol.filePath,
+    description: symbol.description,
+    consumers: symbol.referencedBy
+  };
+  index.state[id] = state;
+  index.symbolMap[symbol.symbol] = { category: "state", id };
+}
+function addGate(symbol, index) {
+  const id = extractId(symbol.symbol);
+  const element = {
+    id,
+    name: formatName(id),
+    symbol: symbol.symbol,
+    category: "gates",
+    path: symbol.filePath,
+    description: symbol.description,
+    related: symbol.references
+  };
+  index.gates[id] = element;
+  index.symbolMap[symbol.symbol] = { category: "gates", id };
+}
+function addSignal(symbol, index) {
+  const id = extractId(symbol.symbol);
+  const element = {
+    id,
+    name: formatName(id),
+    symbol: symbol.symbol,
+    category: "signals",
+    path: symbol.filePath,
+    description: symbol.description,
+    related: symbol.references
+  };
+  index.signals[id] = element;
+  index.symbolMap[symbol.symbol] = { category: "signals", id };
+}
+function addAspect(symbol, index) {
+  const id = extractId(symbol.symbol);
+  const element = {
+    id,
+    name: formatName(id),
+    symbol: symbol.symbol,
+    category: "aspects",
+    path: symbol.filePath,
+    description: symbol.description,
+    related: symbol.references
+  };
+  index.aspects[id] = element;
+  index.symbolMap[symbol.symbol] = { category: "aspects", id };
+}
+function buildScreenReferences(index) {
+  for (const screen of Object.values(index.screens)) {
+    if (screen.components) {
+      for (const compId of screen.components) {
+        const comp = index.components[compId];
+        if (comp) {
+          comp.screens = comp.screens || [];
+          if (!comp.screens.includes(screen.id)) {
+            comp.screens.push(screen.id);
+          }
+        }
+      }
+    }
+  }
+}
+function extractId(symbol) {
+  return symbol.slice(1);
+}
+function formatName(id) {
+  return id.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+function inferVisualTags(id, _data, customMappings) {
+  const tags = [];
+  if (customMappings?.[id]) {
+    return customMappings[id];
+  }
+  const patterns = [
+    [/button/i, "button"],
+    [/btn/i, "button"],
+    [/form/i, "form"],
+    [/input/i, "input"],
+    [/field/i, "input"],
+    [/select/i, "input"],
+    [/card/i, "card"],
+    [/list/i, "list"],
+    [/table/i, "list"],
+    [/modal/i, "modal"],
+    [/dialog/i, "modal"],
+    [/drawer/i, "modal"],
+    [/nav/i, "nav"],
+    [/menu/i, "menu"],
+    [/dropdown/i, "menu"],
+    [/header/i, "header"],
+    [/footer/i, "footer"],
+    [/sidebar/i, "sidebar"],
+    [/hero/i, "hero"],
+    [/grid/i, "grid"],
+    [/chart/i, "chart"],
+    [/graph/i, "chart"],
+    [/icon/i, "icon"],
+    [/image/i, "image"],
+    [/avatar/i, "avatar"],
+    [/badge/i, "badge"],
+    [/tag/i, "badge"],
+    [/tab/i, "tab"],
+    [/accordion/i, "accordion"],
+    [/toast/i, "toast"],
+    [/notification/i, "toast"],
+    [/alert/i, "toast"],
+    [/spinner/i, "spinner"],
+    [/loader/i, "spinner"],
+    [/loading/i, "spinner"],
+    [/skeleton/i, "skeleton"]
+  ];
+  for (const [pattern, tag] of patterns) {
+    if (pattern.test(id)) {
+      tags.push(tag);
+    }
+  }
+  return tags;
+}
+function serializeScanIndex(index) {
+  return JSON.stringify(index, null, 2);
+}
+
+// ../paradigm-mcp/src/utils/session-tracker.ts
+import * as fs4 from "fs";
+import * as path5 from "path";
+
+// ../paradigm-mcp/src/utils/global-store.ts
+import * as fs3 from "fs";
+import * as path4 from "path";
+import * as os from "os";
+import * as crypto from "crypto";
+import * as yaml4 from "js-yaml";
+function getGlobalDir() {
+  const dir = path4.join(os.homedir(), ".paradigm");
+  if (!fs3.existsSync(dir)) {
+    fs3.mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+function getProjectHash(rootDir) {
+  const absolute = path4.resolve(rootDir);
+  return crypto.createHash("sha256").update(absolute).digest("hex").slice(0, 12);
+}
+function getSessionDir(rootDir) {
+  const hash = getProjectHash(rootDir);
+  const dir = path4.join(getGlobalDir(), "sessions", hash);
+  if (!fs3.existsSync(dir)) {
+    fs3.mkdirSync(dir, { recursive: true });
+  }
+  const handoffsDir = path4.join(dir, "pending-handoffs");
+  if (!fs3.existsSync(handoffsDir)) {
+    fs3.mkdirSync(handoffsDir, { recursive: true });
+  }
+  return dir;
+}
+function writeProjectMeta(rootDir) {
+  const sessionDir = getSessionDir(rootDir);
+  const metaPath = path4.join(sessionDir, "_project-meta.json");
+  const projectName = path4.basename(path4.resolve(rootDir));
+  const meta = {
+    name: projectName,
+    path: path4.resolve(rootDir),
+    lastSeen: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  fs3.writeFileSync(metaPath, JSON.stringify(meta, null, 2));
+}
+function writePendingHandoff(rootDir, handoff) {
+  const sessionDir = getSessionDir(rootDir);
+  const filePath = path4.join(sessionDir, "pending-handoffs", `${handoff.id}.json`);
+  fs3.writeFileSync(filePath, JSON.stringify(handoff, null, 2));
+}
+function loadPendingHandoffs(rootDir) {
+  const sessionDir = getSessionDir(rootDir);
+  const handoffsDir = path4.join(sessionDir, "pending-handoffs");
+  if (!fs3.existsSync(handoffsDir)) {
+    return [];
+  }
+  const handoffs = [];
+  try {
+    const files = fs3.readdirSync(handoffsDir);
+    for (const file of files) {
+      if (!file.endsWith(".json")) continue;
+      try {
+        const content = fs3.readFileSync(path4.join(handoffsDir, file), "utf8");
+        const handoff = JSON.parse(content);
+        if (handoff.status === "pending") {
+          handoffs.push(handoff);
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  handoffs.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+  return handoffs;
+}
+function markHandoffDelivered(rootDir, handoffId) {
+  const sessionDir = getSessionDir(rootDir);
+  const filePath = path4.join(sessionDir, "pending-handoffs", `${handoffId}.json`);
+  if (!fs3.existsSync(filePath)) return;
+  try {
+    const content = fs3.readFileSync(filePath, "utf8");
+    const handoff = JSON.parse(content);
+    handoff.status = "delivered";
+    fs3.writeFileSync(filePath, JSON.stringify(handoff, null, 2));
+  } catch {
+  }
+}
+function getGlobalWisdomDir() {
+  const dir = path4.join(getGlobalDir(), "wisdom");
+  if (!fs3.existsSync(dir)) {
+    fs3.mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+function loadGlobalAntipatterns() {
+  const filePath = path4.join(getGlobalWisdomDir(), "antipatterns.yaml");
+  if (!fs3.existsSync(filePath)) return [];
+  try {
+    const content = fs3.readFileSync(filePath, "utf8");
+    const data = yaml4.load(content);
+    return data?.antipatterns || [];
+  } catch {
+    return [];
+  }
+}
+function loadGlobalDecisions() {
+  const decisionsDir = path4.join(getGlobalWisdomDir(), "decisions");
+  if (!fs3.existsSync(decisionsDir)) return [];
+  const decisions = [];
+  try {
+    const files = fs3.readdirSync(decisionsDir);
+    for (const file of files) {
+      if (!file.endsWith(".yaml") && !file.endsWith(".yml")) continue;
+      try {
+        const content = fs3.readFileSync(path4.join(decisionsDir, file), "utf8");
+        const decision = yaml4.load(content);
+        decisions.push(decision);
+      } catch {
+      }
+    }
+  } catch {
+  }
+  decisions.sort((a, b) => a.id.localeCompare(b.id));
+  return decisions;
+}
+function loadGlobalPreferences() {
+  const filePath = path4.join(getGlobalWisdomDir(), "preferences.yaml");
+  if (!fs3.existsSync(filePath)) return null;
+  try {
+    const content = fs3.readFileSync(filePath, "utf8");
+    return yaml4.load(content);
+  } catch {
+    return null;
+  }
+}
+function recordGlobalAntipattern(antipattern) {
+  const filePath = path4.join(getGlobalWisdomDir(), "antipatterns.yaml");
+  let data = { version: "1.0", antipatterns: [] };
+  if (fs3.existsSync(filePath)) {
+    try {
+      const content = fs3.readFileSync(filePath, "utf8");
+      data = yaml4.load(content);
+      if (!data.antipatterns) data.antipatterns = [];
+    } catch {
+    }
+  }
+  data.antipatterns.push({
+    ...antipattern,
+    added: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  fs3.writeFileSync(filePath, yaml4.dump(data, { lineWidth: -1 }));
+}
+function recordGlobalDecision(decision) {
+  const decisionsDir = path4.join(getGlobalWisdomDir(), "decisions");
+  if (!fs3.existsSync(decisionsDir)) {
+    fs3.mkdirSync(decisionsDir, { recursive: true });
+  }
+  const slug = decision.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  const fileName = `${decision.id}-${slug}.yaml`;
+  const filePath = path4.join(decisionsDir, fileName);
+  fs3.writeFileSync(filePath, yaml4.dump(decision, { lineWidth: -1 }));
+}
+
+// ../paradigm-mcp/src/utils/session-tracker.ts
+var MODEL_PRICING = {
+  "claude-opus-4": { input: 15, output: 75, name: "Claude Opus 4" },
+  "claude-sonnet-4": { input: 3, output: 15, name: "Claude Sonnet 4" },
+  "claude-haiku-3.5": { input: 0.8, output: 4, name: "Claude Haiku 3.5" }
+};
+var MAX_BREADCRUMBS = 50;
+var BREADCRUMBS_FILE = ".paradigm/session-breadcrumbs.json";
+var CHECKPOINT_FILE = ".paradigm/session-checkpoint.json";
+var CHECKPOINT_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+var SessionTracker = class {
+  session;
+  rootDir = null;
+  _recovered = false;
+  lastLoreEntryId = null;
+  constructor() {
+    this.session = this.createNewSession();
+  }
+  /**
+   * Set the project root directory (for persisting breadcrumbs)
+   */
+  setRootDir(rootDir) {
+    this.rootDir = rootDir;
+  }
+  createNewSession() {
+    return {
+      sessionId: `s${Date.now().toString(36)}`,
+      startTime: Date.now(),
+      lastActivity: Date.now(),
+      model: "claude-sonnet-4",
+      resourceReads: [],
+      toolCalls: [],
+      breadcrumbs: [],
+      totals: {
+        resourceReadCount: 0,
+        toolCallCount: 0,
+        totalBytes: 0,
+        totalTokens: 0,
+        estimatedCostUsd: 0
+      }
+    };
+  }
+  /**
+   * Add a breadcrumb (summarized action for session recovery)
+   */
+  addBreadcrumb(action, summary, options = {}) {
+    this.session.breadcrumbs.push({
+      timestamp: Date.now(),
+      action,
+      tool: options.tool,
+      symbol: options.symbol,
+      summary
+    });
+    if (this.session.breadcrumbs.length > MAX_BREADCRUMBS) {
+      this.session.breadcrumbs = this.session.breadcrumbs.slice(-MAX_BREADCRUMBS);
+    }
+    this.persistBreadcrumbs();
+  }
+  /**
+   * Get recent breadcrumbs
+   */
+  getBreadcrumbs(limit = 20) {
+    return this.session.breadcrumbs.slice(-limit);
+  }
+  /**
+   * Persist breadcrumbs to file (dual-write: local + global)
+   */
+  persistBreadcrumbs() {
+    if (!this.rootDir) return;
+    const data = {
+      sessionId: this.session.sessionId,
+      startTime: this.session.startTime,
+      lastActivity: this.session.lastActivity,
+      breadcrumbs: this.session.breadcrumbs,
+      symbolsModified: this.extractSymbolsFromBreadcrumbs(),
+      filesExplored: this.extractFilesFromBreadcrumbs()
+    };
+    let jsonData;
+    try {
+      jsonData = JSON.stringify(data, null, 2);
+    } catch (err) {
+      console.error("[paradigm-mcp] persistBreadcrumbs: JSON.stringify failed:", err.message);
+      return;
+    }
+    try {
+      const filePath = path5.join(this.rootDir, BREADCRUMBS_FILE);
+      const dir = path5.dirname(filePath);
+      if (!fs4.existsSync(dir)) {
+        fs4.mkdirSync(dir, { recursive: true });
+      }
+      fs4.writeFileSync(filePath, jsonData);
+    } catch (err) {
+      console.error("[paradigm-mcp] persistBreadcrumbs: local write failed:", err.message);
+    }
+    try {
+      const globalSessionDir = getSessionDir(this.rootDir);
+      fs4.writeFileSync(path5.join(globalSessionDir, "breadcrumbs.json"), jsonData);
+      writeProjectMeta(this.rootDir);
+    } catch (err) {
+      console.error("[paradigm-mcp] persistBreadcrumbs: global write failed:", err.message);
+    }
+  }
+  /**
+   * Load previous session breadcrumbs from file.
+   * Prefers global path (~/.paradigm/sessions/{hash}/breadcrumbs.json),
+   * falls back to local (.paradigm/session-breadcrumbs.json).
+   */
+  loadPreviousSession() {
+    if (!this.rootDir) return null;
+    try {
+      const globalSessionDir = getSessionDir(this.rootDir);
+      const globalPath = path5.join(globalSessionDir, "breadcrumbs.json");
+      if (fs4.existsSync(globalPath)) {
+        const content = fs4.readFileSync(globalPath, "utf8");
+        return JSON.parse(content);
+      }
+    } catch {
+    }
+    try {
+      const filePath = path5.join(this.rootDir, BREADCRUMBS_FILE);
+      if (!fs4.existsSync(filePath)) return null;
+      const content = fs4.readFileSync(filePath, "utf8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Save a cognitive-transition checkpoint for crash recovery.
+   * Fills in timestamp, sessionId, and snapshots recent breadcrumbs.
+   * Returns the checkpoint and whether it was persisted to disk.
+   */
+  saveCheckpoint(data) {
+    const checkpoint = {
+      phase: data.phase,
+      context: data.context,
+      timestamp: Date.now(),
+      sessionId: this.session.sessionId,
+      plan: data.plan,
+      modifiedFiles: data.modifiedFiles,
+      symbolsTouched: data.symbolsTouched,
+      decisions: data.decisions,
+      recentBreadcrumbs: this.session.breadcrumbs.slice(-10)
+    };
+    const persisted = this.persistCheckpoint(checkpoint);
+    return { checkpoint, persisted };
+  }
+  /**
+   * Load the most recent checkpoint.
+   * Prefers global path, falls back to local.
+   * Returns null for checkpoints older than 7 days.
+   */
+  loadCheckpoint() {
+    if (!this.rootDir) return null;
+    let checkpoint = null;
+    try {
+      const globalSessionDir = getSessionDir(this.rootDir);
+      const globalPath = path5.join(globalSessionDir, "checkpoint.json");
+      if (fs4.existsSync(globalPath)) {
+        const content = fs4.readFileSync(globalPath, "utf8");
+        checkpoint = JSON.parse(content);
+      }
+    } catch {
+    }
+    if (!checkpoint) {
+      try {
+        const localPath = path5.join(this.rootDir, CHECKPOINT_FILE);
+        if (fs4.existsSync(localPath)) {
+          const content = fs4.readFileSync(localPath, "utf8");
+          checkpoint = JSON.parse(content);
+        }
+      } catch {
+      }
+    }
+    if (checkpoint && Date.now() - checkpoint.timestamp > CHECKPOINT_MAX_AGE_MS) {
+      return null;
+    }
+    return checkpoint;
+  }
+  /**
+   * Persist checkpoint to both local and global paths.
+   * Returns which writes succeeded so callers can report accurately.
+   */
+  persistCheckpoint(checkpoint) {
+    const result = { local: false, global: false };
+    if (!this.rootDir) {
+      console.error("[paradigm-mcp] persistCheckpoint: rootDir not set, skipping write");
+      return result;
+    }
+    let jsonData;
+    try {
+      jsonData = JSON.stringify(checkpoint, null, 2);
+    } catch (err) {
+      console.error("[paradigm-mcp] persistCheckpoint: JSON.stringify failed:", err.message);
+      return result;
+    }
+    try {
+      const filePath = path5.join(this.rootDir, CHECKPOINT_FILE);
+      const dir = path5.dirname(filePath);
+      if (!fs4.existsSync(dir)) {
+        fs4.mkdirSync(dir, { recursive: true });
+      }
+      fs4.writeFileSync(filePath, jsonData);
+      result.local = true;
+    } catch (err) {
+      console.error("[paradigm-mcp] persistCheckpoint: local write failed:", err.message);
+    }
+    try {
+      const globalSessionDir = getSessionDir(this.rootDir);
+      fs4.writeFileSync(path5.join(globalSessionDir, "checkpoint.json"), jsonData);
+      writeProjectMeta(this.rootDir);
+      result.global = true;
+    } catch (err) {
+      console.error("[paradigm-mcp] persistCheckpoint: global write failed:", err.message);
+    }
+    return result;
+  }
+  /**
+   * Set the last lore entry ID recorded in this session
+   */
+  setLastLoreEntryId(id) {
+    this.lastLoreEntryId = id;
+  }
+  /**
+   * Get the last lore entry ID recorded in this session
+   */
+  getLastLoreEntryId() {
+    return this.lastLoreEntryId;
+  }
+  /**
+   * Check whether auto-recovery has already fired this session.
+   */
+  hasRecoveredThisSession() {
+    return this._recovered;
+  }
+  /**
+   * Mark that auto-recovery has fired (so it only fires once per session).
+   */
+  markRecovered() {
+    this._recovered = true;
+  }
+  /**
+   * Extract symbols from breadcrumbs
+   */
+  extractSymbolsFromBreadcrumbs() {
+    const symbols = /* @__PURE__ */ new Set();
+    for (const bc of this.session.breadcrumbs) {
+      if (bc.symbol) symbols.add(bc.symbol);
+    }
+    return Array.from(symbols);
+  }
+  /**
+   * Extract files from breadcrumbs
+   */
+  extractFilesFromBreadcrumbs() {
+    const files = /* @__PURE__ */ new Set();
+    for (const bc of this.session.breadcrumbs) {
+      const matches = bc.summary.match(/\b[\w./]+\.(ts|js|tsx|jsx|py|go|rs|yaml|json|md)\b/g);
+      if (matches) {
+        for (const m of matches) {
+          files.add(m);
+        }
+      }
+    }
+    return Array.from(files);
+  }
+  /**
+   * Estimate tokens from text (approx 3.5 chars per token)
+   */
+  estimateTokens(text) {
+    const len = typeof text === "number" ? text : text.length;
+    return Math.ceil(len / 3.5);
+  }
+  /**
+   * Calculate cost for tokens using current model pricing
+   */
+  calculateCost(tokens, isOutput = true) {
+    const pricing = MODEL_PRICING[this.session.model];
+    const rate = isOutput ? pricing.output : pricing.input;
+    return tokens / 1e6 * rate;
+  }
+  /**
+   * Set the model for cost calculations
+   */
+  setModel(model) {
+    this.session.model = model;
+    this.recalculateTotals();
+  }
+  /**
+   * Get current model
+   */
+  getModel() {
+    return this.session.model;
+  }
+  /**
+   * Track a resource read
+   */
+  trackResourceRead(uri, bytes) {
+    const resourceType = this.extractResourceType(uri);
+    const tokens = this.estimateTokens(bytes);
+    this.session.resourceReads.push({
+      timestamp: Date.now(),
+      resourceType,
+      uri,
+      bytes,
+      tokens
+    });
+    this.session.lastActivity = Date.now();
+    this.updateTotals(bytes, tokens);
+  }
+  /**
+   * Track a tool call
+   */
+  trackToolCall(toolName, responseBytes) {
+    const tokens = this.estimateTokens(responseBytes);
+    this.session.toolCalls.push({
+      timestamp: Date.now(),
+      toolName,
+      responseBytes,
+      responseTokens: tokens
+    });
+    this.session.lastActivity = Date.now();
+    this.updateTotals(responseBytes, tokens);
+  }
+  /**
+   * Update running totals
+   */
+  updateTotals(bytes, tokens) {
+    this.session.totals.resourceReadCount = this.session.resourceReads.length;
+    this.session.totals.toolCallCount = this.session.toolCalls.length;
+    this.session.totals.totalBytes += bytes;
+    this.session.totals.totalTokens += tokens;
+    this.session.totals.estimatedCostUsd = this.calculateCost(this.session.totals.totalTokens);
+  }
+  /**
+   * Recalculate totals (used when model changes)
+   */
+  recalculateTotals() {
+    this.session.totals.estimatedCostUsd = this.calculateCost(this.session.totals.totalTokens);
+  }
+  /**
+   * Extract resource type from URI
+   */
+  extractResourceType(uri) {
+    const path10 = uri.replace("paradigm://", "");
+    const firstPart = path10.split("/")[0];
+    return firstPart || "unknown";
+  }
+  /**
+   * Get session statistics
+   */
+  getStats() {
+    return { ...this.session };
+  }
+  /**
+   * Get detailed cost breakdown
+   */
+  getCostBreakdown() {
+    const resourcesByType = {};
+    let resourceBytes = 0;
+    let resourceTokens = 0;
+    for (const read of this.session.resourceReads) {
+      if (!resourcesByType[read.resourceType]) {
+        resourcesByType[read.resourceType] = { count: 0, bytes: 0, tokens: 0 };
+      }
+      resourcesByType[read.resourceType].count++;
+      resourcesByType[read.resourceType].bytes += read.bytes;
+      resourcesByType[read.resourceType].tokens += read.tokens;
+      resourceBytes += read.bytes;
+      resourceTokens += read.tokens;
+    }
+    const toolsByName = {};
+    let toolBytes = 0;
+    let toolTokens = 0;
+    for (const call of this.session.toolCalls) {
+      if (!toolsByName[call.toolName]) {
+        toolsByName[call.toolName] = { count: 0, bytes: 0, tokens: 0 };
+      }
+      toolsByName[call.toolName].count++;
+      toolsByName[call.toolName].bytes += call.responseBytes;
+      toolsByName[call.toolName].tokens += call.responseTokens;
+      toolBytes += call.responseBytes;
+      toolTokens += call.responseTokens;
+    }
+    const totalTokens = resourceTokens + toolTokens;
+    const totalCost = this.calculateCost(totalTokens);
+    return {
+      model: MODEL_PRICING[this.session.model].name,
+      modelId: this.session.model,
+      pricing: MODEL_PRICING[this.session.model],
+      resources: {
+        count: this.session.resourceReads.length,
+        bytes: resourceBytes,
+        tokens: resourceTokens,
+        costUsd: this.calculateCost(resourceTokens),
+        byType: resourcesByType
+      },
+      tools: {
+        count: this.session.toolCalls.length,
+        bytes: toolBytes,
+        tokens: toolTokens,
+        costUsd: this.calculateCost(toolTokens),
+        byName: toolsByName
+      },
+      total: {
+        tokens: totalTokens,
+        costUsd: totalCost
+      }
+    };
+  }
+  /**
+   * Get handoff recommendation based on context usage
+   */
+  getHandoffRecommendation(contextWindowSize = 2e5, estimatedTotalTokens) {
+    const mcpTokens = this.session.totals.totalTokens;
+    const estimatedConversationOverhead = mcpTokens * 4;
+    const totalEstimate = estimatedTotalTokens || mcpTokens + estimatedConversationOverhead;
+    const usagePercent = Math.round(totalEstimate / contextWindowSize * 100);
+    let recommendation;
+    let message;
+    if (usagePercent >= 85) {
+      recommendation = "handoff-urgent";
+      message = "Context is nearly full. Initiate handoff immediately to preserve session continuity.";
+    } else if (usagePercent >= 70) {
+      recommendation = "handoff-recommended";
+      message = "Context usage is high. Consider initiating handoff soon to ensure smooth transition.";
+    } else if (usagePercent >= 50) {
+      recommendation = "consider-handoff";
+      message = "Context usage is moderate. Plan a good stopping point for potential handoff.";
+    } else {
+      recommendation = "continue";
+      message = "Context usage is healthy. Continue working.";
+    }
+    const signals = [];
+    const durationMin = Math.round((Date.now() - this.session.startTime) / 6e4);
+    const totalCalls = this.session.toolCalls.length + this.session.resourceReads.length;
+    if (totalCalls > 50) {
+      signals.push(`High number of MCP interactions (${totalCalls})`);
+    }
+    if (durationMin > 30) {
+      signals.push(`Session duration >30 min (${durationMin} min)`);
+    }
+    if (this.session.totals.totalBytes > 5e5) {
+      signals.push(`Large data volume (${Math.round(this.session.totals.totalBytes / 1024)}KB)`);
+    }
+    return { recommendation, message, usagePercent, signals };
+  }
+  /**
+   * Get session duration in minutes
+   */
+  getDurationMinutes() {
+    return Math.round((Date.now() - this.session.startTime) / 6e4);
+  }
+  /**
+   * Reset session (for handoff or new session)
+   */
+  reset() {
+    this.session = this.createNewSession();
+    this._recovered = false;
+    this.lastLoreEntryId = null;
+  }
+};
+var tracker = null;
+function getSessionTracker() {
+  if (!tracker) {
+    tracker = new SessionTracker();
+  }
+  return tracker;
+}
+function resetSessionTracker() {
+  if (tracker) {
+    tracker.reset();
+  }
+}
+
+// ../paradigm-mcp/src/tools/context.ts
+function trackToolCall(responseSize, toolName = "unknown") {
+  getSessionTracker().trackToolCall(toolName, responseSize);
+}
+function trackResourceRead(responseSize, uri = "paradigm://unknown") {
+  getSessionTracker().trackResourceRead(uri, responseSize);
+}
+function resetSession() {
+  resetSessionTracker();
+}
+function extractBreadcrumbInfo(toolName, args) {
+  switch (toolName) {
+    case "paradigm_search":
+      return {
+        summary: `Searched for "${args.query}"${args.type ? ` (type: ${args.type})` : ""}`,
+        symbol: args.query
+      };
+    case "paradigm_ripple":
+      return {
+        summary: `Ripple analysis on ${args.symbol}${args.depth ? ` (depth: ${args.depth})` : ""}`,
+        symbol: args.symbol
+      };
+    case "paradigm_related":
+      return {
+        summary: `Checked relations for ${args.symbol}`,
+        symbol: args.symbol
+      };
+    case "paradigm_status":
+      return { summary: "Checked project status" };
+    case "paradigm_navigate": {
+      const intent = args.intent;
+      const target = args.target;
+      const task = args.task;
+      if (intent === "context" && task) return { summary: `Navigate context: "${task}"` };
+      if (target) return { summary: `Navigate ${intent || "find"}: ${target}`, symbol: target };
+      return { summary: `Navigate (${intent || "unknown"})` };
+    }
+    case "paradigm_gates_for_route":
+      return { summary: `Gate suggestions for ${args.method || "GET"} ${args.route}` };
+    case "paradigm_wisdom_context":
+      return {
+        summary: `Checked wisdom for ${Array.isArray(args.symbols) ? args.symbols.join(", ") : "symbols"}`,
+        symbol: Array.isArray(args.symbols) ? args.symbols[0] : void 0
+      };
+    case "paradigm_history_context":
+      return {
+        summary: `Checked history for ${Array.isArray(args.symbols) ? args.symbols.join(", ") : "symbols"}`,
+        symbol: Array.isArray(args.symbols) ? args.symbols[0] : void 0
+      };
+    case "paradigm_history_record":
+      return {
+        summary: `Recorded ${args.type}: ${(args.description || "").slice(0, 60)}`,
+        symbol: Array.isArray(args.symbols) ? args.symbols[0] : void 0
+      };
+    case "paradigm_history_fragility":
+      return {
+        summary: `Checked fragility for ${Array.isArray(args.symbols) ? args.symbols.join(", ") : "symbols"}`,
+        symbol: Array.isArray(args.symbols) ? args.symbols[0] : void 0
+      };
+    case "paradigm_flows_affected":
+      return {
+        summary: `Checked flows affected by ${args.symbol}`,
+        symbol: args.symbol
+      };
+    case "paradigm_reindex":
+      return { summary: "Rebuilt static index files" };
+    case "paradigm_session_checkpoint":
+      return {
+        summary: `Checkpoint: phase=${args.phase}, ${(args.context || "").slice(0, 60)}`
+      };
+    case "paradigm_task_create":
+      return { summary: `Created task: "${(args.blurb || "").slice(0, 60)}"` };
+    case "paradigm_task_done":
+      return { summary: `Completed task ${args.id}` };
+    case "paradigm_task_shelve":
+      return { summary: `Shelved task ${args.id}` };
+    case "paradigm_task_list":
+      return { summary: `Listed tasks (status: ${args.status || "open"})` };
+    case "paradigm_task_update":
+      return { summary: `Updated task ${args.id}` };
+    case "paradigm_assessment_record":
+      return {
+        summary: `Assessment: ${(args.title || "").slice(0, 60)} \u2192 ${args.arc_id}`,
+        symbol: Array.isArray(args.symbols) ? args.symbols[0] : void 0
+      };
+    case "paradigm_assessment_list":
+      return { summary: args.arc_id ? `Listed entries in ${args.arc_id}` : "Listed assessment arcs" };
+    case "paradigm_assessment_search":
+      return {
+        summary: `Searched assessments${args.symbol ? ` for ${args.symbol}` : ""}`,
+        symbol: args.symbol
+      };
+    case "paradigm_assessment_arc_create":
+      return { summary: `Created arc: ${args.id}` };
+    case "paradigm_assessment_arc_close":
+      return { summary: `Closed arc: ${args.arc_id}` };
+    default: {
+      const shortName = toolName.replace(/^paradigm_/, "");
+      const firstArg = Object.values(args).find((v) => typeof v === "string" && v.length > 0);
+      return {
+        summary: firstArg ? `${shortName}: ${firstArg.slice(0, 60)}` : shortName,
+        symbol: args.symbol || void 0
+      };
+    }
+  }
+}
+function addToolBreadcrumb(toolName, args) {
+  const tracker2 = getSessionTracker();
+  const { summary, symbol } = extractBreadcrumbInfo(toolName, args);
+  tracker2.addBreadcrumb("tool-call", summary, { tool: toolName, symbol });
+}
+function getContextToolsList() {
+  return [
+    {
+      name: "paradigm_context_check",
+      description: "Check if context handoff is recommended based on session activity. Call this periodically during long sessions. Returns usage percentage and recommendation (continue, consider-handoff, handoff-recommended, handoff-urgent). ~100 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          estimatedTotalTokens: {
+            type: "number",
+            description: "Optional: Your estimate of total conversation tokens (if available)"
+          },
+          contextWindowSize: {
+            type: "number",
+            description: "Context window size in tokens (default: 200000)"
+          }
+        }
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_handoff_prepare",
+      description: "Prepare a handoff summary. Generates a structured handoff file with markdown summary and recovery instructions. Returns structured markdown with summary, modified files, and next steps. ~300 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          summary: {
+            type: "string",
+            description: "Brief summary of work done in this session"
+          },
+          nextSteps: {
+            type: "array",
+            items: { type: "string" },
+            description: "List of next steps for the continuing session"
+          },
+          agent: {
+            type: "string",
+            description: 'Target agent role (e.g., "builder", "architect")'
+          },
+          modifiedFiles: {
+            type: "array",
+            items: { type: "string" },
+            description: "List of files modified in this session"
+          },
+          symbolsTouched: {
+            type: "array",
+            items: { type: "string" },
+            description: "List of symbols (@feature, #component, etc.) touched"
+          },
+          openQuestions: {
+            type: "array",
+            items: { type: "string" },
+            description: "Unresolved questions or decisions needed"
+          }
+        },
+        required: ["summary"]
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_session_stats",
+      description: "Get current session statistics (MCP interactions, estimated tokens). Returns tool call count, estimated tokens used, and cost breakdown. ~100 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {}
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_session_recover",
+      description: "Load previous session breadcrumbs for continuity. Call this at the start of a new session to understand what was done before. Returns symbols modified, files explored, recent actions, and suggestions for continuity. ~200 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {}
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_session_checkpoint",
+      description: "Save a cognitive-transition checkpoint for crash recovery. Call when transitioning between phases (planning \u2192 implementing \u2192 validating \u2192 complete). ~100 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          phase: {
+            type: "string",
+            enum: ["planning", "implementing", "validating", "complete"],
+            description: "Current workflow phase"
+          },
+          context: {
+            type: "string",
+            description: "What's top-of-mind right now (1-3 sentences)"
+          },
+          plan: {
+            type: "string",
+            description: "Optional: the current plan or approach"
+          },
+          modifiedFiles: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional: files modified so far"
+          },
+          symbolsTouched: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional: symbols touched so far"
+          },
+          decisions: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional: key decisions made so far"
+          }
+        },
+        required: ["phase", "context"]
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false
+      }
+    },
+    {
+      name: "paradigm_session_checkpoint",
+      description: "Save a cognitive-transition checkpoint for crash recovery. Call when transitioning between phases (planning \u2192 implementing \u2192 validating \u2192 complete). ~100 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          phase: {
+            type: "string",
+            enum: ["planning", "implementing", "validating", "complete"],
+            description: "Current workflow phase"
+          },
+          context: {
+            type: "string",
+            description: "What's top-of-mind right now (1-3 sentences)"
+          },
+          plan: {
+            type: "string",
+            description: "Optional: the current plan or approach"
+          },
+          modifiedFiles: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional: files modified so far"
+          },
+          symbolsTouched: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional: symbols touched so far"
+          },
+          decisions: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional: key decisions made so far"
+          }
+        },
+        required: ["phase", "context"]
+      }
+    }
+  ];
+}
+async function handleContextTool(name, args, _ctx) {
+  const tracker2 = getSessionTracker();
+  if (name === "paradigm_context_check") {
+    const contextWindowSize = args.contextWindowSize || 2e5;
+    const estimatedTotal = args.estimatedTotalTokens;
+    const stats = tracker2.getStats();
+    const { recommendation, message, usagePercent, signals } = tracker2.getHandoffRecommendation(
+      contextWindowSize,
+      estimatedTotal
+    );
+    const durationMin = tracker2.getDurationMinutes();
+    return {
+      handled: true,
+      text: JSON.stringify({
+        recommendation,
+        message,
+        stats: {
+          sessionDurationMinutes: durationMin,
+          mcpToolCalls: stats.totals.toolCallCount,
+          mcpResourceReads: stats.totals.resourceReadCount,
+          estimatedMcpTokens: stats.totals.totalTokens,
+          estimatedTotalTokens: estimatedTotal || Math.round(stats.totals.totalTokens * 5),
+          contextWindowSize,
+          usagePercent
+        },
+        signals,
+        action: recommendation === "continue" ? null : "Call paradigm_handoff_prepare to create handoff file"
+      }, null, 2)
+    };
+  }
+  if (name === "paradigm_handoff_prepare") {
+    const summary = args.summary;
+    const nextSteps = args.nextSteps || [];
+    const agent = args.agent || "builder";
+    const modifiedFiles = args.modifiedFiles || [];
+    const symbolsTouched = args.symbolsTouched || [];
+    const openQuestions = args.openQuestions || [];
+    const stats = tracker2.getStats();
+    const breakdown = tracker2.getCostBreakdown();
+    const handoffId = `h${Date.now().toString(36)}`;
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const handoffPayload = {
+      id: handoffId,
+      timestamp,
+      from: "current-session",
+      to: agent,
+      summary,
+      nextSteps,
+      modifiedFiles,
+      symbolsTouched,
+      openQuestions,
+      sessionStats: {
+        duration: tracker2.getDurationMinutes(),
+        mcpCalls: stats.totals.toolCallCount + stats.totals.resourceReadCount,
+        estimatedTokens: stats.totals.totalTokens,
+        estimatedCostUsd: breakdown.total.costUsd,
+        model: breakdown.model
+      },
+      status: "pending"
+    };
+    try {
+      writePendingHandoff(_ctx.rootDir, handoffPayload);
+    } catch {
+    }
+    const markdownSummary = `# Handoff: ${timestamp}
+
+## Session Summary
+${summary}
+
+## Next Steps
+${nextSteps.map((step, i) => `${i + 1}. ${step}`).join("\n") || "(none specified)"}
+
+## Key Context
+- Modified files: ${modifiedFiles.length > 0 ? modifiedFiles.join(", ") : "(not specified)"}
+- Symbols touched: ${symbolsTouched.length > 0 ? symbolsTouched.join(", ") : "(not specified)"}
+- Open questions: ${openQuestions.length > 0 ? openQuestions.join(", ") : "(none)"}
+`;
+    resetSession();
+    return {
+      handled: true,
+      text: JSON.stringify({
+        handoff: handoffPayload,
+        markdownSummary,
+        persisted: true,
+        recovery: "The next session will automatically receive this handoff via paradigm_session_recover."
+      }, null, 2)
+    };
+  }
+  if (name === "paradigm_session_stats") {
+    const stats = tracker2.getStats();
+    const breakdown = tracker2.getCostBreakdown();
+    const durationMin = tracker2.getDurationMinutes();
+    return {
+      handled: true,
+      text: JSON.stringify({
+        session: {
+          startTime: new Date(stats.startTime).toISOString(),
+          durationMinutes: durationMin,
+          lastActivity: new Date(stats.lastActivity).toISOString()
+        },
+        model: {
+          name: breakdown.model,
+          id: breakdown.modelId,
+          pricing: {
+            inputPerMillion: `$${breakdown.pricing.input.toFixed(2)}`,
+            outputPerMillion: `$${breakdown.pricing.output.toFixed(2)}`
+          }
+        },
+        interactions: {
+          toolCalls: stats.totals.toolCallCount,
+          resourceReads: stats.totals.resourceReadCount,
+          totalInteractions: stats.totals.toolCallCount + stats.totals.resourceReadCount
+        },
+        tokens: {
+          total: stats.totals.totalTokens,
+          byCategory: {
+            resources: breakdown.resources.tokens,
+            tools: breakdown.tools.tokens
+          }
+        },
+        cost: {
+          totalUsd: `$${breakdown.total.costUsd.toFixed(4)}`,
+          breakdown: {
+            resources: `$${breakdown.resources.costUsd.toFixed(4)}`,
+            tools: `$${breakdown.tools.costUsd.toFixed(4)}`
+          },
+          note: "Cost is for MCP output tokens only (responses sent to model)"
+        },
+        details: {
+          resourcesByType: breakdown.resources.byType,
+          toolsByName: breakdown.tools.byName
+        }
+      }, null, 2)
+    };
+  }
+  if (name === "paradigm_session_recover") {
+    tracker2.setRootDir(_ctx.rootDir);
+    const previousSession = tracker2.loadPreviousSession();
+    const checkpoint = tracker2.loadCheckpoint();
+    let pendingHandoffs = [];
+    try {
+      pendingHandoffs = loadPendingHandoffs(_ctx.rootDir);
+    } catch {
+    }
+    if (!previousSession && pendingHandoffs.length === 0 && !checkpoint) {
+      return {
+        handled: true,
+        text: JSON.stringify({
+          found: false,
+          message: "No previous session breadcrumbs, checkpoints, or pending handoffs found.",
+          tip: "Breadcrumbs persist to ~/.paradigm/sessions/ and handoffs persist via paradigm_handoff_prepare. Checkpoints persist via paradigm_session_checkpoint."
+        }, null, 2)
+      };
+    }
+    const result = { found: true };
+    if (checkpoint) {
+      const ageMs = Date.now() - checkpoint.timestamp;
+      const ageMinutes = Math.round(ageMs / 6e4);
+      const ageHours = Math.round(ageMs / 36e5);
+      result.checkpoint = {
+        phase: checkpoint.phase,
+        context: checkpoint.context,
+        age: ageHours > 1 ? `${ageHours} hours ago` : `${ageMinutes} minutes ago`,
+        timestamp: new Date(checkpoint.timestamp).toISOString(),
+        sessionId: checkpoint.sessionId,
+        plan: checkpoint.plan,
+        modifiedFiles: checkpoint.modifiedFiles,
+        symbolsTouched: checkpoint.symbolsTouched,
+        decisions: checkpoint.decisions,
+        recentBreadcrumbs: checkpoint.recentBreadcrumbs?.map((bc) => ({
+          time: new Date(bc.timestamp).toISOString(),
+          action: bc.action,
+          tool: bc.tool,
+          symbol: bc.symbol,
+          summary: bc.summary
+        }))
+      };
+    }
+    if (previousSession) {
+      const ageMs = Date.now() - previousSession.lastActivity;
+      const ageMinutes = Math.round(ageMs / 6e4);
+      const ageHours = Math.round(ageMs / 36e5);
+      const recentActions = previousSession.breadcrumbs.slice(-10);
+      const actionSummary = recentActions.map((bc) => ({
+        time: new Date(bc.timestamp).toISOString(),
+        action: bc.action,
+        tool: bc.tool,
+        symbol: bc.symbol,
+        summary: bc.summary
+      }));
+      result.previousSession = {
+        sessionId: previousSession.sessionId,
+        startTime: new Date(previousSession.startTime).toISOString(),
+        lastActivity: new Date(previousSession.lastActivity).toISOString(),
+        age: ageHours > 1 ? `${ageHours} hours ago` : `${ageMinutes} minutes ago`
+      };
+      result.context = {
+        symbolsModified: previousSession.symbolsModified,
+        filesExplored: previousSession.filesExplored
+      };
+      result.recentActions = actionSummary;
+    }
+    if (pendingHandoffs.length > 0) {
+      result.pendingHandoffs = pendingHandoffs.map((h) => ({
+        id: h.id,
+        timestamp: h.timestamp,
+        from: h.from,
+        to: h.to,
+        summary: h.summary,
+        nextSteps: h.nextSteps,
+        modifiedFiles: h.modifiedFiles,
+        symbolsTouched: h.symbolsTouched,
+        openQuestions: h.openQuestions
+      }));
+      for (const h of pendingHandoffs) {
+        try {
+          markHandoffDelivered(_ctx.rootDir, h.id);
+        } catch {
+        }
+      }
+    }
+    let suggestion = "Continue where the previous session left off.";
+    if (checkpoint) {
+      suggestion = `Previous session was in "${checkpoint.phase}" phase: ${checkpoint.context}`;
+      if (checkpoint.decisions?.length) {
+        suggestion += ` Key decisions: ${checkpoint.decisions.slice(0, 2).join("; ")}`;
+      }
+    } else if (pendingHandoffs.length > 0) {
+      const latest = pendingHandoffs[pendingHandoffs.length - 1];
+      suggestion = `Handoff received: "${latest.summary}". `;
+      if (latest.nextSteps.length > 0) {
+        suggestion += `Start with: ${latest.nextSteps[0]}`;
+      }
+    } else if (previousSession) {
+      const recentActions = previousSession.breadcrumbs.slice(-10);
+      if (recentActions.length > 0) {
+        const lastAction = recentActions[recentActions.length - 1];
+        if (lastAction.symbol) {
+          suggestion = `Last work involved ${lastAction.symbol}. Consider checking its current state with paradigm_ripple.`;
+        }
+      }
+    }
+    result.suggestion = suggestion;
+    result.agentInstruction = "Present a brief summary of the previous session, then ask the user what they would like to do: (1) Continue \u2014 pick up where the last session left off, (2) Discard \u2014 ignore the previous session and start fresh, or (3) let them describe what they want to work on instead. Do NOT automatically continue without asking.";
+    tracker2.markRecovered();
+    return {
+      handled: true,
+      text: JSON.stringify(result, null, 2)
+    };
+  }
+  if (name === "paradigm_session_checkpoint") {
+    tracker2.setRootDir(_ctx.rootDir);
+    const phase = args.phase;
+    const context = args.context;
+    const plan = args.plan;
+    const modifiedFiles = args.modifiedFiles;
+    const symbolsTouched = args.symbolsTouched;
+    const decisions = args.decisions;
+    const { checkpoint, persisted } = tracker2.saveCheckpoint({
+      phase,
+      context,
+      plan,
+      modifiedFiles,
+      symbolsTouched,
+      decisions
+    });
+    const anyPersisted = persisted.local || persisted.global;
+    return {
+      handled: true,
+      text: JSON.stringify({
+        saved: anyPersisted,
+        persisted,
+        checkpoint: {
+          phase: checkpoint.phase,
+          context: checkpoint.context,
+          sessionId: checkpoint.sessionId,
+          timestamp: new Date(checkpoint.timestamp).toISOString(),
+          modifiedFiles: checkpoint.modifiedFiles?.length || 0,
+          symbolsTouched: checkpoint.symbolsTouched?.length || 0,
+          decisions: checkpoint.decisions?.length || 0,
+          recentBreadcrumbs: checkpoint.recentBreadcrumbs?.length || 0
+        },
+        ...anyPersisted ? { note: "Checkpoint saved. Recovery data will be auto-surfaced on the first tool call of the next session." } : { warning: "Checkpoint was NOT persisted to disk. Both local and global writes failed. Check MCP server stderr for details." }
+      }, null, 2)
+    };
+  }
+  return { handled: false, text: "" };
+}
+async function buildRecoveryPreamble(rootDir) {
+  const tracker2 = getSessionTracker();
+  tracker2.setRootDir(rootDir);
+  const checkpoint = tracker2.loadCheckpoint();
+  let pendingHandoffs = [];
+  try {
+    pendingHandoffs = loadPendingHandoffs(rootDir);
+  } catch {
+  }
+  if (!checkpoint && pendingHandoffs.length === 0) {
+    return null;
+  }
+  const lines = [];
+  lines.push("--- SESSION RECOVERY ---");
+  if (checkpoint) {
+    const ageMs = Date.now() - checkpoint.timestamp;
+    const ageMinutes = Math.round(ageMs / 6e4);
+    const ageHours = Math.round(ageMs / 36e5);
+    const ageStr = ageHours > 1 ? `${ageHours}h ago` : `${ageMinutes}m ago`;
+    lines.push(`Previous session was in "${checkpoint.phase}" phase (${ageStr}): ${checkpoint.context}`);
+    if (checkpoint.modifiedFiles?.length) {
+      lines.push(`Modified files: ${checkpoint.modifiedFiles.join(", ")}`);
+    }
+    if (checkpoint.symbolsTouched?.length) {
+      lines.push(`Symbols: ${checkpoint.symbolsTouched.join(", ")}`);
+    }
+    if (checkpoint.decisions?.length) {
+      lines.push(`Decisions: ${checkpoint.decisions.join("; ")}`);
+    }
+    if (checkpoint.plan) {
+      lines.push(`Plan: ${checkpoint.plan.slice(0, 200)}`);
+    }
+  }
+  if (pendingHandoffs.length > 0) {
+    const latest = pendingHandoffs[pendingHandoffs.length - 1];
+    lines.push(`Pending handoff: "${latest.summary}"`);
+    if (latest.nextSteps.length > 0) {
+      lines.push(`Next steps: ${latest.nextSteps.slice(0, 3).join(", ")}`);
+    }
+  }
+  try {
+    const { loadTasks } = await import("./task-loader-7M2FCBX6.js");
+    const openTasks = await loadTasks(rootDir, { status: "open", limit: 5 });
+    if (openTasks.length > 0) {
+      lines.push("");
+      lines.push("Open tasks:");
+      for (const task of openTasks) {
+        const tags = task.tags.length > 0 ? ` [${task.tags.join(", ")}]` : "";
+        lines.push(`  [${task.priority}] ${task.id}: ${task.blurb}${tags}`);
+      }
+    }
+  } catch {
+  }
+  try {
+    const { loadArcs } = await import("./assessment-loader-C5EOUM47.js");
+    const activeArcs = await loadArcs(rootDir, "active");
+    if (activeArcs.length > 0) {
+      const checkpointSymbols = checkpoint?.symbolsTouched || [];
+      const relevantArcs = checkpointSymbols.length > 0 ? activeArcs.filter((arc) => arc.symbols.some((s) => checkpointSymbols.includes(s))) : activeArcs.slice(0, 3);
+      if (relevantArcs.length > 0) {
+        lines.push("");
+        lines.push("Active assessment arcs:");
+        for (const arc of relevantArcs) {
+          lines.push(`  ${arc.id}: ${arc.name} (${arc.entry_count} entries)`);
+        }
+      }
+    }
+  } catch {
+  }
+  lines.push("");
+  lines.push("IMPORTANT: Present a brief summary of this recovery data to the user, then ask what they would like to do: (1) Continue \u2014 pick up where the last session left off, (2) Discard \u2014 ignore the previous session and start fresh, or (3) let them describe what they want to work on instead. Do NOT automatically continue without asking.");
+  lines.push("---");
+  return lines.join("\n");
+}
+
+// ../paradigm-mcp/src/utils/tool-cache.ts
+var ToolCache = class {
+  cache = /* @__PURE__ */ new Map();
+  ttlMs;
+  constructor(ttlMs = 3e4) {
+    this.ttlMs = ttlMs;
+  }
+  /**
+   * Get a cached value, or compute and cache it
+   */
+  async getOrCompute(key, compute) {
+    const existing = this.cache.get(key);
+    if (existing && Date.now() - existing.createdAt < this.ttlMs) {
+      return existing.data;
+    }
+    const data = await compute();
+    this.cache.set(key, { data, createdAt: Date.now() });
+    return data;
+  }
+  /**
+   * Invalidate a specific key
+   */
+  invalidate(key) {
+    this.cache.delete(key);
+  }
+  /**
+   * Invalidate all keys matching a prefix
+   */
+  invalidatePrefix(prefix) {
+    for (const key of this.cache.keys()) {
+      if (key.startsWith(prefix)) {
+        this.cache.delete(key);
+      }
+    }
+  }
+  /**
+   * Clear the entire cache
+   */
+  clear() {
+    this.cache.clear();
+  }
+  /**
+   * Get cache stats for debugging
+   */
+  stats() {
+    return { size: this.cache.size, ttlMs: this.ttlMs };
+  }
+};
+var toolCache = new ToolCache(3e4);
+
+// ../paradigm-mcp/src/utils/aspect-graph.ts
+import * as fs5 from "fs";
+import * as path6 from "path";
+import * as crypto2 from "crypto";
+import { execSync } from "child_process";
+import initSqlJs from "sql.js";
+var cachedSQL = null;
+async function getSqlJs() {
+  if (!cachedSQL) {
+    cachedSQL = await initSqlJs();
+  }
+  return cachedSQL;
+}
+var SCHEMA_STATEMENTS = [
+  `CREATE TABLE IF NOT EXISTS aspects (
+    id TEXT PRIMARY KEY,
+    description TEXT NOT NULL,
+    category TEXT DEFAULT 'rule',
+    severity TEXT DEFAULT 'medium',
+    value TEXT,
+    enforcement TEXT,
+    defined_in TEXT NOT NULL,
+    tags TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  )`,
+  `CREATE TABLE IF NOT EXISTS anchors (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    aspect_id TEXT NOT NULL REFERENCES aspects(id) ON DELETE CASCADE,
+    file_path TEXT NOT NULL,
+    start_line INTEGER NOT NULL,
+    end_line INTEGER NOT NULL,
+    content_hash TEXT,
+    normalized_hash TEXT,
+    materialized_at_commit TEXT,
+    last_verified TEXT,
+    drifted INTEGER DEFAULT 0
+  )`,
+  `CREATE INDEX IF NOT EXISTS idx_anchors_file ON anchors(file_path)`,
+  `CREATE INDEX IF NOT EXISTS idx_anchors_aspect ON anchors(aspect_id)`,
+  `CREATE TABLE IF NOT EXISTS edges (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    source TEXT NOT NULL,
+    target TEXT NOT NULL,
+    relation TEXT NOT NULL,
+    weight REAL DEFAULT 1.0,
+    origin TEXT DEFAULT 'explicit',
+    created_at TEXT NOT NULL
+  )`,
+  `CREATE INDEX IF NOT EXISTS idx_edges_source ON edges(source)`,
+  `CREATE INDEX IF NOT EXISTS idx_edges_target ON edges(target)`,
+  `CREATE TABLE IF NOT EXISTS lore_links (
+    aspect_id TEXT NOT NULL,
+    lore_id TEXT NOT NULL,
+    PRIMARY KEY (aspect_id, lore_id)
+  )`,
+  `CREATE TABLE IF NOT EXISTS search_log (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    query TEXT NOT NULL,
+    results_returned TEXT NOT NULL,
+    selected_result TEXT,
+    timestamp TEXT NOT NULL
+  )`,
+  `CREATE INDEX IF NOT EXISTS idx_search_query ON search_log(query)`,
+  `CREATE TABLE IF NOT EXISTS search_weights (
+    query_normalized TEXT NOT NULL,
+    aspect_id TEXT NOT NULL,
+    weight REAL DEFAULT 1.0,
+    hit_count INTEGER DEFAULT 1,
+    last_hit TEXT NOT NULL,
+    PRIMARY KEY (query_normalized, aspect_id)
+  )`,
+  `CREATE TABLE IF NOT EXISTS heatmap (
+    aspect_id TEXT NOT NULL,
+    access_type TEXT NOT NULL,
+    count INTEGER DEFAULT 0,
+    last_accessed TEXT NOT NULL,
+    PRIMARY KEY (aspect_id, access_type)
+  )`
+];
+var FTS_SQL = `CREATE VIRTUAL TABLE IF NOT EXISTS aspects_fts USING fts5(id, description, enforcement, tags)`;
+function queryRows(db, sql, params) {
+  const stmt = db.prepare(sql);
+  if (params && params.length > 0) {
+    stmt.bind(params);
+  }
+  const rows = [];
+  while (stmt.step()) {
+    rows.push(stmt.getAsObject());
+  }
+  stmt.free();
+  return rows;
+}
+function queryOne(db, sql, params) {
+  const stmt = db.prepare(sql);
+  if (params && params.length > 0) {
+    stmt.bind(params);
+  }
+  let result = null;
+  if (stmt.step()) {
+    result = stmt.getAsObject();
+  }
+  stmt.free();
+  return result;
+}
+async function openAspectGraph(rootDir) {
+  const SQL = await getSqlJs();
+  const dbDir = path6.join(rootDir, ".paradigm");
+  const dbPath = path6.join(dbDir, "aspect-graph.db");
+  let db;
+  if (fs5.existsSync(dbPath)) {
+    const buffer = fs5.readFileSync(dbPath);
+    db = new SQL.Database(buffer);
+  } else {
+    if (!fs5.existsSync(dbDir)) {
+      fs5.mkdirSync(dbDir, { recursive: true });
+    }
+    db = new SQL.Database();
+  }
+  for (const stmt of SCHEMA_STATEMENTS) {
+    db.run(stmt);
+  }
+  try {
+    db.run(FTS_SQL);
+  } catch {
+  }
+  return db;
+}
+function closeAspectGraph(db, rootDir) {
+  if (rootDir) {
+    const dbDir = path6.join(rootDir, ".paradigm");
+    if (!fs5.existsSync(dbDir)) {
+      fs5.mkdirSync(dbDir, { recursive: true });
+    }
+    const dbPath = path6.join(dbDir, "aspect-graph.db");
+    const data = db.export();
+    fs5.writeFileSync(dbPath, Buffer.from(data));
+  }
+  db.close();
+}
+function materializeAspects(db, symbols, rootDir) {
+  const aspects = symbols.filter((s) => s.type === "aspect");
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let headCommit = null;
+  try {
+    headCommit = execSync("git rev-parse HEAD", { cwd: rootDir, encoding: "utf8" }).trim();
+  } catch {
+  }
+  db.run("DELETE FROM anchors");
+  db.run("DELETE FROM edges");
+  db.run("DELETE FROM aspects");
+  try {
+    db.run("DELETE FROM aspects_fts");
+  } catch {
+  }
+  for (const entry of aspects) {
+    const data = entry.data ?? {};
+    const category = inferCategory(data, entry);
+    const severity = inferSeverity(data, entry);
+    const value = data.value != null ? String(data.value) : null;
+    const enforcement = entry.enforcement ?? (data.enforcement != null ? String(data.enforcement) : null);
+    const tags = entry.tags ? JSON.stringify(entry.tags) : null;
+    db.run(
+      `INSERT INTO aspects (id, description, category, severity, value, enforcement, defined_in, tags, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        entry.symbol,
+        entry.description ?? "",
+        category,
+        severity,
+        value,
+        enforcement,
+        entry.filePath,
+        tags,
+        entry.created ?? now,
+        entry.modified ?? now
+      ]
+    );
+    if (entry.anchors) {
+      for (const anchor of entry.anchors) {
+        const { startLine, endLine } = resolveAnchorLines(anchor);
+        const hashes = computeAnchorHash(anchor, null);
+        db.run(
+          `INSERT INTO anchors (aspect_id, file_path, start_line, end_line, content_hash, normalized_hash, materialized_at_commit, last_verified)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+          [entry.symbol, anchor.path, startLine, endLine, hashes.exact, hashes.normalized, headCommit, now]
+        );
+      }
+    }
+    const explicitEdges = data.edges;
+    if (Array.isArray(explicitEdges)) {
+      for (const edge of explicitEdges) {
+        db.run(
+          `INSERT INTO edges (source, target, relation, weight, origin, created_at)
+           VALUES (?, ?, ?, ?, ?, ?)`,
+          [
+            edge.source ?? entry.symbol,
+            edge.target ?? "",
+            edge.relation ?? "related-to",
+            edge.weight ?? 1,
+            edge.origin ?? "explicit",
+            now
+          ]
+        );
+      }
+    }
+    if (entry.appliesTo) {
+      for (const target of entry.appliesTo) {
+        db.run(
+          `INSERT INTO edges (source, target, relation, weight, origin, created_at)
+           VALUES (?, ?, ?, ?, ?, ?)`,
+          [entry.symbol, target, "related-to", 0.5, "inferred", now]
+        );
+      }
+    }
+    try {
+      db.run(
+        `INSERT INTO aspects_fts (id, description, enforcement, tags)
+         VALUES (?, ?, ?, ?)`,
+        [entry.symbol, entry.description ?? "", enforcement ?? "", tags ?? ""]
+      );
+    } catch {
+    }
+  }
+}
+function getAspect(db, aspectId) {
+  return queryOne(db, "SELECT * FROM aspects WHERE id = ?", [aspectId]);
+}
+function getAnchorsForAspect(db, aspectId) {
+  return queryRows(db, "SELECT * FROM anchors WHERE aspect_id = ?", [aspectId]);
+}
+function getEdgesFrom(db, symbol) {
+  return queryRows(db, "SELECT * FROM edges WHERE source = ?", [symbol]);
+}
+function getEdgesTo(db, symbol) {
+  return queryRows(db, "SELECT * FROM edges WHERE target = ?", [symbol]);
+}
+function getAllEdgesFor(db, symbol) {
+  return queryRows(
+    db,
+    "SELECT * FROM edges WHERE source = ? OR target = ?",
+    [symbol, symbol]
+  );
+}
+function incrementHeatmap(db, aspectId, accessType) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.run(
+    `INSERT INTO heatmap (aspect_id, access_type, count, last_accessed)
+     VALUES (?, ?, 1, ?)
+     ON CONFLICT(aspect_id, access_type)
+     DO UPDATE SET count = count + 1, last_accessed = ?`,
+    [aspectId, accessType, now, now]
+  );
+}
+function getHeatmap(db, limit = 20, accessType) {
+  if (accessType) {
+    return queryRows(
+      db,
+      "SELECT * FROM heatmap WHERE access_type = ? ORDER BY count DESC LIMIT ?",
+      [accessType, limit]
+    );
+  }
+  return queryRows(
+    db,
+    "SELECT * FROM heatmap ORDER BY count DESC LIMIT ?",
+    [limit]
+  );
+}
+function checkDrift(db, rootDir, aspectId, autoHeal = true) {
+  const anchorRows = aspectId ? queryRows(db, "SELECT * FROM anchors WHERE aspect_id = ?", [aspectId]) : queryRows(db, "SELECT * FROM anchors");
+  const results = [];
+  for (const anchor of anchorRows) {
+    const absolutePath = path6.isAbsolute(anchor.file_path) ? anchor.file_path : path6.join(rootDir, anchor.file_path);
+    if (!fs5.existsSync(absolutePath)) {
+      results.push({
+        aspectId: anchor.aspect_id,
+        path: anchor.file_path,
+        startLine: anchor.start_line,
+        endLine: anchor.end_line,
+        status: "missing",
+        resolvedBy: "none",
+        exists: false,
+        drifted: true
+      });
+      continue;
+    }
+    try {
+      const fileContent = fs5.readFileSync(absolutePath, "utf8");
+      const lines = fileContent.split("\n");
+      const startIdx = Math.max(0, anchor.start_line - 1);
+      const endIdx = Math.min(lines.length, anchor.end_line);
+      const sliceContent = lines.slice(startIdx, endIdx).join("\n");
+      const currentExactHash = crypto2.createHash("sha256").update(sliceContent).digest("hex");
+      if (anchor.content_hash != null && currentExactHash === anchor.content_hash) {
+        results.push({
+          aspectId: anchor.aspect_id,
+          path: anchor.file_path,
+          startLine: anchor.start_line,
+          endLine: anchor.end_line,
+          status: "clean",
+          resolvedBy: "exact-hash",
+          exists: true,
+          drifted: false
+        });
+        if (anchor.drifted === 1) {
+          db.run("UPDATE anchors SET drifted = 0 WHERE id = ?", [anchor.id]);
+        }
+        continue;
+      }
+      const currentNormalizedHash = crypto2.createHash("sha256").update(normalizeForHash(sliceContent)).digest("hex");
+      if (anchor.normalized_hash != null && currentNormalizedHash === anchor.normalized_hash) {
+        db.run("UPDATE anchors SET content_hash = ?, drifted = 0 WHERE id = ?", [currentExactHash, anchor.id]);
+        results.push({
+          aspectId: anchor.aspect_id,
+          path: anchor.file_path,
+          startLine: anchor.start_line,
+          endLine: anchor.end_line,
+          status: "cosmetic",
+          resolvedBy: "normalized-hash",
+          exists: true,
+          drifted: false
+        });
+        continue;
+      }
+      if (anchor.content_hash == null && anchor.normalized_hash == null) {
+        db.run(
+          "UPDATE anchors SET content_hash = ?, normalized_hash = ?, drifted = 0 WHERE id = ?",
+          [currentExactHash, currentNormalizedHash, anchor.id]
+        );
+        results.push({
+          aspectId: anchor.aspect_id,
+          path: anchor.file_path,
+          startLine: anchor.start_line,
+          endLine: anchor.end_line,
+          status: "clean",
+          resolvedBy: "exact-hash",
+          exists: true,
+          drifted: false
+        });
+        continue;
+      }
+      let resolvedByGit = false;
+      if (anchor.materialized_at_commit) {
+        const mapping = computeLineShift(
+          rootDir,
+          anchor.file_path,
+          anchor.materialized_at_commit,
+          anchor.start_line,
+          anchor.end_line
+        );
+        if (mapping) {
+          const shiftedStartIdx = Math.max(0, mapping.currentStart - 1);
+          const shiftedEndIdx = Math.min(lines.length, mapping.currentEnd);
+          const shiftedContent = lines.slice(shiftedStartIdx, shiftedEndIdx).join("\n");
+          const shiftedExactHash = crypto2.createHash("sha256").update(shiftedContent).digest("hex");
+          if (anchor.content_hash != null && shiftedExactHash === anchor.content_hash) {
+            const healed = autoHeal;
+            if (healed) {
+              db.run(
+                "UPDATE anchors SET start_line = ?, end_line = ?, drifted = 0 WHERE id = ?",
+                [mapping.currentStart, mapping.currentEnd, anchor.id]
+              );
+              const aspectRow = queryRows(
+                db,
+                "SELECT defined_in FROM aspects WHERE id = ?",
+                [anchor.aspect_id]
+              );
+              if (aspectRow.length > 0) {
+                healAnchorInPurposeFile(
+                  rootDir,
+                  aspectRow[0].defined_in,
+                  anchor.file_path,
+                  anchor.start_line,
+                  anchor.end_line,
+                  mapping.currentStart,
+                  mapping.currentEnd
+                );
+              }
+            }
+            results.push({
+              aspectId: anchor.aspect_id,
+              path: anchor.file_path,
+              startLine: healed ? mapping.currentStart : anchor.start_line,
+              endLine: healed ? mapping.currentEnd : anchor.end_line,
+              status: "shifted",
+              resolvedBy: "git-line-mapping",
+              exists: true,
+              drifted: false,
+              suggestedStart: mapping.currentStart,
+              suggestedEnd: mapping.currentEnd,
+              autoHealed: healed
+            });
+            resolvedByGit = true;
+          } else {
+            const shiftedNormalized = crypto2.createHash("sha256").update(normalizeForHash(shiftedContent)).digest("hex");
+            if (anchor.normalized_hash != null && shiftedNormalized === anchor.normalized_hash) {
+              if (autoHeal) {
+                const shiftedNewHash = crypto2.createHash("sha256").update(shiftedContent).digest("hex");
+                db.run(
+                  "UPDATE anchors SET start_line = ?, end_line = ?, content_hash = ?, drifted = 0 WHERE id = ?",
+                  [mapping.currentStart, mapping.currentEnd, shiftedNewHash, anchor.id]
+                );
+                const aspectRow = queryRows(
+                  db,
+                  "SELECT defined_in FROM aspects WHERE id = ?",
+                  [anchor.aspect_id]
+                );
+                if (aspectRow.length > 0) {
+                  healAnchorInPurposeFile(
+                    rootDir,
+                    aspectRow[0].defined_in,
+                    anchor.file_path,
+                    anchor.start_line,
+                    anchor.end_line,
+                    mapping.currentStart,
+                    mapping.currentEnd
+                  );
+                }
+              }
+              results.push({
+                aspectId: anchor.aspect_id,
+                path: anchor.file_path,
+                startLine: autoHeal ? mapping.currentStart : anchor.start_line,
+                endLine: autoHeal ? mapping.currentEnd : anchor.end_line,
+                status: "shifted",
+                resolvedBy: "git-line-mapping",
+                exists: true,
+                drifted: false,
+                suggestedStart: mapping.currentStart,
+                suggestedEnd: mapping.currentEnd,
+                autoHealed: autoHeal
+              });
+              resolvedByGit = true;
+            }
+          }
+        }
+      }
+      if (resolvedByGit) continue;
+      db.run("UPDATE anchors SET drifted = 1 WHERE id = ?", [anchor.id]);
+      results.push({
+        aspectId: anchor.aspect_id,
+        path: anchor.file_path,
+        startLine: anchor.start_line,
+        endLine: anchor.end_line,
+        status: "modified",
+        resolvedBy: "none",
+        exists: true,
+        currentContent: sliceContent,
+        drifted: true
+      });
+    } catch {
+      results.push({
+        aspectId: anchor.aspect_id,
+        path: anchor.file_path,
+        startLine: anchor.start_line,
+        endLine: anchor.end_line,
+        status: "modified",
+        resolvedBy: "none",
+        exists: true,
+        drifted: true
+      });
+    }
+  }
+  return results;
+}
+function resolveAnchorLines(anchor) {
+  const { lines } = anchor;
+  if (typeof lines === "number") {
+    return { startLine: lines, endLine: lines };
+  }
+  if (Array.isArray(lines)) {
+    if (lines.length === 2) {
+      return { startLine: lines[0], endLine: lines[1] };
+    }
+    return {
+      startLine: Math.min(...lines),
+      endLine: Math.max(...lines)
+    };
+  }
+  return { startLine: 1, endLine: 1 };
+}
+function parseUnifiedDiffHunks(diffOutput) {
+  const hunks = [];
+  const hunkPattern = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/gm;
+  let match;
+  while ((match = hunkPattern.exec(diffOutput)) !== null) {
+    hunks.push({
+      oldStart: parseInt(match[1], 10),
+      oldCount: match[2] !== void 0 ? parseInt(match[2], 10) : 1,
+      newStart: parseInt(match[3], 10),
+      newCount: match[4] !== void 0 ? parseInt(match[4], 10) : 1
+    });
+  }
+  return hunks;
+}
+function computeLineShift(rootDir, filePath, fromCommit, originalStart, originalEnd) {
+  let diff;
+  try {
+    diff = execSync(
+      `git diff ${fromCommit}..HEAD --unified=0 -- "${filePath}"`,
+      { cwd: rootDir, encoding: "utf8", timeout: 5e3 }
+    );
+  } catch {
+    return null;
+  }
+  if (!diff.trim()) {
+    return { originalStart, originalEnd, currentStart: originalStart, currentEnd: originalEnd };
+  }
+  const hunks = parseUnifiedDiffHunks(diff);
+  let offset = 0;
+  for (const hunk of hunks) {
+    const hunkOldEnd = hunk.oldStart + hunk.oldCount;
+    if (hunkOldEnd <= originalStart) {
+      offset += hunk.newCount - hunk.oldCount;
+      continue;
+    }
+    if (hunk.oldStart < originalEnd) {
+      return null;
+    }
+    break;
+  }
+  if (offset === 0) return null;
+  return {
+    originalStart,
+    originalEnd,
+    currentStart: originalStart + offset,
+    currentEnd: originalEnd + offset
+  };
+}
+function healAnchorInPurposeFile(rootDir, purposeFilePath, anchorFilePath, oldStart, oldEnd, newStart, newEnd) {
+  const absolutePurpose = path6.isAbsolute(purposeFilePath) ? purposeFilePath : path6.join(rootDir, purposeFilePath);
+  if (!fs5.existsSync(absolutePurpose)) return false;
+  try {
+    const content = fs5.readFileSync(absolutePurpose, "utf8");
+    const oldAnchor = oldStart === oldEnd ? `${anchorFilePath}:${oldStart}` : `${anchorFilePath}:${oldStart}-${oldEnd}`;
+    const newAnchor = newStart === newEnd ? `${anchorFilePath}:${newStart}` : `${anchorFilePath}:${newStart}-${newEnd}`;
+    if (!content.includes(oldAnchor)) return false;
+    const updated = content.replace(oldAnchor, newAnchor);
+    fs5.writeFileSync(absolutePurpose, updated, "utf8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function normalizeForHash(content) {
+  return content.split("\n").map((line) => line.trimEnd()).filter((line) => line.trim() !== "").map((line) => line.replace(/\s+/g, " ")).join("\n");
+}
+function computeAnchorHash(anchor, rootDir) {
+  if (!rootDir) return { exact: null, normalized: null };
+  const absolutePath = path6.isAbsolute(anchor.path) ? anchor.path : path6.join(rootDir, anchor.path);
+  if (!fs5.existsSync(absolutePath)) return { exact: null, normalized: null };
+  try {
+    const fileContent = fs5.readFileSync(absolutePath, "utf8");
+    const lines = fileContent.split("\n");
+    const { startLine, endLine } = resolveAnchorLines(anchor);
+    const startIdx = Math.max(0, startLine - 1);
+    const endIdx = Math.min(lines.length, endLine);
+    const sliceContent = lines.slice(startIdx, endIdx).join("\n");
+    const exact = crypto2.createHash("sha256").update(sliceContent).digest("hex");
+    const normalized = crypto2.createHash("sha256").update(normalizeForHash(sliceContent)).digest("hex");
+    return { exact, normalized };
+  } catch {
+    return { exact: null, normalized: null };
+  }
+}
+function inferCategory(data, entry) {
+  if (typeof data.category === "string") return data.category;
+  const desc = (entry.description ?? "").toLowerCase();
+  if (/\b(must|require|always)\b/.test(desc)) return "rule";
+  if (/\b(decided|chose)\b/.test(desc)) return "decision";
+  if (/\b(limit|cannot)\b/.test(desc)) return "constraint";
+  if (/\b(set to|configured|value)\b/.test(desc)) return "configuration";
+  return "rule";
+}
+function inferSeverity(data, entry) {
+  if (typeof data.severity === "string") return data.severity;
+  const tags = entry.tags ?? [];
+  if (tags.includes("critical")) return "critical";
+  if (tags.includes("security") || tags.includes("compliance")) return "high";
+  return "medium";
+}
+
+// ../paradigm-mcp/src/utils/lore-loader.ts
+import * as fs6 from "fs";
+import * as path7 from "path";
+import * as yaml5 from "js-yaml";
+var LORE_DIR = ".paradigm/lore";
+var ENTRIES_DIR = "entries";
+var TIMELINE_FILE = "timeline.yaml";
+async function loadLoreEntries(rootDir, filter) {
+  const entriesPath = path7.join(rootDir, LORE_DIR, ENTRIES_DIR);
+  if (!fs6.existsSync(entriesPath)) {
+    return [];
+  }
+  migrateLegacyEntries(rootDir);
+  const entries = [];
+  const dateDirs = fs6.readdirSync(entriesPath).filter((d) => /^\d{4}-\d{2}-\d{2}$/.test(d)).sort().reverse();
+  for (const dateDir of dateDirs) {
+    if (filter?.dateFrom && dateDir < filter.dateFrom.slice(0, 10)) continue;
+    if (filter?.dateTo && dateDir > filter.dateTo.slice(0, 10)) continue;
+    const dirPath = path7.join(entriesPath, dateDir);
+    const files = fs6.readdirSync(dirPath).filter((f) => f.endsWith(".yaml")).sort();
+    for (const file of files) {
+      try {
+        const content = fs6.readFileSync(path7.join(dirPath, file), "utf8");
+        const entry = yaml5.load(content);
+        entries.push(entry);
+      } catch {
+      }
+    }
+  }
+  return filter ? applyFilter(entries, filter) : entries;
+}
+async function loadLoreEntry(rootDir, entryId) {
+  const dateMatch = entryId.match(/^L-(\d{4}-\d{2}-\d{2})-/);
+  if (dateMatch) {
+    const dateStr = dateMatch[1];
+    const entryPath = path7.join(rootDir, LORE_DIR, ENTRIES_DIR, dateStr, `${entryId}.yaml`);
+    if (fs6.existsSync(entryPath)) {
+      try {
+        const content = fs6.readFileSync(entryPath, "utf8");
+        return yaml5.load(content);
+      } catch {
+        return null;
+      }
+    }
+  }
+  const entries = await loadLoreEntries(rootDir);
+  return entries.find((e) => e.id === entryId) || null;
+}
+async function loadLoreTimeline(rootDir) {
+  const timelinePath = path7.join(rootDir, LORE_DIR, TIMELINE_FILE);
+  if (!fs6.existsSync(timelinePath)) {
+    return null;
+  }
+  try {
+    const content = fs6.readFileSync(timelinePath, "utf8");
+    return yaml5.load(content);
+  } catch {
+    return null;
+  }
+}
+async function recordLoreEntry(rootDir, entry) {
+  const lorePath = path7.join(rootDir, LORE_DIR);
+  const dateStr = entry.timestamp.slice(0, 10);
+  const datePath = path7.join(lorePath, ENTRIES_DIR, dateStr);
+  if (!fs6.existsSync(datePath)) {
+    fs6.mkdirSync(datePath, { recursive: true });
+  }
+  if (!entry.id) {
+    entry.id = generateLoreId(rootDir, dateStr);
+  }
+  const entryPath = path7.join(datePath, `${entry.id}.yaml`);
+  fs6.writeFileSync(entryPath, yaml5.dump(entry, { lineWidth: -1, noRefs: true }));
+  await rebuildTimeline(rootDir);
+  return entry.id;
+}
+async function rebuildTimeline(rootDir) {
+  const lorePath = path7.join(rootDir, LORE_DIR);
+  const entriesPath = path7.join(lorePath, ENTRIES_DIR);
+  if (!fs6.existsSync(entriesPath)) return;
+  migrateLegacyEntries(rootDir);
+  const authors = /* @__PURE__ */ new Set();
+  let entryCount = 0;
+  let lastUpdated = "";
+  const dateDirs = fs6.readdirSync(entriesPath).filter((d) => /^\d{4}-\d{2}-\d{2}$/.test(d));
+  for (const dateDir of dateDirs) {
+    const dirPath = path7.join(entriesPath, dateDir);
+    const files = fs6.readdirSync(dirPath).filter((f) => f.endsWith(".yaml"));
+    for (const file of files) {
+      try {
+        const content = fs6.readFileSync(path7.join(dirPath, file), "utf8");
+        const entry = yaml5.load(content);
+        authors.add(entry.author.id);
+        entryCount++;
+        if (!lastUpdated || entry.timestamp > lastUpdated) {
+          lastUpdated = entry.timestamp;
+        }
+      } catch {
+      }
+    }
+  }
+  let project = "unknown";
+  const configPath = path7.join(rootDir, ".paradigm", "config.yaml");
+  if (fs6.existsSync(configPath)) {
+    try {
+      const config = yaml5.load(fs6.readFileSync(configPath, "utf8"));
+      project = config.project || config.name || "unknown";
+    } catch {
+    }
+  }
+  const timeline = {
+    version: "1.0",
+    project,
+    entries: entryCount,
+    last_updated: lastUpdated || (/* @__PURE__ */ new Date()).toISOString(),
+    authors: Array.from(authors)
+  };
+  if (!fs6.existsSync(lorePath)) {
+    fs6.mkdirSync(lorePath, { recursive: true });
+  }
+  fs6.writeFileSync(
+    path7.join(lorePath, TIMELINE_FILE),
+    yaml5.dump(timeline, { lineWidth: -1, noRefs: true })
+  );
+}
+function migrateLegacyEntries(rootDir) {
+  const entriesPath = path7.join(rootDir, LORE_DIR, ENTRIES_DIR);
+  if (!fs6.existsSync(entriesPath)) return 0;
+  const rootFiles = fs6.readdirSync(entriesPath).filter((f) => f.endsWith(".yaml") && !f.startsWith("."));
+  let migrated = 0;
+  for (const file of rootFiles) {
+    const filePath = path7.join(entriesPath, file);
+    const stat = fs6.statSync(filePath);
+    if (!stat.isFile()) continue;
+    try {
+      const content = fs6.readFileSync(filePath, "utf8");
+      const raw = yaml5.load(content);
+      if (raw.author && typeof raw.author === "object") continue;
+      const dateStr = typeof raw.date === "string" ? raw.date.slice(0, 10) : (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+      const datePath = path7.join(entriesPath, dateStr);
+      if (!fs6.existsSync(datePath)) {
+        fs6.mkdirSync(datePath, { recursive: true });
+      }
+      const id = generateLoreId(rootDir, dateStr);
+      const oldType = String(raw.type || "agent-session");
+      const v2Type = ["agent-session", "human-note", "decision", "review", "incident", "milestone"].includes(oldType) ? oldType : "agent-session";
+      let verification;
+      if (raw.test_results && typeof raw.test_results === "object") {
+        const tr = raw.test_results;
+        verification = {
+          status: tr.total === tr.passed ? "pass" : "partial",
+          details: { tests: tr.total === tr.passed ? "pass" : "fail" }
+        };
+      }
+      const v2Entry = {
+        id,
+        type: v2Type,
+        timestamp: `${dateStr}T00:00:00.000Z`,
+        author: { type: "agent", id: "unknown" },
+        title: String(raw.title || file.replace(".yaml", "")),
+        summary: String(raw.summary || ""),
+        symbols_touched: Array.isArray(raw.symbols_touched) ? raw.symbols_touched : [],
+        files_modified: Array.isArray(raw.files_modified) ? raw.files_modified : void 0,
+        ...verification ? { verification } : {},
+        tags: ["migrated", oldType]
+      };
+      fs6.writeFileSync(
+        path7.join(datePath, `${id}.yaml`),
+        yaml5.dump(v2Entry, { lineWidth: -1, noRefs: true })
+      );
+      fs6.unlinkSync(filePath);
+      migrated++;
+    } catch {
+    }
+  }
+  return migrated;
+}
+async function updateLoreEntry(rootDir, entryId, partial) {
+  const entry = await loadLoreEntry(rootDir, entryId);
+  if (!entry) return false;
+  const dateStr = entry.timestamp.slice(0, 10);
+  const entryPath = path7.join(rootDir, LORE_DIR, ENTRIES_DIR, dateStr, `${entryId}.yaml`);
+  if (!fs6.existsSync(entryPath)) return false;
+  if (partial.title !== void 0) entry.title = partial.title;
+  if (partial.summary !== void 0) entry.summary = partial.summary;
+  if (partial.type !== void 0) entry.type = partial.type;
+  if (partial.duration_minutes !== void 0) entry.duration_minutes = partial.duration_minutes;
+  if (partial.symbols_touched !== void 0) entry.symbols_touched = partial.symbols_touched;
+  if (partial.symbols_created !== void 0) entry.symbols_created = partial.symbols_created;
+  if (partial.files_created !== void 0) entry.files_created = partial.files_created;
+  if (partial.files_modified !== void 0) entry.files_modified = partial.files_modified;
+  if (partial.lines_added !== void 0) entry.lines_added = partial.lines_added;
+  if (partial.lines_removed !== void 0) entry.lines_removed = partial.lines_removed;
+  if (partial.commit !== void 0) entry.commit = partial.commit;
+  if (partial.decisions !== void 0) entry.decisions = partial.decisions;
+  if (partial.errors_encountered !== void 0) entry.errors_encountered = partial.errors_encountered;
+  if (partial.learnings !== void 0) entry.learnings = partial.learnings;
+  if (partial.verification !== void 0) entry.verification = partial.verification;
+  if (partial.tags !== void 0) entry.tags = partial.tags;
+  fs6.writeFileSync(entryPath, yaml5.dump(entry, { lineWidth: -1, noRefs: true }));
+  await rebuildTimeline(rootDir);
+  return true;
+}
+async function deleteLoreEntry(rootDir, entryId) {
+  const entry = await loadLoreEntry(rootDir, entryId);
+  if (!entry) return false;
+  const dateStr = entry.timestamp.slice(0, 10);
+  const entryPath = path7.join(rootDir, LORE_DIR, ENTRIES_DIR, dateStr, `${entryId}.yaml`);
+  if (!fs6.existsSync(entryPath)) return false;
+  fs6.unlinkSync(entryPath);
+  const dateDir = path7.dirname(entryPath);
+  const remaining = fs6.readdirSync(dateDir).filter((f) => f.endsWith(".yaml"));
+  if (remaining.length === 0) {
+    fs6.rmdirSync(dateDir);
+  }
+  await rebuildTimeline(rootDir);
+  return true;
+}
+function applyFilter(entries, filter) {
+  let result = entries;
+  if (filter.author) {
+    result = result.filter((e) => e.author.id === filter.author);
+  }
+  if (filter.authorType) {
+    result = result.filter((e) => e.author.type === filter.authorType);
+  }
+  if (filter.symbol) {
+    result = result.filter(
+      (e) => e.symbols_touched.includes(filter.symbol) || e.symbols_created?.includes(filter.symbol)
+    );
+  }
+  if (filter.dateFrom) {
+    const from = new Date(filter.dateFrom).getTime();
+    result = result.filter((e) => new Date(e.timestamp).getTime() >= from);
+  }
+  if (filter.dateTo) {
+    const to = new Date(filter.dateTo).getTime();
+    result = result.filter((e) => new Date(e.timestamp).getTime() <= to);
+  }
+  if (filter.type) {
+    result = result.filter((e) => e.type === filter.type);
+  }
+  if (filter.tags && filter.tags.length > 0) {
+    result = result.filter((e) => filter.tags.some((tag) => e.tags?.includes(tag)));
+  }
+  if (filter.hasReview !== void 0) {
+    result = result.filter((e) => filter.hasReview ? e.review != null : e.review == null);
+  }
+  result.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+  if (filter.offset) result = result.slice(filter.offset);
+  if (filter.limit) result = result.slice(0, filter.limit);
+  return result;
+}
+function generateLoreId(rootDir, dateStr) {
+  const datePath = path7.join(rootDir, LORE_DIR, ENTRIES_DIR, dateStr);
+  if (!fs6.existsSync(datePath)) {
+    return `L-${dateStr}-001`;
+  }
+  const existing = fs6.readdirSync(datePath).filter((f) => f.startsWith("L-") && f.endsWith(".yaml")).map((f) => {
+    const match = f.match(/L-\d{4}-\d{2}-\d{2}-(\d+)\.yaml/);
+    return match ? parseInt(match[1], 10) : 0;
+  });
+  const next = existing.length > 0 ? Math.max(...existing) + 1 : 1;
+  return `L-${dateStr}-${String(next).padStart(3, "0")}`;
+}
+
+// ../paradigm-mcp/src/utils/aspect-lore-bridge.ts
+var LORE_ID_PATTERN = /L-\d{4}-\d{2}-\d{2}-\d{3}/g;
+async function materializeLoreLinks(db, rootDir) {
+  db.run("DELETE FROM lore_links");
+  const loreEntries = await loadLoreEntries(rootDir);
+  if (loreEntries.length === 0) {
+    return 0;
+  }
+  const symbolToLore = buildSymbolToLoreMap(loreEntries);
+  const loreById = /* @__PURE__ */ new Map();
+  for (const entry of loreEntries) {
+    loreById.set(entry.id, entry);
+  }
+  const links = /* @__PURE__ */ new Set();
+  const aspectRows = db.exec("SELECT id, enforcement FROM aspects");
+  if (aspectRows.length > 0) {
+    const { columns, values } = aspectRows[0];
+    const idIdx = columns.indexOf("id");
+    const enfIdx = columns.indexOf("enforcement");
+    for (const row of values) {
+      const aspectId = String(row[idIdx]);
+      const enforcement = row[enfIdx];
+      if (enforcement && typeof enforcement === "string") {
+        const matches = enforcement.match(LORE_ID_PATTERN);
+        if (matches) {
+          for (const loreId of matches) {
+            if (loreById.has(loreId)) {
+              links.add(`${aspectId}\0${loreId}`);
+            }
+          }
+        }
+      }
+    }
+  }
+  const edgeRows = db.exec("SELECT source, target FROM edges");
+  if (edgeRows.length > 0 && aspectRows.length > 0) {
+    const aspectSymbols = buildAspectSymbolMap(db, edgeRows);
+    for (const [aspectId, symbols] of aspectSymbols) {
+      for (const symbol of symbols) {
+        const loreIds = symbolToLore.get(symbol);
+        if (loreIds) {
+          for (const loreId of loreIds) {
+            links.add(`${aspectId}\0${loreId}`);
+          }
+        }
+      }
+    }
+  }
+  if (links.size === 0) {
+    return 0;
+  }
+  const stmt = db.prepare("INSERT OR IGNORE INTO lore_links (aspect_id, lore_id) VALUES (?, ?)");
+  try {
+    for (const key of links) {
+      const [aspectId, loreId] = key.split("\0");
+      stmt.bind([aspectId, loreId]);
+      stmt.step();
+      stmt.reset();
+    }
+  } finally {
+    stmt.free();
+  }
+  return links.size;
+}
+async function getLoreForAspect(db, rootDir, aspectId) {
+  const result = db.exec("SELECT lore_id FROM lore_links WHERE aspect_id = ?", [aspectId]);
+  if (result.length === 0 || result[0].values.length === 0) {
+    return [];
+  }
+  const loreIds = result[0].values.map((row) => String(row[0]));
+  return loadLoreSummaries(rootDir, loreIds);
+}
+async function inferLoreEdges(db, rootDir) {
+  const loreEntries = await loadLoreEntries(rootDir);
+  if (loreEntries.length === 0) {
+    return 0;
+  }
+  const aspectIdsResult = db.exec("SELECT id FROM aspects");
+  const knownAspects = /* @__PURE__ */ new Set();
+  if (aspectIdsResult.length > 0) {
+    for (const row of aspectIdsResult[0].values) {
+      knownAspects.add(String(row[0]));
+    }
+  }
+  if (knownAspects.size < 2) {
+    return 0;
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let edgesInferred = 0;
+  const stmt = db.prepare(
+    `INSERT OR IGNORE INTO edges (source, target, relation, weight, origin, created_at)
+     VALUES (?, ?, 'related-to', 0.3, 'learned', ?)`
+  );
+  try {
+    for (const entry of loreEntries) {
+      if (!entry.symbols_touched || entry.symbols_touched.length < 2) {
+        continue;
+      }
+      const aspectsInEntry = [];
+      for (const symbol of entry.symbols_touched) {
+        const stripped = symbol.startsWith("~") ? symbol.slice(1) : symbol;
+        if (knownAspects.has(stripped)) {
+          aspectsInEntry.push(stripped);
+        }
+      }
+      for (let i = 0; i < aspectsInEntry.length; i++) {
+        for (let j = i + 1; j < aspectsInEntry.length; j++) {
+          const [source, target] = aspectsInEntry[i] < aspectsInEntry[j] ? [aspectsInEntry[i], aspectsInEntry[j]] : [aspectsInEntry[j], aspectsInEntry[i]];
+          stmt.bind([source, target, now]);
+          stmt.step();
+          stmt.reset();
+          edgesInferred++;
+        }
+      }
+    }
+  } finally {
+    stmt.free();
+  }
+  return edgesInferred;
+}
+function buildSymbolToLoreMap(entries) {
+  const map = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (!entry.symbols_touched) continue;
+    for (const symbol of entry.symbols_touched) {
+      let set = map.get(symbol);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        map.set(symbol, set);
+      }
+      set.add(entry.id);
+    }
+  }
+  return map;
+}
+function buildAspectSymbolMap(db, edgeRows) {
+  const aspectIdsResult = db.exec("SELECT id FROM aspects");
+  const knownAspects = /* @__PURE__ */ new Set();
+  if (aspectIdsResult.length > 0) {
+    for (const row of aspectIdsResult[0].values) {
+      knownAspects.add(String(row[0]));
+    }
+  }
+  const map = /* @__PURE__ */ new Map();
+  if (edgeRows.length === 0) return map;
+  const { columns, values } = edgeRows[0];
+  const srcIdx = columns.indexOf("source");
+  const tgtIdx = columns.indexOf("target");
+  for (const row of values) {
+    const source = String(row[srcIdx]);
+    const target = String(row[tgtIdx]);
+    if (knownAspects.has(source)) {
+      let set = map.get(source);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        map.set(source, set);
+      }
+      set.add(target);
+      set.add(`~${source}`);
+    }
+    if (knownAspects.has(target)) {
+      let set = map.get(target);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        map.set(target, set);
+      }
+      set.add(source);
+      set.add(`~${target}`);
+    }
+  }
+  return map;
+}
+async function loadLoreSummaries(rootDir, loreIds) {
+  const seen = /* @__PURE__ */ new Set();
+  const summaries = [];
+  for (const loreId of loreIds) {
+    if (seen.has(loreId)) continue;
+    seen.add(loreId);
+    const entry = await loadLoreEntry(rootDir, loreId);
+    if (entry) {
+      summaries.push(toLoreSummary(entry));
+    }
+  }
+  return summaries;
+}
+function toLoreSummary(entry) {
+  return {
+    id: entry.id,
+    title: entry.title,
+    summary: entry.summary,
+    timestamp: entry.timestamp,
+    symbolsTouched: entry.symbols_touched
+  };
+}
+
+// ../paradigm-mcp/src/utils/personas-loader.ts
+import * as fs7 from "fs";
+import * as path8 from "path";
+import * as yaml6 from "js-yaml";
+var PERSONAS_ROOT = ".paradigm/personas";
+var INDEX_FILE = "index.yaml";
+async function loadPersonas(rootDir, filter) {
+  const personasDir = path8.join(rootDir, PERSONAS_ROOT);
+  if (!fs7.existsSync(personasDir)) return [];
+  const files = fs7.readdirSync(personasDir).filter((f) => f.endsWith(".persona"));
+  const personas = [];
+  for (const file of files) {
+    try {
+      const content = fs7.readFileSync(path8.join(personasDir, file), "utf8");
+      const persona = yaml6.load(content);
+      if (persona && persona.id) {
+        personas.push(persona);
+      }
+    } catch {
+    }
+  }
+  return applyFilter2(personas, filter);
+}
+async function loadPersona(rootDir, id) {
+  const filePath = path8.join(rootDir, PERSONAS_ROOT, `${id}.persona`);
+  if (!fs7.existsSync(filePath)) return null;
+  try {
+    return yaml6.load(fs7.readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function applyFilter2(personas, filter) {
+  if (!filter) return personas;
+  let result = personas;
+  if (filter.tag) {
+    result = result.filter((p) => p.tags?.includes(filter.tag));
+  }
+  if (filter.trigger_type) {
+    result = result.filter((p) => p.trigger.type === filter.trigger_type);
+  }
+  if (filter.gate) {
+    result = result.filter(
+      (p) => p.journey.some((s) => s.gates.includes(filter.gate))
+    );
+  }
+  if (filter.flow) {
+    result = result.filter(
+      (p) => p.journey.some((s) => s.flow === filter.flow)
+    );
+  }
+  if (filter.limit) {
+    result = result.slice(0, filter.limit);
+  }
+  return result;
+}
+async function createPersona(rootDir, data) {
+  const personasDir = path8.join(rootDir, PERSONAS_ROOT);
+  fs7.mkdirSync(personasDir, { recursive: true });
+  const filePath = path8.join(personasDir, `${data.id}.persona`);
+  if (fs7.existsSync(filePath)) {
+    throw new Error(`Persona ${data.id} already exists`);
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const persona = {
+    version: "1.0",
+    id: data.id,
+    name: data.name,
+    description: data.description,
+    traits: data.traits,
+    trigger: data.trigger,
+    fixtures: data.fixtures,
+    tags: data.tags || [],
+    journey: data.journey || [],
+    created: now,
+    updated: now
+  };
+  fs7.writeFileSync(filePath, yaml6.dump(persona, { indent: 2, lineWidth: 120, noRefs: true, sortKeys: false }));
+  await rebuildPersonaIndex(rootDir);
+  return data.id;
+}
+async function updatePersona(rootDir, id, partial) {
+  const persona = await loadPersona(rootDir, id);
+  if (!persona) return false;
+  const filePath = path8.join(rootDir, PERSONAS_ROOT, `${id}.persona`);
+  const updated = {
+    ...persona,
+    ...partial,
+    id: persona.id,
+    // immutable
+    version: persona.version,
+    // immutable
+    created: persona.created,
+    // immutable
+    updated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  fs7.writeFileSync(filePath, yaml6.dump(updated, { indent: 2, lineWidth: 120, noRefs: true, sortKeys: false }));
+  await rebuildPersonaIndex(rootDir);
+  return true;
+}
+async function deletePersona(rootDir, id) {
+  const filePath = path8.join(rootDir, PERSONAS_ROOT, `${id}.persona`);
+  if (!fs7.existsSync(filePath)) {
+    return { deleted: false, warnings: [] };
+  }
+  const warnings = [];
+  const all = await loadPersonas(rootDir);
+  for (const p of all) {
+    if (p.id === id) continue;
+    if (p.trigger.spawned_by?.startsWith(id + ".")) {
+      warnings.push(`Persona ${p.id} is spawned by ${id} \u2014 it will become orphaned`);
+    }
+    for (const step of p.journey) {
+      if (step.spawns?.some((s) => s.persona === id)) {
+        warnings.push(`Persona ${p.id} step ${step.id} spawns ${id} \u2014 spawn will break`);
+      }
+    }
+  }
+  fs7.unlinkSync(filePath);
+  await rebuildPersonaIndex(rootDir);
+  return { deleted: true, warnings };
+}
+async function addStep(rootDir, personaId, step, afterStepId) {
+  const persona = await loadPersona(rootDir, personaId);
+  if (!persona) return false;
+  if (persona.journey.some((s) => s.id === step.id)) {
+    throw new Error(`Step ${step.id} already exists in persona ${personaId}`);
+  }
+  if (afterStepId) {
+    const idx = persona.journey.findIndex((s) => s.id === afterStepId);
+    if (idx === -1) throw new Error(`Step ${afterStepId} not found in persona ${personaId}`);
+    persona.journey.splice(idx + 1, 0, step);
+  } else {
+    persona.journey.push(step);
+  }
+  return updatePersona(rootDir, personaId, { journey: persona.journey });
+}
+async function removeStep(rootDir, personaId, stepId) {
+  const persona = await loadPersona(rootDir, personaId);
+  if (!persona) return { removed: false, warnings: [] };
+  const idx = persona.journey.findIndex((s) => s.id === stepId);
+  if (idx === -1) return { removed: false, warnings: [] };
+  const step = persona.journey[idx];
+  const warnings = [];
+  if (step.produces) {
+    for (const key of Object.keys(step.produces)) {
+      const pattern = `{{produces.${key}}}`;
+      for (let i = idx + 1; i < persona.journey.length; i++) {
+        const later = persona.journey[i];
+        const serialized = JSON.stringify(later);
+        if (serialized.includes(pattern)) {
+          warnings.push(`Step ${later.id} consumes {{produces.${key}}} from this step`);
+        }
+      }
+    }
+  }
+  if (step.spawns && step.spawns.length > 0) {
+    for (const spawn of step.spawns) {
+      warnings.push(`Step spawns persona ${spawn.persona} \u2014 spawn chain will break`);
+    }
+  }
+  persona.journey.splice(idx, 1);
+  await updatePersona(rootDir, personaId, { journey: persona.journey });
+  return { removed: true, warnings };
+}
+var PERSONA_ID_REGEX = /^[a-z][a-z0-9-]*$/;
+var STEP_ID_REGEX = /^[a-z][a-z0-9-]*$/;
+var ROUTE_REGEX = /^(GET|POST|PUT|PATCH|DELETE)\s+\//;
+async function validatePersona(rootDir, persona, deep = false) {
+  const errors = [];
+  const warnings = [];
+  if (!PERSONA_ID_REGEX.test(persona.id)) {
+    errors.push({ type: "invalid-id", detail: `ID "${persona.id}" must match /^[a-z][a-z0-9-]*$/` });
+  }
+  if (!persona.name || persona.name.trim() === "") {
+    errors.push({ type: "missing-name", detail: "Name is required" });
+  }
+  if (!persona.trigger || !persona.trigger.type) {
+    errors.push({ type: "missing-trigger", detail: "Trigger with type is required" });
+  }
+  if (persona.trigger.type !== "root" && !persona.trigger.spawned_by) {
+    errors.push({ type: "missing-spawned-by", detail: `Non-root trigger type "${persona.trigger.type}" requires spawned_by` });
+  }
+  if (!persona.journey || persona.journey.length === 0) {
+    errors.push({ type: "empty-journey", detail: "Journey must have at least one step" });
+  }
+  const stepIds = /* @__PURE__ */ new Set();
+  const producedKeys = /* @__PURE__ */ new Set();
+  for (const step of persona.journey) {
+    if (!STEP_ID_REGEX.test(step.id)) {
+      errors.push({ type: "invalid-step-id", step: step.id, detail: `Step ID must match /^[a-z][a-z0-9-]*$/` });
+    }
+    if (stepIds.has(step.id)) {
+      errors.push({ type: "duplicate-step-id", step: step.id, detail: `Duplicate step ID "${step.id}"` });
+    }
+    stepIds.add(step.id);
+    if (!ROUTE_REGEX.test(step.route)) {
+      errors.push({ type: "invalid-route", step: step.id, route: step.route, detail: `Route must match "METHOD /path" (e.g., "POST /api/auth/signup")` });
+    }
+    if (!step.gates || step.gates.length === 0) {
+      errors.push({ type: "missing-gates", step: step.id, detail: "Step must have at least one gate" });
+    }
+    if (!step.expect || step.expect.status === void 0) {
+      errors.push({ type: "missing-expect", step: step.id, detail: "Step must have expect with status" });
+    }
+    const serialized = JSON.stringify(step);
+    const producesRefs = serialized.match(/\{\{produces\.([^}]+)\}\}/g) || [];
+    for (const ref of producesRefs) {
+      const key = ref.replace("{{produces.", "").replace("}}", "");
+      if (!producedKeys.has(key)) {
+        errors.push({ type: "unresolved-produces", step: step.id, key, detail: `{{produces.${key}}} used but not produced by a prior step` });
+      }
+    }
+    if (step.produces) {
+      for (const key of Object.keys(step.produces)) {
+        producedKeys.add(key);
+      }
+    }
+  }
+  if (deep) {
+    const portalPath = path8.join(rootDir, "portal.yaml");
+    let portalGates = [];
+    let portalRoutes = [];
+    if (fs7.existsSync(portalPath)) {
+      try {
+        const portal = yaml6.load(fs7.readFileSync(portalPath, "utf8"));
+        if (portal.gates && typeof portal.gates === "object") {
+          portalGates = Object.keys(portal.gates);
+        }
+        if (portal.routes && typeof portal.routes === "object") {
+          portalRoutes = Object.keys(portal.routes);
+        }
+      } catch {
+      }
+    }
+    for (const step of persona.journey) {
+      for (const gate of step.gates) {
+        if (portalGates.length > 0 && !portalGates.includes(gate)) {
+          errors.push({ type: "gate-not-found", step: step.id, gate, detail: `Gate ${gate} not defined in portal.yaml` });
+        }
+      }
+    }
+    for (const step of persona.journey) {
+      if (portalRoutes.length > 0) {
+        const stepRoute = step.route;
+        const matchesAny = portalRoutes.some((pr) => routeMatches(pr, stepRoute));
+        if (!matchesAny) {
+          warnings.push({ type: "route-not-in-portal", detail: `Route "${stepRoute}" (step ${step.id}) not found in portal.yaml` });
+        }
+      }
+    }
+    for (const step of persona.journey) {
+      if (step.spawns) {
+        for (const spawn of step.spawns) {
+          const target = await loadPersona(rootDir, spawn.persona);
+          if (!target) {
+            errors.push({ type: "spawn-target-missing", step: step.id, detail: `Spawn target persona "${spawn.persona}" does not exist` });
+          }
+        }
+      }
+    }
+    const spawnCycle = await detectSpawnCycle(rootDir, persona.id);
+    if (spawnCycle) {
+      errors.push({ type: "spawn-cycle", detail: `Circular spawn dependency: ${spawnCycle.join(" \u2192 ")}` });
+    }
+    if (portalRoutes.length > 0 || portalGates.length > 0) {
+      const allPersonas = await loadPersonas(rootDir);
+      const allGatesUsed = /* @__PURE__ */ new Set();
+      const allRoutesUsed = /* @__PURE__ */ new Set();
+      for (const p of allPersonas) {
+        for (const step of p.journey) {
+          for (const gate of step.gates) allGatesUsed.add(gate);
+          allRoutesUsed.add(step.route);
+        }
+      }
+      let allFlows = [];
+      const flowIndexPath = path8.join(rootDir, ".paradigm", "flow-index.json");
+      if (fs7.existsSync(flowIndexPath)) {
+        try {
+          const flowIndex = JSON.parse(fs7.readFileSync(flowIndexPath, "utf8"));
+          allFlows = Object.keys(flowIndex.flows || {});
+        } catch {
+        }
+      }
+      const allFlowsUsed = /* @__PURE__ */ new Set();
+      for (const p of allPersonas) {
+        for (const step of p.journey) {
+          if (step.flow) allFlowsUsed.add(step.flow);
+        }
+      }
+      return {
+        persona: persona.id,
+        valid: errors.length === 0,
+        errors,
+        warnings,
+        coverage: {
+          routes: {
+            covered: allRoutesUsed.size,
+            total: portalRoutes.length,
+            uncovered: portalRoutes.filter((r) => !allRoutesUsed.has(r))
+          },
+          gates: {
+            covered: allGatesUsed.size,
+            total: portalGates.length,
+            uncovered: portalGates.filter((g) => !allGatesUsed.has(g))
+          },
+          flows: {
+            covered: allFlowsUsed.size,
+            total: allFlows.length,
+            uncovered: allFlows.filter((f) => !allFlowsUsed.has(f))
+          }
+        }
+      };
+    }
+  }
+  return {
+    persona: persona.id,
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+function routeMatches(portalRoute, stepRoute) {
+  const normalize = (r) => r.replace(/:[a-zA-Z_]+/g, ":param").replace(/\{\{[^}]+\}\}/g, ":param");
+  return normalize(portalRoute) === normalize(stepRoute);
+}
+async function detectSpawnCycle(rootDir, startId) {
+  const visited = /* @__PURE__ */ new Set();
+  const stack = [];
+  async function visit(id) {
+    if (visited.has(id)) {
+      const cycleStart = stack.indexOf(id);
+      if (cycleStart !== -1) {
+        return [...stack.slice(cycleStart), id];
+      }
+      return null;
+    }
+    visited.add(id);
+    stack.push(id);
+    const persona = await loadPersona(rootDir, id);
+    if (persona) {
+      for (const step of persona.journey) {
+        if (step.spawns) {
+          for (const spawn of step.spawns) {
+            const cycle = await visit(spawn.persona);
+            if (cycle) return cycle;
+          }
+        }
+      }
+    }
+    stack.pop();
+    return null;
+  }
+  return visit(startId);
+}
+async function rebuildPersonaIndex(rootDir) {
+  const personasDir = path8.join(rootDir, PERSONAS_ROOT);
+  fs7.mkdirSync(personasDir, { recursive: true });
+  const personas = await loadPersonas(rootDir);
+  const entries = {};
+  const gateCoverage = {};
+  const routeCoverage = {};
+  for (const p of personas) {
+    const gates = /* @__PURE__ */ new Set();
+    const flows = /* @__PURE__ */ new Set();
+    const routes = [];
+    const spawns = /* @__PURE__ */ new Set();
+    for (const step of p.journey) {
+      for (const g of step.gates) gates.add(g);
+      if (step.flow) flows.add(step.flow);
+      routes.push(step.route);
+      if (step.spawns) {
+        for (const s of step.spawns) spawns.add(s.persona);
+      }
+    }
+    entries[p.id] = {
+      name: p.name,
+      trigger: p.trigger.type,
+      spawned_by: p.trigger.spawned_by,
+      steps: p.journey.length,
+      gates: [...gates],
+      flows: [...flows],
+      routes,
+      spawns: [...spawns],
+      tags: p.tags || []
+    };
+    for (const gate of gates) {
+      if (!gateCoverage[gate]) gateCoverage[gate] = [];
+      gateCoverage[gate].push(p.id);
+    }
+    for (const route of routes) {
+      if (!routeCoverage[route]) routeCoverage[route] = [];
+      routeCoverage[route].push(p.id);
+    }
+  }
+  let uncoveredRoutes = [];
+  const portalPath = path8.join(rootDir, "portal.yaml");
+  if (fs7.existsSync(portalPath)) {
+    try {
+      const portal = yaml6.load(fs7.readFileSync(portalPath, "utf8"));
+      if (portal.routes && typeof portal.routes === "object") {
+        const portalRoutes = Object.keys(portal.routes);
+        uncoveredRoutes = portalRoutes.filter((pr) => {
+          return !Object.keys(routeCoverage).some((sr) => routeMatches(pr, sr));
+        });
+      }
+    } catch {
+    }
+  }
+  const chains = {};
+  const chainsDir = path8.join(personasDir, "chains");
+  if (fs7.existsSync(chainsDir)) {
+    const chainFiles = fs7.readdirSync(chainsDir).filter((f) => f.endsWith(".yaml"));
+    for (const file of chainFiles) {
+      try {
+        const content = fs7.readFileSync(path8.join(chainsDir, file), "utf8");
+        const chain = yaml6.load(content);
+        if (chain && chain.id) {
+          const orderIds = chain.order.map((o) => o.persona);
+          let totalSteps = 0;
+          const totalGates = /* @__PURE__ */ new Set();
+          for (const pid of orderIds) {
+            const entry = entries[pid];
+            if (entry) {
+              totalSteps += entry.steps;
+              for (const g of entry.gates) totalGates.add(g);
+            }
+          }
+          chains[chain.id] = {
+            description: chain.description || "",
+            order: orderIds,
+            total_steps: totalSteps,
+            total_gates: totalGates.size
+          };
+        }
+      } catch {
+      }
+    }
+  }
+  const index = {
+    version: "1.0",
+    generated: (/* @__PURE__ */ new Date()).toISOString(),
+    personas: entries,
+    chains,
+    gate_coverage: gateCoverage,
+    route_coverage: routeCoverage,
+    uncovered_routes: uncoveredRoutes
+  };
+  fs7.writeFileSync(
+    path8.join(personasDir, INDEX_FILE),
+    yaml6.dump(index, { indent: 2, lineWidth: 120, noRefs: true, sortKeys: false })
+  );
+  return index;
+}
+async function getPersonaCoverage(rootDir) {
+  const personas = await loadPersonas(rootDir);
+  const allGatesUsed = /* @__PURE__ */ new Set();
+  const allRoutesUsed = /* @__PURE__ */ new Set();
+  const allFlowsUsed = /* @__PURE__ */ new Set();
+  for (const p of personas) {
+    for (const step of p.journey) {
+      for (const gate of step.gates) allGatesUsed.add(gate);
+      allRoutesUsed.add(step.route);
+      if (step.flow) allFlowsUsed.add(step.flow);
+    }
+  }
+  let portalGates = [];
+  let portalRoutes = [];
+  const portalPath = path8.join(rootDir, "portal.yaml");
+  if (fs7.existsSync(portalPath)) {
+    try {
+      const portal = yaml6.load(fs7.readFileSync(portalPath, "utf8"));
+      if (portal.gates && typeof portal.gates === "object") portalGates = Object.keys(portal.gates);
+      if (portal.routes && typeof portal.routes === "object") portalRoutes = Object.keys(portal.routes);
+    } catch {
+    }
+  }
+  let allFlows = [];
+  const flowIndexPath = path8.join(rootDir, ".paradigm", "flow-index.json");
+  if (fs7.existsSync(flowIndexPath)) {
+    try {
+      const flowIndex = JSON.parse(fs7.readFileSync(flowIndexPath, "utf8"));
+      allFlows = Object.keys(flowIndex.flows || {});
+    } catch {
+    }
+  }
+  return {
+    routes: {
+      covered: allRoutesUsed.size,
+      total: portalRoutes.length,
+      uncovered: portalRoutes.filter(
+        (r) => !Array.from(allRoutesUsed).some((sr) => routeMatches(r, sr))
+      )
+    },
+    gates: {
+      covered: allGatesUsed.size,
+      total: portalGates.length,
+      uncovered: portalGates.filter((g) => !allGatesUsed.has(g))
+    },
+    flows: {
+      covered: allFlowsUsed.size,
+      total: allFlows.length,
+      uncovered: allFlows.filter((f) => !allFlowsUsed.has(f))
+    },
+    personas: personas.length
+  };
+}
+async function getAffectedPersonas(rootDir, symbol) {
+  const personas = await loadPersonas(rootDir);
+  const results = [];
+  for (const p of personas) {
+    const affectedSteps = [];
+    const spawnsBlocked = [];
+    for (const step of p.journey) {
+      const matches = step.gates.includes(symbol) || step.flow === symbol || step.route === symbol || step.signals?.includes(symbol);
+      if (matches) {
+        affectedSteps.push(step.id);
+        if (step.spawns) {
+          for (const spawn of step.spawns) {
+            spawnsBlocked.push(spawn.persona);
+          }
+        }
+      }
+    }
+    if (affectedSteps.length > 0) {
+      results.push({ persona: p.id, steps: affectedSteps, spawns_blocked: spawnsBlocked });
+    }
+  }
+  return results;
+}
+function deepGet(obj, path10) {
+  const parts = path10.split(/[.\[\]]+/).filter(Boolean);
+  let current = obj;
+  for (const part of parts) {
+    if (current == null || typeof current !== "object") return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function assertStep(step, event) {
+  const assertions = [];
+  if (event.status !== step.expect.status) {
+    assertions.push({
+      type: "status",
+      field: "status",
+      expected: step.expect.status,
+      actual: event.status,
+      message: `Step ${step.id}: status is ${event.status}, expected ${step.expect.status}`
+    });
+  }
+  if (step.expect.body?.has) {
+    const body = event.body;
+    for (const key of step.expect.body.has) {
+      if (!body || typeof body !== "object" || !(key in body)) {
+        assertions.push({
+          type: "body.has",
+          field: key,
+          expected: true,
+          actual: false,
+          message: `Step ${step.id}: body missing key '${key}'`
+        });
+      }
+    }
+  }
+  if (step.expect.body?.match) {
+    const body = event.body;
+    for (const [field, expected] of Object.entries(step.expect.body.match)) {
+      const actual = body ? deepGet(body, field) : void 0;
+      if (JSON.stringify(actual) !== JSON.stringify(expected)) {
+        assertions.push({
+          type: "body.match",
+          field,
+          expected,
+          actual: actual ?? null,
+          message: `Step ${step.id}: '${field}' is ${JSON.stringify(actual ?? null)}, expected ${JSON.stringify(expected)}`
+        });
+      }
+    }
+  }
+  if (step.signals && step.signals.length > 0) {
+    const firedSignals = event.signals_fired || [];
+    for (const signal of step.signals) {
+      if (!firedSignals.includes(signal)) {
+        assertions.push({
+          type: "signal",
+          field: "signals_fired",
+          expected: signal,
+          actual: firedSignals,
+          message: `Step ${step.id}: signal '${signal}' was not fired`
+        });
+      }
+    }
+  }
+  if (step.gates.length > 0 && event.gates_traversed) {
+    for (const gate of step.gates) {
+      if (!event.gates_traversed.includes(gate)) {
+        assertions.push({
+          type: "gate",
+          field: "gates_traversed",
+          expected: gate,
+          actual: event.gates_traversed,
+          message: `Step ${step.id}: gate '${gate}' was not traversed`
+        });
+      }
+    }
+  }
+  return assertions;
+}
+async function validateAgainstSentinel(persona, options = {}) {
+  const steps = [];
+  try {
+    const { SentinelStorage } = await import("./dist-YB7T54QE.js");
+    const storage = new SentinelStorage();
+    const events = storage.queryEvents?.({
+      schemaId: "paradigm-personas",
+      eventType: "persona.step.complete",
+      scopeValue: persona.id,
+      limit: 500
+    }) || [];
+    const filtered = events.filter((e) => {
+      const data = JSON.parse(e.data_json || "{}");
+      if (options.run_id && data.run_id !== options.run_id) return false;
+      if (options.chain_id && data.chain_id !== options.chain_id) return false;
+      if (options.environment && data.environment !== options.environment) return false;
+      return true;
+    });
+    const failEvents = storage.queryEvents?.({
+      schemaId: "paradigm-personas",
+      eventType: "persona.step.fail",
+      scopeValue: persona.id,
+      limit: 500
+    }) || [];
+    const filteredFails = failEvents.filter((e) => {
+      const data = JSON.parse(e.data_json || "{}");
+      if (options.run_id && data.run_id !== options.run_id) return false;
+      if (options.chain_id && data.chain_id !== options.chain_id) return false;
+      if (options.environment && data.environment !== options.environment) return false;
+      return true;
+    });
+    const eventMap = /* @__PURE__ */ new Map();
+    for (const e of [...filtered, ...filteredFails]) {
+      const data = JSON.parse(e.data_json || "{}");
+      if (data.step_id) {
+        eventMap.set(data.step_id, data);
+      }
+    }
+    for (const step of persona.journey) {
+      const eventData = eventMap.get(step.id);
+      if (!eventData) {
+        steps.push({
+          step_id: step.id,
+          matched: false,
+          assertions: [],
+          message: `No Sentinel event found for step '${step.id}' \u2014 step was never exercised`
+        });
+        continue;
+      }
+      const assertions = assertStep(step, {
+        status: eventData.status,
+        body: eventData.body,
+        gates_traversed: eventData.gates_traversed,
+        signals_fired: eventData.signals_fired
+      });
+      steps.push({
+        step_id: step.id,
+        matched: true,
+        passed: assertions.length === 0,
+        assertions
+      });
+    }
+  } catch {
+    for (const step of persona.journey) {
+      steps.push({
+        step_id: step.id,
+        matched: false,
+        assertions: [],
+        message: "Sentinel unavailable \u2014 cannot validate events"
+      });
+    }
+  }
+  const matched = steps.filter((s) => s.matched).length;
+  const passed = steps.filter((s) => s.passed).length;
+  const failed = steps.filter((s) => s.matched && !s.passed).length;
+  const totalAssertionFailures = steps.reduce((sum, s) => sum + s.assertions.length, 0);
+  return {
+    run_id: options.run_id,
+    environment: options.environment,
+    steps,
+    summary: {
+      total_steps: persona.journey.length,
+      matched,
+      unmatched: persona.journey.length - matched,
+      passed,
+      failed,
+      assertion_failures: totalAssertionFailures
+    }
+  };
+}
+
+// ../paradigm-mcp/src/tools/reindex.ts
+var SYMBOL_CATEGORIES = {
+  "@": { category: "features", prefix: "@" },
+  "#": { category: "components", prefix: "#" },
+  "^": { category: "gates", prefix: "^" },
+  "$": { category: "flows", prefix: "$" },
+  "&": { category: "integrations", prefix: "&" },
+  "!": { category: "signals", prefix: "!" },
+  "%": { category: "state", prefix: "%" }
+};
+var DIRECTORY_PATTERNS = {
+  features: ["src/features/", "features/", "app/", "src/app/", "src/modules/", "modules/"],
+  components: ["src/components/", "components/", "src/lib/", "lib/", "src/ui/", "ui/"],
+  gates: ["middleware/", "src/middleware/", "auth/", "src/auth/", "guards/", "src/guards/"],
+  flows: ["flows/", "src/flows/", "workflows/", "src/workflows/", "sagas/", "src/sagas/"],
+  integrations: ["integrations/", "src/integrations/", "external/", "src/external/", "vendors/"],
+  signals: ["events/", "src/events/", "handlers/", "src/handlers/"],
+  state: ["stores/", "src/stores/", "state/", "src/state/", "reducers/", "src/reducers/"]
+};
+var KEY_FILE_PATTERNS = {
+  config: [".paradigm/config.yaml", "package.json", "tsconfig.json", ".env.example"],
+  entry: ["src/index.ts", "src/index.tsx", "src/main.ts", "src/main.tsx", "index.ts", "main.ts", "src/app.ts", "src/app.tsx"],
+  types: ["src/types/", "types/", "src/types.ts", "types.ts"]
+};
+var DEFAULT_SKIP_PATTERNS = {
+  always: [
+    "node_modules/",
+    "dist/",
+    "build/",
+    ".git/",
+    ".next/",
+    ".nuxt/",
+    ".cache/",
+    "*.lock",
+    "*.log"
+  ],
+  unless_testing: [
+    "**/*.test.ts",
+    "**/*.test.tsx",
+    "**/*.spec.ts",
+    "**/*.spec.tsx",
+    "__tests__/",
+    "test/",
+    "tests/"
+  ],
+  unless_docs: ["docs/", "*.md", "README*", "CHANGELOG*"]
+};
+function getReindexToolsList() {
+  return [
+    {
+      name: "paradigm_reindex",
+      description: "Rebuild scan-index.json, navigator.yaml, and flow-index.json from .purpose files. Call after modifying paradigm files or at the end of a work session to ensure static index files are fresh. Returns counts of indexed symbols, files processed, and any errors. ~150 tokens.",
+      inputSchema: {
+        type: "object",
+        properties: {}
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true
+      }
+    }
+  ];
+}
+async function handleReindexTool(name, _args, ctx, reloadContext) {
+  if (name !== "paradigm_reindex") {
+    return { handled: false, text: "" };
+  }
+  try {
+    const result = await rebuildStaticFiles(ctx.rootDir, ctx);
+    await reloadContext();
+    toolCache.clear();
+    const text = JSON.stringify(result, null, 2);
+    trackToolCall(text.length, name);
+    return { handled: true, text };
+  } catch (err) {
+    const text = JSON.stringify({ error: err.message }, null, 2);
+    trackToolCall(text.length, name);
+    return { handled: true, text };
+  }
+}
+async function rebuildStaticFiles(rootDir, ctx) {
+  const filesWritten = [];
+  let aggregation;
+  if (ctx) {
+    aggregation = ctx.aggregation;
+  } else {
+    aggregation = await aggregateFromDirectory(rootDir);
+  }
+  const projectName = ctx?.projectName || path9.basename(rootDir);
+  const paradigmDir = path9.join(rootDir, ".paradigm");
+  if (!fs8.existsSync(paradigmDir)) {
+    fs8.mkdirSync(paradigmDir, { recursive: true });
+  }
+  const scanIndex = generateScanIndex(
+    {
+      symbols: aggregation.symbols,
+      purposeFiles: aggregation.purposeFiles,
+      portalFiles: aggregation.portalFiles
+    },
+    { projectName }
+  );
+  const scanIndexPath = path9.join(paradigmDir, "scan-index.json");
+  fs8.writeFileSync(scanIndexPath, serializeScanIndex(scanIndex), "utf8");
+  filesWritten.push(".paradigm/scan-index.json");
+  const navigatorData = buildNavigatorData(rootDir, aggregation);
+  const navigatorPath = path9.join(paradigmDir, "navigator.yaml");
+  fs8.writeFileSync(
+    navigatorPath,
+    yaml7.dump(navigatorData, { indent: 2, lineWidth: 120, noRefs: true, sortKeys: false }),
+    "utf8"
+  );
+  filesWritten.push(".paradigm/navigator.yaml");
+  const flowIndex = generateFlowIndex(rootDir, aggregation.purposeFiles);
+  let flowCount = 0;
+  if (flowIndex && Object.keys(flowIndex.flows).length > 0) {
+    const flowIndexPath = path9.join(paradigmDir, "flow-index.json");
+    fs8.writeFileSync(flowIndexPath, JSON.stringify(flowIndex, null, 2), "utf8");
+    filesWritten.push(".paradigm/flow-index.json");
+    flowCount = Object.keys(flowIndex.flows).length;
+  }
+  let aspectGraphStats;
+  try {
+    const db = await openAspectGraph(rootDir);
+    materializeAspects(db, aggregation.symbols, rootDir);
+    const loreLinks = await materializeLoreLinks(db, rootDir);
+    const inferredEdges = await inferLoreEdges(db, rootDir);
+    const aspectCount = db.exec("SELECT COUNT(*) FROM aspects")[0]?.values[0]?.[0] ?? 0;
+    const anchorCount = db.exec("SELECT COUNT(*) FROM anchors")[0]?.values[0]?.[0] ?? 0;
+    const edgeCount = db.exec("SELECT COUNT(*) FROM edges")[0]?.values[0]?.[0] ?? 0;
+    closeAspectGraph(db, rootDir);
+    filesWritten.push(".paradigm/aspect-graph.db");
+    aspectGraphStats = {
+      aspects: aspectCount,
+      anchors: anchorCount,
+      edges: edgeCount,
+      loreLinks
+    };
+  } catch {
+  }
+  let personaCount = 0;
+  try {
+    const personaIndex = await rebuildPersonaIndex(rootDir);
+    personaCount = Object.keys(personaIndex.personas).length;
+    if (personaCount > 0) {
+      filesWritten.push(".paradigm/personas/index.yaml");
+    }
+  } catch {
+  }
+  const breakdown = {};
+  for (const sym of aggregation.symbols) {
+    breakdown[sym.type] = (breakdown[sym.type] || 0) + 1;
+  }
+  return {
+    action: "reindex",
+    filesWritten,
+    symbolCount: aggregation.symbols.length,
+    breakdown,
+    flowCount,
+    aspectGraphStats,
+    personaCount
+  };
+}
+function buildNavigatorData(rootDir, aggregation) {
+  return {
+    version: "1.0",
+    generated: (/* @__PURE__ */ new Date()).toISOString(),
+    structure: buildStructure(rootDir),
+    key_files: buildKeyFiles(rootDir),
+    skip_patterns: buildSkipPatterns(rootDir),
+    symbols: buildSymbolMap(aggregation.symbols, aggregation.purposeFiles, rootDir)
+  };
+}
+function buildStructure(rootDir) {
+  const structure = {};
+  for (const [category, patterns] of Object.entries(DIRECTORY_PATTERNS)) {
+    const existingPaths = patterns.filter((p) => fs8.existsSync(path9.join(rootDir, p)));
+    if (existingPaths.length > 0) {
+      const symbolInfo = Object.values(SYMBOL_CATEGORIES).find((s) => s.category === category);
+      structure[category] = { paths: existingPaths, symbol: symbolInfo?.prefix || "@" };
+    }
+  }
+  return structure;
+}
+function buildKeyFiles(rootDir) {
+  const keyFiles = {};
+  for (const [category, patterns] of Object.entries(KEY_FILE_PATTERNS)) {
+    const existingPaths = patterns.filter((p) => fs8.existsSync(path9.join(rootDir, p)));
+    if (existingPaths.length > 0) {
+      keyFiles[category] = existingPaths;
+    }
+  }
+  if (!keyFiles.config) keyFiles.config = [];
+  if (!keyFiles.entry) keyFiles.entry = [];
+  if (!keyFiles.types) keyFiles.types = [];
+  return keyFiles;
+}
+function buildSkipPatterns(rootDir) {
+  const patterns = {
+    always: [...DEFAULT_SKIP_PATTERNS.always],
+    unless_testing: [...DEFAULT_SKIP_PATTERNS.unless_testing],
+    unless_docs: [...DEFAULT_SKIP_PATTERNS.unless_docs]
+  };
+  const gitignorePath = path9.join(rootDir, ".gitignore");
+  if (fs8.existsSync(gitignorePath)) {
+    try {
+      const content = fs8.readFileSync(gitignorePath, "utf8");
+      const gitignorePatterns = content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#")).filter(
+        (line) => line.endsWith("/") || line.includes("*") || ["node_modules", "dist", "build", ".cache"].some((p) => line.includes(p))
+      ).slice(0, 20);
+      for (const pattern of gitignorePatterns) {
+        if (!patterns.always.includes(pattern)) {
+          patterns.always.push(pattern);
+        }
+      }
+    } catch {
+    }
+  }
+  return patterns;
+}
+function getSymbolPrefix(type) {
+  switch (type) {
+    case "feature":
+      return "@";
+    case "component":
+      return "#";
+    case "gate":
+      return "^";
+    case "flow":
+      return "$";
+    case "integration":
+      return "&";
+    case "signal":
+      return "!";
+    case "state":
+      return "%";
+    case "idea":
+      return "?";
+    case "deprecated":
+      return "~";
+    case "aspect":
+      return "~";
+    default:
+      return "@";
+  }
+}
+function buildSymbolMap(symbols, purposeFiles, _rootDir) {
+  const symbolMap = {};
+  for (const symbol of symbols) {
+    const prefix = getSymbolPrefix(symbol.type);
+    const symbolId = `${prefix}${symbol.id}`;
+    if (symbol.filePath) {
+      symbolMap[symbolId] = symbol.filePath;
+    } else {
+      const matchingPurpose = purposeFiles.find((pf) => {
+        const dir = path9.dirname(pf);
+        return dir.toLowerCase().includes(symbol.id.toLowerCase());
+      });
+      if (matchingPurpose) {
+        symbolMap[symbolId] = path9.dirname(matchingPurpose) + "/";
+      }
+    }
+  }
+  return symbolMap;
+}
+function generateFlowIndex(rootDir, purposeFiles) {
+  const flows = {};
+  const symbolToFlows = {};
+  for (const filePath of purposeFiles) {
+    try {
+      const content = fs8.readFileSync(filePath, "utf8");
+      const data = yaml7.load(content);
+      if (!data?.flows) continue;
+      if (Array.isArray(data.flows)) {
+        for (const flowItem of data.flows) {
+          const flow = flowItem;
+          if (!flow.name) continue;
+          const flowId = `$${flow.name}`;
+          const steps = parseFlowSteps(flow.steps);
+          if (steps.length > 0) {
+            flows[flowId] = {
+              id: flowId,
+              description: flow.description || "",
+              steps,
+              definedIn: path9.relative(rootDir, filePath)
+            };
+            indexFlowSymbols(flowId, steps, symbolToFlows);
+          }
+        }
+      } else {
+        for (const [name, flowDef] of Object.entries(data.flows)) {
+          const flowId = name.startsWith("$") ? name : `$${name}`;
+          const steps = parseFlowSteps(flowDef.steps);
+          if (steps.length > 0) {
+            flows[flowId] = {
+              id: flowId,
+              description: flowDef.description || "",
+              trigger: flowDef.trigger,
+              steps,
+              validation: flowDef.validation,
+              definedIn: path9.relative(rootDir, filePath)
+            };
+            indexFlowSymbols(flowId, steps, symbolToFlows);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  if (Object.keys(flows).length === 0) {
+    return null;
+  }
+  return {
+    version: "1.0",
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    flows,
+    symbolToFlows
+  };
+}
+function parseFlowSteps(steps) {
+  if (!steps || !Array.isArray(steps)) return [];
+  const result = [];
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    if (typeof step === "object" && step !== null) {
+      const s = step;
+      const action = s.action || s.description || s.component || "";
+      if (action) {
+        result.push({
+          id: s.id || `step-${i + 1}`,
+          action,
+          symbol: s.symbol || s.component,
+          expect: s.expect
+        });
+      }
+    }
+  }
+  return result;
+}
+function indexFlowSymbols(flowId, steps, symbolToFlows) {
+  for (const step of steps) {
+    if (step.symbol) {
+      if (!symbolToFlows[step.symbol]) {
+        symbolToFlows[step.symbol] = [];
+      }
+      if (!symbolToFlows[step.symbol].includes(flowId)) {
+        symbolToFlows[step.symbol].push(flowId);
+      }
+    }
+  }
+}
+
+export {
+  parsePurposeFileDetailed,
+  serializePurposeFile,
+  findPurposeFiles,
+  validatePurposeFile,
+  parseGateConfig,
+  aggregateFromDirectory,
+  buildSymbolIndex,
+  getSymbol,
+  getSymbolsByType,
+  searchSymbols,
+  getReferencesTo,
+  getReferencesFrom,
+  getSymbolCounts,
+  getAllSymbols,
+  loadGlobalAntipatterns,
+  loadGlobalDecisions,
+  loadGlobalPreferences,
+  recordGlobalAntipattern,
+  recordGlobalDecision,
+  getSessionTracker,
+  trackToolCall,
+  trackResourceRead,
+  addToolBreadcrumb,
+  getContextToolsList,
+  handleContextTool,
+  buildRecoveryPreamble,
+  toolCache,
+  openAspectGraph,
+  closeAspectGraph,
+  getAspect,
+  getAnchorsForAspect,
+  getEdgesFrom,
+  getEdgesTo,
+  getAllEdgesFor,
+  incrementHeatmap,
+  getHeatmap,
+  checkDrift,
+  loadLoreEntries,
+  loadLoreEntry,
+  loadLoreTimeline,
+  recordLoreEntry,
+  updateLoreEntry,
+  deleteLoreEntry,
+  getLoreForAspect,
+  loadPersonas,
+  loadPersona,
+  createPersona,
+  updatePersona,
+  deletePersona,
+  addStep,
+  removeStep,
+  validatePersona,
+  getPersonaCoverage,
+  getAffectedPersonas,
+  validateAgainstSentinel,
+  getReindexToolsList,
+  handleReindexTool,
+  rebuildStaticFiles
+};