@swarmvaultai/engine 0.7.31 → 0.9.0

package/dist/index.js

@@ -1,4 +1,5 @@
 import {
+  PRIMARY_SCHEMA_FILENAME,
   appendJsonLine,
   assertProviderCapability,
   createProvider,
@@ -22,7 +23,7 @@ import {
   uniqueBy,
   writeFileIfChanged,
   writeJsonFile
-} from "./chunk-NECZ4MUE.js";
+} from "./chunk-RSQRF4FV.js";
 import {
   estimatePageTokens,
   estimateTokens,
@@ -32,6 +33,7 @@ import {
 // src/agents.ts
 import crypto from "crypto";
 import fs from "fs/promises";
+import os from "os";
 import path from "path";
 import { fileURLToPath } from "url";
 import YAML from "yaml";
@@ -83,23 +85,128 @@ var agentFileKinds = {
   copilot: ".github/copilot-instructions.md",
   trae: ".trae/rules/swarmvault.md",
   claw: ".claw/skills/swarmvault/SKILL.md",
-  droid: ".factory/rules/swarmvault.md"
+  droid: ".factory/rules/swarmvault.md",
+  kiro: ".kiro/skills/swarmvault/SKILL.md",
+  kiroSteering: ".kiro/steering/swarmvault.md",
+  antigravityRules: ".agent/rules/swarmvault.md",
+  antigravityWorkflow: ".agent/workflows/swarmvault.md",
+  vscode: ".github/chatmodes/swarmvault.chatmode.md"
 };
+var hermesUserSkillRelative = path.join(".hermes", "skills", "swarmvault", "SKILL.md");
+function hermesUserSkillPath() {
+  return path.join(os.homedir(), hermesUserSkillRelative);
+}
+var SWARMVAULT_RULE_BULLETS = [
+  "- Read `swarmvault.schema.md` before compile or query style work. It is the canonical schema path.",
+  "- Treat `raw/` as immutable source input.",
+  "- Treat `wiki/` as generated markdown owned by the agent and compiler workflow.",
+  "- Read `wiki/graph/report.md` before broad file searching when it exists; otherwise start with `wiki/index.md`.",
+  "- For graph questions, prefer `swarmvault graph query`, `swarmvault graph path`, and `swarmvault graph explain` before broad grep/glob searching.",
+  "- Preserve frontmatter fields including `page_id`, `source_ids`, `node_ids`, `freshness`, and `source_hashes`.",
+  "- Save high-value answers back into `wiki/outputs/` instead of leaving them only in chat.",
+  "- Prefer `swarmvault ingest`, `swarmvault compile`, `swarmvault query`, and `swarmvault lint` for SwarmVault maintenance tasks."
+];
 function buildManagedBlock(target) {
   const heading = target === "aider" ? "# SwarmVault Conventions" : target === "copilot" ? "# SwarmVault Repository Instructions" : "# SwarmVault Rules";
+  return [managedStart, heading, "", ...SWARMVAULT_RULE_BULLETS, managedEnd, ""].join("\n");
+}
+function buildSkillFrontmatter() {
+  const frontmatter = YAML.stringify({
+    name: "swarmvault",
+    description: "SwarmVault graph-first workflow. Use to read the compiled wiki and query the knowledge graph before broad file search."
+  }).trimEnd();
+  return ["---", frontmatter, "---"].join("\n");
+}
+function buildSkillBody() {
+  return [
+    "# SwarmVault",
+    "",
+    "SwarmVault compiles curated sources in `raw/` into a queryable wiki in `wiki/` and a knowledge graph in `state/graph.json`.",
+    "",
+    "## Rules",
+    "",
+    ...SWARMVAULT_RULE_BULLETS,
+    "",
+    "## Entry points",
+    "",
+    "- `swarmvault ingest <path>` \u2014 register a new source",
+    "- `swarmvault compile` \u2014 refresh wiki pages and graph",
+    '- `swarmvault query "<question>"` \u2014 save-first multi-step query',
+    "- `swarmvault graph query|path|explain` \u2014 deterministic graph traversal",
+    "- `swarmvault lint` \u2014 wiki health and contradiction checks",
+    ""
+  ].join("\n");
+}
+function buildStandaloneSkillFile() {
+  return `${buildSkillFrontmatter()}
+
+${buildSkillBody()}`;
+}
+function buildKiroSteeringFile() {
+  const frontmatter = YAML.stringify({
+    inclusion: "always",
+    description: "Always-on SwarmVault rules."
+  }).trimEnd();
+  return ["---", frontmatter, "---", "", "# SwarmVault Rules", "", ...SWARMVAULT_RULE_BULLETS, ""].join("\n");
+}
+function buildAntigravityRulesFile() {
+  const frontmatter = YAML.stringify({
+    alwaysApply: true,
+    description: "SwarmVault graph-first repository rules."
+  }).trimEnd();
+  return [
+    "---",
+    frontmatter,
+    "---",
+    "",
+    "# SwarmVault Rules",
+    "",
+    ...SWARMVAULT_RULE_BULLETS,
+    "",
+    "> MCP navigation hint: SwarmVault exposes a local MCP server via `swarmvault mcp`. Wire it into your Antigravity MCP config to query the graph without shelling out."
+  ].join("\n");
+}
+function buildAntigravityWorkflowFile() {
+  const frontmatter = YAML.stringify({
+    command: "swarmvault",
+    description: "Compile, query, and lint the SwarmVault vault."
+  }).trimEnd();
   return [
-    managedStart,
-    heading,
+    "---",
+    frontmatter,
+    "---",
+    "",
+    "# /swarmvault",
+    "",
+    "Run SwarmVault against the current directory.",
+    "",
+    "## Steps",
+    "",
+    "1. If no vault exists, run `swarmvault init`.",
+    "2. For new sources, run `swarmvault ingest <path>`.",
+    "3. Run `swarmvault compile` to refresh the wiki and graph.",
+    "4. For follow-up questions, prefer `swarmvault query`, `swarmvault graph query`, `swarmvault graph path`, `swarmvault graph explain`.",
+    "5. Save high-value answers to `wiki/outputs/`.",
+    ""
+  ].join("\n");
+}
+function buildVscodeChatmodeFile() {
+  const frontmatter = YAML.stringify({
+    description: "SwarmVault graph-first workflow for VS Code Copilot Chat.",
+    tools: ["codebase", "terminal"]
+  }).trimEnd();
+  return [
+    "---",
+    frontmatter,
+    "---",
+    "",
+    "# SwarmVault mode",
+    "",
+    "You are working inside a SwarmVault vault. Follow these rules before other actions:",
+    "",
+    ...SWARMVAULT_RULE_BULLETS,
     "",
-    "- Read `swarmvault.schema.md` before compile or query style work. It is the canonical schema path.",
-    "- Treat `raw/` as immutable source input.",
-    "- Treat `wiki/` as generated markdown owned by the agent and compiler workflow.",
-    "- Read `wiki/graph/report.md` before broad file searching when it exists; otherwise start with `wiki/index.md`.",
-    "- For graph questions, prefer `swarmvault graph query`, `swarmvault graph path`, and `swarmvault graph explain` before broad grep/glob searching.",
-    "- Preserve frontmatter fields including `page_id`, `source_ids`, `node_ids`, `freshness`, and `source_hashes`.",
-    "- Save high-value answers back into `wiki/outputs/` instead of leaving them only in chat.",
-    "- Prefer `swarmvault ingest`, `swarmvault compile`, `swarmvault query`, and `swarmvault lint` for SwarmVault maintenance tasks.",
-    managedEnd,
+    "Use the terminal tool to run `swarmvault` commands. Prefer graph queries over broad grep/glob.",
     ""
   ].join("\n");
 }
@@ -136,6 +243,14 @@ function primaryTargetPathForAgent(rootDir, agent) {
       return path.join(rootDir, agentFileKinds.claw);
     case "droid":
       return path.join(rootDir, agentFileKinds.droid);
+    case "kiro":
+      return path.join(rootDir, agentFileKinds.kiro);
+    case "hermes":
+      return hermesUserSkillPath();
+    case "antigravity":
+      return path.join(rootDir, agentFileKinds.antigravityRules);
+    case "vscode":
+      return path.join(rootDir, agentFileKinds.vscode);
     default:
       throw new Error(`Unsupported agent ${String(agent)}`);
   }
@@ -174,6 +289,15 @@ function targetsForAgent(rootDir, agent, options = {}) {
   if (agent === "aider") {
     targets.push(path.join(rootDir, ".aider.conf.yml"));
   }
+  if (agent === "kiro") {
+    targets.push(path.join(rootDir, agentFileKinds.kiroSteering));
+  }
+  if (agent === "hermes") {
+    targets.push(path.join(rootDir, agentFileKinds.agents));
+  }
+  if (agent === "antigravity") {
+    targets.push(path.join(rootDir, agentFileKinds.antigravityWorkflow));
+  }
   if (options.hook && supportsAgentHook(agent)) {
     const configPath = hookConfigPathForAgent(rootDir, agent);
     const scriptPath = hookScriptPathForAgent(rootDir, agent);
@@ -409,6 +533,21 @@ async function installAgent(rootDir, agent, options = {}) {
     case "droid":
       await writeOwnedFile(target, buildManagedBlock("droid"));
       break;
+    case "kiro":
+      await writeOwnedFile(target, buildStandaloneSkillFile());
+      await writeOwnedFile(path.join(rootDir, agentFileKinds.kiroSteering), buildKiroSteeringFile());
+      break;
+    case "hermes":
+      await upsertManagedBlock(path.join(rootDir, agentFileKinds.agents), buildManagedBlock("agents"));
+      await writeOwnedFile(hermesUserSkillPath(), buildStandaloneSkillFile());
+      break;
+    case "antigravity":
+      await writeOwnedFile(target, buildAntigravityRulesFile());
+      await writeOwnedFile(path.join(rootDir, agentFileKinds.antigravityWorkflow), buildAntigravityWorkflowFile());
+      break;
+    case "vscode":
+      await writeOwnedFile(target, buildVscodeChatmodeFile());
+      break;
     default:
       throw new Error(`Unsupported agent ${String(agent)}`);
   }
@@ -2624,7 +2763,10 @@ async function pushGraphNeo4j(rootDir, options = {}) {
 
 // src/graph-tools.ts
 function normalizeTarget(value) {
-  return normalizeWhitespace(value).toLowerCase();
+  return normalizeWhitespace(value).normalize("NFKD").replace(/\p{Mn}+/gu, "").toLowerCase();
+}
+function computeNormLabel(label) {
+  return normalizeTarget(label);
 }
 function nodeById(graph) {
   return new Map(graph.nodes.map((node) => [node.id, node]));
@@ -8567,7 +8709,7 @@ async function analyzeCodeSource(manifest, extractedText, schemaHash) {
 
 // src/extraction.ts
 import fs7 from "fs/promises";
-import os from "os";
+import os2 from "os";
 import path7 from "path";
 import { Readable } from "stream";
 import { parse as parseCsvSync } from "csv-parse/sync";
@@ -8691,7 +8833,7 @@ async function materializeAttachmentPath(input) {
   if (!input.bytes) {
     throw new Error("Image extraction requires a file path or bytes.");
   }
-  const tempDir = await fs7.mkdtemp(path7.join(os.tmpdir(), "swarmvault-image-extract-"));
+  const tempDir = await fs7.mkdtemp(path7.join(os2.tmpdir(), "swarmvault-image-extract-"));
   const extension = input.mimeType.split("/")[1]?.split("+")[0] ?? "bin";
   const tempPath = path7.join(tempDir, `source.${extension}`);
   await fs7.writeFile(tempPath, input.bytes);
@@ -8773,6 +8915,27 @@ async function extractImageWithVision(rootDir, input) {
     await attachment.cleanup();
   }
 }
+async function buildCorpusHint(rootDir, maxTerms = 6) {
+  let graphPath;
+  try {
+    const { paths } = await loadVaultConfig(rootDir);
+    graphPath = paths.graphPath;
+  } catch {
+    return void 0;
+  }
+  if (!await fileExists(graphPath)) {
+    return void 0;
+  }
+  const graph = await readJsonFile(graphPath);
+  if (!graph || !Array.isArray(graph.nodes) || graph.nodes.length === 0) {
+    return void 0;
+  }
+  const top = graph.nodes.filter((node) => node.type !== "source" && Boolean(node.label)).sort((left, right) => (right.degree ?? 0) - (left.degree ?? 0)).slice(0, maxTerms).map((node) => node.label.trim()).filter((label) => label.length > 0);
+  if (top.length === 0) {
+    return void 0;
+  }
+  return `This audio is likely about ${top.join(", ")}.`;
+}
 async function extractAudioTranscription(rootDir, input) {
   let provider;
   try {
@@ -8793,11 +8956,13 @@ async function extractAudioTranscription(rootDir, input) {
       }
     };
   }
+  const corpusHint = input.corpusHint ?? await buildCorpusHint(rootDir);
   try {
     const result = await provider.transcribeAudio({
       mimeType: input.mimeType,
       bytes: input.bytes,
-      fileName: input.fileName
+      fileName: input.fileName,
+      corpusHint
     });
     const metadata = {};
     if (result.duration !== void 0) {
@@ -8806,6 +8971,9 @@ async function extractAudioTranscription(rootDir, input) {
     if (result.language) {
       metadata.language = result.language;
     }
+    if (corpusHint) {
+      metadata.corpus_hint = corpusHint;
+    }
     return {
       extractedText: result.text || void 0,
       artifact: {
@@ -18221,7 +18389,7 @@ async function resolveImageGenerationProvider(rootDir) {
   if (!providerConfig) {
     throw new Error(`No provider configured with id "${preferredProviderId}" for task "imageProvider".`);
   }
-  const { createProvider: createProvider2 } = await import("./registry-4C55ZCPL.js");
+  const { createProvider: createProvider2 } = await import("./registry-JR5WY22P.js");
   return createProvider2(preferredProviderId, providerConfig, rootDir);
 }
 async function generateOutputArtifacts(rootDir, input) {
@@ -19255,6 +19423,13 @@ function autoResolution(nodeCount, edgeCount) {
   if (edgeCount / Math.max(1, nodeCount) < 2) return 0.8;
   return 1;
 }
+function pruneDanglingEdges(nodes, edges) {
+  const nodeIds = new Set(nodes.map((node) => node.id));
+  return edges.filter((edge) => nodeIds.has(edge.source) && nodeIds.has(edge.target));
+}
+function applyNormLabel(nodes) {
+  return nodes.map((node) => node.normLabel ? node : { ...node, normLabel: computeNormLabel(node.label) });
+}
 function deriveGraphMetrics(nodes, edges, options) {
   const adjacency = /* @__PURE__ */ new Map();
   const connect = (left, right) => {
@@ -19672,20 +19847,33 @@ function buildGraph(manifests, analyses, pages, sourceProjects, _codeIndex, opti
       }
       for (const symbol of analysis.code.symbols) {
         for (const targetName of symbol.calls) {
-          const targetId = resolveLocalSymbolId(targetName);
-          if (!targetId || targetId === symbol.id) {
+          const localTargetId = resolveLocalSymbolId(targetName);
+          if (localTargetId && localTargetId !== symbol.id) {
+            pushEdge({
+              id: `${symbol.id}->${localTargetId}:calls`,
+              source: symbol.id,
+              target: localTargetId,
+              relation: "calls",
+              status: "extracted",
+              evidenceClass: "extracted",
+              confidence: 1,
+              provenance: [analysis.sourceId]
+            });
             continue;
           }
-          pushEdge({
-            id: `${symbol.id}->${targetId}:calls`,
-            source: symbol.id,
-            target: targetId,
-            relation: "calls",
-            status: "extracted",
-            evidenceClass: "extracted",
-            confidence: 1,
-            provenance: [analysis.sourceId]
-          });
+          const crossFileTargetId = importedSymbolIdsByName.get(targetName);
+          if (crossFileTargetId && crossFileTargetId !== symbol.id) {
+            pushEdge({
+              id: `${symbol.id}->${crossFileTargetId}:calls`,
+              source: symbol.id,
+              target: crossFileTargetId,
+              relation: "calls",
+              status: "inferred",
+              evidenceClass: "inferred",
+              confidence: 0.8,
+              provenance: [analysis.sourceId]
+            });
+          }
         }
         for (const targetName of symbol.extends) {
           const targetId = resolveLocalSymbolId(targetName) ?? importedSymbolIdsByName.get(targetName);
@@ -19800,11 +19988,17 @@ function buildGraph(manifests, analyses, pages, sourceProjects, _codeIndex, opti
     analyses
   );
   const metrics = deriveGraphMetrics(graphNodes, enriched.edges, { resolution: options?.communityResolution });
+  const finalNodes = applyNormLabel(metrics.nodes);
+  const finalEdges = pruneDanglingEdges(finalNodes, enriched.edges);
+  const finalHyperedges = (enriched.hyperedges ?? []).filter((hyperedge) => {
+    const nodeIdSet = new Set(finalNodes.map((node) => node.id));
+    return hyperedge.nodeIds.every((id) => nodeIdSet.has(id));
+  });
   return {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    nodes: metrics.nodes,
-    edges: enriched.edges,
-    hyperedges: enriched.hyperedges,
+    nodes: finalNodes,
+    edges: finalEdges,
+    hyperedges: finalHyperedges,
     communities: metrics.communities,
     sources: manifests,
     pages
@@ -21344,18 +21538,52 @@ async function rejectApproval(rootDir, approvalId, targets = []) {
 }
 async function listCandidates(rootDir) {
   const pages = await listPages(rootDir);
-  return pages.filter(
+  const candidates = pages.filter(
     (page) => page.status === "candidate" && (page.kind === "concept" || page.kind === "entity")
-  ).map((page) => ({
-    pageId: page.id,
-    title: page.title,
-    kind: page.kind,
-    path: page.path,
-    activePath: candidateActivePath(page),
-    sourceIds: page.sourceIds,
-    createdAt: page.createdAt,
-    updatedAt: page.updatedAt
-  })).sort((left, right) => left.title.localeCompare(right.title));
+  );
+  let scoreLookup = null;
+  try {
+    const { config, paths } = await loadVaultConfig(rootDir);
+    const promotionConfig = resolvePromotionConfig(config);
+    const graph = await readJsonFile(paths.graphPath);
+    if (graph) {
+      const compileState = await readJsonFile(paths.compileStatePath) ?? emptyCompileState();
+      const now = Date.now();
+      const decisions = candidates.map(
+        (page) => evaluateCandidateForPromotion(page, graph, compileState.candidateHistory, promotionConfig, now)
+      );
+      scoreLookup = new Map(
+        decisions.map((decision) => [
+          decision.pageId,
+          {
+            score: decision.score,
+            breakdown: Object.fromEntries(decision.gates.map((gate) => [gate.gate, gate.value]))
+          }
+        ])
+      );
+    }
+  } catch {
+    scoreLookup = null;
+  }
+  return candidates.map((page) => {
+    const scored = scoreLookup?.get(page.id);
+    return {
+      pageId: page.id,
+      title: page.title,
+      kind: page.kind,
+      path: page.path,
+      activePath: candidateActivePath(page),
+      sourceIds: page.sourceIds,
+      createdAt: page.createdAt,
+      updatedAt: page.updatedAt,
+      ...scored ? { score: scored.score, scoreBreakdown: scored.breakdown } : {}
+    };
+  }).sort((left, right) => {
+    const ls = left.score ?? -1;
+    const rs = right.score ?? -1;
+    if (ls !== rs) return rs - ls;
+    return left.title.localeCompare(right.title);
+  });
 }
 function resolveCandidateTarget(pages, target) {
   const candidate = pages.find((page) => page.status === "candidate" && (page.id === target || page.path === target));
@@ -21622,7 +21850,101 @@ async function ensureObsidianWorkspace(rootDir) {
     })
   ]);
 }
+async function initLiteVault(rootDir, options) {
+  const rawDir = path23.join(rootDir, "raw");
+  const wikiDir = path23.join(rootDir, "wiki");
+  const schemaPath = path23.join(rootDir, PRIMARY_SCHEMA_FILENAME);
+  const indexPath = path23.join(wikiDir, "index.md");
+  const logPath = path23.join(wikiDir, "log.md");
+  await Promise.all([ensureDir(rawDir), ensureDir(wikiDir)]);
+  if (!await fileExists(schemaPath)) {
+    await fs19.writeFile(schemaPath, defaultVaultSchema("default"), "utf8");
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  if (!await fileExists(indexPath)) {
+    await fs19.writeFile(
+      indexPath,
+      matter10.stringify(
+        [
+          "# Wiki Index",
+          "",
+          "This lite vault is agent-maintained. Drop sources into `raw/`, edit `swarmvault.schema.md` to teach the agent how the wiki should be organized, then ask your agent to read sources and update pages here.",
+          "",
+          "- Summaries, entity pages, and concept pages live under `wiki/`.",
+          "- Append every ingest/query/lint operation to `wiki/log.md`.",
+          "- Run `swarmvault init` (without `--lite`) when you want the full toolchain with graph, search, and approvals.",
+          ""
+        ].join("\n"),
+        {
+          page_id: "wiki:index",
+          kind: "index",
+          title: "Wiki Index",
+          tags: ["index"],
+          source_ids: [],
+          project_ids: [],
+          node_ids: [],
+          freshness: "fresh",
+          status: "active",
+          confidence: 1,
+          created_at: now,
+          updated_at: now,
+          compiled_from: [],
+          managed_by: "agent",
+          backlinks: [],
+          schema_hash: "",
+          source_hashes: {},
+          source_semantic_hashes: {}
+        }
+      ),
+      "utf8"
+    );
+  }
+  if (!await fileExists(logPath)) {
+    await fs19.writeFile(
+      logPath,
+      matter10.stringify(
+        [
+          "# Activity Log",
+          "",
+          "Append-only chronological record. One line per ingest/query/lint operation, newest at the bottom.",
+          "",
+          "Format: `## [YYYY-MM-DD] <verb> | <subject>`",
+          ""
+        ].join("\n"),
+        {
+          page_id: "wiki:log",
+          kind: "index",
+          title: "Activity Log",
+          tags: ["log", "append-only"],
+          source_ids: [],
+          project_ids: [],
+          node_ids: [],
+          freshness: "fresh",
+          status: "active",
+          confidence: 1,
+          created_at: now,
+          updated_at: now,
+          compiled_from: [],
+          managed_by: "agent",
+          backlinks: [],
+          schema_hash: "",
+          source_hashes: {},
+          source_semantic_hashes: {}
+        }
+      ),
+      "utf8"
+    );
+  }
+  if (options.obsidian) {
+    const obsidianDir = path23.join(rootDir, ".obsidian");
+    await ensureDir(obsidianDir);
+  }
+}
 async function initVault(rootDir, options = {}) {
+  if (options.lite) {
+    await initLiteVault(rootDir, options);
+    return;
+  }
   const requestedProfile = options.profile ?? "default";
   const { config, paths } = await initWorkspace(rootDir, { profile: requestedProfile });
   const profile = config.profile;
@@ -23318,7 +23640,7 @@ async function getWatchStatus(rootDir) {
 }
 
 // src/mcp.ts
-var SERVER_VERSION = "0.7.31";
+var SERVER_VERSION = "0.9.0";
 async function createMcpServer(rootDir) {
   const server = new McpServer({
     name: "swarmvault",
@@ -25889,6 +26211,8 @@ async function deleteManagedSource(rootDir, id) {
 
 // src/viewer.ts
 import { execFile as execFile2 } from "child_process";
+import { randomUUID } from "crypto";
+import { EventEmitter } from "events";
 import fs23 from "fs/promises";
 import http from "http";
 import path28 from "path";
@@ -26015,6 +26339,33 @@ function buildViewerGraphArtifact(graph, options = {}) {
 }
 
 // src/viewer.ts
+var ViewerEventBus = class extends EventEmitter {
+  publish(event) {
+    const enriched = {
+      id: event.id ?? randomUUID(),
+      timestamp: event.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+      type: event.type,
+      level: event.level,
+      message: event.message,
+      meta: event.meta
+    };
+    this.emit("event", enriched);
+    return enriched;
+  }
+};
+var viewerEventBus = new ViewerEventBus();
+viewerEventBus.setMaxListeners(64);
+function toViewerLintFindings(findings) {
+  const detectedAt = (/* @__PURE__ */ new Date()).toISOString();
+  return findings.map((finding, index) => ({
+    id: `${finding.code}:${index}`,
+    severity: finding.severity,
+    category: finding.code,
+    message: finding.message,
+    pagePath: finding.pagePath,
+    detectedAt
+  }));
+}
 var execFileAsync2 = promisify2(execFile2);
 async function isReadableFile(absolutePath) {
   try {
@@ -26262,6 +26613,76 @@ async function startGraphServer(rootDir, port, options = {}) {
         response.end(JSON.stringify(result));
         return;
       }
+      if (url.pathname === "/api/lint") {
+        try {
+          const findings = await lintVault(rootDir);
+          response.writeHead(200, { "content-type": "application/json" });
+          response.end(JSON.stringify(toViewerLintFindings(findings)));
+        } catch (error) {
+          response.writeHead(200, { "content-type": "application/json" });
+          response.end(JSON.stringify([]));
+          console.warn(`[viewer] /api/lint failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return;
+      }
+      if (url.pathname === "/api/workspace") {
+        const reportPath = path28.join(paths.wikiDir, "graph", "report.json");
+        const [graphRaw, reportRaw, approvalsRaw, candidatesRaw, watchStatusRaw, lintRaw] = await Promise.all([
+          readJsonFile(paths.graphPath).catch(() => null),
+          readJsonFile(reportPath).catch(() => null),
+          listApprovals(rootDir).catch(() => []),
+          listCandidates(rootDir).catch(() => []),
+          getWatchStatus(rootDir).catch(() => ({ generatedAt: "", watchedRepoRoots: [], pendingSemanticRefresh: [] })),
+          lintVault(rootDir).catch(() => [])
+        ]);
+        const viewerGraph = graphRaw ? buildViewerGraphArtifact(graphRaw, { report: reportRaw, full: options.full ?? false }) : null;
+        response.writeHead(200, { "content-type": "application/json" });
+        response.end(
+          JSON.stringify({
+            graph: viewerGraph,
+            graphReport: reportRaw ?? null,
+            approvals: approvalsRaw,
+            candidates: candidatesRaw,
+            watchStatus: watchStatusRaw,
+            lintFindings: toViewerLintFindings(lintRaw)
+          })
+        );
+        return;
+      }
+      if (url.pathname === "/api/events") {
+        response.writeHead(200, {
+          "content-type": "text/event-stream",
+          "cache-control": "no-cache, no-transform",
+          connection: "keep-alive",
+          "x-accel-buffering": "no"
+        });
+        const send = (event) => {
+          response.write(`id: ${event.id}
+`);
+          response.write(`data: ${JSON.stringify(event)}
+
+`);
+        };
+        send({
+          id: randomUUID(),
+          type: "connected",
+          level: "info",
+          message: "Activity stream connected.",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        const listener = (event) => send(event);
+        viewerEventBus.on("event", listener);
+        const heartbeat = setInterval(() => {
+          response.write(`: keepalive ${(/* @__PURE__ */ new Date()).toISOString()}
+
+`);
+        }, 25e3);
+        request.on("close", () => {
+          clearInterval(heartbeat);
+          viewerEventBus.off("event", listener);
+        });
+        return;
+      }
       if (url.pathname === "/api/clip" && request.method === "POST") {
         const body = await readJsonBody(request);
         const clipUrl = typeof body.url === "string" ? body.url.trim() : "";

package/dist/registry-2QC3VN7M.js

@@ -0,0 +1,12 @@
+import {
+  assertProviderCapability,
+  createProvider,
+  getProviderForTask,
+  getResolvedPaths
+} from "./chunk-BTWPJEP2.js";
+export {
+  assertProviderCapability,
+  createProvider,
+  getProviderForTask,
+  getResolvedPaths
+};