@swarmvaultai/engine 0.4.0 → 0.6.0

package/dist/index.js

@@ -21,7 +21,7 @@ import {
   uniqueBy,
   writeFileIfChanged,
   writeJsonFile
-} from "./chunk-CWLDFLH2.js";
+} from "./chunk-FD3LJQ4T.js";
 
 // src/agents.ts
 import crypto from "crypto";
@@ -8502,8 +8502,8 @@ async function readExtractionArtifact(rootDir, manifest) {
 }
 
 // src/mcp.ts
-import fs19 from "fs/promises";
-import path23 from "path";
+import fs20 from "fs/promises";
+import path24 from "path";
 import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z as z8 } from "zod";
@@ -8616,8 +8616,8 @@ function buildSchemaPrompt(schema, instruction) {
 }
 
 // src/vault.ts
-import fs18 from "fs/promises";
-import path22 from "path";
+import fs19 from "fs/promises";
+import path23 from "path";
 import matter9 from "gray-matter";
 import { z as z7 } from "zod";
 
@@ -11137,15 +11137,15 @@ function sourceTypeForNode(node, pagesById) {
   return pagesById.get(node.pageId)?.sourceType;
 }
 function supportingPathDetails(graph, edge) {
-  const path28 = shortestGraphPath(graph, edge.source, edge.target);
+  const path29 = shortestGraphPath(graph, edge.source, edge.target);
   const edgesById = new Map(graph.edges.map((item) => [item.id, item]));
-  const pathEdges = path28.edgeIds.map((edgeId) => edgesById.get(edgeId)).filter((item) => Boolean(item));
+  const pathEdges = path29.edgeIds.map((edgeId) => edgesById.get(edgeId)).filter((item) => Boolean(item));
   return {
-    pathNodeIds: path28.nodeIds,
-    pathEdgeIds: path28.edgeIds,
+    pathNodeIds: path29.nodeIds,
+    pathEdgeIds: path29.edgeIds,
     pathRelations: pathEdges.map((item) => item.relation),
     pathEvidenceClasses: pathEdges.map((item) => item.evidenceClass),
-    pathSummary: path28.summary
+    pathSummary: path29.summary
   };
 }
 function surpriseScore(edge, graph, pagesById, hyperedgesByNodeId) {
@@ -11214,7 +11214,7 @@ function topSurprisingConnections(graph, pagesById) {
     }).map((edge) => {
       const source = nodesById.get(edge.source);
       const target = nodesById.get(edge.target);
-      const path28 = supportingPathDetails(graph, edge);
+      const path29 = supportingPathDetails(graph, edge);
       const scored = surpriseScore(edge, graph, pagesById, hyperedgesByNodeId);
       return {
         id: edge.id,
@@ -11225,11 +11225,11 @@ function topSurprisingConnections(graph, pagesById) {
         relation: edge.relation,
         evidenceClass: edge.evidenceClass,
         confidence: edge.confidence,
-        pathNodeIds: path28.pathNodeIds,
-        pathEdgeIds: path28.pathEdgeIds,
-        pathRelations: path28.pathRelations,
-        pathEvidenceClasses: path28.pathEvidenceClasses,
-        pathSummary: path28.pathSummary,
+        pathNodeIds: path29.pathNodeIds,
+        pathEdgeIds: path29.pathEdgeIds,
+        pathRelations: path29.pathRelations,
+        pathEvidenceClasses: path29.pathEvidenceClasses,
+        pathSummary: path29.pathSummary,
         why: scored.why,
         explanation: scored.explanation,
         surpriseScore: scored.score
@@ -12691,6 +12691,58 @@ function searchPages(dbPath, query, limitOrOptions = 5) {
   }));
 }
 
+// src/source-sessions.ts
+import fs18 from "fs/promises";
+import path22 from "path";
+function sessionStatePathFor(paths, sessionId) {
+  return path22.join(paths.sourceSessionsDir, `${sessionId}.json`);
+}
+async function listGuidedSourceSessions(rootDir) {
+  const { paths } = await loadVaultConfig(rootDir);
+  const entries = await fs18.readdir(paths.sourceSessionsDir, { withFileTypes: true }).catch(() => []);
+  const sessions = await Promise.all(
+    entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map(async (entry) => await readJsonFile(path22.join(paths.sourceSessionsDir, entry.name)))
+  );
+  return sessions.filter((session) => Boolean(session)).sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+}
+async function readGuidedSourceSession(rootDir, sessionId) {
+  const { paths } = await loadVaultConfig(rootDir);
+  return await readJsonFile(sessionStatePathFor(paths, sessionId));
+}
+async function findLatestGuidedSourceSessionByScope(rootDir, scopeId) {
+  const sessions = await listGuidedSourceSessions(rootDir);
+  return sessions.find((session) => session.scopeId === scopeId) ?? null;
+}
+async function writeGuidedSourceSession(rootDir, session) {
+  const { paths } = await loadVaultConfig(rootDir);
+  await ensureDir(paths.sourceSessionsDir);
+  const next = {
+    ...session,
+    updatedAt: session.updatedAt || (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const filePath = sessionStatePathFor(paths, session.sessionId);
+  await fs18.writeFile(filePath, `${JSON.stringify(next, null, 2)}
+`, "utf8");
+  return filePath;
+}
+async function updateGuidedSourceSessionStatus(rootDir, sessionId, status) {
+  const existing = await readGuidedSourceSession(rootDir, sessionId);
+  if (!existing) {
+    return null;
+  }
+  const next = {
+    ...existing,
+    status,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await writeGuidedSourceSession(rootDir, next);
+  return next;
+}
+async function guidedSourceSessionStatePath(rootDir, sessionId) {
+  const { paths } = await loadVaultConfig(rootDir);
+  return sessionStatePathFor(paths, sessionId);
+}
+
 // src/vault.ts
 var COMPILE_PROGRESS_THRESHOLD = 120;
 var COMPILE_PROGRESS_UPDATE_INTERVAL = 50;
@@ -12745,7 +12797,7 @@ function outputFormatInstruction(format) {
   }
 }
 function outputAssetPath(slug, fileName) {
-  return toPosix(path22.join("outputs", "assets", slug, fileName));
+  return toPosix(path23.join("outputs", "assets", slug, fileName));
 }
 function outputAssetId(slug, role) {
   return `output:${slug}:asset:${role}`;
@@ -12885,7 +12937,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-2REAPKPO.js");
+  const { createProvider: createProvider2 } = await import("./registry-XOPLQNZY.js");
   return createProvider2(preferredProviderId, providerConfig, rootDir);
 }
 async function generateOutputArtifacts(rootDir, input) {
@@ -13083,7 +13135,7 @@ async function generateOutputArtifacts(rootDir, input) {
   };
 }
 function normalizeProjectRoot(root) {
-  const normalized = toPosix(path22.posix.normalize(root.replace(/\\/g, "/"))).replace(/^\.\/+/, "").replace(/\/+$/, "");
+  const normalized = toPosix(path23.posix.normalize(root.replace(/\\/g, "/"))).replace(/^\.\/+/, "").replace(/\/+$/, "");
   return normalized;
 }
 function projectEntries(config) {
@@ -13109,10 +13161,10 @@ function manifestPathForProject(rootDir, manifest) {
   if (!rawPath) {
     return toPosix(manifest.storedPath);
   }
-  if (!path22.isAbsolute(rawPath)) {
+  if (!path23.isAbsolute(rawPath)) {
     return normalizeProjectRoot(rawPath);
   }
-  const relative = toPosix(path22.relative(rootDir, rawPath));
+  const relative = toPosix(path23.relative(rootDir, rawPath));
   return relative.startsWith("..") ? toPosix(rawPath) : normalizeProjectRoot(relative);
 }
 function prefixMatches(value, prefix) {
@@ -13263,6 +13315,9 @@ function approvalSummary(manifest) {
   return {
     approvalId: manifest.approvalId,
     createdAt: manifest.createdAt,
+    bundleType: manifest.bundleType,
+    title: manifest.title,
+    sourceSessionId: manifest.sourceSessionId,
     entryCount: manifest.entries.length,
     pendingCount: manifest.entries.filter((entry) => entry.status === "pending").length,
     acceptedCount: manifest.entries.filter((entry) => entry.status === "accepted").length,
@@ -13286,7 +13341,7 @@ function pageHashes(pages) {
   return Object.fromEntries(pages.map((page) => [page.page.id, page.contentHash]));
 }
 async function buildManagedGraphPage(absolutePath, defaults, build) {
-  const existingContent = await fileExists(absolutePath) ? await fs18.readFile(absolutePath, "utf8") : null;
+  const existingContent = await fileExists(absolutePath) ? await fs19.readFile(absolutePath, "utf8") : null;
   let existing = await loadExistingManagedPageState(absolutePath, {
     status: defaults.status ?? "active",
     managedBy: defaults.managedBy
@@ -13324,7 +13379,7 @@ async function buildManagedGraphPage(absolutePath, defaults, build) {
   return built;
 }
 async function buildManagedContent(absolutePath, defaults, build) {
-  const existingContent = await fileExists(absolutePath) ? await fs18.readFile(absolutePath, "utf8") : null;
+  const existingContent = await fileExists(absolutePath) ? await fs19.readFile(absolutePath, "utf8") : null;
   let existing = await loadExistingManagedPageState(absolutePath, {
     status: defaults.status ?? "active",
     managedBy: defaults.managedBy
@@ -13366,7 +13421,7 @@ function manifestDetailValue(manifest, key) {
 }
 async function loadAnalysesBySourceIds(paths, sourceIds) {
   const analyses = await Promise.all(
-    sourceIds.map(async (sourceId) => await readJsonFile(path22.join(paths.analysesDir, `${sourceId}.json`)))
+    sourceIds.map(async (sourceId) => await readJsonFile(path23.join(paths.analysesDir, `${sourceId}.json`)))
   );
   return analyses.filter((analysis) => Boolean(analysis?.sourceId));
 }
@@ -13374,6 +13429,10 @@ async function buildDashboardRecords(paths, graph, schemaHash, report) {
   const sourcePages = graph.pages.filter((page) => page.kind === "source");
   const reviewPages = graph.pages.filter((page) => page.kind === "output" && page.path.startsWith("outputs/source-reviews/"));
   const briefPages = graph.pages.filter((page) => page.kind === "output" && page.path.startsWith("outputs/source-briefs/"));
+  const guidePages = graph.pages.filter((page) => page.kind === "output" && page.path.startsWith("outputs/source-guides/"));
+  const sessionPages = graph.pages.filter((page) => page.kind === "output" && page.path.startsWith("outputs/source-sessions/"));
+  const conceptPages = graph.pages.filter((page) => page.kind === "concept" && page.status !== "candidate").slice(0, 16);
+  const entityPages = graph.pages.filter((page) => page.kind === "entity" && page.status !== "candidate").slice(0, 16);
   const manifests = graph.sources;
   const manifestBySourceId = new Map(manifests.map((manifest) => [manifest.sourceId, manifest]));
   const timelineManifests = manifests.filter((manifest) => manifestDetailValue(manifest, "occurred_at")).sort((left, right) => (manifestDetailValue(right, "occurred_at") ?? "").localeCompare(manifestDetailValue(left, "occurred_at") ?? "")).slice(0, 25);
@@ -13382,6 +13441,10 @@ async function buildDashboardRecords(paths, graph, schemaHash, report) {
   const openQuestions = uniqueStrings3(
     analyses.flatMap((analysis) => analysis.questions.map((question) => `${analysis.title}: ${question}`))
   ).slice(0, 20);
+  const sourceSessions = await listGuidedSourceSessions(paths.rootDir);
+  const stagedGuideBundles = (await Promise.all(
+    (await fs19.readdir(paths.approvalsDir, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isDirectory()).map(async (entry) => await readJsonFile(approvalManifestPath(paths, entry.name)))
+  )).filter((manifest) => Boolean(manifest)).filter((manifest) => manifest.bundleType === "guided_source" || manifest.bundleType === "guided_session").sort((left, right) => right.createdAt.localeCompare(left.createdAt)).slice(0, 12);
   const dashboards = [
     {
       relativePath: "dashboards/index.md",
@@ -13391,7 +13454,11 @@ async function buildDashboardRecords(paths, graph, schemaHash, report) {
           "# Dashboards",
           "",
           "- [[dashboards/recent-sources|Recent Sources]]",
+          "- [[dashboards/reading-log|Reading Log]]",
           "- [[dashboards/timeline|Timeline]]",
+          "- [[dashboards/source-sessions|Source Sessions]]",
+          "- [[dashboards/source-guides|Source Guides]]",
+          "- [[dashboards/research-map|Research Map]]",
           "- [[dashboards/contradictions|Contradictions]]",
           "- [[dashboards/open-questions|Open Questions]]",
           "",
@@ -13464,6 +13531,57 @@ async function buildDashboardRecords(paths, graph, schemaHash, report) {
         }
       )
     },
+    {
+      relativePath: "dashboards/reading-log.md",
+      title: "Reading Log",
+      content: (metadata) => matter9.stringify(
+        [
+          "# Reading Log",
+          "",
+          ...timelineManifests.length ? timelineManifests.map((manifest) => {
+            const occurredAt = manifestDetailValue(manifest, "occurred_at") ?? manifest.updatedAt;
+            const participants = manifestDetailValue(manifest, "participants");
+            return `- ${occurredAt}: ${manifest.title}${participants ? ` (${participants})` : ""}`;
+          }) : recentSourcePages.map((page) => `- ${page.updatedAt}: [[${page.path.replace(/\.md$/, "")}|${page.title}]]`),
+          ...sourceSessions.length ? [
+            "",
+            "## Active Guided Sessions",
+            "",
+            ...sourceSessions.slice(0, 8).map(
+              (session) => `- ${session.updatedAt}: \`${session.status}\` [[outputs/source-sessions/${session.scopeId}|${session.scopeTitle}]]`
+            )
+          ] : [],
+          "",
+          "```dataview",
+          "TABLE occurred_at, source_type, participants, container_title",
+          'FROM "sources"',
+          "SORT occurred_at desc",
+          "LIMIT 25",
+          "```",
+          ""
+        ].join("\n"),
+        {
+          page_id: "dashboards:reading-log",
+          kind: "index",
+          title: "Reading Log",
+          tags: ["index", "dashboard", "reading-log"],
+          source_ids: timelineManifests.map((manifest) => manifest.sourceId),
+          project_ids: [],
+          node_ids: [],
+          freshness: "fresh",
+          status: metadata.status,
+          confidence: 1,
+          created_at: metadata.createdAt,
+          updated_at: metadata.updatedAt,
+          compiled_from: timelineManifests.map((manifest) => manifest.sourceId),
+          managed_by: metadata.managedBy,
+          backlinks: [],
+          schema_hash: schemaHash,
+          source_hashes: {},
+          source_semantic_hashes: {}
+        }
+      )
+    },
     {
       relativePath: "dashboards/timeline.md",
       title: "Timeline",
@@ -13507,6 +13625,169 @@ async function buildDashboardRecords(paths, graph, schemaHash, report) {
         }
       )
     },
+    {
+      relativePath: "dashboards/source-sessions.md",
+      title: "Source Sessions",
+      content: (metadata) => matter9.stringify(
+        [
+          "# Source Sessions",
+          "",
+          "## Active Sessions",
+          "",
+          ...sourceSessions.length ? sourceSessions.slice(0, 16).map(
+            (session) => `- ${session.updatedAt}: \`${session.status}\` \`${session.sessionId}\` [[outputs/source-sessions/${session.scopeId}|${session.scopeTitle}]]`
+          ) : ["- No guided source sessions yet."],
+          "",
+          "## Pending Guided Bundles",
+          "",
+          ...stagedGuideBundles.length ? stagedGuideBundles.map(
+            (bundle) => `- ${bundle.createdAt}: \`${bundle.approvalId}\`${bundle.title ? ` ${bundle.title}` : ""} (${bundle.entries.length} staged entr${bundle.entries.length === 1 ? "y" : "ies"})`
+          ) : ["- No staged guided bundles right now."],
+          "",
+          "```dataview",
+          'LIST FROM "outputs/source-sessions"',
+          "SORT file.mtime desc",
+          "```",
+          ""
+        ].join("\n"),
+        {
+          page_id: "dashboards:source-sessions",
+          kind: "index",
+          title: "Source Sessions",
+          tags: ["index", "dashboard", "source-sessions"],
+          source_ids: uniqueStrings3([
+            ...sessionPages.flatMap((page) => page.sourceIds),
+            ...sourceSessions.flatMap((session) => session.sourceIds)
+          ]),
+          project_ids: [],
+          node_ids: [],
+          freshness: "fresh",
+          status: metadata.status,
+          confidence: 1,
+          created_at: metadata.createdAt,
+          updated_at: metadata.updatedAt,
+          compiled_from: uniqueStrings3([
+            ...sessionPages.flatMap((page) => page.sourceIds),
+            ...sourceSessions.flatMap((session) => session.sourceIds)
+          ]),
+          managed_by: metadata.managedBy,
+          backlinks: [],
+          schema_hash: schemaHash,
+          source_hashes: {},
+          source_semantic_hashes: {}
+        }
+      )
+    },
+    {
+      relativePath: "dashboards/source-guides.md",
+      title: "Source Guides",
+      content: (metadata) => matter9.stringify(
+        [
+          "# Source Guides",
+          "",
+          ...guidePages.length ? guidePages.map((page) => `- [[${page.path.replace(/\.md$/, "")}|${page.title}]]`) : ["- No accepted source guides yet."],
+          "",
+          "## Pending Guided Bundles",
+          "",
+          ...stagedGuideBundles.length ? stagedGuideBundles.map(
+            (bundle) => `- ${bundle.createdAt}: \`${bundle.approvalId}\`${bundle.title ? ` ${bundle.title}` : ""} (${bundle.entries.length} staged entr${bundle.entries.length === 1 ? "y" : "ies"})`
+          ) : ["- No staged guided bundles right now."],
+          "",
+          "```dataview",
+          'LIST FROM "outputs/source-guides"',
+          "SORT file.mtime desc",
+          "```",
+          ""
+        ].join("\n"),
+        {
+          page_id: "dashboards:source-guides",
+          kind: "index",
+          title: "Source Guides",
+          tags: ["index", "dashboard", "source-guides"],
+          source_ids: uniqueStrings3([
+            ...guidePages.flatMap((page) => page.sourceIds),
+            ...stagedGuideBundles.flatMap((bundle) => bundle.entries.flatMap((entry) => entry.sourceIds))
+          ]),
+          project_ids: [],
+          node_ids: [],
+          freshness: "fresh",
+          status: metadata.status,
+          confidence: 1,
+          created_at: metadata.createdAt,
+          updated_at: metadata.updatedAt,
+          compiled_from: uniqueStrings3([
+            ...guidePages.flatMap((page) => page.sourceIds),
+            ...stagedGuideBundles.flatMap((bundle) => bundle.entries.flatMap((entry) => entry.sourceIds))
+          ]),
+          managed_by: metadata.managedBy,
+          backlinks: [],
+          schema_hash: schemaHash,
+          source_hashes: {},
+          source_semantic_hashes: {}
+        }
+      )
+    },
+    {
+      relativePath: "dashboards/research-map.md",
+      title: "Research Map",
+      content: (metadata) => matter9.stringify(
+        [
+          "# Research Map",
+          "",
+          "## Canonical Concept Pages",
+          "",
+          ...conceptPages.length ? conceptPages.map((page) => `- [[${page.path.replace(/\.md$/, "")}|${page.title}]]`) : ["- No concept pages yet."],
+          "",
+          "## Canonical Entity Pages",
+          "",
+          ...entityPages.length ? entityPages.map((page) => `- [[${page.path.replace(/\.md$/, "")}|${page.title}]]`) : ["- No entity pages yet."],
+          "",
+          "## Recently Guided Sources",
+          "",
+          ...guidePages.length ? guidePages.slice(0, 8).map((page) => `- [[${page.path.replace(/\.md$/, "")}|${page.title}]]`) : ["- No accepted source guides yet."],
+          "",
+          "## Active Source Sessions",
+          "",
+          ...sourceSessions.length ? sourceSessions.slice(0, 8).map((session) => `- \`${session.status}\` [[outputs/source-sessions/${session.scopeId}|${session.scopeTitle}]]`) : ["- No active source sessions yet."],
+          ...report?.suggestedQuestions?.length ? ["", "## Suggested Questions", "", ...report.suggestedQuestions.slice(0, 8).map((question) => `- ${question}`)] : [],
+          "",
+          "```dataview",
+          'TABLE file.folder, file.mtime FROM "concepts" OR "entities"',
+          "SORT file.mtime desc",
+          "LIMIT 30",
+          "```",
+          ""
+        ].join("\n"),
+        {
+          page_id: "dashboards:research-map",
+          kind: "index",
+          title: "Research Map",
+          tags: ["index", "dashboard", "research-map"],
+          source_ids: uniqueStrings3([
+            ...conceptPages.flatMap((page) => page.sourceIds),
+            ...entityPages.flatMap((page) => page.sourceIds),
+            ...guidePages.flatMap((page) => page.sourceIds)
+          ]),
+          project_ids: [],
+          node_ids: [],
+          freshness: "fresh",
+          status: metadata.status,
+          confidence: 1,
+          created_at: metadata.createdAt,
+          updated_at: metadata.updatedAt,
+          compiled_from: uniqueStrings3([
+            ...conceptPages.flatMap((page) => page.sourceIds),
+            ...entityPages.flatMap((page) => page.sourceIds),
+            ...guidePages.flatMap((page) => page.sourceIds)
+          ]),
+          managed_by: metadata.managedBy,
+          backlinks: [],
+          schema_hash: schemaHash,
+          source_hashes: {},
+          source_semantic_hashes: {}
+        }
+      )
+    },
     {
       relativePath: "dashboards/contradictions.md",
       title: "Contradictions",
@@ -13520,14 +13801,14 @@ async function buildDashboardRecords(paths, graph, schemaHash, report) {
             return `- ${left} / ${right}: ${contradiction.claimA} <> ${contradiction.claimB}`;
           }) : ["- No contradictions are currently flagged."],
           "",
-          ...reviewPages.length || briefPages.length ? [
+          ...reviewPages.length || briefPages.length || guidePages.length ? [
             "## Related Reviews",
             "",
-            ...[...reviewPages, ...briefPages].slice(0, 12).map((page) => `- [[${page.path.replace(/\.md$/, "")}|${page.title}]]`),
+            ...[...guidePages, ...reviewPages, ...briefPages].slice(0, 12).map((page) => `- [[${page.path.replace(/\.md$/, "")}|${page.title}]]`),
             ""
           ] : [],
           "```dataview",
-          'LIST FROM "outputs/source-reviews"',
+          'LIST FROM "outputs/source-reviews" OR "outputs/source-guides"',
           "SORT file.mtime desc",
           "```",
           ""
@@ -13562,9 +13843,15 @@ async function buildDashboardRecords(paths, graph, schemaHash, report) {
           "# Open Questions",
           "",
           ...openQuestions.length ? openQuestions.map((question) => `- ${question}`) : ["- No open questions are currently extracted."],
+          ...sourceSessions.length ? [
+            "",
+            "## Active Guided Sessions",
+            "",
+            ...sourceSessions.filter((session) => session.status === "awaiting_input" || session.status === "staged").slice(0, 8).map((session) => `- \`${session.status}\` [[outputs/source-sessions/${session.scopeId}|${session.scopeTitle}]]`)
+          ] : [],
           "",
           "```dataview",
-          'LIST FROM "outputs/source-briefs" OR "outputs/source-reviews"',
+          'LIST FROM "outputs/source-briefs" OR "outputs/source-reviews" OR "outputs/source-guides" OR "outputs/source-sessions"',
           "SORT file.mtime desc",
           "```",
           ""
@@ -13594,7 +13881,7 @@ async function buildDashboardRecords(paths, graph, schemaHash, report) {
   ];
   const records = [];
   for (const dashboard of dashboards) {
-    const absolutePath = path22.join(paths.wikiDir, dashboard.relativePath);
+    const absolutePath = path23.join(paths.wikiDir, dashboard.relativePath);
     const compiledFrom = dashboard.relativePath === "dashboards/recent-sources.md" ? recentSourcePages.flatMap((page) => page.sourceIds) : [];
     const content = await buildManagedContent(
       absolutePath,
@@ -13708,7 +13995,7 @@ function resetGraphNodeMetrics(nodes) {
   return nodes.map(({ communityId: _communityId, degree: _degree, bridgeScore: _bridgeScore, isGodNode: _isGodNode, ...node }) => node);
 }
 function manifestRepoPath(manifest) {
-  return toPosix(manifest.repoRelativePath ?? path22.basename(manifest.originalPath ?? manifest.storedPath));
+  return toPosix(manifest.repoRelativePath ?? path23.basename(manifest.originalPath ?? manifest.storedPath));
 }
 function goPackageScopeKey(manifest, analysis) {
   if (analysis.code?.language !== "go") {
@@ -13718,7 +14005,7 @@ function goPackageScopeKey(manifest, analysis) {
   if (!packageName) {
     return null;
   }
-  return `${packageName}:${path22.posix.dirname(manifestRepoPath(manifest))}`;
+  return `${packageName}:${path23.posix.dirname(manifestRepoPath(manifest))}`;
 }
 function buildGoPackageSymbolLookups(analyses, manifestsById) {
   const lookups = /* @__PURE__ */ new Map();
@@ -14187,7 +14474,7 @@ async function buildGraphOrientationPages(graph, paths, schemaHash, previousComp
   const benchmark = await readJsonFile(paths.benchmarkPath);
   const communityRecords = [];
   for (const community of graph.communities ?? []) {
-    const absolutePath = path22.join(paths.wikiDir, "graph", "communities", `${community.id.replace(/^community:/, "")}.md`);
+    const absolutePath = path23.join(paths.wikiDir, "graph", "communities", `${community.id.replace(/^community:/, "")}.md`);
     communityRecords.push(
       await buildManagedGraphPage(
         absolutePath,
@@ -14216,7 +14503,7 @@ async function buildGraphOrientationPages(graph, paths, schemaHash, previousComp
     graphHash: graphHash(graph),
     contradictions
   });
-  const reportAbsolutePath = path22.join(paths.wikiDir, "graph", "report.md");
+  const reportAbsolutePath = path23.join(paths.wikiDir, "graph", "report.md");
   const reportRecord = await buildManagedGraphPage(
     reportAbsolutePath,
     {
@@ -14237,7 +14524,7 @@ async function buildGraphOrientationPages(graph, paths, schemaHash, previousComp
   };
 }
 async function writePage(wikiDir, relativePath, content, changedPages) {
-  const absolutePath = path22.resolve(wikiDir, relativePath);
+  const absolutePath = path23.resolve(wikiDir, relativePath);
   const changed = await writeFileIfChanged(absolutePath, content);
   if (changed) {
     changedPages.push(relativePath);
@@ -14303,29 +14590,29 @@ async function requiredCompileArtifactsExist(paths) {
     paths.graphPath,
     paths.codeIndexPath,
     paths.searchDbPath,
-    path22.join(paths.wikiDir, "index.md"),
-    path22.join(paths.wikiDir, "sources", "index.md"),
-    path22.join(paths.wikiDir, "code", "index.md"),
-    path22.join(paths.wikiDir, "concepts", "index.md"),
-    path22.join(paths.wikiDir, "entities", "index.md"),
-    path22.join(paths.wikiDir, "outputs", "index.md"),
-    path22.join(paths.wikiDir, "projects", "index.md"),
-    path22.join(paths.wikiDir, "candidates", "index.md")
+    path23.join(paths.wikiDir, "index.md"),
+    path23.join(paths.wikiDir, "sources", "index.md"),
+    path23.join(paths.wikiDir, "code", "index.md"),
+    path23.join(paths.wikiDir, "concepts", "index.md"),
+    path23.join(paths.wikiDir, "entities", "index.md"),
+    path23.join(paths.wikiDir, "outputs", "index.md"),
+    path23.join(paths.wikiDir, "projects", "index.md"),
+    path23.join(paths.wikiDir, "candidates", "index.md")
   ];
   const checks = await Promise.all(requiredPaths.map((filePath) => fileExists(filePath)));
   return checks.every(Boolean);
 }
 async function loadAvailableCachedAnalyses(paths, manifests) {
   const analyses = await Promise.all(
-    manifests.map(async (manifest) => readJsonFile(path22.join(paths.analysesDir, `${manifest.sourceId}.json`)))
+    manifests.map(async (manifest) => readJsonFile(path23.join(paths.analysesDir, `${manifest.sourceId}.json`)))
   );
   return analyses.filter((analysis) => Boolean(analysis));
 }
 function approvalManifestPath(paths, approvalId) {
-  return path22.join(paths.approvalsDir, approvalId, "manifest.json");
+  return path23.join(paths.approvalsDir, approvalId, "manifest.json");
 }
 function approvalGraphPath(paths, approvalId) {
-  return path22.join(paths.approvalsDir, approvalId, "state", "graph.json");
+  return path23.join(paths.approvalsDir, approvalId, "state", "graph.json");
 }
 async function readApprovalManifest(paths, approvalId) {
   const manifest = await readJsonFile(approvalManifestPath(paths, approvalId));
@@ -14335,10 +14622,10 @@ async function readApprovalManifest(paths, approvalId) {
   return manifest;
 }
 async function writeApprovalManifest(paths, manifest) {
-  await fs18.writeFile(approvalManifestPath(paths, manifest.approvalId), `${JSON.stringify(manifest, null, 2)}
+  await fs19.writeFile(approvalManifestPath(paths, manifest.approvalId), `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
 }
-async function buildApprovalEntries(paths, changedFiles, deletedPaths, previousGraph, graph) {
+async function buildApprovalEntries(paths, changedFiles, deletedPaths, previousGraph, graph, labelsByPath = /* @__PURE__ */ new Map()) {
   const previousPagesById = new Map((previousGraph?.pages ?? []).map((page) => [page.id, page]));
   const previousPagesByPath = new Map((previousGraph?.pages ?? []).map((page) => [page.path, page]));
   const nextPagesByPath = new Map(graph.pages.map((page) => [page.path, page]));
@@ -14350,7 +14637,7 @@ async function buildApprovalEntries(paths, changedFiles, deletedPaths, previousG
       continue;
     }
     const previousPage = previousPagesById.get(nextPage.id);
-    const currentExists = await fileExists(path22.join(paths.wikiDir, file.relativePath));
+    const currentExists = await fileExists(path23.join(paths.wikiDir, file.relativePath));
     if (previousPage && previousPage.path !== nextPage.path) {
       entries.push({
         pageId: nextPage.id,
@@ -14360,7 +14647,8 @@ async function buildApprovalEntries(paths, changedFiles, deletedPaths, previousG
         status: "pending",
         sourceIds: nextPage.sourceIds,
         nextPath: nextPage.path,
-        previousPath: previousPage.path
+        previousPath: previousPage.path,
+        label: labelsByPath.get(nextPage.path) ?? labelsByPath.get(previousPage.path)
       });
       handledDeletedPaths.add(previousPage.path);
       continue;
@@ -14373,7 +14661,8 @@ async function buildApprovalEntries(paths, changedFiles, deletedPaths, previousG
       status: "pending",
       sourceIds: nextPage.sourceIds,
       nextPath: nextPage.path,
-      previousPath: previousPage?.path
+      previousPath: previousPage?.path,
+      label: labelsByPath.get(nextPage.path) ?? (previousPage?.path ? labelsByPath.get(previousPage.path) : void 0)
     });
   }
   for (const deletedPath of deletedPaths.sort((left, right) => left.localeCompare(right))) {
@@ -14383,31 +14672,34 @@ async function buildApprovalEntries(paths, changedFiles, deletedPaths, previousG
     const previousPage = previousPagesByPath.get(deletedPath);
     entries.push({
       pageId: previousPage?.id ?? `page:${slugify(deletedPath)}`,
-      title: previousPage?.title ?? path22.basename(deletedPath, ".md"),
+      title: previousPage?.title ?? path23.basename(deletedPath, ".md"),
       kind: previousPage?.kind ?? "index",
       changeType: "delete",
       status: "pending",
       sourceIds: previousPage?.sourceIds ?? [],
-      previousPath: deletedPath
+      previousPath: deletedPath,
+      label: labelsByPath.get(deletedPath)
     });
   }
   return uniqueBy(entries, (entry) => `${entry.pageId}:${entry.changeType}:${entry.nextPath ?? ""}:${entry.previousPath ?? ""}`);
 }
 async function stageApprovalBundle(paths, changedFiles, deletedPaths, previousGraph, graph) {
   const approvalId = `compile-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
-  const approvalDir = path22.join(paths.approvalsDir, approvalId);
+  const approvalDir = path23.join(paths.approvalsDir, approvalId);
   await ensureDir(approvalDir);
-  await ensureDir(path22.join(approvalDir, "wiki"));
-  await ensureDir(path22.join(approvalDir, "state"));
+  await ensureDir(path23.join(approvalDir, "wiki"));
+  await ensureDir(path23.join(approvalDir, "state"));
   for (const file of changedFiles) {
-    const targetPath = path22.join(approvalDir, "wiki", file.relativePath);
-    await ensureDir(path22.dirname(targetPath));
-    await fs18.writeFile(targetPath, file.content, "utf8");
+    const targetPath = path23.join(approvalDir, "wiki", file.relativePath);
+    await ensureDir(path23.dirname(targetPath));
+    await fs19.writeFile(targetPath, file.content, "utf8");
   }
-  await fs18.writeFile(path22.join(approvalDir, "state", "graph.json"), JSON.stringify(graph, null, 2), "utf8");
+  await fs19.writeFile(path23.join(approvalDir, "state", "graph.json"), JSON.stringify(graph, null, 2), "utf8");
   await writeApprovalManifest(paths, {
     approvalId,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    bundleType: "compile",
+    title: "Compile Approval",
     entries: await buildApprovalEntries(paths, changedFiles, deletedPaths, previousGraph, graph)
   });
   return { approvalId, approvalDir };
@@ -14468,7 +14760,7 @@ async function syncVaultArtifacts(rootDir, input) {
       confidence: 1
     });
     const sourceRecord = await buildManagedGraphPage(
-      path22.join(paths.wikiDir, preview.path),
+      path23.join(paths.wikiDir, preview.path),
       {
         managedBy: "system",
         confidence: 1,
@@ -14514,7 +14806,7 @@ async function syncVaultArtifacts(rootDir, input) {
       );
       records.push(
         await buildManagedGraphPage(
-          path22.join(paths.wikiDir, modulePreview.path),
+          path23.join(paths.wikiDir, modulePreview.path),
           {
             managedBy: "system",
             confidence: 1,
@@ -14548,8 +14840,8 @@ async function syncVaultArtifacts(rootDir, input) {
       const relativePath = promoted ? activeAggregatePath(itemKind, slug) : candidatePagePathFor(itemKind, slug);
       const aggregateSourceClass2 = aggregateManifestSourceClass(input.manifests, sourceIds);
       const fallbackPaths = [
-        path22.join(paths.wikiDir, activeAggregatePath(itemKind, slug)),
-        path22.join(paths.wikiDir, candidatePagePathFor(itemKind, slug))
+        path23.join(paths.wikiDir, activeAggregatePath(itemKind, slug)),
+        path23.join(paths.wikiDir, candidatePagePathFor(itemKind, slug))
       ];
       const confidence = nodeConfidence(aggregate.sourceAnalyses.length);
       const preview = emptyGraphPage({
@@ -14567,7 +14859,7 @@ async function syncVaultArtifacts(rootDir, input) {
         status: promoted ? "active" : "candidate"
       });
       const pageRecord = await buildManagedGraphPage(
-        path22.join(paths.wikiDir, relativePath),
+        path23.join(paths.wikiDir, relativePath),
         {
           status: promoted ? "active" : "candidate",
           managedBy: "system",
@@ -14696,7 +14988,7 @@ async function syncVaultArtifacts(rootDir, input) {
       confidence: 1
     }),
     content: await buildManagedContent(
-      path22.join(paths.wikiDir, "projects", "index.md"),
+      path23.join(paths.wikiDir, "projects", "index.md"),
       {
         managedBy: "system",
         compiledFrom: indexCompiledFrom(projectIndexRefs)
@@ -14720,7 +15012,7 @@ async function syncVaultArtifacts(rootDir, input) {
     records.push({
       page: projectIndexRef,
       content: await buildManagedContent(
-        path22.join(paths.wikiDir, projectIndexRef.path),
+        path23.join(paths.wikiDir, projectIndexRef.path),
         {
           managedBy: "system",
           compiledFrom: indexCompiledFrom(Object.values(sections).flat())
@@ -14748,7 +15040,7 @@ async function syncVaultArtifacts(rootDir, input) {
       confidence: 1
     }),
     content: await buildManagedContent(
-      path22.join(paths.wikiDir, "index.md"),
+      path23.join(paths.wikiDir, "index.md"),
       {
         managedBy: "system",
         compiledFrom: indexCompiledFrom(allPages)
@@ -14784,7 +15076,7 @@ async function syncVaultArtifacts(rootDir, input) {
         confidence: 1
       }),
       content: await buildManagedContent(
-        path22.join(paths.wikiDir, relativePath),
+        path23.join(paths.wikiDir, relativePath),
         {
           managedBy: "system",
           compiledFrom: indexCompiledFrom(pages)
@@ -14795,12 +15087,12 @@ async function syncVaultArtifacts(rootDir, input) {
   }
   const nextPagePaths = new Set(records.map((record) => record.page.path));
   const obsoleteGraphPaths = (previousGraph?.pages ?? []).filter((page) => page.kind !== "output" && page.kind !== "insight").map((page) => page.path).filter((relativePath) => !nextPagePaths.has(relativePath));
-  const existingProjectIndexPaths = (await listFilesRecursive(paths.projectsDir)).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path22.relative(paths.wikiDir, absolutePath))).filter((relativePath) => !nextPagePaths.has(relativePath));
+  const existingProjectIndexPaths = (await listFilesRecursive(paths.projectsDir)).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path23.relative(paths.wikiDir, absolutePath))).filter((relativePath) => !nextPagePaths.has(relativePath));
   const obsoletePaths = uniqueStrings3([...obsoleteGraphPaths, ...existingProjectIndexPaths]);
   const changedFiles = [];
   for (const record of records) {
-    const absolutePath = path22.join(paths.wikiDir, record.page.path);
-    const current = await fileExists(absolutePath) ? await fs18.readFile(absolutePath, "utf8") : null;
+    const absolutePath = path23.join(paths.wikiDir, record.page.path);
+    const current = await fileExists(absolutePath) ? await fs19.readFile(absolutePath, "utf8") : null;
     if (current !== record.content) {
       changedPages.push(record.page.path);
       changedFiles.push({ relativePath: record.page.path, content: record.content });
@@ -14825,10 +15117,10 @@ async function syncVaultArtifacts(rootDir, input) {
     await writePage(paths.wikiDir, record.page.path, record.content, writeChanges);
   }
   for (const relativePath of obsoletePaths) {
-    await fs18.rm(path22.join(paths.wikiDir, relativePath), { force: true });
+    await fs19.rm(path23.join(paths.wikiDir, relativePath), { force: true });
   }
   await writeJsonFile(paths.graphPath, graph);
-  await writeJsonFile(path22.join(paths.wikiDir, "graph", "report.json"), graphOrientation.report);
+  await writeJsonFile(path23.join(paths.wikiDir, "graph", "report.json"), graphOrientation.report);
   await writeJsonFile(paths.codeIndexPath, input.codeIndex);
   await writeJsonFile(paths.compileStatePath, {
     generatedAt: graph.generatedAt,
@@ -14923,18 +15215,18 @@ async function refreshIndexesAndSearch(rootDir, pages) {
     })
   );
   await Promise.all([
-    ensureDir(path22.join(paths.wikiDir, "sources")),
-    ensureDir(path22.join(paths.wikiDir, "code")),
-    ensureDir(path22.join(paths.wikiDir, "concepts")),
-    ensureDir(path22.join(paths.wikiDir, "entities")),
-    ensureDir(path22.join(paths.wikiDir, "outputs")),
-    ensureDir(path22.join(paths.wikiDir, "dashboards")),
-    ensureDir(path22.join(paths.wikiDir, "graph")),
-    ensureDir(path22.join(paths.wikiDir, "graph", "communities")),
-    ensureDir(path22.join(paths.wikiDir, "projects")),
-    ensureDir(path22.join(paths.wikiDir, "candidates"))
+    ensureDir(path23.join(paths.wikiDir, "sources")),
+    ensureDir(path23.join(paths.wikiDir, "code")),
+    ensureDir(path23.join(paths.wikiDir, "concepts")),
+    ensureDir(path23.join(paths.wikiDir, "entities")),
+    ensureDir(path23.join(paths.wikiDir, "outputs")),
+    ensureDir(path23.join(paths.wikiDir, "dashboards")),
+    ensureDir(path23.join(paths.wikiDir, "graph")),
+    ensureDir(path23.join(paths.wikiDir, "graph", "communities")),
+    ensureDir(path23.join(paths.wikiDir, "projects")),
+    ensureDir(path23.join(paths.wikiDir, "candidates"))
   ]);
-  const projectsIndexPath = path22.join(paths.wikiDir, "projects", "index.md");
+  const projectsIndexPath = path23.join(paths.wikiDir, "projects", "index.md");
   await writeFileIfChanged(
     projectsIndexPath,
     await buildManagedContent(
@@ -14955,7 +15247,7 @@ async function refreshIndexesAndSearch(rootDir, pages) {
       outputs: pages.filter((page) => page.kind === "output" && page.projectIds.includes(project.id)),
       candidates: pages.filter((page) => page.status === "candidate" && page.projectIds.includes(project.id))
     };
-    const absolutePath = path22.join(paths.wikiDir, "projects", project.id, "index.md");
+    const absolutePath = path23.join(paths.wikiDir, "projects", project.id, "index.md");
     await writeFileIfChanged(
       absolutePath,
       await buildManagedContent(
@@ -14973,7 +15265,7 @@ async function refreshIndexesAndSearch(rootDir, pages) {
       )
     );
   }
-  const rootIndexPath = path22.join(paths.wikiDir, "index.md");
+  const rootIndexPath = path23.join(paths.wikiDir, "index.md");
   await writeFileIfChanged(
     rootIndexPath,
     await buildManagedContent(
@@ -14999,7 +15291,7 @@ async function refreshIndexesAndSearch(rootDir, pages) {
     ["candidates/index.md", "candidates", pagesWithGraph.filter((page) => page.status === "candidate")],
     ["graph/index.md", "graph", pagesWithGraph.filter((page) => page.kind === "graph_report" || page.kind === "community_summary")]
   ]) {
-    const absolutePath = path22.join(paths.wikiDir, relativePath);
+    const absolutePath = path23.join(paths.wikiDir, relativePath);
     await writeFileIfChanged(
       absolutePath,
       await buildManagedContent(
@@ -15013,31 +15305,31 @@ async function refreshIndexesAndSearch(rootDir, pages) {
     );
   }
   for (const record of graphOrientation.records) {
-    await writeFileIfChanged(path22.join(paths.wikiDir, record.page.path), record.content);
+    await writeFileIfChanged(path23.join(paths.wikiDir, record.page.path), record.content);
   }
   for (const record of dashboardRecords) {
-    await writeFileIfChanged(path22.join(paths.wikiDir, record.page.path), record.content);
+    await writeFileIfChanged(path23.join(paths.wikiDir, record.page.path), record.content);
   }
   if (graphOrientation.report) {
-    await writeJsonFile(path22.join(paths.wikiDir, "graph", "report.json"), graphOrientation.report);
+    await writeJsonFile(path23.join(paths.wikiDir, "graph", "report.json"), graphOrientation.report);
   }
-  const existingProjectIndexPaths = (await listFilesRecursive(paths.projectsDir)).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path22.relative(paths.wikiDir, absolutePath)));
+  const existingProjectIndexPaths = (await listFilesRecursive(paths.projectsDir)).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path23.relative(paths.wikiDir, absolutePath)));
   const allowedProjectIndexPaths = /* @__PURE__ */ new Set([
     "projects/index.md",
     ...configuredProjects.map((project) => `projects/${project.id}/index.md`)
   ]);
   await Promise.all(
-    existingProjectIndexPaths.filter((relativePath) => !allowedProjectIndexPaths.has(relativePath)).map((relativePath) => fs18.rm(path22.join(paths.wikiDir, relativePath), { force: true }))
+    existingProjectIndexPaths.filter((relativePath) => !allowedProjectIndexPaths.has(relativePath)).map((relativePath) => fs19.rm(path23.join(paths.wikiDir, relativePath), { force: true }))
   );
-  const existingGraphPages = (await listFilesRecursive(path22.join(paths.wikiDir, "graph").replace(/\/$/, "")).catch(() => [])).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path22.relative(paths.wikiDir, absolutePath)));
+  const existingGraphPages = (await listFilesRecursive(path23.join(paths.wikiDir, "graph").replace(/\/$/, "")).catch(() => [])).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path23.relative(paths.wikiDir, absolutePath)));
   const allowedGraphPages = /* @__PURE__ */ new Set(["graph/index.md", ...graphOrientation.records.map((record) => record.page.path)]);
   await Promise.all(
-    existingGraphPages.filter((relativePath) => !allowedGraphPages.has(relativePath)).map((relativePath) => fs18.rm(path22.join(paths.wikiDir, relativePath), { force: true }))
+    existingGraphPages.filter((relativePath) => !allowedGraphPages.has(relativePath)).map((relativePath) => fs19.rm(path23.join(paths.wikiDir, relativePath), { force: true }))
   );
-  const existingDashboardPages = (await listFilesRecursive(path22.join(paths.wikiDir, "dashboards")).catch(() => [])).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path22.relative(paths.wikiDir, absolutePath)));
+  const existingDashboardPages = (await listFilesRecursive(path23.join(paths.wikiDir, "dashboards")).catch(() => [])).filter((absolutePath) => absolutePath.endsWith(".md")).map((absolutePath) => toPosix(path23.relative(paths.wikiDir, absolutePath)));
   const allowedDashboardPages = /* @__PURE__ */ new Set(["dashboards/index.md", ...dashboardRecords.map((record) => record.page.path)]);
   await Promise.all(
-    existingDashboardPages.filter((relativePath) => !allowedDashboardPages.has(relativePath)).map((relativePath) => fs18.rm(path22.join(paths.wikiDir, relativePath), { force: true }))
+    existingDashboardPages.filter((relativePath) => !allowedDashboardPages.has(relativePath)).map((relativePath) => fs19.rm(path23.join(paths.wikiDir, relativePath), { force: true }))
   );
   await rebuildSearchIndex(paths.searchDbPath, pagesWithGraph, paths.wikiDir);
 }
@@ -15057,7 +15349,7 @@ async function prepareOutputPageSave(rootDir, input) {
       confidence: 0.74
     }
   });
-  const absolutePath = path22.join(paths.wikiDir, output.page.path);
+  const absolutePath = path23.join(paths.wikiDir, output.page.path);
   return {
     page: output.page,
     savedPath: absolutePath,
@@ -15069,15 +15361,15 @@ async function prepareOutputPageSave(rootDir, input) {
 async function persistOutputPage(rootDir, input) {
   const { paths } = await loadVaultConfig(rootDir);
   const prepared = await prepareOutputPageSave(rootDir, input);
-  await ensureDir(path22.dirname(prepared.savedPath));
-  await fs18.writeFile(prepared.savedPath, prepared.content, "utf8");
+  await ensureDir(path23.dirname(prepared.savedPath));
+  await fs19.writeFile(prepared.savedPath, prepared.content, "utf8");
   for (const assetFile of prepared.assetFiles) {
-    const assetPath = path22.join(paths.wikiDir, assetFile.relativePath);
-    await ensureDir(path22.dirname(assetPath));
+    const assetPath = path23.join(paths.wikiDir, assetFile.relativePath);
+    await ensureDir(path23.dirname(assetPath));
     if (typeof assetFile.content === "string") {
-      await fs18.writeFile(assetPath, assetFile.content, assetFile.encoding ?? "utf8");
+      await fs19.writeFile(assetPath, assetFile.content, assetFile.encoding ?? "utf8");
     } else {
-      await fs18.writeFile(assetPath, assetFile.content);
+      await fs19.writeFile(assetPath, assetFile.content);
     }
   }
   return { page: prepared.page, savedPath: prepared.savedPath, outputAssets: prepared.outputAssets };
@@ -15098,7 +15390,7 @@ async function prepareExploreHubSave(rootDir, input) {
       confidence: 0.76
     }
   });
-  const absolutePath = path22.join(paths.wikiDir, hub.page.path);
+  const absolutePath = path23.join(paths.wikiDir, hub.page.path);
   return {
     page: hub.page,
     savedPath: absolutePath,
@@ -15110,20 +15402,20 @@ async function prepareExploreHubSave(rootDir, input) {
 async function persistExploreHub(rootDir, input) {
   const { paths } = await loadVaultConfig(rootDir);
   const prepared = await prepareExploreHubSave(rootDir, input);
-  await ensureDir(path22.dirname(prepared.savedPath));
-  await fs18.writeFile(prepared.savedPath, prepared.content, "utf8");
+  await ensureDir(path23.dirname(prepared.savedPath));
+  await fs19.writeFile(prepared.savedPath, prepared.content, "utf8");
   for (const assetFile of prepared.assetFiles) {
-    const assetPath = path22.join(paths.wikiDir, assetFile.relativePath);
-    await ensureDir(path22.dirname(assetPath));
+    const assetPath = path23.join(paths.wikiDir, assetFile.relativePath);
+    await ensureDir(path23.dirname(assetPath));
     if (typeof assetFile.content === "string") {
-      await fs18.writeFile(assetPath, assetFile.content, assetFile.encoding ?? "utf8");
+      await fs19.writeFile(assetPath, assetFile.content, assetFile.encoding ?? "utf8");
     } else {
-      await fs18.writeFile(assetPath, assetFile.content);
+      await fs19.writeFile(assetPath, assetFile.content);
     }
   }
   return { page: prepared.page, savedPath: prepared.savedPath, outputAssets: prepared.outputAssets };
 }
-async function stageOutputApprovalBundle(rootDir, stagedPages) {
+async function stageOutputApprovalBundle(rootDir, stagedPages, options = {}) {
   const { paths } = await loadVaultConfig(rootDir);
   const previousGraph = await readJsonFile(paths.graphPath);
   const changedFiles = stagedPages.flatMap((item) => [
@@ -15134,18 +15426,19 @@ async function stageOutputApprovalBundle(rootDir, stagedPages) {
       binary: typeof assetFile.content !== "string"
     }))
   ]);
+  const labelsByPath = new Map(stagedPages.filter((item) => item.label).map((item) => [item.page.path, item.label]));
   const approvalId = `schedule-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
-  const approvalDir = path22.join(paths.approvalsDir, approvalId);
+  const approvalDir = path23.join(paths.approvalsDir, approvalId);
   await ensureDir(approvalDir);
-  await ensureDir(path22.join(approvalDir, "wiki"));
-  await ensureDir(path22.join(approvalDir, "state"));
+  await ensureDir(path23.join(approvalDir, "wiki"));
+  await ensureDir(path23.join(approvalDir, "state"));
   for (const file of changedFiles) {
-    const targetPath = path22.join(approvalDir, "wiki", file.relativePath);
-    await ensureDir(path22.dirname(targetPath));
+    const targetPath = path23.join(approvalDir, "wiki", file.relativePath);
+    await ensureDir(path23.dirname(targetPath));
     if ("binary" in file && file.binary) {
-      await fs18.writeFile(targetPath, Buffer.from(file.content, "base64"));
+      await fs19.writeFile(targetPath, Buffer.from(file.content, "base64"));
     } else {
-      await fs18.writeFile(targetPath, file.content, "utf8");
+      await fs19.writeFile(targetPath, file.content, "utf8");
     }
   }
   const nextPages = sortGraphPages([
@@ -15160,22 +15453,26 @@ async function stageOutputApprovalBundle(rootDir, stagedPages) {
     sources: previousGraph?.sources ?? [],
     pages: nextPages
   };
-  await fs18.writeFile(path22.join(approvalDir, "state", "graph.json"), JSON.stringify(graph, null, 2), "utf8");
+  await fs19.writeFile(path23.join(approvalDir, "state", "graph.json"), JSON.stringify(graph, null, 2), "utf8");
   await writeApprovalManifest(paths, {
     approvalId,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    bundleType: options.bundleType ?? "generated_output",
+    title: options.title,
+    sourceSessionId: options.sourceSessionId,
     entries: await buildApprovalEntries(
       paths,
       stagedPages.map((item) => ({ relativePath: item.page.path, content: item.content })),
       [],
       previousGraph ?? null,
-      graph
+      graph,
+      labelsByPath
     )
   });
   return { approvalId, approvalDir };
 }
-async function stageGeneratedOutputPages(rootDir, stagedPages) {
-  return await stageOutputApprovalBundle(rootDir, stagedPages);
+async function stageGeneratedOutputPages(rootDir, stagedPages, options = {}) {
+  return await stageOutputApprovalBundle(rootDir, stagedPages, options);
 }
 async function executeQuery(rootDir, question, format) {
   const { paths } = await loadVaultConfig(rootDir);
@@ -15192,9 +15489,9 @@ async function executeQuery(rootDir, question, format) {
   const searchResults = searchPages(paths.searchDbPath, question, 5);
   const excerpts = await Promise.all(
     searchResults.map(async (result) => {
-      const absolutePath = path22.join(paths.wikiDir, result.path);
+      const absolutePath = path23.join(paths.wikiDir, result.path);
       try {
-        const content = await fs18.readFile(absolutePath, "utf8");
+        const content = await fs19.readFile(absolutePath, "utf8");
         const parsed = matter9(content);
         return `# ${result.title}
 ${truncate(normalizeWhitespace(parsed.content), 1200)}`;
@@ -15429,7 +15726,7 @@ function computeChangeSummary(current, staged, changeType) {
 async function listApprovals(rootDir) {
   const { paths } = await loadVaultConfig(rootDir);
   const manifests = await Promise.all(
-    (await fs18.readdir(paths.approvalsDir, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isDirectory()).map(async (entry) => {
+    (await fs19.readdir(paths.approvalsDir, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isDirectory()).map(async (entry) => {
       try {
         return await readApprovalManifest(paths, entry.name);
       } catch {
@@ -15445,8 +15742,8 @@ async function readApproval(rootDir, approvalId, options) {
   const details = await Promise.all(
     manifest.entries.map(async (entry) => {
       const currentPath = entry.previousPath ?? entry.nextPath;
-      const currentContent = currentPath ? await fs18.readFile(path22.join(paths.wikiDir, currentPath), "utf8").catch(() => void 0) : void 0;
-      const stagedContent = entry.nextPath ? await fs18.readFile(path22.join(paths.approvalsDir, approvalId, "wiki", entry.nextPath), "utf8").catch(() => void 0) : void 0;
+      const currentContent = currentPath ? await fs19.readFile(path23.join(paths.wikiDir, currentPath), "utf8").catch(() => void 0) : void 0;
+      const stagedContent = entry.nextPath ? await fs19.readFile(path23.join(paths.approvalsDir, approvalId, "wiki", entry.nextPath), "utf8").catch(() => void 0) : void 0;
       const detail = {
         ...entry,
         currentContent,
@@ -15479,26 +15776,26 @@ async function acceptApproval(rootDir, approvalId, targets = []) {
       if (!entry.nextPath) {
         throw new Error(`Approval entry ${entry.pageId} is missing a staged path.`);
       }
-      const stagedAbsolutePath = path22.join(paths.approvalsDir, approvalId, "wiki", entry.nextPath);
-      const stagedContent = await fs18.readFile(stagedAbsolutePath, "utf8");
-      const targetAbsolutePath = path22.join(paths.wikiDir, entry.nextPath);
-      await ensureDir(path22.dirname(targetAbsolutePath));
-      await fs18.writeFile(targetAbsolutePath, stagedContent, "utf8");
+      const stagedAbsolutePath = path23.join(paths.approvalsDir, approvalId, "wiki", entry.nextPath);
+      const stagedContent = await fs19.readFile(stagedAbsolutePath, "utf8");
+      const targetAbsolutePath = path23.join(paths.wikiDir, entry.nextPath);
+      await ensureDir(path23.dirname(targetAbsolutePath));
+      await fs19.writeFile(targetAbsolutePath, stagedContent, "utf8");
       if (entry.changeType === "promote" && entry.previousPath) {
-        await fs18.rm(path22.join(paths.wikiDir, entry.previousPath), { force: true });
+        await fs19.rm(path23.join(paths.wikiDir, entry.previousPath), { force: true });
       }
       const nextPage = bundleGraph?.pages.find((page) => page.id === entry.pageId && page.path === entry.nextPath) ?? parseStoredPage(entry.nextPath, stagedContent);
       if (nextPage.kind === "output" && nextPage.outputAssets?.length) {
-        const outputAssetDir = path22.join(paths.wikiDir, "outputs", "assets", path22.basename(nextPage.path, ".md"));
-        await fs18.rm(outputAssetDir, { recursive: true, force: true });
+        const outputAssetDir = path23.join(paths.wikiDir, "outputs", "assets", path23.basename(nextPage.path, ".md"));
+        await fs19.rm(outputAssetDir, { recursive: true, force: true });
         for (const asset of nextPage.outputAssets) {
-          const stagedAssetPath = path22.join(paths.approvalsDir, approvalId, "wiki", asset.path);
+          const stagedAssetPath = path23.join(paths.approvalsDir, approvalId, "wiki", asset.path);
           if (!await fileExists(stagedAssetPath)) {
             continue;
           }
-          const targetAssetPath = path22.join(paths.wikiDir, asset.path);
-          await ensureDir(path22.dirname(targetAssetPath));
-          await fs18.copyFile(stagedAssetPath, targetAssetPath);
+          const targetAssetPath = path23.join(paths.wikiDir, asset.path);
+          await ensureDir(path23.dirname(targetAssetPath));
+          await fs19.copyFile(stagedAssetPath, targetAssetPath);
         }
       }
       nextPages = nextPages.filter(
@@ -15509,10 +15806,10 @@ async function acceptApproval(rootDir, approvalId, targets = []) {
     } else {
       const deletedPage = nextPages.find((page) => page.id === entry.pageId || page.path === entry.previousPath) ?? bundleGraph?.pages.find((page) => page.id === entry.pageId || page.path === entry.previousPath) ?? null;
       if (entry.previousPath) {
-        await fs18.rm(path22.join(paths.wikiDir, entry.previousPath), { force: true });
+        await fs19.rm(path23.join(paths.wikiDir, entry.previousPath), { force: true });
       }
       if (deletedPage?.kind === "output") {
-        await fs18.rm(path22.join(paths.wikiDir, "outputs", "assets", path22.basename(deletedPage.path, ".md")), {
+        await fs19.rm(path23.join(paths.wikiDir, "outputs", "assets", path23.basename(deletedPage.path, ".md")), {
           recursive: true,
           force: true
         });
@@ -15535,6 +15832,9 @@ async function acceptApproval(rootDir, approvalId, targets = []) {
   await writeJsonFile(paths.compileStatePath, compileState);
   await refreshIndexesAndSearch(rootDir, nextGraph.pages);
   await writeApprovalManifest(paths, manifest);
+  if (manifest.sourceSessionId) {
+    await updateGuidedSourceSessionStatus(rootDir, manifest.sourceSessionId, "accepted");
+  }
   await recordSession(rootDir, {
     operation: "review",
     title: `Accepted review entries from ${approvalId}`,
@@ -15561,6 +15861,9 @@ async function rejectApproval(rootDir, approvalId, targets = []) {
     entry.status = "rejected";
   }
   await writeApprovalManifest(paths, manifest);
+  if (manifest.sourceSessionId) {
+    await updateGuidedSourceSessionStatus(rootDir, manifest.sourceSessionId, "rejected");
+  }
   await recordSession(rootDir, {
     operation: "review",
     title: `Rejected review entries from ${approvalId}`,
@@ -15603,7 +15906,7 @@ async function promoteCandidate(rootDir, target) {
   const { paths } = await loadVaultConfig(rootDir);
   const graph = await readJsonFile(paths.graphPath);
   const candidate = resolveCandidateTarget(graph?.pages ?? [], target);
-  const raw = await fs18.readFile(path22.join(paths.wikiDir, candidate.path), "utf8");
+  const raw = await fs19.readFile(path23.join(paths.wikiDir, candidate.path), "utf8");
   const parsed = matter9(raw);
   const nextUpdatedAt = (/* @__PURE__ */ new Date()).toISOString();
   const nextContent = matter9.stringify(parsed.content, {
@@ -15615,10 +15918,10 @@ async function promoteCandidate(rootDir, target) {
     )
   });
   const nextPath = candidateActivePath(candidate);
-  const nextAbsolutePath = path22.join(paths.wikiDir, nextPath);
-  await ensureDir(path22.dirname(nextAbsolutePath));
-  await fs18.writeFile(nextAbsolutePath, nextContent, "utf8");
-  await fs18.rm(path22.join(paths.wikiDir, candidate.path), { force: true });
+  const nextAbsolutePath = path23.join(paths.wikiDir, nextPath);
+  await ensureDir(path23.dirname(nextAbsolutePath));
+  await fs19.writeFile(nextAbsolutePath, nextContent, "utf8");
+  await fs19.rm(path23.join(paths.wikiDir, candidate.path), { force: true });
   const nextPage = parseStoredPage(nextPath, nextContent, { createdAt: candidate.createdAt, updatedAt: nextUpdatedAt });
   const nextPages = sortGraphPages(
     (graph?.pages ?? []).filter((page) => page.id !== candidate.id && page.path !== candidate.path).concat(nextPage)
@@ -15663,7 +15966,7 @@ async function archiveCandidate(rootDir, target) {
   const { paths } = await loadVaultConfig(rootDir);
   const graph = await readJsonFile(paths.graphPath);
   const candidate = resolveCandidateTarget(graph?.pages ?? [], target);
-  await fs18.rm(path22.join(paths.wikiDir, candidate.path), { force: true });
+  await fs19.rm(path23.join(paths.wikiDir, candidate.path), { force: true });
   const nextPages = sortGraphPages((graph?.pages ?? []).filter((page) => page.id !== candidate.id && page.path !== candidate.path));
   const nextGraph = {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -15702,18 +16005,18 @@ async function archiveCandidate(rootDir, target) {
 }
 async function ensureObsidianWorkspace(rootDir) {
   const { config } = await loadVaultConfig(rootDir);
-  const obsidianDir = path22.join(rootDir, ".obsidian");
+  const obsidianDir = path23.join(rootDir, ".obsidian");
   const projectIds = projectEntries(config).map((project) => project.id);
   await ensureDir(obsidianDir);
   await Promise.all([
-    writeJsonFile(path22.join(obsidianDir, "app.json"), {
+    writeJsonFile(path23.join(obsidianDir, "app.json"), {
       alwaysUpdateLinks: true,
       newFileLocation: "folder",
       newFileFolderPath: "wiki/insights",
       useMarkdownLinks: false,
       attachmentFolderPath: "raw/assets"
     }),
-    writeJsonFile(path22.join(obsidianDir, "core-plugins.json"), [
+    writeJsonFile(path23.join(obsidianDir, "core-plugins.json"), [
       "file-explorer",
       "global-search",
       "switcher",
@@ -15723,7 +16026,7 @@ async function ensureObsidianWorkspace(rootDir) {
       "tag-pane",
       "page-preview"
     ]),
-    writeJsonFile(path22.join(obsidianDir, "graph.json"), {
+    writeJsonFile(path23.join(obsidianDir, "graph.json"), {
       "collapse-filter": false,
       search: "",
       showTags: true,
@@ -15735,7 +16038,7 @@ async function ensureObsidianWorkspace(rootDir) {
       })),
       localJumps: false
     }),
-    writeJsonFile(path22.join(obsidianDir, "workspace.json"), {
+    writeJsonFile(path23.join(obsidianDir, "workspace.json"), {
       active: "root",
       lastOpenFiles: ["wiki/index.md", "wiki/projects/index.md", "wiki/candidates/index.md", "wiki/insights/index.md"],
       left: {
@@ -15748,22 +16051,32 @@ async function ensureObsidianWorkspace(rootDir) {
   ]);
 }
 async function initVault(rootDir, options = {}) {
-  const { paths } = await initWorkspace(rootDir);
+  const profile = options.profile ?? "default";
+  const { paths } = await initWorkspace(rootDir, { profile });
   await installConfiguredAgents(rootDir);
-  const insightsIndexPath = path22.join(paths.wikiDir, "insights", "index.md");
+  const insightsIndexPath = path23.join(paths.wikiDir, "insights", "index.md");
   const now = (/* @__PURE__ */ new Date()).toISOString();
   await writeFileIfChanged(
     insightsIndexPath,
     matter9.stringify(
-      [
+      (profile === "personal-research" ? [
+        "# Insights",
+        "",
+        "Human-authored research notes live here.",
+        "",
+        "- Use this folder for thesis notes, reading reflections, synthesis drafts, and decisions you want to keep explicitly human-authored.",
+        "- Guided sessions can stage `wiki/insights/` updates through the approval queue, but SwarmVault never applies them without review.",
+        "- Treat these pages as the human judgment layer for your vault.",
+        ""
+      ] : [
         "# Insights",
         "",
         "Human-authored notes live here.",
         "",
         "- SwarmVault can read these pages during compile and query.",
-        "- SwarmVault does not rewrite files inside `wiki/insights/` after initialization.",
+        "- SwarmVault can stage insight-page updates through guided sessions, but it never applies them without review.",
         ""
-      ].join("\n"),
+      ]).join("\n"),
       {
         page_id: "insights:index",
         kind: "index",
@@ -15787,7 +16100,7 @@ async function initVault(rootDir, options = {}) {
     )
   );
   await writeFileIfChanged(
-    path22.join(paths.wikiDir, "projects", "index.md"),
+    path23.join(paths.wikiDir, "projects", "index.md"),
     matter9.stringify(["# Projects", "", "- Run `swarmvault compile` to build project rollups.", ""].join("\n"), {
       page_id: "projects:index",
       kind: "index",
@@ -15810,7 +16123,7 @@ async function initVault(rootDir, options = {}) {
     })
   );
   await writeFileIfChanged(
-    path22.join(paths.wikiDir, "candidates", "index.md"),
+    path23.join(paths.wikiDir, "candidates", "index.md"),
     matter9.stringify(["# Candidates", "", "- Run `swarmvault compile` to stage candidate pages.", ""].join("\n"), {
       page_id: "candidates:index",
       kind: "index",
@@ -15835,6 +16148,43 @@ async function initVault(rootDir, options = {}) {
   if (options.obsidian) {
     await ensureObsidianWorkspace(rootDir);
   }
+  if (profile === "personal-research") {
+    await writeFileIfChanged(
+      path23.join(paths.wikiDir, "insights", "research-playbook.md"),
+      matter9.stringify(
+        [
+          "# Personal Research Playbook",
+          "",
+          "- Add one source at a time with `swarmvault ingest <input> --guide` or `swarmvault source add <input> --guide`.",
+          "- Resume a guided session with `swarmvault source session <source-id-or-session-id>` whenever you want to answer the session prompts directly.",
+          "- Review `wiki/outputs/source-briefs/`, `wiki/outputs/source-reviews/`, `wiki/outputs/source-guides/`, and `wiki/outputs/source-sessions/` before accepting staged updates.",
+          "- Keep unresolved questions visible in `wiki/dashboards/open-questions.md`.",
+          "- Use `swarmvault review list` and `swarmvault review show --diff` to decide what becomes canonical.",
+          ""
+        ].join("\n"),
+        {
+          page_id: "insights:research-playbook",
+          kind: "insight",
+          title: "Personal Research Playbook",
+          tags: ["insight", "research", "playbook"],
+          source_ids: [],
+          project_ids: [],
+          node_ids: [],
+          freshness: "fresh",
+          status: "active",
+          confidence: 1,
+          created_at: now,
+          updated_at: now,
+          compiled_from: [],
+          managed_by: "human",
+          backlinks: [],
+          schema_hash: "",
+          source_hashes: {},
+          source_semantic_hashes: {}
+        }
+      )
+    );
+  }
 }
 async function runConfiguredBenchmark(rootDir, config) {
   if (config.benchmark?.enabled === false) {
@@ -15950,7 +16300,7 @@ async function compileVault(rootDir, options = {}) {
     ),
     Promise.all(
       clean.map(async (manifest) => {
-        const cached = await readJsonFile(path22.join(paths.analysesDir, `${manifest.sourceId}.json`));
+        const cached = await readJsonFile(path23.join(paths.analysesDir, `${manifest.sourceId}.json`));
         if (cached) {
           analysisProgress.tick(manifest.title);
           return cached;
@@ -15978,22 +16328,22 @@ async function compileVault(rootDir, options = {}) {
       }
       const enriched = enrichResolvedCodeImports(manifest, analysis, codeIndex);
       if (analysisSignature(enriched) !== analysisSignature(analysis)) {
-        await writeJsonFile(path22.join(paths.analysesDir, `${analysis.sourceId}.json`), enriched);
+        await writeJsonFile(path23.join(paths.analysesDir, `${analysis.sourceId}.json`), enriched);
       }
       return enriched;
     })
   );
   await Promise.all([
-    ensureDir(path22.join(paths.wikiDir, "sources")),
-    ensureDir(path22.join(paths.wikiDir, "code")),
-    ensureDir(path22.join(paths.wikiDir, "concepts")),
-    ensureDir(path22.join(paths.wikiDir, "entities")),
-    ensureDir(path22.join(paths.wikiDir, "outputs")),
-    ensureDir(path22.join(paths.wikiDir, "projects")),
-    ensureDir(path22.join(paths.wikiDir, "insights")),
-    ensureDir(path22.join(paths.wikiDir, "candidates")),
-    ensureDir(path22.join(paths.wikiDir, "candidates", "concepts")),
-    ensureDir(path22.join(paths.wikiDir, "candidates", "entities"))
+    ensureDir(path23.join(paths.wikiDir, "sources")),
+    ensureDir(path23.join(paths.wikiDir, "code")),
+    ensureDir(path23.join(paths.wikiDir, "concepts")),
+    ensureDir(path23.join(paths.wikiDir, "entities")),
+    ensureDir(path23.join(paths.wikiDir, "outputs")),
+    ensureDir(path23.join(paths.wikiDir, "projects")),
+    ensureDir(path23.join(paths.wikiDir, "insights")),
+    ensureDir(path23.join(paths.wikiDir, "candidates")),
+    ensureDir(path23.join(paths.wikiDir, "candidates", "concepts")),
+    ensureDir(path23.join(paths.wikiDir, "candidates", "entities"))
   ]);
   const sync = await syncVaultArtifacts(rootDir, {
     schemas,
@@ -16140,7 +16490,7 @@ async function queryVault(rootDir, options) {
           assetFiles: staged.assetFiles
         }
       ]);
-      stagedPath = path22.join(approval.approvalDir, "wiki", staged.page.path);
+      stagedPath = path23.join(approval.approvalDir, "wiki", staged.page.path);
       savedPageId = staged.page.id;
       approvalId = approval.approvalId;
       approvalDir = approval.approvalDir;
@@ -16396,9 +16746,9 @@ ${orchestrationNotes.join("\n")}
     approvalId = approval.approvalId;
     approvalDir = approval.approvalDir;
     stepResults.forEach((result, index) => {
-      result.stagedPath = path22.join(approval.approvalDir, "wiki", stagedStepPages[index]?.page.path ?? "");
+      result.stagedPath = path23.join(approval.approvalDir, "wiki", stagedStepPages[index]?.page.path ?? "");
     });
-    stagedHubPath = path22.join(approval.approvalDir, "wiki", hubPage.path);
+    stagedHubPath = path23.join(approval.approvalDir, "wiki", hubPage.path);
   } else {
     await refreshVaultAfterOutputSave(rootDir);
   }
@@ -16485,11 +16835,11 @@ async function benchmarkVault(rootDir, options = {}) {
     }
   }
   for (const page of graph.pages) {
-    const absolutePath = path22.join(paths.wikiDir, page.path);
+    const absolutePath = path23.join(paths.wikiDir, page.path);
     if (!await fileExists(absolutePath)) {
       continue;
     }
-    const parsed = matter9(await fs18.readFile(absolutePath, "utf8"));
+    const parsed = matter9(await fs19.readFile(absolutePath, "utf8"));
     pageContentsById.set(page.id, parsed.content);
   }
   const configuredQuestions = (config.benchmark?.questions ?? []).map((question) => normalizeWhitespace(question)).filter(Boolean);
@@ -16544,7 +16894,7 @@ async function listGraphHyperedges(rootDir, target, limit = 25) {
 }
 async function readGraphReport(rootDir) {
   const { paths } = await loadVaultConfig(rootDir);
-  return readJsonFile(path22.join(paths.wikiDir, "graph", "report.json"));
+  return readJsonFile(path23.join(paths.wikiDir, "graph", "report.json"));
 }
 async function listGodNodes(rootDir, limit = 10) {
   const graph = await ensureCompiledGraph(rootDir);
@@ -16557,15 +16907,15 @@ async function listPages(rootDir) {
 }
 async function readPage(rootDir, relativePath) {
   const { paths } = await loadVaultConfig(rootDir);
-  const absolutePath = path22.resolve(paths.wikiDir, relativePath);
+  const absolutePath = path23.resolve(paths.wikiDir, relativePath);
   if (!absolutePath.startsWith(paths.wikiDir) || !await fileExists(absolutePath)) {
     return null;
   }
-  const raw = await fs18.readFile(absolutePath, "utf8");
+  const raw = await fs19.readFile(absolutePath, "utf8");
   const parsed = matter9(raw);
   return {
     path: relativePath,
-    title: typeof parsed.data.title === "string" ? parsed.data.title : path22.basename(relativePath, path22.extname(relativePath)),
+    title: typeof parsed.data.title === "string" ? parsed.data.title : path23.basename(relativePath, path23.extname(relativePath)),
     frontmatter: parsed.data,
     content: parsed.content
   };
@@ -16601,7 +16951,7 @@ function structuralLintFindings(_rootDir, paths, graph, schemas, manifests, sour
           severity: "warning",
           code: "stale_page",
           message: `Page ${page.title} is stale because the vault schema changed.`,
-          pagePath: path22.join(paths.wikiDir, page.path),
+          pagePath: path23.join(paths.wikiDir, page.path),
           relatedPageIds: [page.id]
         });
       }
@@ -16614,7 +16964,7 @@ function structuralLintFindings(_rootDir, paths, graph, schemas, manifests, sour
             severity: "warning",
             code: "stale_page",
             message: `Page ${page.title} is stale because source ${sourceId} changed.`,
-            pagePath: path22.join(paths.wikiDir, page.path),
+            pagePath: path23.join(paths.wikiDir, page.path),
             relatedSourceIds: [sourceId],
             relatedPageIds: [page.id]
           });
@@ -16625,13 +16975,13 @@ function structuralLintFindings(_rootDir, paths, graph, schemas, manifests, sour
           severity: "info",
           code: "orphan_page",
           message: `Page ${page.title} has no backlinks.`,
-          pagePath: path22.join(paths.wikiDir, page.path),
+          pagePath: path23.join(paths.wikiDir, page.path),
           relatedPageIds: [page.id]
         });
       }
-      const absolutePath = path22.join(paths.wikiDir, page.path);
+      const absolutePath = path23.join(paths.wikiDir, page.path);
       if (await fileExists(absolutePath)) {
-        const content = await fs18.readFile(absolutePath, "utf8");
+        const content = await fs19.readFile(absolutePath, "utf8");
         if (content.includes("## Claims")) {
           const uncited = content.split("\n").filter((line) => line.startsWith("- ") && !line.includes("[source:"));
           if (uncited.length) {
@@ -16748,7 +17098,7 @@ async function bootstrapDemo(rootDir, input) {
 }
 
 // src/mcp.ts
-var SERVER_VERSION = "0.4.0";
+var SERVER_VERSION = "0.6.0";
 async function createMcpServer(rootDir) {
   const server = new McpServer({
     name: "swarmvault",
@@ -17019,7 +17369,7 @@ async function createMcpServer(rootDir) {
     },
     async () => {
       const { paths } = await loadVaultConfig(rootDir);
-      const files = (await listFilesRecursive(paths.sessionsDir)).filter((filePath) => filePath.endsWith(".md")).map((filePath) => toPosix(path23.relative(paths.sessionsDir, filePath))).sort();
+      const files = (await listFilesRecursive(paths.sessionsDir)).filter((filePath) => filePath.endsWith(".md")).map((filePath) => toPosix(path24.relative(paths.sessionsDir, filePath))).sort();
       return asTextResource("swarmvault://sessions", JSON.stringify(files, null, 2));
     }
   );
@@ -17052,8 +17402,8 @@ async function createMcpServer(rootDir) {
         return asTextResource(`swarmvault://pages/${encodedPath}`, `Page not found: ${relativePath}`);
       }
       const { paths } = await loadVaultConfig(rootDir);
-      const absolutePath = path23.resolve(paths.wikiDir, relativePath);
-      return asTextResource(`swarmvault://pages/${encodedPath}`, await fs19.readFile(absolutePath, "utf8"));
+      const absolutePath = path24.resolve(paths.wikiDir, relativePath);
+      return asTextResource(`swarmvault://pages/${encodedPath}`, await fs20.readFile(absolutePath, "utf8"));
     }
   );
   server.registerResource(
@@ -17061,11 +17411,11 @@ async function createMcpServer(rootDir) {
     new ResourceTemplate("swarmvault://sessions/{path}", {
       list: async () => {
         const { paths } = await loadVaultConfig(rootDir);
-        const files = (await listFilesRecursive(paths.sessionsDir)).filter((filePath) => filePath.endsWith(".md")).map((filePath) => toPosix(path23.relative(paths.sessionsDir, filePath))).sort();
+        const files = (await listFilesRecursive(paths.sessionsDir)).filter((filePath) => filePath.endsWith(".md")).map((filePath) => toPosix(path24.relative(paths.sessionsDir, filePath))).sort();
         return {
           resources: files.map((relativePath) => ({
             uri: `swarmvault://sessions/${encodeURIComponent(relativePath)}`,
-            name: path23.basename(relativePath, ".md"),
+            name: path24.basename(relativePath, ".md"),
             title: relativePath,
             description: "SwarmVault session artifact",
             mimeType: "text/markdown"
@@ -17082,11 +17432,11 @@ async function createMcpServer(rootDir) {
       const { paths } = await loadVaultConfig(rootDir);
       const encodedPath = typeof variables.path === "string" ? variables.path : "";
       const relativePath = decodeURIComponent(encodedPath);
-      const absolutePath = path23.resolve(paths.sessionsDir, relativePath);
+      const absolutePath = path24.resolve(paths.sessionsDir, relativePath);
       if (!absolutePath.startsWith(paths.sessionsDir) || !await fileExists(absolutePath)) {
         return asTextResource(`swarmvault://sessions/${encodedPath}`, `Session not found: ${relativePath}`);
       }
-      return asTextResource(`swarmvault://sessions/${encodedPath}`, await fs19.readFile(absolutePath, "utf8"));
+      return asTextResource(`swarmvault://sessions/${encodedPath}`, await fs20.readFile(absolutePath, "utf8"));
     }
   );
   return server;
@@ -17134,13 +17484,13 @@ function asTextResource(uri, text) {
 }
 
 // src/schedule.ts
-import fs20 from "fs/promises";
-import path24 from "path";
+import fs21 from "fs/promises";
+import path25 from "path";
 function scheduleStatePath(schedulesDir, jobId) {
-  return path24.join(schedulesDir, `${encodeURIComponent(jobId)}.json`);
+  return path25.join(schedulesDir, `${encodeURIComponent(jobId)}.json`);
 }
 function scheduleLockPath(schedulesDir, jobId) {
-  return path24.join(schedulesDir, `${encodeURIComponent(jobId)}.lock`);
+  return path25.join(schedulesDir, `${encodeURIComponent(jobId)}.lock`);
 }
 function parseEveryDuration(value) {
   const match = value.trim().match(/^(\d+)(m|h|d)$/i);
@@ -17243,13 +17593,13 @@ async function acquireJobLease(rootDir, jobId) {
   const { paths } = await loadVaultConfig(rootDir);
   const leasePath = scheduleLockPath(paths.schedulesDir, jobId);
   await ensureDir(paths.schedulesDir);
-  const handle = await fs20.open(leasePath, "wx");
+  const handle = await fs21.open(leasePath, "wx");
   await handle.writeFile(`${process.pid}
 ${(/* @__PURE__ */ new Date()).toISOString()}
 `);
   await handle.close();
   return async () => {
-    await fs20.rm(leasePath, { force: true });
+    await fs21.rm(leasePath, { force: true });
   };
 }
 async function listSchedules(rootDir) {
@@ -17397,8 +17747,9 @@ async function serveSchedules(rootDir, pollMs = 3e4) {
 
 // src/sources.ts
 import { spawn as spawn2 } from "child_process";
-import fs21 from "fs/promises";
-import path25 from "path";
+import fs22 from "fs/promises";
+import path26 from "path";
+import matter10 from "gray-matter";
 import { JSDOM as JSDOM3 } from "jsdom";
 var DEFAULT_CRAWL_MAX_PAGES = 12;
 var DEFAULT_CRAWL_MAX_DEPTH = 2;
@@ -17425,24 +17776,24 @@ function normalizeManagedStatus(value) {
   return value === "missing" || value === "error" ? value : "ready";
 }
 function withinRoot2(rootPath, targetPath) {
-  const relative = path25.relative(rootPath, targetPath);
-  return relative === "" || !relative.startsWith("..") && !path25.isAbsolute(relative);
+  const relative = path26.relative(rootPath, targetPath);
+  return relative === "" || !relative.startsWith("..") && !path26.isAbsolute(relative);
 }
 async function findNearestGitRoot3(startPath) {
-  let current = path25.resolve(startPath);
+  let current = path26.resolve(startPath);
   try {
-    const stat = await fs21.stat(current);
+    const stat = await fs22.stat(current);
     if (!stat.isDirectory()) {
-      current = path25.dirname(current);
+      current = path26.dirname(current);
     }
   } catch {
-    current = path25.dirname(current);
+    current = path26.dirname(current);
   }
   while (true) {
-    if (await fileExists(path25.join(current, ".git"))) {
+    if (await fileExists(path26.join(current, ".git"))) {
       return current;
     }
-    const parent = path25.dirname(current);
+    const parent = path26.dirname(current);
     if (parent === current) {
       return null;
     }
@@ -17516,7 +17867,7 @@ function isAllowedDocsCandidate(candidate, startUrl) {
   if (candidate.origin !== startUrl.origin) {
     return false;
   }
-  const extension = path25.extname(candidate.pathname).toLowerCase();
+  const extension = path26.extname(candidate.pathname).toLowerCase();
   if (extension && extension !== ".html" && extension !== ".htm" && extension !== ".md") {
     return false;
   }
@@ -17605,14 +17956,14 @@ function matchesManagedSourceSpec(existing, input) {
     return false;
   }
   if (input.kind === "directory" || input.kind === "file") {
-    return path25.resolve(existing.path ?? "") === path25.resolve(input.path);
+    return path26.resolve(existing.path ?? "") === path26.resolve(input.path);
   }
   return (existing.url ?? "") === input.url;
 }
 async function resolveManagedSourceInput(rootDir, input) {
-  const absoluteInput = path25.resolve(rootDir, input);
+  const absoluteInput = path26.resolve(rootDir, input);
   if (!(input.startsWith("http://") || input.startsWith("https://"))) {
-    const stat = await fs21.stat(absoluteInput).catch(() => null);
+    const stat = await fs22.stat(absoluteInput).catch(() => null);
     if (!stat) {
       throw new Error(`Source not found: ${input}`);
     }
@@ -17620,7 +17971,7 @@ async function resolveManagedSourceInput(rootDir, input) {
       return {
         kind: "file",
         path: absoluteInput,
-        title: path25.basename(absoluteInput, path25.extname(absoluteInput)) || absoluteInput
+        title: path26.basename(absoluteInput, path26.extname(absoluteInput)) || absoluteInput
       };
     }
     if (!stat.isDirectory()) {
@@ -17632,7 +17983,7 @@ async function resolveManagedSourceInput(rootDir, input) {
       kind: "directory",
       path: absoluteInput,
       repoRoot,
-      title: path25.basename(absoluteInput) || absoluteInput
+      title: path26.basename(absoluteInput) || absoluteInput
     };
   }
   const github = normalizeGitHubRepoRootUrl(input);
@@ -17655,16 +18006,16 @@ async function resolveManagedSourceInput(rootDir, input) {
   };
 }
 function directorySourceIdsFor(manifests, inputPath) {
-  return manifests.filter((manifest) => manifest.originalPath && withinRoot2(path25.resolve(inputPath), path25.resolve(manifest.originalPath))).map((manifest) => manifest.sourceId).sort((left, right) => left.localeCompare(right));
+  return manifests.filter((manifest) => manifest.originalPath && withinRoot2(path26.resolve(inputPath), path26.resolve(manifest.originalPath))).map((manifest) => manifest.sourceId).sort((left, right) => left.localeCompare(right));
 }
 function fileSourceIdsFor(manifests, inputPath) {
-  const absoluteInput = path25.resolve(inputPath);
-  return manifests.filter((manifest) => manifest.originalPath && path25.resolve(manifest.originalPath) === absoluteInput).map((manifest) => manifest.sourceId).sort((left, right) => left.localeCompare(right));
+  const absoluteInput = path26.resolve(inputPath);
+  return manifests.filter((manifest) => manifest.originalPath && path26.resolve(manifest.originalPath) === absoluteInput).map((manifest) => manifest.sourceId).sort((left, right) => left.localeCompare(right));
 }
 async function syncDirectorySource(rootDir, inputPath, repoRoot) {
   const manifestsBefore = await listManifests(rootDir);
   const previousInScope = manifestsBefore.filter(
-    (manifest) => manifest.originalPath && withinRoot2(path25.resolve(inputPath), path25.resolve(manifest.originalPath))
+    (manifest) => manifest.originalPath && withinRoot2(path26.resolve(inputPath), path26.resolve(manifest.originalPath))
   );
   const result = await ingestDirectory(rootDir, inputPath, { repoRoot });
   const removed = [];
@@ -17672,7 +18023,7 @@ async function syncDirectorySource(rootDir, inputPath, repoRoot) {
     if (!manifest.originalPath) {
       continue;
     }
-    if (await fileExists(path25.resolve(manifest.originalPath))) {
+    if (await fileExists(path26.resolve(manifest.originalPath))) {
       continue;
     }
     const removedManifest = await removeManifestBySourceId(rootDir, manifest.sourceId);
@@ -17682,7 +18033,7 @@ async function syncDirectorySource(rootDir, inputPath, repoRoot) {
   }
   const manifestsAfter = await listManifests(rootDir);
   return {
-    title: path25.basename(inputPath) || inputPath,
+    title: path26.basename(inputPath) || inputPath,
     sourceIds: directorySourceIdsFor(manifestsAfter, inputPath),
     counts: {
       scannedCount: result.scannedCount,
@@ -17698,7 +18049,7 @@ async function syncFileSource(rootDir, inputPath) {
   const result = await ingestInputDetailed(rootDir, inputPath);
   const manifestsAfter = await listManifests(rootDir);
   return {
-    title: path25.basename(inputPath, path25.extname(inputPath)) || inputPath,
+    title: path26.basename(inputPath, path26.extname(inputPath)) || inputPath,
     sourceIds: fileSourceIdsFor(manifestsAfter, inputPath),
     counts: {
       scannedCount: result.scannedCount,
@@ -17732,8 +18083,8 @@ async function runGitCommand(cwd, args) {
 }
 async function syncGitHubRepoSource(rootDir, entry) {
   const workingDir = await managedSourceWorkingDir(rootDir, entry.id);
-  const checkoutDir = path25.join(workingDir, "checkout");
-  await fs21.rm(checkoutDir, { recursive: true, force: true });
+  const checkoutDir = path26.join(workingDir, "checkout");
+  await fs22.rm(checkoutDir, { recursive: true, force: true });
   await ensureDir(workingDir);
   if (!entry.url) {
     throw new Error(`Managed source ${entry.id} is missing its repository URL.`);
@@ -17860,7 +18211,7 @@ function scopedNodeIds(graph, sourceIds) {
 async function loadSourceAnalyses(rootDir, sourceIds) {
   const { paths } = await loadVaultConfig(rootDir);
   const analyses = await Promise.all(
-    sourceIds.map(async (sourceId) => await readJsonFile(path25.join(paths.analysesDir, `${sourceId}.json`)))
+    sourceIds.map(async (sourceId) => await readJsonFile(path26.join(paths.analysesDir, `${sourceId}.json`)))
   );
   return analyses.filter((analysis) => Boolean(analysis?.sourceId));
 }
@@ -17927,7 +18278,7 @@ function renderDeterministicSourceBrief(input) {
     ""
   ].join("\n");
 }
-async function generateSourceBriefMarkdown(rootDir, source) {
+async function generateSourceBriefMarkdownForScope(rootDir, source) {
   const { paths } = await loadVaultConfig(rootDir);
   const graph = await readJsonFile(paths.graphPath);
   if (!graph) {
@@ -17964,7 +18315,7 @@ Entities: ${analysis.entities.map((entity) => entity.name).join(", ") || "none"}
       ),
       prompt: [
         `Source title: ${source.title}`,
-        `Source kind: ${source.kind}`,
+        `Source kind: ${source.kind ?? "source"}`,
         `Tracked source ids: ${source.sourceIds.join(", ") || "none"}`,
         "",
         "Pages:",
@@ -17982,12 +18333,12 @@ Entities: ${analysis.entities.map((entity) => entity.name).join(", ") || "none"}
     return fallback;
   }
 }
-async function writeSourceBrief(rootDir, source) {
+async function writeSourceBriefForScope(rootDir, source) {
   if (!source.sourceIds.length) {
     return null;
   }
   const { paths } = await loadVaultConfig(rootDir);
-  const markdown = await generateSourceBriefMarkdown(rootDir, source);
+  const markdown = await generateSourceBriefMarkdownForScope(rootDir, source);
   if (!markdown) {
     return null;
   }
@@ -18020,11 +18371,14 @@ async function writeSourceBrief(rootDir, source) {
       confidence: 0.82
     }
   });
-  const absolutePath = path25.join(paths.wikiDir, output.page.path);
-  await ensureDir(path25.dirname(absolutePath));
-  await fs21.writeFile(absolutePath, output.content, "utf8");
+  const absolutePath = path26.join(paths.wikiDir, output.page.path);
+  await ensureDir(path26.dirname(absolutePath));
+  await fs22.writeFile(absolutePath, output.content, "utf8");
   return absolutePath;
 }
+async function writeSourceBrief(rootDir, source) {
+  return await writeSourceBriefForScope(rootDir, scopeFromManagedSource(source));
+}
 async function generateBriefsForSources(rootDir, sources) {
   const briefPaths = /* @__PURE__ */ new Map();
   for (const source of sources) {
@@ -18038,6 +18392,59 @@ async function generateBriefsForSources(rootDir, sources) {
   }
   return briefPaths;
 }
+var GUIDED_SESSION_QUESTIONS = [
+  {
+    id: "importance",
+    prompt: "What matters most from this source for your wiki right now?"
+  },
+  {
+    id: "exclude",
+    prompt: "What should stay provisional, be ignored, or be kept out for now?"
+  },
+  {
+    id: "targets",
+    prompt: "Which canonical pages or topics should this source update?"
+  },
+  {
+    id: "conflicts",
+    prompt: "What feels new, reinforcing, or conflicting compared with what you already believe?"
+  },
+  {
+    id: "followups",
+    prompt: "What follow-up questions or next sources should stay open?"
+  }
+];
+function defaultGuidedSessionQuestions() {
+  return GUIDED_SESSION_QUESTIONS.map((question) => ({ ...question }));
+}
+function normalizeGuidedAnswerValue(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function normalizeGuidedAnswers(input) {
+  if (!input) {
+    return {};
+  }
+  if (Array.isArray(input)) {
+    return Object.fromEntries(
+      GUIDED_SESSION_QUESTIONS.map((question, index) => [question.id, normalizeGuidedAnswerValue(input[index])]).filter(
+        (entry) => Boolean(entry[1])
+      )
+    );
+  }
+  return Object.fromEntries(
+    Object.entries(input).map(([key, value]) => [key, normalizeGuidedAnswerValue(value)]).filter((entry) => Boolean(entry[1]))
+  );
+}
+function mergeGuidedSessionQuestions(questions, answers) {
+  const normalizedAnswers = normalizeGuidedAnswers(answers);
+  return questions.map((question) => ({
+    ...question,
+    answer: normalizedAnswers[question.id] ?? question.answer
+  }));
+}
+function answeredGuidedSessionQuestions(questions) {
+  return questions.filter((question) => typeof question.answer === "string" && question.answer.trim().length > 0);
+}
 function renderDeterministicSourceReview(input) {
   const canonicalPages = input.sourcePages.filter((page) => page.kind === "source" || page.kind === "concept" || page.kind === "entity").slice(0, 10);
   const modulePages = input.sourcePages.filter((page) => page.kind === "module").slice(0, 8);
@@ -18137,7 +18544,7 @@ Entities: ${analysis.entities.map((entity) => entity.name).join(", ") || "none"}
     return fallback;
   }
 }
-async function stageSourceReviewForScope(rootDir, scope) {
+async function buildSourceReviewStagedPage(rootDir, scope) {
   const { paths } = await loadVaultConfig(rootDir);
   const markdown = await generateSourceReviewMarkdown(rootDir, scope);
   if (!markdown) {
@@ -18172,44 +18579,671 @@ async function stageSourceReviewForScope(rootDir, scope) {
       confidence: 0.79
     }
   });
-  const approval = await stageGeneratedOutputPages(rootDir, [{ page: output.page, content: output.content }]);
-  return {
-    sourceId: scope.id,
-    pageId: output.page.id,
-    reviewPath: path25.join(approval.approvalDir, "wiki", output.page.path),
-    staged: true,
-    approvalId: approval.approvalId,
-    approvalDir: approval.approvalDir
-  };
+  return { page: output.page, content: output.content };
+}
+function classifySourceGuidePageBuckets(sourcePages, scopeSourceIds) {
+  const scopeSet = new Set(scopeSourceIds);
+  const canonicalPages = sourcePages.filter((page) => page.kind === "source" || page.kind === "concept" || page.kind === "entity").slice(0, 12);
+  const newPages = canonicalPages.filter((page) => page.sourceIds.every((sourceId) => scopeSet.has(sourceId))).slice(0, 6);
+  const reinforcingPages = canonicalPages.filter((page) => page.sourceIds.some((sourceId) => !scopeSet.has(sourceId))).slice(0, 6);
+  return { canonicalPages, newPages, reinforcingPages };
+}
+function findContradictionsForScope(scope, report) {
+  return report?.contradictions.filter(
+    (contradiction) => scope.sourceIds.includes(contradiction.sourceIdA) || scope.sourceIds.includes(contradiction.sourceIdB)
+  ) ?? [];
 }
-function scopeFromManagedSource(source) {
-  return {
-    id: source.id,
-    title: source.title,
-    sourceIds: source.sourceIds
-  };
+function selectGuidedTargetPages(scope, sourcePages, questions) {
+  const { canonicalPages } = classifySourceGuidePageBuckets(sourcePages, scope.sourceIds);
+  if (!canonicalPages.length) {
+    return [];
+  }
+  const desiredTargets = normalizeWhitespace(
+    questions.find((question) => question.id === "targets")?.answer ?? questions.find((question) => question.id === "importance")?.answer ?? ""
+  ).toLowerCase();
+  const matchedTargets = desiredTargets ? canonicalPages.filter((page) => {
+    const title = page.title.toLowerCase();
+    const relative = page.path.replace(/\.md$/, "").toLowerCase();
+    return desiredTargets.includes(title) || desiredTargets.includes(relative) || title.includes(desiredTargets);
+  }) : [];
+  return (matchedTargets.length ? matchedTargets : canonicalPages).slice(0, 6);
 }
-async function reviewSourceScope(rootDir, scope) {
-  return await stageSourceReviewForScope(rootDir, scope);
+function insightRelativePathForTarget(page, scope) {
+  const basename = path26.basename(page.path);
+  if (page.kind === "concept") {
+    return `insights/concepts/${basename}`;
+  }
+  if (page.kind === "entity") {
+    return `insights/entities/${basename}`;
+  }
+  if (page.kind === "source") {
+    return `insights/sources/${slugify(page.title || scope.title)}.md`;
+  }
+  return `insights/topics/${slugify(page.title || scope.title)}.md`;
 }
-async function reviewManagedSource(rootDir, id) {
-  const managedSources = await loadManagedSources(rootDir);
-  const managedSource = managedSources.find((source) => source.id === id);
-  if (managedSource) {
-    if (!await loadVaultConfig(rootDir).then(({ paths }) => fileExists(paths.graphPath))) {
-      await compileVault(rootDir, {});
-    }
-    return await stageSourceReviewForScope(rootDir, scopeFromManagedSource(managedSource));
+function insightTitleForTarget(page, scope) {
+  if (page.kind === "concept" || page.kind === "entity") {
+    return page.title;
   }
-  const manifest = (await listManifests(rootDir)).find((candidate) => candidate.sourceId === id);
-  if (!manifest) {
-    throw new Error(`Managed source or source id not found: ${id}`);
+  if (page.kind === "source") {
+    return `Source Notes: ${page.title}`;
   }
-  return await stageSourceReviewForScope(rootDir, {
-    id: manifest.sourceId,
-    title: manifest.title,
-    sourceIds: [manifest.sourceId]
-  });
+  return `${scope.title} Notes`;
+}
+function insightTagsForTarget(page) {
+  return uniqueStrings4(["insight", "guided-session", `guided/${page?.kind ?? "topic"}`]);
+}
+function guidedUpdateMarker(scopeId) {
+  return {
+    start: `<!-- swarmvault-guided-source:${scopeId}:start -->`,
+    end: `<!-- swarmvault-guided-source:${scopeId}:end -->`
+  };
+}
+function replaceMarkedSection(content, scopeId, replacement) {
+  const marker = guidedUpdateMarker(scopeId);
+  const block = `${marker.start}
+${replacement.trim()}
+${marker.end}`;
+  const startIndex = content.indexOf(marker.start);
+  const endIndex = content.indexOf(marker.end);
+  if (startIndex !== -1 && endIndex !== -1 && endIndex > startIndex) {
+    return `${content.slice(0, startIndex).trimEnd()}
+
+${block}
+`;
+  }
+  return `${content.trimEnd()}
+
+${block}
+`;
+}
+function renderDeterministicSourceGuide(input) {
+  const { canonicalPages, newPages, reinforcingPages } = classifySourceGuidePageBuckets(input.sourcePages, input.scope.sourceIds);
+  const modulePages = input.sourcePages.filter((page) => page.kind === "module").slice(0, 6);
+  const takeaways = uniqueStrings4(
+    input.analyses.flatMap((analysis) => [
+      analysis.summary,
+      ...analysis.concepts.map((concept) => concept.description),
+      ...analysis.entities.map((entity) => entity.description)
+    ]).filter(Boolean).map((value) => normalizeWhitespace(value))
+  ).slice(0, 7).map((value) => truncate(value, 180));
+  const questions = uniqueStrings4(input.analyses.flatMap((analysis) => analysis.questions)).slice(0, 6);
+  const contradictions = input.report?.contradictions.filter(
+    (contradiction) => input.scope.sourceIds.includes(contradiction.sourceIdA) || input.scope.sourceIds.includes(contradiction.sourceIdB)
+  ) ?? [];
+  return [
+    `# Source Guide: ${input.scope.title}`,
+    "",
+    "## What This Source Is",
+    "",
+    takeaways.length ? takeaways[0] : `${input.scope.title} has been compiled into the vault and is ready for guided review.`,
+    "",
+    "## Key Takeaways",
+    "",
+    ...takeaways.length ? takeaways.map((takeaway) => `- ${takeaway}`) : ["- No takeaways are available until the source is compiled."],
+    "",
+    "## Proposed Canonical Pages To Update",
+    "",
+    ...canonicalPages.length ? canonicalPages.map((page) => `- [[${page.path.replace(/\.md$/, "")}|${page.title}]]`) : ["- No likely canonical pages were identified yet."],
+    "",
+    "## New, Reinforcing, And Conflicting Claims",
+    "",
+    ...newPages.length ? ["New or source-local pages:", ...newPages.map((page) => `- [[${page.path.replace(/\.md$/, "")}|${page.title}]]`), ""] : [],
+    ...reinforcingPages.length ? ["Reinforcing existing pages:", ...reinforcingPages.map((page) => `- [[${page.path.replace(/\.md$/, "")}|${page.title}]]`), ""] : [],
+    ...contradictions.length ? ["Conflicts to judge:", ...contradictions.map((contradiction) => `- ${contradiction.claimA} / ${contradiction.claimB}`), ""] : ["Conflicts to judge:", "- No contradictions are currently flagged for this source scope.", ""],
+    "## What Should Probably Stay Out For Now",
+    "",
+    ...modulePages.length ? ["- Avoid promoting narrow implementation details unless they matter to your thesis or recurring questions."] : ["- Avoid promoting incidental details that are not yet supported by multiple sources or clear research goals."],
+    ...contradictions.length ? ["- Keep contested claims provisional until you review the conflicting evidence side by side."] : [],
+    "",
+    "## Needs Human Judgment",
+    "",
+    ...questions.length ? questions.map((question) => `- ${question}`) : ["- Decide which proposed canonical pages deserve durable summary updates."],
+    "",
+    "## Suggested Follow-up Questions",
+    "",
+    ...questions.length ? questions.map((question) => `- ${question}`) : ["- What changed in your understanding after reading this source?"],
+    ""
+  ].join("\n");
+}
+async function generateSourceGuideMarkdown(rootDir, scope) {
+  const { paths } = await loadVaultConfig(rootDir);
+  let graph = await readJsonFile(paths.graphPath);
+  if (!graph) {
+    await compileVault(rootDir, {});
+    graph = await readJsonFile(paths.graphPath);
+  }
+  if (!graph) {
+    return null;
+  }
+  const sourcePages = scopedSourcePages(graph, scope.sourceIds);
+  const analyses = await loadSourceAnalyses(rootDir, scope.sourceIds);
+  const report = await readGraphReport(rootDir);
+  const fallback = renderDeterministicSourceGuide({
+    scope,
+    sourcePages,
+    analyses,
+    report
+  });
+  const provider = await getProviderForTask(rootDir, "queryProvider");
+  if (provider.type === "heuristic") {
+    return fallback;
+  }
+  try {
+    const schemas = await loadVaultSchemas(rootDir);
+    const { canonicalPages, newPages, reinforcingPages } = classifySourceGuidePageBuckets(sourcePages, scope.sourceIds);
+    const pageContext = sourcePages.slice(0, 12).map((page) => `- ${page.title} (${page.kind}) -> ${page.path}`).join("\n");
+    const analysisContext = analyses.slice(0, 8).map(
+      (analysis) => `# ${analysis.title}
+Summary: ${analysis.summary}
+Questions: ${analysis.questions.join(" | ") || "none"}
+Concepts: ${analysis.concepts.map((concept) => concept.name).join(", ") || "none"}
+Entities: ${analysis.entities.map((entity) => entity.name).join(", ") || "none"}`
+    ).join("\n\n---\n\n");
+    const response = await provider.generateText({
+      system: buildSchemaPrompt(
+        schemas.effective.global,
+        "Write a concise markdown source guide with sections: What This Source Is, Key Takeaways, Proposed Canonical Pages To Update, New Reinforcing And Conflicting Claims, What Should Probably Stay Out For Now, Needs Human Judgment, Suggested Follow-up Questions. Focus on helping a human integrate one source into an evolving research wiki."
+      ),
+      prompt: [
+        `Source scope: ${scope.title}`,
+        `Scope id: ${scope.id}`,
+        `Tracked source ids: ${scope.sourceIds.join(", ") || "none"}`,
+        `Current brief path: ${scope.briefPath ?? "none"}`,
+        "",
+        "Likely canonical pages:",
+        canonicalPages.length ? canonicalPages.map((page) => `- ${page.title} -> ${page.path}`).join("\n") : "- none",
+        "",
+        "Likely source-local pages:",
+        newPages.length ? newPages.map((page) => `- ${page.title} -> ${page.path}`).join("\n") : "- none",
+        "",
+        "Likely reinforcing pages:",
+        reinforcingPages.length ? reinforcingPages.map((page) => `- ${page.title} -> ${page.path}`).join("\n") : "- none",
+        "",
+        "Pages:",
+        pageContext || "- none",
+        "",
+        "Analyses:",
+        analysisContext || "No analysis context available.",
+        "",
+        "Deterministic fallback draft:",
+        fallback
+      ].join("\n")
+    });
+    return response.text?.trim() ? response.text.trim() : fallback;
+  } catch {
+    return fallback;
+  }
+}
+async function buildSourceGuideStagedPage(rootDir, scope) {
+  const { paths } = await loadVaultConfig(rootDir);
+  const markdown = await generateSourceGuideMarkdown(rootDir, scope);
+  if (!markdown) {
+    throw new Error(`Could not generate a source guide for ${scope.id}.`);
+  }
+  const graph = await readJsonFile(paths.graphPath);
+  const relatedPages = graph ? scopedSourcePages(graph, scope.sourceIds) : [];
+  const relatedPageIds = relatedPages.slice(0, 18).map((page) => page.id);
+  const relatedNodeIds = graph ? scopedNodeIds(graph, scope.sourceIds).slice(0, 28) : [];
+  const projectIds = uniqueStrings4(relatedPages.flatMap((page) => page.projectIds));
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const output = buildOutputPage({
+    title: `Source Guide: ${scope.title}`,
+    question: `Guide ${scope.title}`,
+    answer: markdown,
+    citations: scope.sourceIds,
+    schemaHash: graph?.generatedAt ?? "",
+    outputFormat: "report",
+    relatedPageIds,
+    relatedNodeIds,
+    relatedSourceIds: scope.sourceIds,
+    projectIds,
+    extraTags: ["source-guide", "guided-ingest"],
+    origin: "query",
+    slug: `source-guides/${scope.id}`,
+    metadata: {
+      status: "draft",
+      createdAt: now,
+      updatedAt: now,
+      compiledFrom: scope.sourceIds,
+      managedBy: "system",
+      confidence: 0.8
+    }
+  });
+  return { page: output.page, content: output.content };
+}
+async function stageSourceReviewForScope(rootDir, scope) {
+  const output = await buildSourceReviewStagedPage(rootDir, scope);
+  const approval = await stageGeneratedOutputPages(rootDir, [{ page: output.page, content: output.content, label: "source-review" }], {
+    bundleType: "source_review",
+    title: `Source Review: ${scope.title}`
+  });
+  return {
+    sourceId: scope.id,
+    pageId: output.page.id,
+    reviewPath: path26.join(approval.approvalDir, "wiki", output.page.path),
+    staged: true,
+    approvalId: approval.approvalId,
+    approvalDir: approval.approvalDir
+  };
+}
+function nextGuidedSourceSessionId(scope) {
+  return `source-session-${slugify(scope.id)}-${sha256(`${scope.id}:${(/* @__PURE__ */ new Date()).toISOString()}`).slice(0, 8)}`;
+}
+function shouldReuseGuidedSourceSession(session) {
+  return Boolean(session && session.status === "awaiting_input");
+}
+function questionAnswer(questions, id, fallback) {
+  return normalizeGuidedAnswerValue(questions.find((question) => question.id === id)?.answer) ?? fallback;
+}
+async function prepareGuidedSourceSession(rootDir, scope, answers) {
+  const existing = await findLatestGuidedSourceSessionByScope(rootDir, scope.id);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const session = shouldReuseGuidedSourceSession(existing) ? {
+    ...existing,
+    scopeTitle: scope.title,
+    sourceIds: scope.sourceIds,
+    kind: scope.kind,
+    questions: mergeGuidedSessionQuestions(existing.questions, answers),
+    updatedAt: now
+  } : {
+    sessionId: nextGuidedSourceSessionId(scope),
+    scopeId: scope.id,
+    scopeTitle: scope.title,
+    sourceIds: scope.sourceIds,
+    kind: scope.kind,
+    status: "awaiting_input",
+    createdAt: now,
+    updatedAt: now,
+    questions: mergeGuidedSessionQuestions(defaultGuidedSessionQuestions(), answers),
+    briefPath: scope.briefPath,
+    targetedPagePaths: [],
+    stagedUpdatePaths: []
+  };
+  const statePath = await guidedSourceSessionStatePath(rootDir, session.sessionId);
+  return { session, statePath };
+}
+async function buildSourceSessionSavedPage(rootDir, scope, session) {
+  const { paths } = await loadVaultConfig(rootDir);
+  let graph = await readJsonFile(paths.graphPath);
+  if (!graph) {
+    await compileVault(rootDir, {});
+    graph = await readJsonFile(paths.graphPath);
+  }
+  const sourcePages = graph ? scopedSourcePages(graph, scope.sourceIds) : [];
+  const analyses = await loadSourceAnalyses(rootDir, scope.sourceIds);
+  const report = await readGraphReport(rootDir);
+  const contradictions = findContradictionsForScope(scope, report);
+  const relatedPageIds = uniqueStrings4([
+    ...sourcePages.slice(0, 18).map((page) => page.id),
+    ...session.targetedPagePaths.map((relativePath) => {
+      const page = graph?.pages.find((candidate) => candidate.path === relativePath);
+      return page?.id ?? "";
+    })
+  ]);
+  const relatedNodeIds = graph ? scopedNodeIds(graph, scope.sourceIds).slice(0, 28) : [];
+  const projectIds = uniqueStrings4(sourcePages.flatMap((page) => page.projectIds));
+  const relativeBriefPath = session.briefPath && path26.isAbsolute(session.briefPath) ? path26.relative(paths.wikiDir, session.briefPath) : session.briefPath;
+  const sessionMarkdown = [
+    `# Guided Session: ${scope.title}`,
+    "",
+    `Status: \`${session.status}\``,
+    `Session ID: \`${session.sessionId}\``,
+    ...session.approvalId ? [`Approval Bundle: \`${session.approvalId}\``] : [],
+    ...relativeBriefPath ? [`Brief: \`${relativeBriefPath}\``] : [],
+    "",
+    "## What This Source Is",
+    "",
+    ...analyses.length ? analyses.slice(0, 6).map((analysis) => `- ${analysis.title}: ${analysis.summary}`) : ["- Awaiting compile context."],
+    "",
+    "## Guided Questions",
+    "",
+    ...session.questions.flatMap((question) => [`### ${question.prompt}`, "", question.answer ?? "_Awaiting input._", ""]),
+    "## Proposed Wiki Targets",
+    "",
+    ...session.targetedPagePaths.length ? session.targetedPagePaths.map((targetPath) => `- [[${targetPath.replace(/\.md$/, "")}]]`) : ["- No canonical update targets selected yet."],
+    "",
+    "## Conflicts And Judgment Calls",
+    "",
+    ...contradictions.length ? contradictions.map((contradiction) => `- ${contradiction.claimA} / ${contradiction.claimB}`) : ["- No contradictions are currently flagged for this source scope."],
+    "",
+    "## Follow-up Questions",
+    "",
+    ...(() => {
+      const followups = questionAnswer(session.questions, "followups", "");
+      if (followups) {
+        return followups.split(/\n+/).map((line) => line.trim()).filter(Boolean).map((line) => `- ${line.replace(/^-+\s*/, "")}`);
+      }
+      const analysisQuestions = uniqueStrings4(analyses.flatMap((analysis) => analysis.questions)).slice(0, 6);
+      return analysisQuestions.length ? analysisQuestions.map((question) => `- ${question}`) : ["- No follow-up questions recorded yet."];
+    })(),
+    "",
+    "## Related Artifacts",
+    "",
+    `- [[outputs/source-briefs/${scope.id}|Source Brief]]`,
+    `- [[outputs/source-reviews/${scope.id}|Source Review]]`,
+    `- [[outputs/source-guides/${scope.id}|Source Guide]]`,
+    ""
+  ].join("\n");
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const output = buildOutputPage({
+    title: `Guided Session: ${scope.title}`,
+    question: `Guided Session ${scope.title}`,
+    answer: sessionMarkdown,
+    citations: scope.sourceIds,
+    schemaHash: graph?.generatedAt ?? "",
+    outputFormat: "report",
+    relatedPageIds,
+    relatedNodeIds,
+    relatedSourceIds: scope.sourceIds,
+    projectIds,
+    extraTags: ["source-session", "guided-session"],
+    origin: "query",
+    slug: `source-sessions/${scope.id}`,
+    metadata: {
+      status: "active",
+      createdAt: now,
+      updatedAt: now,
+      compiledFrom: scope.sourceIds,
+      managedBy: "system",
+      confidence: 0.81
+    }
+  });
+  return { page: output.page, content: output.content };
+}
+async function persistSourceSessionPage(rootDir, scope, session) {
+  const { paths } = await loadVaultConfig(rootDir);
+  const output = await buildSourceSessionSavedPage(rootDir, scope, session);
+  const absolutePath = path26.join(paths.wikiDir, output.page.path);
+  await ensureDir(path26.dirname(absolutePath));
+  await fs22.writeFile(absolutePath, output.content, "utf8");
+  return { pageId: output.page.id, sessionPath: absolutePath };
+}
+async function buildGuidedInsightUpdatePages(rootDir, scope, session) {
+  const { paths } = await loadVaultConfig(rootDir);
+  let graph = await readJsonFile(paths.graphPath);
+  if (!graph) {
+    await compileVault(rootDir, {});
+    graph = await readJsonFile(paths.graphPath);
+  }
+  if (!graph) {
+    return [];
+  }
+  const sourcePages = scopedSourcePages(graph, scope.sourceIds);
+  const analyses = await loadSourceAnalyses(rootDir, scope.sourceIds);
+  const report = await readGraphReport(rootDir);
+  const contradictions = findContradictionsForScope(scope, report);
+  const selectedTargets = selectGuidedTargetPages(scope, sourcePages, session.questions);
+  const targetPages = selectedTargets.length ? selectedTargets : [null];
+  return await Promise.all(
+    targetPages.map(async (targetPage, index) => {
+      const relativePath = targetPage ? insightRelativePathForTarget(targetPage, scope) : `insights/topics/${slugify(scope.title)}.md`;
+      const absolutePath = path26.join(paths.wikiDir, relativePath);
+      const existingContent = await fileExists(absolutePath) ? await fs22.readFile(absolutePath, "utf8") : "";
+      const parsed = existingContent ? matter10(existingContent) : { data: {}, content: "" };
+      const existingData = parsed.data;
+      const existingSourceIds = Array.isArray(existingData.source_ids) ? existingData.source_ids.filter((value) => typeof value === "string") : [];
+      const existingProjectIds = Array.isArray(existingData.project_ids) ? existingData.project_ids.filter((value) => typeof value === "string") : [];
+      const existingNodeIds = Array.isArray(existingData.node_ids) ? existingData.node_ids.filter((value) => typeof value === "string") : [];
+      const existingBacklinks = Array.isArray(existingData.backlinks) ? existingData.backlinks.filter((value) => typeof value === "string") : [];
+      const createdAt = typeof existingData.created_at === "string" && existingData.created_at.trim() ? existingData.created_at : (/* @__PURE__ */ new Date()).toISOString();
+      const title = typeof existingData.title === "string" && existingData.title.trim() || (targetPage ? insightTitleForTarget(targetPage, scope) : `${scope.title} Notes`);
+      const baseBody = parsed.content.trim() ? parsed.content.trim() : [`# ${title}`, "", "Human-curated insight page. Guided sessions stage replaceable update blocks here.", ""].join("\n");
+      const importance = questionAnswer(
+        session.questions,
+        "importance",
+        "Capture the most important new ideas from this source before treating them as canonical."
+      );
+      const exclude = questionAnswer(
+        session.questions,
+        "exclude",
+        "Keep uncertain or incidental details provisional until they matter to the research thread."
+      );
+      const conflictNotes = questionAnswer(
+        session.questions,
+        "conflicts",
+        contradictions.length ? "Review the conflicting evidence before accepting any canonical summary changes." : "No explicit conflicts were called out."
+      );
+      const followups = questionAnswer(session.questions, "followups", "Track follow-up questions on the source session page.");
+      const updateBlock = [
+        `## Guided Session Update: ${scope.title}`,
+        "",
+        `Session: [[outputs/source-sessions/${scope.id}|Guided Session]]`,
+        `Source Guide: [[outputs/source-guides/${scope.id}|Source Guide]]`,
+        "",
+        "### What Matters Now",
+        "",
+        importance,
+        "",
+        "### Proposed Integration",
+        "",
+        targetPage ? `- Fold the strongest source-backed takeaways into [[${targetPage.path.replace(/\.md$/, "")}|${targetPage.title}]].` : `- Start a durable topic note for ${scope.title}.`,
+        ...analyses.slice(0, 5).map((analysis) => `- ${truncate(normalizeWhitespace(analysis.summary), 180)}`),
+        "",
+        "### Keep Provisional Or Out",
+        "",
+        exclude,
+        "",
+        "### Reinforcing Or Conflicting Notes",
+        "",
+        conflictNotes,
+        ...contradictions.length ? ["", ...contradictions.slice(0, 4).map((contradiction) => `- ${contradiction.claimA} / ${contradiction.claimB}`)] : [],
+        "",
+        "### Follow-up Questions",
+        "",
+        followups,
+        ""
+      ].join("\n");
+      const nextBody = replaceMarkedSection(baseBody, scope.id, updateBlock);
+      const content = matter10.stringify(`${nextBody.trimEnd()}
+`, {
+        ...existingData,
+        page_id: typeof existingData.page_id === "string" && existingData.page_id.trim() || `insight:${slugify(relativePath.replace(/\.md$/, ""))}`,
+        kind: "insight",
+        title,
+        tags: uniqueStrings4([
+          ...Array.isArray(existingData.tags) ? existingData.tags.filter((value) => typeof value === "string") : [],
+          ...insightTagsForTarget(targetPage)
+        ]),
+        source_ids: uniqueStrings4([...existingSourceIds, ...scope.sourceIds]),
+        project_ids: uniqueStrings4([...existingProjectIds, ...targetPage?.projectIds ?? []]),
+        node_ids: uniqueStrings4([...existingNodeIds, ...targetPage?.nodeIds ?? []]),
+        freshness: "fresh",
+        status: existingData.status === "archived" ? "archived" : "active",
+        confidence: 0.83,
+        created_at: createdAt,
+        updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+        compiled_from: uniqueStrings4([
+          ...Array.isArray(existingData.compiled_from) ? existingData.compiled_from.filter((value) => typeof value === "string") : [],
+          ...scope.sourceIds
+        ]),
+        managed_by: "human",
+        backlinks: uniqueStrings4([
+          ...existingBacklinks,
+          ...targetPage ? [targetPage.id] : [],
+          `output:source-sessions/${scope.id}`,
+          `output:source-guides/${scope.id}`
+        ]),
+        schema_hash: typeof existingData.schema_hash === "string" ? existingData.schema_hash : "",
+        source_hashes: existingData.source_hashes && typeof existingData.source_hashes === "object" ? existingData.source_hashes : {},
+        source_semantic_hashes: existingData.source_semantic_hashes && typeof existingData.source_semantic_hashes === "object" ? existingData.source_semantic_hashes : {}
+      });
+      const page = parseStoredPage(relativePath, content, {
+        createdAt,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      if (index === 0) {
+        session.targetedPagePaths = uniqueStrings4([
+          ...session.targetedPagePaths,
+          ...selectedTargets.length ? selectedTargets.map((page2) => page2.path) : [relativePath]
+        ]);
+      }
+      return { page, content, label: "guided-update" };
+    })
+  );
+}
+async function stageSourceGuideForScope(rootDir, scope, options = {}) {
+  const { session, statePath } = await prepareGuidedSourceSession(rootDir, scope, options.answers);
+  const briefPath = scope.briefPath ?? session.briefPath ?? await writeSourceBriefForScope(rootDir, scope) ?? void 0;
+  session.briefPath = briefPath;
+  if (briefPath) {
+    await refreshVaultAfterOutputSave(rootDir);
+  }
+  if (answeredGuidedSessionQuestions(session.questions).length === 0) {
+    session.status = "awaiting_input";
+    const persisted2 = await persistSourceSessionPage(rootDir, scope, session);
+    session.sessionPath = persisted2.sessionPath;
+    await writeGuidedSourceSession(rootDir, session);
+    await refreshVaultAfterOutputSave(rootDir);
+    return {
+      sourceId: scope.id,
+      sessionId: session.sessionId,
+      sessionPath: persisted2.sessionPath,
+      sessionStatePath: statePath,
+      status: session.status,
+      questions: session.questions,
+      awaitingInput: true,
+      targetedPagePaths: session.targetedPagePaths,
+      stagedUpdatePaths: session.stagedUpdatePaths,
+      briefPath,
+      staged: false
+    };
+  }
+  session.status = "ready_to_stage";
+  await writeGuidedSourceSession(rootDir, session);
+  const reviewOutput = await buildSourceReviewStagedPage(rootDir, scope);
+  const guideOutput = await buildSourceGuideStagedPage(rootDir, {
+    ...scope,
+    briefPath
+  });
+  const guidedUpdates = await buildGuidedInsightUpdatePages(rootDir, scope, session);
+  session.stagedUpdatePaths = guidedUpdates.map((item) => item.page.path);
+  const approval = await stageGeneratedOutputPages(
+    rootDir,
+    [
+      { page: reviewOutput.page, content: reviewOutput.content, label: "source-review" },
+      { page: guideOutput.page, content: guideOutput.content, label: "source-guide" },
+      ...guidedUpdates
+    ],
+    {
+      bundleType: "guided_session",
+      title: `Guided Session: ${scope.title}`,
+      sourceSessionId: session.sessionId
+    }
+  );
+  session.status = "staged";
+  session.reviewPath = path26.join(approval.approvalDir, "wiki", reviewOutput.page.path);
+  session.guidePath = path26.join(approval.approvalDir, "wiki", guideOutput.page.path);
+  session.approvalId = approval.approvalId;
+  session.approvalDir = approval.approvalDir;
+  const persisted = await persistSourceSessionPage(rootDir, scope, session);
+  session.sessionPath = persisted.sessionPath;
+  await writeGuidedSourceSession(rootDir, session);
+  await refreshVaultAfterOutputSave(rootDir);
+  return {
+    sourceId: scope.id,
+    pageId: guideOutput.page.id,
+    guidePath: session.guidePath,
+    reviewPageId: reviewOutput.page.id,
+    reviewPath: session.reviewPath,
+    sessionId: session.sessionId,
+    sessionPath: persisted.sessionPath,
+    sessionStatePath: statePath,
+    status: session.status,
+    questions: session.questions,
+    targetedPagePaths: session.targetedPagePaths,
+    stagedUpdatePaths: session.stagedUpdatePaths,
+    briefPath,
+    staged: true,
+    approvalId: approval.approvalId,
+    approvalDir: approval.approvalDir
+  };
+}
+function scopeFromManagedSource(source) {
+  return {
+    id: source.id,
+    title: source.title,
+    sourceIds: source.sourceIds,
+    kind: source.kind,
+    briefPath: source.briefPath
+  };
+}
+function scopeFromManifest(manifest, manifests) {
+  const groupId = manifest.sourceGroupId ?? manifest.sourceId;
+  return {
+    id: groupId,
+    title: manifest.sourceGroupTitle ?? manifest.title,
+    sourceIds: manifest.sourceGroupId ? manifests.filter((candidate) => candidate.sourceGroupId === manifest.sourceGroupId).map((candidate) => candidate.sourceId) : [manifest.sourceId],
+    kind: manifest.sourceKind
+  };
+}
+async function resolveSourceScope(rootDir, id) {
+  const managedSources = await loadManagedSources(rootDir);
+  const managedSource = managedSources.find((source) => source.id === id);
+  if (managedSource) {
+    return scopeFromManagedSource(managedSource);
+  }
+  const latestSession = await findLatestGuidedSourceSessionByScope(rootDir, id);
+  if (latestSession) {
+    return {
+      id: latestSession.scopeId,
+      title: latestSession.scopeTitle,
+      sourceIds: latestSession.sourceIds
+    };
+  }
+  const manifests = await listManifests(rootDir);
+  const manifest = manifests.find((candidate) => candidate.sourceId === id) ?? manifests.find((candidate) => candidate.sourceGroupId === id);
+  if (!manifest) {
+    return null;
+  }
+  return scopeFromManifest(manifest, manifests);
+}
+async function reviewSourceScope(rootDir, scope) {
+  return await stageSourceReviewForScope(rootDir, scope);
+}
+async function guideSourceScope(rootDir, scope, options = {}) {
+  return await stageSourceGuideForScope(rootDir, scope, options);
+}
+async function reviewManagedSource(rootDir, id) {
+  const scope = await resolveSourceScope(rootDir, id);
+  if (!scope) {
+    throw new Error(`Managed source or source id not found: ${id}`);
+  }
+  if (!await loadVaultConfig(rootDir).then(({ paths }) => fileExists(paths.graphPath))) {
+    await compileVault(rootDir, {});
+  }
+  return await stageSourceReviewForScope(rootDir, scope);
+}
+async function guideManagedSource(rootDir, id, options = {}) {
+  const scope = await resolveSourceScope(rootDir, id);
+  if (!scope) {
+    throw new Error(`Managed source or source id not found: ${id}`);
+  }
+  if (!await loadVaultConfig(rootDir).then(({ paths }) => fileExists(paths.graphPath))) {
+    await compileVault(rootDir, {});
+  }
+  return await stageSourceGuideForScope(rootDir, scope, options);
+}
+async function resumeSourceSession(rootDir, id, options = {}) {
+  const existingSession = await readGuidedSourceSession(rootDir, id);
+  if (existingSession) {
+    return await stageSourceGuideForScope(
+      rootDir,
+      {
+        id: existingSession.scopeId,
+        title: existingSession.scopeTitle,
+        sourceIds: existingSession.sourceIds,
+        kind: existingSession.kind,
+        briefPath: existingSession.briefPath
+      },
+      options
+    );
+  }
+  const scope = await resolveSourceScope(rootDir, id);
+  if (!scope) {
+    throw new Error(`Managed source, source scope, or guided session not found: ${id}`);
+  }
+  return await stageSourceGuideForScope(rootDir, scope, options);
 }
 function shouldCompile(changedSources, graphExists, compileRequested) {
   return compileRequested && (!graphExists || changedSources.length > 0);
@@ -18220,14 +19254,15 @@ async function listManagedSourceRecords(rootDir) {
 }
 async function addManagedSource(rootDir, input, options = {}) {
   const compileRequested = options.compile ?? true;
-  const briefRequested = options.brief ?? true;
-  const reviewRequested = options.review ?? false;
+  const guideRequested = options.guide ?? false;
+  const briefRequested = guideRequested ? true : options.brief ?? true;
+  const reviewRequested = guideRequested ? false : options.review ?? false;
   const sources = await loadManagedSources(rootDir);
   const resolved = await resolveManagedSourceInput(rootDir, input);
   const existing = sources.find((candidate) => matchesManagedSourceSpec(candidate, resolved));
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const source = existing ?? {
-    id: resolved.kind === "directory" || resolved.kind === "file" ? stableManagedSourceId(resolved.kind, path25.resolve(resolved.path), resolved.title) : stableManagedSourceId(resolved.kind, resolved.url, resolved.title),
+    id: resolved.kind === "directory" || resolved.kind === "file" ? stableManagedSourceId(resolved.kind, path26.resolve(resolved.path), resolved.title) : stableManagedSourceId(resolved.kind, resolved.url, resolved.title),
     kind: resolved.kind,
     title: resolved.title,
     path: resolved.kind === "directory" || resolved.kind === "file" ? resolved.path : void 0,
@@ -18262,17 +19297,27 @@ async function addManagedSource(rootDir, input, options = {}) {
   const nextSources = existing ? sources.map((candidate) => candidate.id === nextSource.id ? nextSource : candidate) : [...sources, nextSource];
   await saveManagedSources(rootDir, nextSources);
   const review = reviewRequested && nextSource.status === "ready" ? await stageSourceReviewForScope(rootDir, scopeFromManagedSource(nextSource)) : void 0;
+  const guide = guideRequested && nextSource.status === "ready" ? await stageSourceGuideForScope(
+    rootDir,
+    {
+      ...scopeFromManagedSource(nextSource),
+      briefPath: nextSource.briefPath
+    },
+    { answers: options.guideAnswers }
+  ) : void 0;
   return {
     source: nextSource,
     compile,
     briefGenerated,
-    review
+    review,
+    guide
   };
 }
 async function reloadManagedSources(rootDir, options = {}) {
   const compileRequested = options.compile ?? true;
-  const briefRequested = options.brief ?? true;
-  const reviewRequested = options.review ?? false;
+  const guideRequested = options.guide ?? false;
+  const briefRequested = guideRequested ? true : options.brief ?? true;
+  const reviewRequested = guideRequested ? false : options.review ?? false;
   const sources = await loadManagedSources(rootDir);
   const selected = options.all || !options.id ? sources : sources.filter((source) => source.id === options.id);
   if (!selected.length) {
@@ -18311,11 +19356,24 @@ async function reloadManagedSources(rootDir, options = {}) {
   const reviews = reviewRequested ? await Promise.all(
     nextSources.filter((source) => selected.some((candidate) => candidate.id === source.id)).filter((source) => source.status === "ready").map(async (source) => await stageSourceReviewForScope(rootDir, scopeFromManagedSource(source)))
   ) : [];
+  const guides = guideRequested ? await Promise.all(
+    nextSources.filter((source) => selected.some((candidate) => candidate.id === source.id)).filter((source) => source.status === "ready").map(
+      async (source) => await stageSourceGuideForScope(
+        rootDir,
+        {
+          ...scopeFromManagedSource(source),
+          briefPath: source.briefPath
+        },
+        { answers: options.guideAnswers }
+      )
+    )
+  ) : [];
   return {
     sources: nextSources.filter((source) => selected.some((candidate) => candidate.id === source.id)),
     compile,
     briefPaths: [...briefPaths.values()],
-    reviews
+    reviews,
+    guides
   };
 }
 async function deleteManagedSource(rootDir, id) {
@@ -18329,17 +19387,17 @@ async function deleteManagedSource(rootDir, id) {
     sources.filter((source) => source.id !== id)
   );
   const workingDir = await managedSourceWorkingDir(rootDir, id);
-  await fs21.rm(workingDir, { recursive: true, force: true });
+  await fs22.rm(workingDir, { recursive: true, force: true });
   return { removed: target };
 }
 
 // src/viewer.ts
 import { execFile } from "child_process";
-import fs22 from "fs/promises";
+import fs23 from "fs/promises";
 import http from "http";
-import path27 from "path";
+import path28 from "path";
 import { promisify } from "util";
-import matter10 from "gray-matter";
+import matter11 from "gray-matter";
 import mime2 from "mime-types";
 
 // src/graph-presentation.ts
@@ -18461,7 +19519,7 @@ function buildViewerGraphArtifact(graph, options = {}) {
 }
 
 // src/watch.ts
-import path26 from "path";
+import path27 from "path";
 import process3 from "process";
 import chokidar from "chokidar";
 var MAX_BACKOFF_MS = 3e4;
@@ -18469,15 +19527,15 @@ var BACKOFF_THRESHOLD = 3;
 var CRITICAL_THRESHOLD = 10;
 var REPO_WATCH_IGNORES = /* @__PURE__ */ new Set([".git", ".venv"]);
 function withinRoot3(rootPath, targetPath) {
-  const relative = path26.relative(rootPath, targetPath);
-  return relative === "" || !relative.startsWith("..") && !path26.isAbsolute(relative);
+  const relative = path27.relative(rootPath, targetPath);
+  return relative === "" || !relative.startsWith("..") && !path27.isAbsolute(relative);
 }
 function hasIgnoredRepoSegment(baseDir, targetPath) {
-  const relativePath = path26.relative(baseDir, targetPath);
+  const relativePath = path27.relative(baseDir, targetPath);
   if (!relativePath || relativePath.startsWith("..")) {
     return false;
   }
-  return relativePath.split(path26.sep).some((segment) => REPO_WATCH_IGNORES.has(segment));
+  return relativePath.split(path27.sep).some((segment) => REPO_WATCH_IGNORES.has(segment));
 }
 function workspaceIgnoreRoots(rootDir, paths) {
   return [
@@ -18486,16 +19544,16 @@ function workspaceIgnoreRoots(rootDir, paths) {
     paths.stateDir,
     paths.agentDir,
     paths.inboxDir,
-    path26.join(rootDir, ".claude"),
-    path26.join(rootDir, ".cursor"),
-    path26.join(rootDir, ".obsidian")
-  ].map((candidate) => path26.resolve(candidate));
+    path27.join(rootDir, ".claude"),
+    path27.join(rootDir, ".cursor"),
+    path27.join(rootDir, ".obsidian")
+  ].map((candidate) => path27.resolve(candidate));
 }
 async function resolveWatchTargets(rootDir, paths, options) {
-  const targets = /* @__PURE__ */ new Set([path26.resolve(paths.inboxDir)]);
+  const targets = /* @__PURE__ */ new Set([path27.resolve(paths.inboxDir)]);
   if (options.repo) {
     for (const repoRoot of await listTrackedRepoRoots(rootDir)) {
-      targets.add(path26.resolve(repoRoot));
+      targets.add(path27.resolve(repoRoot));
     }
   }
   return [...targets].sort((left, right) => left.localeCompare(right));
@@ -18625,7 +19683,7 @@ async function watchVault(rootDir, options = {}) {
   const { paths } = await initWorkspace(rootDir);
   const baseDebounceMs = options.debounceMs ?? 900;
   const ignoredRoots = workspaceIgnoreRoots(rootDir, paths);
-  const inboxWatchRoot = path26.resolve(paths.inboxDir);
+  const inboxWatchRoot = path27.resolve(paths.inboxDir);
   let watchTargets = await resolveWatchTargets(rootDir, paths, options);
   let timer;
   let running = false;
@@ -18640,7 +19698,7 @@ async function watchVault(rootDir, options = {}) {
     usePolling: true,
     interval: 100,
     ignored: (targetPath) => {
-      const absolutePath = path26.resolve(targetPath);
+      const absolutePath = path27.resolve(targetPath);
       const primaryTarget = watchTargets.filter((watchTarget) => withinRoot3(watchTarget, absolutePath)).sort((left, right) => right.length - left.length)[0] ?? null;
       if (!primaryTarget) {
         return false;
@@ -18829,8 +19887,8 @@ async function watchVault(rootDir, options = {}) {
     }
   };
   const reasonForPath = (targetPath) => {
-    const baseDir = watchTargets.filter((watchTarget) => withinRoot3(watchTarget, path26.resolve(targetPath))).sort((left, right) => right.length - left.length)[0] ?? paths.inboxDir;
-    return path26.relative(baseDir, targetPath) || ".";
+    const baseDir = watchTargets.filter((watchTarget) => withinRoot3(watchTarget, path27.resolve(targetPath))).sort((left, right) => right.length - left.length)[0] ?? paths.inboxDir;
+    return path27.relative(baseDir, targetPath) || ".";
   };
   watcher.on("add", (filePath) => schedule(`add:${reasonForPath(filePath)}`)).on("change", (filePath) => schedule(`change:${reasonForPath(filePath)}`)).on("unlink", (filePath) => schedule(`unlink:${reasonForPath(filePath)}`)).on("addDir", (dirPath) => schedule(`addDir:${reasonForPath(dirPath)}`)).on("unlinkDir", (dirPath) => schedule(`unlinkDir:${reasonForPath(dirPath)}`)).on("error", (caught) => schedule(`error:${caught instanceof Error ? caught.message : String(caught)}`));
   await new Promise((resolve, reject) => {
@@ -18872,15 +19930,15 @@ async function getWatchStatus(rootDir) {
 var execFileAsync = promisify(execFile);
 async function readViewerPage(rootDir, relativePath) {
   const { paths } = await loadVaultConfig(rootDir);
-  const absolutePath = path27.resolve(paths.wikiDir, relativePath);
+  const absolutePath = path28.resolve(paths.wikiDir, relativePath);
   if (!absolutePath.startsWith(paths.wikiDir) || !await fileExists(absolutePath)) {
     return null;
   }
-  const raw = await fs22.readFile(absolutePath, "utf8");
-  const parsed = matter10(raw);
+  const raw = await fs23.readFile(absolutePath, "utf8");
+  const parsed = matter11(raw);
   return {
     path: relativePath,
-    title: typeof parsed.data.title === "string" ? parsed.data.title : path27.basename(relativePath, path27.extname(relativePath)),
+    title: typeof parsed.data.title === "string" ? parsed.data.title : path28.basename(relativePath, path28.extname(relativePath)),
     frontmatter: parsed.data,
     content: parsed.content,
     assets: normalizeOutputAssets(parsed.data.output_assets)
@@ -18888,12 +19946,12 @@ async function readViewerPage(rootDir, relativePath) {
 }
 async function readViewerAsset(rootDir, relativePath) {
   const { paths } = await loadVaultConfig(rootDir);
-  const absolutePath = path27.resolve(paths.wikiDir, relativePath);
+  const absolutePath = path28.resolve(paths.wikiDir, relativePath);
   if (!absolutePath.startsWith(paths.wikiDir) || !await fileExists(absolutePath)) {
     return null;
   }
   return {
-    buffer: await fs22.readFile(absolutePath),
+    buffer: await fs23.readFile(absolutePath),
     mimeType: mime2.lookup(absolutePath) || "application/octet-stream"
   };
 }
@@ -18916,12 +19974,12 @@ async function readJsonBody(request) {
   return JSON.parse(raw);
 }
 async function ensureViewerDist(viewerDistDir) {
-  const indexPath = path27.join(viewerDistDir, "index.html");
+  const indexPath = path28.join(viewerDistDir, "index.html");
   if (await fileExists(indexPath)) {
     return;
   }
-  const viewerProjectDir = path27.dirname(viewerDistDir);
-  if (await fileExists(path27.join(viewerProjectDir, "package.json"))) {
+  const viewerProjectDir = path28.dirname(viewerDistDir);
+  if (await fileExists(path28.join(viewerProjectDir, "package.json"))) {
     await execFileAsync("pnpm", ["build"], { cwd: viewerProjectDir });
   }
 }
@@ -18943,7 +20001,7 @@ async function startGraphServer(rootDir, port, options = {}) {
         response.end(JSON.stringify({ error: "Graph artifact not found. Run `swarmvault compile` first." }));
         return;
       }
-      const reportPath = path27.join(paths.wikiDir, "graph", "report.json");
+      const reportPath = path28.join(paths.wikiDir, "graph", "report.json");
       const report = await readJsonFile(reportPath) ?? null;
       response.writeHead(200, { "content-type": "application/json" });
       response.end(JSON.stringify(buildViewerGraphArtifact(graph, { report, full: options.full ?? false })));
@@ -19003,14 +20061,14 @@ async function startGraphServer(rootDir, port, options = {}) {
       return;
     }
     if (url.pathname === "/api/graph-report") {
-      const reportPath = path27.join(paths.wikiDir, "graph", "report.json");
+      const reportPath = path28.join(paths.wikiDir, "graph", "report.json");
       if (!await fileExists(reportPath)) {
         response.writeHead(404, { "content-type": "application/json" });
         response.end(JSON.stringify({ error: "Graph report artifact not found. Run `swarmvault compile` first." }));
         return;
       }
       response.writeHead(200, { "content-type": "application/json" });
-      response.end(await fs22.readFile(reportPath, "utf8"));
+      response.end(await fs23.readFile(reportPath, "utf8"));
       return;
     }
     if (url.pathname === "/api/watch-status") {
@@ -19093,8 +20151,8 @@ async function startGraphServer(rootDir, port, options = {}) {
       return;
     }
     const relativePath = url.pathname === "/" ? "index.html" : url.pathname.slice(1);
-    const target = path27.join(paths.viewerDistDir, relativePath);
-    const fallback = path27.join(paths.viewerDistDir, "index.html");
+    const target = path28.join(paths.viewerDistDir, relativePath);
+    const fallback = path28.join(paths.viewerDistDir, "index.html");
     const filePath = await fileExists(target) ? target : fallback;
     if (!await fileExists(filePath)) {
       response.writeHead(503, { "content-type": "text/plain" });
@@ -19102,7 +20160,7 @@ async function startGraphServer(rootDir, port, options = {}) {
       return;
     }
     response.writeHead(200, { "content-type": mime2.lookup(filePath) || "text/plain" });
-    response.end(await fs22.readFile(filePath));
+    response.end(await fs23.readFile(filePath));
   });
   await new Promise((resolve) => {
     server.listen(effectivePort, resolve);
@@ -19129,7 +20187,7 @@ async function exportGraphHtml(rootDir, outputPath, options = {}) {
     throw new Error("Graph artifact not found. Run `swarmvault compile` first.");
   }
   await ensureViewerDist(paths.viewerDistDir);
-  const indexPath = path27.join(paths.viewerDistDir, "index.html");
+  const indexPath = path28.join(paths.viewerDistDir, "index.html");
   if (!await fileExists(indexPath)) {
     throw new Error("Viewer build not found. Run `pnpm build` first.");
   }
@@ -19155,17 +20213,17 @@ async function exportGraphHtml(rootDir, outputPath, options = {}) {
       } : null;
     })
   );
-  const rawHtml = await fs22.readFile(indexPath, "utf8");
+  const rawHtml = await fs23.readFile(indexPath, "utf8");
   const scriptMatch = rawHtml.match(/<script type="module" crossorigin src="([^"]+)"><\/script>/);
   const styleMatch = rawHtml.match(/<link rel="stylesheet" crossorigin href="([^"]+)">/);
-  const scriptPath = scriptMatch?.[1] ? path27.join(paths.viewerDistDir, scriptMatch[1].replace(/^\//, "")) : null;
-  const stylePath = styleMatch?.[1] ? path27.join(paths.viewerDistDir, styleMatch[1].replace(/^\//, "")) : null;
+  const scriptPath = scriptMatch?.[1] ? path28.join(paths.viewerDistDir, scriptMatch[1].replace(/^\//, "")) : null;
+  const stylePath = styleMatch?.[1] ? path28.join(paths.viewerDistDir, styleMatch[1].replace(/^\//, "")) : null;
   if (!scriptPath || !await fileExists(scriptPath)) {
     throw new Error("Viewer script bundle not found. Run `pnpm build` first.");
   }
-  const script = await fs22.readFile(scriptPath, "utf8");
-  const style = stylePath && await fileExists(stylePath) ? await fs22.readFile(stylePath, "utf8") : "";
-  const report = await readJsonFile(path27.join(paths.wikiDir, "graph", "report.json"));
+  const script = await fs23.readFile(scriptPath, "utf8");
+  const style = stylePath && await fileExists(stylePath) ? await fs23.readFile(stylePath, "utf8") : "";
+  const report = await readJsonFile(path28.join(paths.wikiDir, "graph", "report.json"));
   const embeddedData = JSON.stringify(
     { graph: buildViewerGraphArtifact(graph, { report, full: options.full ?? false }), pages: pages.filter(Boolean), report },
     null,
@@ -19188,9 +20246,9 @@ async function exportGraphHtml(rootDir, outputPath, options = {}) {
     "</html>",
     ""
   ].filter(Boolean).join("\n");
-  await fs22.mkdir(path27.dirname(outputPath), { recursive: true });
-  await fs22.writeFile(outputPath, html, "utf8");
-  return path27.resolve(outputPath);
+  await fs23.mkdir(path28.dirname(outputPath), { recursive: true });
+  await fs23.writeFile(outputPath, html, "utf8");
+  return path28.resolve(outputPath);
 }
 export {
   acceptApproval,
@@ -19216,6 +20274,8 @@ export {
   getWatchStatus,
   getWebSearchAdapterForTask,
   getWorkspaceInfo,
+  guideManagedSource,
+  guideSourceScope,
   importInbox,
   ingestDirectory,
   ingestInput,
@@ -19250,6 +20310,7 @@ export {
   rejectApproval,
   reloadManagedSources,
   resolvePaths,
+  resumeSourceSession,
   reviewManagedSource,
   reviewSourceScope,
   runSchedule,