@a-company/paradigm 3.46.0 → 5.4.0

package/dist/{platform-server-H7Y6Q7O4.js → platform-server-2D6S6YTK.js}

@@ -8,13 +8,13 @@ import {
   createGraphsRouter,
   createSymbolsRouter
 } from "./chunk-F3BCHPYT.js";
-import "./chunk-ZXMDA7VB.js";
+import "./chunk-PDX44BCA.js";
 
 // src/platform-server/index.ts
 import express from "express";
 import * as http from "http";
-import * as path2 from "path";
-import * as fs2 from "fs";
+import * as path4 from "path";
+import * as fs4 from "fs";
 import { fileURLToPath } from "url";
 import chalk from "chalk";
 
@@ -716,9 +716,390 @@ function createGitRouter(projectDir) {
   return router;
 }
 
+// src/platform-server/routes/ambient.ts
+import { Router as Router3 } from "express";
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as yaml2 from "js-yaml";
+function readJsonlSafe(filePath) {
+  if (!fs2.existsSync(filePath)) return [];
+  try {
+    const content = fs2.readFileSync(filePath, "utf-8");
+    const lines = content.split("\n").filter((l) => l.trim());
+    const results = [];
+    for (const line of lines) {
+      try {
+        results.push(JSON.parse(line));
+      } catch {
+      }
+    }
+    return results;
+  } catch {
+    return [];
+  }
+}
+function writeJsonl(filePath, items) {
+  const dir = path2.dirname(filePath);
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
+  }
+  const content = items.map((item) => JSON.stringify(item)).join("\n") + "\n";
+  fs2.writeFileSync(filePath, content, "utf-8");
+}
+function parseSince(since) {
+  const match = since.match(/^(\d+)(m|h|d)$/);
+  if (!match) return null;
+  const value = parseInt(match[1], 10);
+  const unit = match[2];
+  const now = Date.now();
+  switch (unit) {
+    case "m":
+      return new Date(now - value * 60 * 1e3);
+    case "h":
+      return new Date(now - value * 60 * 60 * 1e3);
+    case "d":
+      return new Date(now - value * 24 * 60 * 60 * 1e3);
+    default:
+      return null;
+  }
+}
+function createAmbientRouter(projectDir, wsContext) {
+  const router = Router3();
+  const eventsPath = path2.join(projectDir, ".paradigm", "events", "stream.jsonl");
+  const nominationsPath = path2.join(projectDir, ".paradigm", "events", "nominations.jsonl");
+  const debatesPath = path2.join(projectDir, ".paradigm", "events", "debates.jsonl");
+  const policyPath = path2.join(projectDir, ".paradigm", "data-policy.yaml");
+  router.get("/events", (req, res) => {
+    try {
+      const {
+        type: typeFilter,
+        source: sourceFilter,
+        symbol: symbolFilter,
+        agent: agentFilter,
+        since: sinceParam,
+        limit: limitParam
+      } = req.query;
+      const limit = limitParam ? parseInt(limitParam, 10) : 50;
+      const sinceDate = sinceParam ? parseSince(sinceParam) : null;
+      let events = readJsonlSafe(eventsPath);
+      if (typeFilter) {
+        events = events.filter((e) => e.type === typeFilter);
+      }
+      if (sourceFilter) {
+        events = events.filter((e) => e.source === sourceFilter);
+      }
+      if (symbolFilter) {
+        events = events.filter((e) => e.symbol === symbolFilter);
+      }
+      if (agentFilter) {
+        events = events.filter((e) => e.agent === agentFilter);
+      }
+      if (sinceDate) {
+        events = events.filter((e) => {
+          if (!e.timestamp) return false;
+          return new Date(e.timestamp).getTime() >= sinceDate.getTime();
+        });
+      }
+      const result = events.slice(-limit);
+      wsContext.broadcast({ type: "ambient:event", action: "query", count: result.length });
+      res.json(result);
+    } catch (err) {
+      res.status(500).json({ error: "Failed to query events", detail: String(err) });
+    }
+  });
+  router.get("/nominations", (req, res) => {
+    try {
+      const {
+        agent: agentFilter,
+        urgency: urgencyFilter,
+        pending_only: pendingOnlyParam,
+        include_debates: includeDebatesParam,
+        limit: limitParam
+      } = req.query;
+      const limit = limitParam ? parseInt(limitParam, 10) : 20;
+      const pendingOnly = pendingOnlyParam !== "false";
+      const includeDebates = includeDebatesParam === "true";
+      let nominations = readJsonlSafe(nominationsPath);
+      if (agentFilter) {
+        nominations = nominations.filter((n) => n.agent === agentFilter);
+      }
+      if (urgencyFilter) {
+        nominations = nominations.filter((n) => n.urgency === urgencyFilter);
+      }
+      if (pendingOnly) {
+        nominations = nominations.filter((n) => !n.engaged);
+      }
+      nominations = nominations.slice(-limit);
+      let debateMap;
+      if (includeDebates) {
+        const debates = readJsonlSafe(debatesPath);
+        debateMap = /* @__PURE__ */ new Map();
+        for (const debate of debates) {
+          if (debate.nominationId) {
+            const existing = debateMap.get(debate.nominationId) || [];
+            existing.push(debate);
+            debateMap.set(debate.nominationId, existing);
+          }
+        }
+      }
+      const result = nominations.map((n) => {
+        const entry = { ...n };
+        if (includeDebates && debateMap && n.id) {
+          entry.debates = debateMap.get(n.id) || [];
+        }
+        return entry;
+      });
+      res.json(result);
+    } catch (err) {
+      res.status(500).json({ error: "Failed to query nominations", detail: String(err) });
+    }
+  });
+  router.post("/nominations/:id/engage", (req, res) => {
+    try {
+      const { id } = req.params;
+      const { response } = req.body;
+      if (!response || !["accepted", "dismissed", "deferred"].includes(response)) {
+        res.status(400).json({ error: "response must be one of: accepted, dismissed, deferred" });
+        return;
+      }
+      const nominations = readJsonlSafe(nominationsPath);
+      const index = nominations.findIndex((n) => n.id === id);
+      if (index === -1) {
+        res.status(404).json({ error: `Nomination not found: ${id}` });
+        return;
+      }
+      nominations[index] = {
+        ...nominations[index],
+        engaged: true,
+        response
+      };
+      writeJsonl(nominationsPath, nominations);
+      wsContext.broadcast({
+        type: "ambient:nomination",
+        action: "engaged",
+        nominationId: id,
+        response
+      });
+      res.json(nominations[index]);
+    } catch (err) {
+      res.status(500).json({ error: "Failed to engage nomination", detail: String(err) });
+    }
+  });
+  router.get("/stream", (req, res) => {
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+    res.flushHeaders();
+    let lastSize = 0;
+    try {
+      const stat = fs2.statSync(eventsPath);
+      lastSize = stat.size;
+    } catch {
+    }
+    const pollInterval = 1e3;
+    const watcher = setInterval(() => {
+      try {
+        if (!fs2.existsSync(eventsPath)) return;
+        const stat = fs2.statSync(eventsPath);
+        if (stat.size <= lastSize) {
+          if (stat.size < lastSize) lastSize = 0;
+          else return;
+        }
+        const fd = fs2.openSync(eventsPath, "r");
+        const buffer = Buffer.alloc(stat.size - lastSize);
+        fs2.readSync(fd, buffer, 0, buffer.length, lastSize);
+        fs2.closeSync(fd);
+        lastSize = stat.size;
+        const newContent = buffer.toString("utf-8");
+        const lines = newContent.split("\n").filter((l) => l.trim());
+        for (const line of lines) {
+          try {
+            const event = JSON.parse(line);
+            res.write(`data: ${JSON.stringify(event)}
+
+`);
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }, pollInterval);
+    res.write(": connected\n\n");
+    req.on("close", () => {
+      clearInterval(watcher);
+    });
+  });
+  router.get("/policy", (_req, res) => {
+    try {
+      if (fs2.existsSync(policyPath)) {
+        const content = fs2.readFileSync(policyPath, "utf-8");
+        const policy = yaml2.load(content);
+        res.json(policy);
+      } else {
+        res.json({
+          version: "1.0",
+          retention: { events: "30d", nominations: "90d", debates: "90d" },
+          collection: { telemetry: false, usage: false },
+          sharing: { external: false }
+        });
+      }
+    } catch (err) {
+      res.status(500).json({ error: "Failed to read data policy", detail: String(err) });
+    }
+  });
+  return router;
+}
+
+// src/platform-server/routes/team.ts
+import { Router as Router4 } from "express";
+import * as fs3 from "fs";
+import * as path3 from "path";
+import * as os from "os";
+import * as yaml3 from "js-yaml";
+function readJsonl(filePath) {
+  if (!fs3.existsSync(filePath)) return [];
+  try {
+    return fs3.readFileSync(filePath, "utf-8").trim().split("\n").filter((line) => line.trim()).map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    }).filter((v) => v !== null);
+  } catch {
+    return [];
+  }
+}
+function loadAgentProfiles() {
+  const globalDir = path3.join(os.homedir(), ".paradigm", "agents");
+  const profiles = [];
+  if (!fs3.existsSync(globalDir)) return profiles;
+  for (const file of fs3.readdirSync(globalDir).filter((f) => f.endsWith(".agent"))) {
+    try {
+      const content = fs3.readFileSync(path3.join(globalDir, file), "utf-8");
+      const p = yaml3.load(content);
+      if (!p?.id) continue;
+      const expertise = p.expertise || [];
+      expertise.sort((a, b) => b.confidence - a.confidence);
+      profiles.push({
+        id: p.id,
+        role: p.role || p.id,
+        nickname: p.nickname,
+        benched: p.benched || false,
+        expertiseCount: expertise.length,
+        topExpertise: expertise.slice(0, 3).map((e) => ({
+          symbol: e.symbol,
+          confidence: parseFloat(e.confidence.toFixed(2))
+        })),
+        threshold: p.attention?.threshold
+      });
+    } catch {
+    }
+  }
+  return profiles;
+}
+function loadTeamThreads() {
+  const mailDir = path3.join(os.homedir(), ".paradigm", "mail", "agents");
+  if (!fs3.existsSync(mailDir)) return [];
+  const allMessages = [];
+  try {
+    for (const agentDir of fs3.readdirSync(mailDir, { withFileTypes: true })) {
+      if (!agentDir.isDirectory()) continue;
+      const agentPath = path3.join(mailDir, agentDir.name);
+      for (const file of ["inbox.jsonl", "outbox.jsonl"]) {
+        const filePath = path3.join(agentPath, file);
+        const notes = readJsonl(filePath);
+        for (const note of notes) {
+          if (!note.threadRoot?.startsWith("thr-orch-")) continue;
+          if (allMessages.some((m) => m.id === note.id)) continue;
+          allMessages.push({
+            id: note.id,
+            threadRoot: note.threadRoot,
+            timestamp: note.timestamp,
+            sender: {
+              name: note.sender?.name || "unknown",
+              role: note.sender?.role,
+              project: note.sender?.project
+            },
+            intent: note.intent || "context",
+            text: note.content?.text || "",
+            symbols: note.symbols || [],
+            diff: note.content?.diff,
+            decision: note.content?.decision
+          });
+        }
+      }
+    }
+  } catch {
+  }
+  const threadMap = /* @__PURE__ */ new Map();
+  for (const msg of allMessages) {
+    const threadId = msg.threadRoot;
+    if (!threadMap.has(threadId)) threadMap.set(threadId, []);
+    threadMap.get(threadId).push(msg);
+  }
+  const threads = [];
+  for (const [threadId, messages] of threadMap) {
+    messages.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+    const stripped = threadId.replace("thr-orch-", "");
+    const parts = stripped.split("-");
+    const displayName = parts[0] ? `Team ${parts[0]}` : threadId;
+    threads.push({
+      id: threadId,
+      displayName,
+      messages,
+      lastActivity: messages[messages.length - 1]?.timestamp || ""
+    });
+  }
+  threads.sort((a, b) => b.lastActivity.localeCompare(a.lastActivity));
+  return threads;
+}
+function createTeamRouter(projectDir) {
+  const router = Router4();
+  router.get("/roster", (_req, res) => {
+    try {
+      const agents = loadAgentProfiles();
+      const active = agents.filter((a) => !a.benched);
+      const benched = agents.filter((a) => a.benched);
+      res.json({ active, benched, total: agents.length });
+    } catch (err) {
+      res.status(500).json({ error: "Failed to load roster", detail: String(err) });
+    }
+  });
+  router.get("/threads", (_req, res) => {
+    try {
+      const threads = loadTeamThreads();
+      res.json({ threads, count: threads.length });
+    } catch (err) {
+      res.status(500).json({ error: "Failed to load threads", detail: String(err) });
+    }
+  });
+  router.patch("/agents/:id/bench", (req, res) => {
+    try {
+      const { id } = req.params;
+      const { benched } = req.body;
+      const globalDir = path3.join(os.homedir(), ".paradigm", "agents");
+      const filePath = path3.join(globalDir, `${id}.agent`);
+      if (!fs3.existsSync(filePath)) {
+        res.status(404).json({ error: `Agent "${id}" not found` });
+        return;
+      }
+      const content = fs3.readFileSync(filePath, "utf-8");
+      const profile = yaml3.load(content);
+      profile.benched = benched;
+      profile.updated = (/* @__PURE__ */ new Date()).toISOString();
+      fs3.writeFileSync(filePath, yaml3.dump(profile, { lineWidth: 120, noRefs: true, sortKeys: false }), "utf-8");
+      res.json({ id, benched, updated: profile.updated });
+    } catch (err) {
+      res.status(500).json({ error: "Failed to update agent", detail: String(err) });
+    }
+  });
+  return router;
+}
+
 // src/platform-server/index.ts
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = path2.dirname(__filename);
+var __dirname = path4.dirname(__filename);
 var log = {
   component(name) {
     const symbol = chalk.magenta(`#${name}`);
@@ -743,8 +1124,8 @@ var log = {
   }
 };
 function resolveSections(options) {
-  const always = ["overview", "lore", "graph", "git"];
-  const requested = options.sections ?? [...always, "sentinel", "university", "symphony"];
+  const always = ["overview", "lore", "graph", "git", "ambient", "team"];
+  const requested = options.sections ?? [...always, "sentinel", "university", "symphony", "docs"];
   const enabled = /* @__PURE__ */ new Set();
   for (const section of requested) {
     if (always.includes(section)) {
@@ -752,15 +1133,15 @@ function resolveSections(options) {
       continue;
     }
     if (section === "sentinel") {
-      const sentinelRoutesPath = path2.join(options.projectDir, ".paradigm");
-      if (fs2.existsSync(sentinelRoutesPath)) {
+      const sentinelRoutesPath = path4.join(options.projectDir, ".paradigm");
+      if (fs4.existsSync(sentinelRoutesPath)) {
         enabled.add(section);
       }
     } else if (section === "university") {
       enabled.add(section);
     } else if (section === "symphony") {
-      const mailDir = path2.join(process.env.HOME || "~", ".paradigm", "score");
-      if (fs2.existsSync(mailDir)) {
+      const mailDir = path4.join(process.env.HOME || "~", ".paradigm", "score");
+      if (fs4.existsSync(mailDir)) {
         enabled.add(section);
       }
     } else {
@@ -804,15 +1185,17 @@ function createPlatformApp(options) {
     res.json({ status: "ok", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
   });
   app.set("agentRouterSlot", true);
-  let uiDistPath = path2.join(__dirname, "..", "platform-ui", "dist");
-  if (!fs2.existsSync(uiDistPath)) {
-    uiDistPath = path2.join(__dirname, "..", "..", "platform-ui", "dist");
+  let uiDistPath = path4.join(__dirname, "..", "platform-ui", "dist");
+  if (!fs4.existsSync(uiDistPath)) {
+    uiDistPath = path4.join(__dirname, "..", "..", "platform-ui", "dist");
   }
-  if (fs2.existsSync(uiDistPath)) {
+  if (fs4.existsSync(uiDistPath)) {
     app.use(express.static(uiDistPath));
-    app.get("{*path}", (req, res) => {
+    app.get("{*path}", (req, res, next) => {
       if (!req.path.startsWith("/api")) {
-        res.sendFile(path2.join(uiDistPath, "index.html"));
+        res.sendFile(path4.join(uiDistPath, "index.html"));
+      } else {
+        next();
       }
     });
   } else {
@@ -843,9 +1226,11 @@ async function startPlatformServer(options) {
   const httpServer = http.createServer(app);
   const wsContext = attachWebSocket(httpServer);
   app.use("/api/platform/agent-command", createAgentRouter(wsContext));
+  app.use("/api/ambient", createAmbientRouter(options.projectDir, wsContext));
+  app.use("/api/team", createTeamRouter(options.projectDir));
   if (sections.has("sentinel")) {
     try {
-      const { createSentinelBridge } = await import("./sentinel-bridge-APDXYAZS.js");
+      const { createSentinelBridge } = await import("./sentinel-bridge-MDUXTQRL.js");
       const sentinelRouter = await createSentinelBridge(options.projectDir, wsContext.broadcast);
       if (sentinelRouter) {
         app.use("/api/sentinel", sentinelRouter);
@@ -857,13 +1242,22 @@ async function startPlatformServer(options) {
   }
   if (sections.has("symphony")) {
     try {
-      const { createSymphonyRouter } = await import("./symphony-YCHBYN3E.js");
+      const { createSymphonyRouter } = await import("./symphony-B75X2MME.js");
       app.use("/api/symphony", createSymphonyRouter(options.projectDir, wsContext.broadcast));
       log.component("platform-server").success("Symphony routes mounted");
     } catch (err) {
       log.component("platform-server").warn("Symphony routes failed to mount");
     }
   }
+  if (sections.has("docs")) {
+    try {
+      const { createDocsRouter } = await import("./docs-PBZB7LYP.js");
+      app.use("/api/docs", createDocsRouter(options.projectDir));
+      log.component("platform-server").success("Docs routes mounted");
+    } catch (err) {
+      log.component("platform-server").warn("Docs routes failed to mount");
+    }
+  }
   return new Promise((resolve, reject) => {
     httpServer.listen(options.port, () => {
       log.component("platform-server").success("Platform running", { url: `http://localhost:${options.port}` });

package/dist/{plugin-update-checker-HMRPGY5Z.js → plugin-update-checker-ELOEEQYS.js}

@@ -4,6 +4,7 @@ import {
   runPluginUpdateCheck,
   schedulePluginUpdateCheck
 } from "./chunk-MP73YDXF.js";
+import "./chunk-7N7GSU6K.js";
 export {
   getPluginUpdateNotice,
   runPluginUpdateCheck,

package/dist/{portal-check-FF5EKZE5.js → portal-check-NPYGII2D.js}

@@ -2,8 +2,8 @@
 import {
   checkPortalCompliance,
   formatComplianceReport
-} from "./chunk-MW5DMGBB.js";
-import "./chunk-ZXMDA7VB.js";
+} from "./chunk-YMDLDELF.js";
+import "./chunk-PDX44BCA.js";
 
 // src/commands/portal-check.ts
 import chalk from "chalk";

package/dist/{portal-compliance-VU4NIFEN.js → portal-compliance-J7DGAPFX.js}

@@ -6,8 +6,8 @@ import {
   formatComplianceReport,
   getComplianceSummary,
   loadPortalConfig
-} from "./chunk-MW5DMGBB.js";
-import "./chunk-ZXMDA7VB.js";
+} from "./chunk-YMDLDELF.js";
+import "./chunk-PDX44BCA.js";
 export {
   checkPortalCompliance,
   extractDeclaredGates,

package/dist/{probe-7JK7IDNI.js → probe-MHL5HQZ2.js}

@@ -2,7 +2,7 @@
 import {
   generateFlowIndex,
   generateNavigator
-} from "./chunk-7COU5S2Z.js";
+} from "./chunk-VL67H5IC.js";
 import {
   generateScanIndex,
   serializeScanIndex
@@ -12,11 +12,11 @@ import {
 } from "./chunk-ZGUAAVMA.js";
 import "./chunk-EDOAWN7J.js";
 import "./chunk-IRKUEJVW.js";
-import "./chunk-QDXI2DHR.js";
+import "./chunk-J2JEQRT3.js";
 import {
   parseParadigmConfig
 } from "./chunk-YO6DVTL7.js";
-import "./chunk-ZXMDA7VB.js";
+import "./chunk-PDX44BCA.js";
 
 // src/commands/probe/index.ts
 import * as fs from "fs";

package/dist/{promote-XO63XMAN.js → promote-F6ZYZZAL.js}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import "./chunk-ZXMDA7VB.js";
+import "./chunk-PDX44BCA.js";
 
 // src/commands/promote.ts
 import * as fs from "fs";
@@ -138,7 +138,7 @@ ${err instanceof Error ? err.message : err}
   }
   spinner.start("Switching MCP configs to PROD...");
   try {
-    const { mcpUseProdCommand } = await import("./switch-WYUMVNA5.js");
+    const { mcpUseProdCommand } = await import("./switch-6EJPZDIA.js");
     await mcpUseProdCommand({ json: true });
     spinner.succeed("MCP configs switched to PROD");
   } catch {

package/dist/{providers-YNFSL6HK.js → providers-GK7PB2OL.js}

@@ -4,8 +4,8 @@ import {
   getBestProvider,
   getConfiguredProvider,
   setConfiguredProvider
-} from "./chunk-FS3WTUHY.js";
-import "./chunk-ZXMDA7VB.js";
+} from "./chunk-TXESEO7Y.js";
+import "./chunk-PDX44BCA.js";
 
 // src/commands/team/providers.ts
 import * as path from "path";

package/dist/{quiz-I75NU2QQ.js → quiz-M66SC7F7.js}

@@ -3,7 +3,7 @@ import {
   loadQuiz,
   saveDiploma
 } from "./chunk-GT5QGC2H.js";
-import "./chunk-ZXMDA7VB.js";
+import "./chunk-PDX44BCA.js";
 
 // src/commands/university/quiz.ts
 import chalk from "chalk";

package/dist/{record-46CLR4OG.js → record-RA4WR2BO.js}

@@ -2,8 +2,8 @@
 import {
   recordLore,
   resolveAuthor
-} from "./chunk-QIOCFXDQ.js";
-import "./chunk-ZXMDA7VB.js";
+} from "./chunk-EKGMAM62.js";
+import "./chunk-PDX44BCA.js";
 
 // src/commands/lore/record.ts
 import chalk from "chalk";

package/dist/{reindex-WIJMCJ4A.js → reindex-65H4WULU.js}

@@ -3,9 +3,10 @@ import {
   getReindexToolsList,
   handleReindexTool,
   rebuildStaticFiles
-} from "./chunk-ZMQA6SCO.js";
-import "./chunk-CDMAMDSG.js";
+} from "./chunk-7HRBT23N.js";
 import "./chunk-L27I3CPZ.js";
+import "./chunk-5VKJBNJL.js";
+import "./chunk-7N7GSU6K.js";
 export {
   getReindexToolsList,
   handleReindexTool,

package/dist/{remember-4EUZKIIB.js → remember-HBWJ655S.js}

@@ -3,7 +3,7 @@ import {
   aggregatePurposes,
   getAllPurposeFiles
 } from "./chunk-EDOAWN7J.js";
-import "./chunk-ZXMDA7VB.js";
+import "./chunk-PDX44BCA.js";
 
 // src/commands/purpose/remember.ts
 import * as path from "path";

package/dist/{retag-KC4JVRLE.js → retag-3OLCVDEQ.js}

@@ -2,8 +2,8 @@
 import {
   loadLoreEntries,
   updateLoreEntry
-} from "./chunk-QIOCFXDQ.js";
-import "./chunk-ZXMDA7VB.js";
+} from "./chunk-EKGMAM62.js";
+import "./chunk-PDX44BCA.js";
 
 // src/commands/lore/retag.ts
 import chalk from "chalk";

package/dist/{review-Q7M4CRB5.js → review-27ATYTD2.js}

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import {
   addReview
-} from "./chunk-QIOCFXDQ.js";
-import "./chunk-ZXMDA7VB.js";
+} from "./chunk-EKGMAM62.js";
+import "./chunk-PDX44BCA.js";
 
 // src/commands/lore/review.ts
 import chalk from "chalk";