diff --git a/routes/sessionStoreReader.js b/routes/sessionStoreReader.js
new file mode 100644
index 0000000..d7773b9
--- /dev/null
+++ b/routes/sessionStoreReader.js
@@ -0,0 +1,193 @@
+/**
+ * Session store reader -- enriches session discovery with metadata from
+ * Copilot CLI's local SQLite databases.
+ *
+ * Reads:
+ *   ~/.copilot/session-store.db  -- summary, repo, branch, host_type, turns
+ *   ~/.copilot/data.db           -- model, reasoning_effort, custom title
+ *
+ * Gracefully returns empty results if databases do not exist.
+ */
+
+import path from "path";
+import fs from "fs";
+
+var _DatabaseSync = null;
+
+function getDatabase() {
+  if (_DatabaseSync !== null) return _DatabaseSync;
+  try {
+    _DatabaseSync = require("node:sqlite").DatabaseSync;
+  } catch (e) {
+    _DatabaseSync = false;
+  }
+  return _DatabaseSync;
+}
+
+function openDB(dbPath) {
+  var DB = getDatabase();
+  if (!DB) return null;
+  try {
+    if (!fs.existsSync(dbPath)) return null;
+    return new DB(dbPath, { readOnly: true });
+  } catch (e) {
+    return null;
+  }
+}
+
+function safeClose(db) {
+  if (!db) return;
+  try { db.close(); } catch (e) {}
+}
+
+/**
+ * Read session metadata from session-store.db.
+ * Returns a Map keyed by session ID.
+ */
+export function readSessionStoreMetadata(homeDir) {
+  var result = new Map();
+  var dbPath = path.join(homeDir, ".copilot", "session-store.db");
+  var db = openDB(dbPath);
+  if (!db) return result;
+
+  try {
+    var rows = db.prepare(
+      "SELECT s.id, s.cwd, s.repository, s.branch, s.summary, s.host_type, s.created_at, s.updated_at, " +
+      "(SELECT COUNT(*) FROM turns t WHERE t.session_id = s.id) as turn_count " +
+      "FROM sessions s ORDER BY s.updated_at DESC LIMIT 500"
+    ).all();
+
+    for (var i = 0; i < rows.length; i++) {
+      var row = rows[i];
+      result.set(row.id, {
+        summary: row.summary || null,
+        repository: row.repository || null,
+        branch: row.branch || null,
+        cwd: row.cwd || null,
+        hostType: row.host_type || null,
+        turnCount: row.turn_count || 0,
+        createdAt: row.created_at || null,
+        updatedAt: row.updated_at || null,
+      });
+    }
+  } catch (e) {
+    // Database may have different schema version
+  }
+
+  safeClose(db);
+  return result;
+}
+
+/**
+ * Read session metadata from data.db (Copilot CLI app database).
+ * Returns a Map keyed by session ID.
+ */
+export function readAppDbMetadata(homeDir) {
+  var result = new Map();
+  var dbPath = path.join(homeDir, ".copilot", "data.db");
+  var db = openDB(dbPath);
+  if (!db) return result;
+
+  try {
+    var rows = db.prepare(
+      "SELECT id, title, model, reasoning_effort, session_type, mode FROM sessions ORDER BY updated_at DESC LIMIT 500"
+    ).all();
+
+    for (var i = 0; i < rows.length; i++) {
+      var row = rows[i];
+      result.set(row.id, {
+        title: row.title || null,
+        model: row.model || null,
+        reasoningEffort: row.reasoning_effort || null,
+        sessionType: row.session_type || null,
+        mode: row.mode || null,
+      });
+    }
+  } catch (e) {
+    // Database may have different schema version
+  }
+
+  safeClose(db);
+  return result;
+}
+
+/**
+ * Merge store metadata into a list of session results (mutates in place).
+ * Also returns store-only sessions (in store but not in results).
+ */
+export function enrichSessionResults(results, homeDir) {
+  var storeData = readSessionStoreMetadata(homeDir);
+  var appData = readAppDbMetadata(homeDir);
+
+  if (storeData.size === 0 && appData.size === 0) return [];
+
+  var seenIds = new Set();
+
+  for (var i = 0; i < results.length; i++) {
+    var entry = results[i];
+    if (entry.format !== "copilot-cli" || !entry.sessionId) continue;
+
+    seenIds.add(entry.sessionId);
+
+    var store = storeData.get(entry.sessionId);
+    if (store) {
+      // Prefer store summary over workspace.yaml/first-message fallback
+      if (store.summary && (!entry.summary || entry.summary.length < store.summary.length)) {
+        entry.summary = store.summary;
+        entry.project = store.summary;
+      }
+      if (store.repository && !entry.repository) entry.repository = store.repository;
+      if (store.branch && !entry.branch) entry.branch = store.branch;
+      if (store.hostType) entry.hostType = store.hostType;
+      if (store.turnCount) entry.turnCount = store.turnCount;
+    }
+
+    var app = appData.get(entry.sessionId);
+    if (app) {
+      if (app.title) entry.customTitle = app.title;
+      if (app.model) entry.model = app.model;
+      if (app.reasoningEffort) entry.reasoningEffort = app.reasoningEffort;
+      if (app.sessionType) entry.sessionType = app.sessionType;
+      if (app.mode) entry.mode = app.mode;
+    }
+  }
+
+  // Find store-only sessions (have events.jsonl but not in scan results)
+  var extras = [];
+  var copilotRoot = path.join(homeDir, ".copilot", "session-state");
+
+  storeData.forEach(function (store, sessionId) {
+    if (seenIds.has(sessionId)) return;
+
+    var eventsFile = path.join(copilotRoot, sessionId, "events.jsonl");
+    try {
+      var stat = fs.statSync(eventsFile);
+      var app = appData.get(sessionId) || {};
+      extras.push({
+        id: "copilot-cli:" + sessionId + ":events.jsonl",
+        path: eventsFile,
+        filename: "events.jsonl",
+        file: store.summary || "events.jsonl",
+        project: store.summary || sessionId.substring(0, 8),
+        projectDir: sessionId,
+        sessionId: sessionId,
+        repository: store.repository || null,
+        branch: store.branch || null,
+        summary: store.summary || null,
+        format: "copilot-cli",
+        source: "store",
+        size: stat.size,
+        mtime: stat.mtime.toISOString(),
+        hostType: store.hostType || null,
+        turnCount: store.turnCount || 0,
+        model: app.model || null,
+        reasoningEffort: app.reasoningEffort || null,
+        customTitle: app.title || null,
+      });
+    } catch (e) {
+      // events.jsonl doesn't exist -- skip
+    }
+  });
+
+  return extras;
+}
diff --git a/routes/sessions.js b/routes/sessions.js
index c25aea3..d51c1c3 100644
--- a/routes/sessions.js
+++ b/routes/sessions.js
@@ -2,8 +2,9 @@
  * Session discovery, file serving, and SSE streaming routes.
  *
  * Handles:
- *   GET /api/sessions -- discover Claude Code, Codex, VS Code, & Copilot CLI sessions
+ *   GET /api/sessions -- discover Claude Code, Codex, VS Code, Copilot CLI, & shared sessions
  *   GET /api/session  -- serve a single session file from HOME
+ *   GET /api/session/shared -- serve a shared session markdown or gist
  *   GET /api/file     -- serve the active watched session file
  *   GET /api/meta     -- return filename & live status
  *   GET /api/stream   -- SSE endpoint for live session updates
@@ -11,6 +12,8 @@
 
 import fs from "fs";
 import path from "path";
+import { enrichSessionResults } from "./sessionStoreReader.js";
+import { findSharedSessionFiles, findSharedSessionGists, parseSharedSessionMarkdown } from "./sharedSessions.js";
 
 function decodeProjectDir(dirName) {
   return (dirName || "").replace(/^-/, "").replace(/-/g, "/");
@@ -332,6 +335,11 @@ function isCodexSessionPath(resolvedSessionPath, homeDir) {
     && /^rollout-.+\.jsonl$/.test(parts[3]);
 }
 
+export function isAllowedSharedPath(resolvedPath, resolvedCwd) {
+  if (!resolvedCwd) return false;
+  return isPathInsideRoot(resolvedCwd, resolvedPath);
+}
+
 export function isAllowedSessionPath(resolvedSessionPath, homeDir) {
   if (!homeDir) return false;
 
@@ -501,12 +509,78 @@ export function handle(pathname, req, res, ctx) {
       } catch (e) {}
     });
 
+    // Enrich Copilot CLI sessions with metadata from session-store.db and data.db
+    var storeExtras = [];
+    try {
+      storeExtras = enrichSessionResults(results, homeDir);
+    } catch (e) {}
+    if (storeExtras.length > 0) {
+      results = results.concat(storeExtras);
+    }
+
+    // Discover shared sessions (local markdown + gists)
+    var cwd = process.cwd();
+    try {
+      var sharedFiles = findSharedSessionFiles(cwd);
+      results = results.concat(sharedFiles);
+    } catch (e) {}
+
+    try {
+      var sharedGists = findSharedSessionGists();
+      results = results.concat(sharedGists);
+    } catch (e) {}
+
     results.sort(function (a, b) { return new Date(b.mtime) - new Date(a.mtime); });
     res.writeHead(200);
     res.end(JSON.stringify(results.slice(0, 200)));
     return true;
   }
 
+  if (pathname === "/api/session/shared") {
+    res.setHeader("Content-Type", "application/json");
+    if (req.method !== "GET") { res.writeHead(405); res.end(JSON.stringify({ error: "Method not allowed" })); return true; }
+
+    var sharedPath = ctx.parsed.query.path;
+    var gistId = ctx.parsed.query.gist;
+
+    if (sharedPath) {
+      // Local shared markdown file
+      try {
+        var resolvedShared = fs.realpathSync(path.resolve(sharedPath));
+        if (!resolvedShared.endsWith(".md")) { res.writeHead(400); res.end(JSON.stringify({ error: "Only .md files" })); return true; }
+        var resolvedCwdShared = fs.realpathSync(process.cwd());
+        if (!isAllowedSharedPath(resolvedShared, resolvedCwdShared)) { res.writeHead(403); res.end(JSON.stringify({ error: "Forbidden" })); return true; }
+        var mdText = fs.readFileSync(resolvedShared, "utf8");
+        var parsed = parseSharedSessionMarkdown(mdText);
+        res.writeHead(200);
+        res.end(JSON.stringify({ source: "file", raw: mdText, parsed: parsed }));
+      } catch (e) {
+        res.writeHead(404);
+        res.end(JSON.stringify({ error: "Not found" }));
+      }
+      return true;
+    }
+
+    if (gistId) {
+      // Download gist content
+      try {
+        var { execFileSync } = require("child_process");
+        var gistOutput = execFileSync("gh", ["gist", "view", gistId, "--raw"], { timeout: 15000, encoding: "utf8" });
+        var parsedGist = parseSharedSessionMarkdown(gistOutput);
+        res.writeHead(200);
+        res.end(JSON.stringify({ source: "gist", raw: gistOutput, parsed: parsedGist }));
+      } catch (e) {
+        res.writeHead(404);
+        res.end(JSON.stringify({ error: "Gist not found or gh CLI unavailable" }));
+      }
+      return true;
+    }
+
+    res.writeHead(400);
+    res.end(JSON.stringify({ error: "Provide path or gist query param" }));
+    return true;
+  }
+
   if (pathname === "/api/session") {
     res.setHeader("Content-Type", "text/plain; charset=utf-8");
     if (req.method !== "GET") { res.writeHead(405); res.end("Method not allowed"); return true; }
diff --git a/routes/sharedSessions.js b/routes/sharedSessions.js
new file mode 100644
index 0000000..7f71898
--- /dev/null
+++ b/routes/sharedSessions.js
@@ -0,0 +1,224 @@
+/**
+ * Shared session discovery -- finds Copilot CLI sessions exported via
+ * /share file (local markdown) and /share gist (GitHub gists).
+ */
+
+import fs from "fs";
+import path from "path";
+import { execFileSync } from "child_process";
+
+/**
+ * Discover copilot-session-*.md files in a directory.
+ */
+export function findSharedSessionFiles(searchDir) {
+  var results = [];
+  if (!searchDir) return results;
+
+  try {
+    var files = fs.readdirSync(searchDir);
+    for (var i = 0; i < files.length; i++) {
+      var fname = files[i];
+      if (!fname.startsWith("copilot-session-") || !fname.endsWith(".md")) continue;
+      var filePath = path.join(searchDir, fname);
+      try {
+        var stat = fs.statSync(filePath);
+        if (!stat.isFile() || stat.size < 50) continue;
+
+        var sessionId = fname.replace("copilot-session-", "").replace(".md", "");
+        var preview = readSharedSessionPreview(filePath);
+
+        results.push({
+          id: "shared-file:" + fname,
+          path: filePath,
+          filename: fname,
+          file: preview.title || fname,
+          project: preview.title || "Shared session",
+          sessionId: sessionId,
+          summary: preview.title || null,
+          format: "shared-md",
+          source: "shared-file",
+          size: stat.size,
+          mtime: stat.mtime.toISOString(),
+          duration: preview.duration || null,
+          startedAt: preview.startedAt || null,
+        });
+      } catch (e) {}
+    }
+  } catch (e) {}
+
+  return results;
+}
+
+/**
+ * Read the header of a shared session markdown file to extract metadata.
+ *
+ * Format:
+ *   # Copilot CLI Session
+ *   > **Session ID:** `<uuid>`
+ *   > **Started:** <date>
+ *   > **Duration:** <time>
+ *   > **Exported:** <date>
+ */
+export function readSharedSessionPreview(filePath) {
+  try {
+    var fd = fs.openSync(filePath, "r");
+    var buf = Buffer.alloc(2048);
+    fs.readSync(fd, buf, 0, 2048, 0);
+    fs.closeSync(fd);
+    var text = buf.toString("utf8");
+
+    var durationMatch = text.match(/\*\*Duration:\*\*\s*(.+)/);
+    var startedMatch = text.match(/\*\*Started:\*\*\s*(.+)/);
+
+    // Extract the first user message as the title
+    var userMatch = text.match(/###\s+\u{1F464}\s+User\s*\n+([\s\S]*?)(?:\n---|\n###)/u);
+    var title = null;
+    if (userMatch) {
+      title = userMatch[1].trim().substring(0, 120);
+      if (title.length === 120) title += "...";
+    }
+
+    return {
+      duration: durationMatch ? durationMatch[1].trim() : null,
+      startedAt: startedMatch ? startedMatch[1].trim() : null,
+      title: title,
+    };
+  } catch (e) {
+    return { duration: null, startedAt: null, title: null };
+  }
+}
+
+var _gistCache = { results: null, fetchedAt: 0 };
+var GIST_CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+
+/**
+ * Discover shared session gists via gh CLI.
+ * Results are cached for GIST_CACHE_TTL_MS to avoid blocking the event loop
+ * on every /api/sessions poll.
+ */
+export function findSharedSessionGists() {
+  var now = Date.now();
+  if (_gistCache.results !== null && now - _gistCache.fetchedAt < GIST_CACHE_TTL_MS) {
+    return _gistCache.results;
+  }
+
+  var results = [];
+
+  try {
+    var output = execFileSync("gh", [
+      "gist", "list", "--limit", "30",
+      "--json", "id,description,files,createdAt,updatedAt",
+    ], { timeout: 10000, encoding: "utf8" });
+
+    var gists = JSON.parse(output);
+    for (var i = 0; i < gists.length; i++) {
+      var gist = gists[i];
+      if (!gist.files || gist.files.length === 0) continue;
+
+      var sessionFile = null;
+      for (var j = 0; j < gist.files.length; j++) {
+        var fname = gist.files[j].filename || gist.files[j];
+        if (typeof fname === "string" && fname.startsWith("copilot-session-") && fname.endsWith(".md")) {
+          sessionFile = fname;
+          break;
+        }
+      }
+      if (!sessionFile) continue;
+
+      var sessionId = sessionFile.replace("copilot-session-", "").replace(".md", "");
+
+      results.push({
+        id: "shared-gist:" + gist.id,
+        gistId: gist.id,
+        filename: sessionFile,
+        file: gist.description || sessionFile,
+        project: gist.description || "Shared gist",
+        sessionId: sessionId,
+        summary: gist.description || null,
+        format: "shared-md",
+        source: "shared-gist",
+        size: 0,
+        mtime: gist.updatedAt || gist.createdAt || new Date().toISOString(),
+      });
+    }
+  } catch (e) {
+    // gh CLI not available or failed
+  }
+
+  _gistCache = { results: results, fetchedAt: Date.now() };
+  return results;
+}
+
+/**
+ * Parse a shared session markdown file into conversation turns.
+ * Returns { turns: [...], metadata: {...} } for the transcript viewer.
+ */
+export function parseSharedSessionMarkdown(text) {
+  var lines = text.split("\n");
+  var turns = [];
+  var currentTurn = null;
+  var metadata = { sessionId: null, startedAt: null, duration: null, exportedAt: null };
+
+  for (var i = 0; i < lines.length; i++) {
+    var line = lines[i];
+
+    // Parse header metadata
+    var sessionIdMatch = line.match(/\*\*Session ID:\*\*\s*`(.+)`/);
+    if (sessionIdMatch) { metadata.sessionId = sessionIdMatch[1]; continue; }
+
+    var startedMatch = line.match(/\*\*Started:\*\*\s*(.+)/);
+    if (startedMatch) { metadata.startedAt = startedMatch[1].trim(); continue; }
+
+    var durationMatch = line.match(/\*\*Duration:\*\*\s*(.+)/);
+    if (durationMatch) { metadata.duration = durationMatch[1].trim(); continue; }
+
+    var exportedMatch = line.match(/\*\*Exported:\*\*\s*(.+)/);
+    if (exportedMatch) { metadata.exportedAt = exportedMatch[1].trim(); continue; }
+
+    // Parse turn headers: ### <emoji> <type>
+    var turnMatch = line.match(/^###\s+(.+?)\s+(User|Reasoning|Info|`(.+)`)$/);
+    if (turnMatch) {
+      if (currentTurn) turns.push(currentTurn);
+      var icon = turnMatch[1];
+      var typeLabel = turnMatch[2];
+      var toolName = turnMatch[3] || null;
+
+      var agent = "system";
+      var track = "output";
+      if (typeLabel === "User") { agent = "user"; track = "context"; }
+      else if (typeLabel === "Reasoning") { agent = "assistant"; track = "reasoning"; }
+      else if (toolName) { agent = "assistant"; track = "tool_call"; }
+      else if (icon.includes("\u2139")) { agent = "system"; track = "output"; }
+
+      currentTurn = { agent: agent, track: track, toolName: toolName, text: "", timestamp: null };
+
+      // Look for timestamp in previous line
+      if (i > 0) {
+        var tsMatch = lines[i - 2] ? lines[i - 2].match(/\u23F1\uFE0F?\s*(.+)</) : null;
+        if (tsMatch) currentTurn.timestamp = tsMatch[1].trim();
+      }
+
+      continue;
+    }
+
+    // Separator
+    if (line.trim() === "---") {
+      if (currentTurn) { turns.push(currentTurn); currentTurn = null; }
+      continue;
+    }
+
+    // Content accumulation
+    if (currentTurn) {
+      currentTurn.text += (currentTurn.text ? "\n" : "") + line;
+    }
+  }
+
+  if (currentTurn) turns.push(currentTurn);
+
+  // Clean up turn text
+  for (var j = 0; j < turns.length; j++) {
+    turns[j].text = turns[j].text.trim();
+  }
+
+  return { turns: turns, metadata: metadata };
+}
diff --git a/src/App.jsx b/src/App.jsx
index ae5f4dd..494fd98 100644
--- a/src/App.jsx
+++ b/src/App.jsx
@@ -339,7 +339,7 @@ function AppShell({
   );
 }
 
-// ── Active session view (consumes PlaybackContext) ──────────────────────────
+// ΓöÇΓöÇ Active session view (consumes PlaybackContext) ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ
 
 function AppSessionView({
   session, activeView, setView, autonomyMetrics, debrief,
diff --git a/src/__tests__/sessionsRoute.test.js b/src/__tests__/sessionsRoute.test.js
index b8d74b6..7e349b1 100644
--- a/src/__tests__/sessionsRoute.test.js
+++ b/src/__tests__/sessionsRoute.test.js
@@ -2,7 +2,7 @@ import fs from "fs";
 import os from "os";
 import { join } from "path";
 import { afterEach, describe, expect, it, vi } from "vitest";
-import { extractVSCodeCustomTitle, extractVSCodeSessionId, clipToLength, filterSessionFiles, findCodexSessionFiles, isAllowedSessionPath, readCodexSessionPreview, readCopilotCliSessionPreview, readVSCodeCustomTitle, readVSCodeSessionPreview } from "../../routes/sessions.js";
+import { extractVSCodeCustomTitle, extractVSCodeSessionId, clipToLength, filterSessionFiles, findCodexSessionFiles, isAllowedSessionPath, isAllowedSharedPath, readCodexSessionPreview, readCopilotCliSessionPreview, readVSCodeCustomTitle, readVSCodeSessionPreview } from "../../routes/sessions.js";
 
 function withTempFile(name, content, fn) {
   var tempDir = fs.mkdtempSync(join(os.tmpdir(), "agentviz-routes-"));
@@ -274,6 +274,34 @@ describe("session path restrictions", function () {
   });
 });
 
+describe("isAllowedSharedPath (shared session file restriction)", function () {
+  it("allows a file inside cwd", function () {
+    var cwd = process.platform === "win32" ? "C:\\Users\\tester\\project" : "/home/tester/project";
+    var filePath = process.platform === "win32"
+      ? "C:\\Users\\tester\\project\\copilot-session-abc.md"
+      : "/home/tester/project/copilot-session-abc.md";
+    expect(isAllowedSharedPath(filePath, cwd)).toBe(true);
+  });
+
+  it("rejects a file outside cwd", function () {
+    var cwd = process.platform === "win32" ? "C:\\Users\\tester\\project" : "/home/tester/project";
+    var outsidePath = process.platform === "win32"
+      ? "C:\\Windows\\System32\\secret.md"
+      : "/etc/secret.md";
+    expect(isAllowedSharedPath(outsidePath, cwd)).toBe(false);
+  });
+
+  it("rejects a sibling directory that shares a common prefix with cwd", function () {
+    var cwd = "/home/tester/project";
+    expect(isAllowedSharedPath("/home/tester/project-evil/session.md", cwd)).toBe(false);
+  });
+
+  it("returns false when cwd is null or empty", function () {
+    expect(isAllowedSharedPath("/home/tester/project/session.md", null)).toBe(false);
+    expect(isAllowedSharedPath("/home/tester/project/session.md", "")).toBe(false);
+  });
+});
+
 describe("filterSessionFiles", function () {
   it("returns .json and .jsonl files, filtering non-session files", function () {
     var files = ["readme.txt", "session.json", "data.csv", "events.jsonl"];
diff --git a/src/__tests__/sharedMdDetection.test.js b/src/__tests__/sharedMdDetection.test.js
new file mode 100644
index 0000000..4aaf850
--- /dev/null
+++ b/src/__tests__/sharedMdDetection.test.js
@@ -0,0 +1,24 @@
+import { describe, it, expect } from "vitest";
+import { detectFormat } from "../lib/parseSession";
+
+describe("detectFormat with shared-md", function () {
+  it("detects shared markdown format", function () {
+    var text = "# \uD83E\uDD16 Copilot CLI Session\n\n> **Session ID:** `abc-123`\n> **Started:** 1/1/2026";
+    expect(detectFormat(text)).toBe("shared-md");
+  });
+
+  it("does not detect shared-md for regular markdown", function () {
+    var text = "# My Project\n\nSome documentation about the project.";
+    expect(detectFormat(text)).not.toBe("shared-md");
+  });
+
+  it("does not detect shared-md for JSONL", function () {
+    var text = '{"type":"user.message","data":{"content":"hello"}}';
+    expect(detectFormat(text)).not.toBe("shared-md");
+  });
+
+  it("still detects copilot-cli format", function () {
+    var text = '{"type":"session.start","data":{"producer":"copilot-agent"}}\n{"type":"user.message"}';
+    expect(detectFormat(text)).toBe("copilot-cli");
+  });
+});
diff --git a/src/__tests__/sharedSessionParser.test.js b/src/__tests__/sharedSessionParser.test.js
new file mode 100644
index 0000000..2e3a138
--- /dev/null
+++ b/src/__tests__/sharedSessionParser.test.js
@@ -0,0 +1,152 @@
+import { describe, it, expect } from "vitest";
+import { parseSharedMarkdown } from "../lib/sharedSessionParser.js";
+
+var SAMPLE_SHARED_SESSION = [
+  "# \uD83E\uDD16 Copilot CLI Session",
+  "",
+  "> **Session ID:** `57588cd3-d08d-4cd9-b0e8-8a28601305ec`",
+  "> **Started:** 1/22/2026, 11:05:28 AM",
+  "> **Duration:** 274m 2s",
+  "> **Exported:** 1/22/2026, 3:39:30 PM",
+  "",
+  "<sub>\u23F1\uFE0F 0s</sub>",
+  "",
+  "### \u2139\uFE0F Info",
+  "",
+  "Welcome spboyer (via gh)!",
+  "",
+  "---",
+  "",
+  "<sub>\u23F1\uFE0F 1s</sub>",
+  "",
+  "### \u2139\uFE0F Info",
+  "",
+  "Configured MCP servers: azure-mcp",
+  "",
+  "---",
+  "",
+  "<sub>\u23F1\uFE0F 272m 41s</sub>",
+  "",
+  "### \uD83D\uDC64 User",
+  "",
+  "can you list the top 10 repos in my profile",
+  "",
+  "---",
+  "",
+  "<sub>\u23F1\uFE0F 272m 45s</sub>",
+  "",
+  "### \uD83D\uDCAD Reasoning",
+  "",
+  "*The user wants to list the top 10 repositories in their GitHub profile.*",
+  "",
+  "---",
+  "",
+  "<sub>\u23F1\uFE0F 272m 59s</sub>",
+  "",
+  "### \u2705 `bash`",
+  "",
+  "**List top 10 repos by stars**",
+  "",
+  "$ gh repo list --limit 10",
+  "",
+  "<details>",
+  "<summary>15 lines</summary>",
+  "",
+  "```",
+  "spboyer/agentviz     Session replay visualizer",
+  "spboyer/waza         CLI for Agent Skills",
+  "```",
+  "",
+  "</details>",
+  "",
+  "---",
+].join("\n");
+
+describe("parseSharedMarkdown", function () {
+  it("returns null for empty input", function () {
+    expect(parseSharedMarkdown("")).toBe(null);
+    expect(parseSharedMarkdown(null)).toBe(null);
+    expect(parseSharedMarkdown(undefined)).toBe(null);
+  });
+
+  it("returns null for non-shared-session text", function () {
+    expect(parseSharedMarkdown("# Some other markdown doc\n\nHello world")).toBe(null);
+    expect(parseSharedMarkdown('{"type":"user.message"}')).toBe(null);
+  });
+
+  it("parses metadata from header", function () {
+    var result = parseSharedMarkdown(SAMPLE_SHARED_SESSION);
+    expect(result).not.toBe(null);
+    expect(result.metadata.sessionId).toBe("57588cd3-d08d-4cd9-b0e8-8a28601305ec");
+    expect(result.metadata.format).toBe("shared-md");
+  });
+
+  it("extracts events from sections", function () {
+    var result = parseSharedMarkdown(SAMPLE_SHARED_SESSION);
+    expect(result.events.length).toBeGreaterThanOrEqual(4);
+  });
+
+  it("identifies agent types correctly", function () {
+    var result = parseSharedMarkdown(SAMPLE_SHARED_SESSION);
+    var agents = result.events.map(function (e) { return e.agent; });
+    expect(agents).toContain("user");
+    expect(agents).toContain("assistant");
+    expect(agents).toContain("system");
+  });
+
+  it("identifies track types correctly", function () {
+    var result = parseSharedMarkdown(SAMPLE_SHARED_SESSION);
+    var tracks = result.events.map(function (e) { return e.track; });
+    expect(tracks).toContain("context"); // user
+    expect(tracks).toContain("reasoning"); // reasoning
+    expect(tracks).toContain("tool_call"); // bash
+    expect(tracks).toContain("output"); // info
+  });
+
+  it("parses tool names from backtick headers", function () {
+    var result = parseSharedMarkdown(SAMPLE_SHARED_SESSION);
+    var toolEvents = result.events.filter(function (e) { return e.toolName; });
+    expect(toolEvents.length).toBeGreaterThan(0);
+    expect(toolEvents[0].toolName).toBe("bash");
+  });
+
+  it("parses timestamps as seconds", function () {
+    var result = parseSharedMarkdown(SAMPLE_SHARED_SESSION);
+    // First info event should be at t=0
+    expect(result.events[0].t).toBe(0);
+    // User event at 272m 41s = 16361s
+    var userEvent = result.events.find(function (e) { return e.agent === "user"; });
+    expect(userEvent.t).toBe(272 * 60 + 41);
+  });
+
+  it("builds turns from user messages", function () {
+    var result = parseSharedMarkdown(SAMPLE_SHARED_SESSION);
+    expect(result.turns.length).toBeGreaterThan(0);
+  });
+
+  it("strips details/summary wrappers from tool output", function () {
+    var result = parseSharedMarkdown(SAMPLE_SHARED_SESSION);
+    var toolEvent = result.events.find(function (e) { return e.toolName === "bash"; });
+    expect(toolEvent.text).not.toContain("<details>");
+    expect(toolEvent.text).not.toContain("<summary>");
+  });
+
+  it("sets metadata.totalEvents and totalToolCalls", function () {
+    var result = parseSharedMarkdown(SAMPLE_SHARED_SESSION);
+    expect(result.metadata.totalEvents).toBe(result.events.length);
+    expect(result.metadata.totalToolCalls).toBeGreaterThan(0);
+  });
+
+  it("handles duration parsing", function () {
+    var result = parseSharedMarkdown(SAMPLE_SHARED_SESSION);
+    // 274m 2s = 16442s
+    expect(result.metadata.duration).toBe(274 * 60 + 2);
+  });
+
+  it("detects error events", function () {
+    var withError = SAMPLE_SHARED_SESSION + "\n<sub>\u23F1\uFE0F 273m 0s</sub>\n\n### \u2705 `bash`\n\nError: command failed\n<exited with exit code 1>\n\n---\n";
+    var result = parseSharedMarkdown(withError);
+    var errors = result.events.filter(function (e) { return e.isError; });
+    expect(errors.length).toBeGreaterThan(0);
+  });
+});
diff --git a/src/__tests__/sharedSessions.test.js b/src/__tests__/sharedSessions.test.js
new file mode 100644
index 0000000..f13e879
--- /dev/null
+++ b/src/__tests__/sharedSessions.test.js
@@ -0,0 +1,79 @@
+import { describe, it, expect } from "vitest";
+import { readSharedSessionPreview, parseSharedSessionMarkdown } from "../../routes/sharedSessions.js";
+
+var SAMPLE_MD = [
+  "# \uD83E\uDD16 Copilot CLI Session",
+  "",
+  "> **Session ID:** `abc-123`",
+  "> **Started:** 3/15/2026, 2:00:00 PM",
+  "> **Duration:** 5m 30s",
+  "> **Exported:** 3/15/2026, 2:05:30 PM",
+  "",
+  "<sub>\u23F1\uFE0F 0s</sub>",
+  "",
+  "### \u2139\uFE0F Info",
+  "",
+  "Welcome user (via gh)!",
+  "",
+  "---",
+  "",
+  "<sub>\u23F1\uFE0F 10s</sub>",
+  "",
+  "### \uD83D\uDC64 User",
+  "",
+  "What is the meaning of life?",
+  "",
+  "---",
+  "",
+  "<sub>\u23F1\uFE0F 12s</sub>",
+  "",
+  "### \uD83D\uDCAD Reasoning",
+  "",
+  "*The user asks a philosophical question.*",
+  "",
+  "---",
+].join("\n");
+
+describe("parseSharedSessionMarkdown (server-side)", function () {
+  it("parses metadata fields", function () {
+    var result = parseSharedSessionMarkdown(SAMPLE_MD);
+    expect(result.metadata.sessionId).toBe("abc-123");
+    expect(result.metadata.duration).toBe("5m 30s");
+    expect(result.metadata.startedAt).toBe("3/15/2026, 2:00:00 PM");
+    expect(result.metadata.exportedAt).toBe("3/15/2026, 2:05:30 PM");
+  });
+
+  it("extracts conversation turns", function () {
+    var result = parseSharedSessionMarkdown(SAMPLE_MD);
+    expect(result.turns.length).toBe(3);
+    expect(result.turns[0].agent).toBe("system");
+    expect(result.turns[1].agent).toBe("user");
+    expect(result.turns[2].agent).toBe("assistant");
+  });
+
+  it("extracts turn text content", function () {
+    var result = parseSharedSessionMarkdown(SAMPLE_MD);
+    expect(result.turns[1].text).toBe("What is the meaning of life?");
+  });
+
+  it("handles tool call turns", function () {
+    var withTool = SAMPLE_MD + "\n<sub>\u23F1\uFE0F 15s</sub>\n\n### \u2705 `grep`\n\nSearching files...\n\n---\n";
+    var result = parseSharedSessionMarkdown(withTool);
+    var toolTurn = result.turns.find(function (t) { return t.toolName; });
+    expect(toolTurn).toBeTruthy();
+    expect(toolTurn.toolName).toBe("grep");
+    expect(toolTurn.track).toBe("tool_call");
+  });
+
+  it("handles empty input", function () {
+    var result = parseSharedSessionMarkdown("");
+    expect(result.turns.length).toBe(0);
+  });
+});
+
+describe("readSharedSessionPreview", function () {
+  // This function reads from disk; test with a synthetic approach
+  it("is a function", function () {
+    expect(typeof readSharedSessionPreview).toBe("function");
+  });
+});
diff --git a/src/hooks/useDiscoveredSessions.js b/src/hooks/useDiscoveredSessions.js
index 5b489cf..76859f5 100644
--- a/src/hooks/useDiscoveredSessions.js
+++ b/src/hooks/useDiscoveredSessions.js
@@ -84,7 +84,7 @@ export default function useDiscoveredSessions() {
   }, [fetchSessions]);
 
   // Fetches the raw content of a discovered session.
-  // Accepts either a session object (with .source field) or a plain path string.
+  // Accepts a session entry object (with .source field) or a plain path string.
   var fetchSessionContent = useCallback(function (session) {
     if (session && session.source === "manifest") {
       return fetch(session.path || session).then(function (r) {
@@ -92,6 +92,27 @@ export default function useDiscoveredSessions() {
         return r.text();
       });
     }
+
+    var src = session && typeof session === "object" ? session.source : null;
+
+    if (src === "shared-file") {
+      return fetch("/api/session/shared?path=" + encodeURIComponent(session.path))
+        .then(function (r) {
+          if (!r.ok) throw new Error("fetch failed: " + r.status);
+          return r.json();
+        })
+        .then(function (data) { return data.raw; });
+    }
+
+    if (src === "shared-gist") {
+      return fetch("/api/session/shared?gist=" + encodeURIComponent(session.gistId))
+        .then(function (r) {
+          if (!r.ok) throw new Error("fetch failed: " + r.status);
+          return r.json();
+        })
+        .then(function (data) { return data.raw; });
+    }
+
     var sessionPath = typeof session === "string" ? session : session.path;
     return fetch("/api/session?path=" + encodeURIComponent(sessionPath))
       .then(function (r) {
diff --git a/src/lib/parseSession.ts b/src/lib/parseSession.ts
index efdffd0..52d8743 100644
--- a/src/lib/parseSession.ts
+++ b/src/lib/parseSession.ts
@@ -7,6 +7,7 @@
  *   - VS Code Copilot Chat JSON (version + requests + sessionId)
  *   - VS Code Copilot prompt exports (copilot_all_prompts_*.json)
  *   - ATIF / Harbor trajectory JSON (schema_version: "ATIF-*")
+ *   - Shared session markdown (from Copilot CLI /share file or /share gist)
  *   - Claude Code JSONL (default fallback)
  *
  * Returns: { events, turns, metadata } or null
@@ -18,23 +19,33 @@ import { detectCopilotCli, parseCopilotCliJSONL } from "./copilotCliParser";
 import { detectCopilotPrompts, parseCopilotPromptsJSON } from "./copilotCostParser";
 import { parseClaudeCodeJSONL } from "./parser";
 import { detectVSCodeChat, parseVSCodeChatJSON } from "./vscodeSessionParser";
+// @ts-ignore -- plain JS module
+import { parseSharedMarkdown } from "./sharedSessionParser";
 import type { ParsedSession, SessionFormat } from "./sessionTypes";
 
 export function detectFormat(text: string): SessionFormat {
   if (detectAtif(text)) return "atif";
   if (detectCodexJSONL(text)) return "codex";
+  if (detectSharedMarkdown(text)) return "shared-md";
   if (detectCopilotCli(text)) return "copilot-cli";
   if (detectVSCodeChat(text)) return "vscode-chat";
   if (detectCopilotPrompts(text)) return "copilot-prompts";
   return "claude-code";
 }
 
+function detectSharedMarkdown(text: string): boolean {
+  // Shared sessions start with "# ... Copilot CLI Session" header
+  const firstChunk = text.substring(0, 500);
+  return firstChunk.includes("Copilot CLI Session") && firstChunk.includes("**Session ID:**");
+}
+
 export function parseSession(text: string): ParsedSession | null {
   const format = detectFormat(text);
 
   let parsed: ParsedSession | null;
   if (format === "atif") parsed = parseAtifJSON(text);
   else if (format === "codex") parsed = parseCodexJSONL(text);
+  else if (format === "shared-md") parsed = parseSharedMarkdown(text);
   else if (format === "copilot-cli") parsed = parseCopilotCliJSONL(text);
   else if (format === "vscode-chat") parsed = parseVSCodeChatJSON(text);
   else if (format === "copilot-prompts") parsed = parseCopilotPromptsJSON(text);
diff --git a/src/lib/sessionTypes.ts b/src/lib/sessionTypes.ts
index 477fafa..31e7c50 100644
--- a/src/lib/sessionTypes.ts
+++ b/src/lib/sessionTypes.ts
@@ -8,7 +8,7 @@ export interface TokenUsage {
   cacheHitRate?: number;
 }
 
-export type SessionFormat = "claude-code" | "copilot-cli" | "vscode-chat" | "atif" | "copilot-prompts" | "codex";
+export type SessionFormat = "claude-code" | "copilot-cli" | "vscode-chat" | "atif" | "copilot-prompts" | "codex" | "shared-md";
 
 export interface ParseIssues {
   malformedLines: number;
diff --git a/src/lib/sharedSessionParser.js b/src/lib/sharedSessionParser.js
new file mode 100644
index 0000000..ceca496
--- /dev/null
+++ b/src/lib/sharedSessionParser.js
@@ -0,0 +1,237 @@
+/**
+ * Shared session markdown parser for AGENTVIZ.
+ *
+ * Parses the markdown format produced by Copilot CLI's /share file command
+ * into normalized events compatible with the AGENTVIZ replay engine.
+ *
+ * Format:
+ *   # Copilot CLI Session
+ *   > **Session ID:** `<uuid>`
+ *   > **Started:** <date>
+ *   > **Duration:** <time>
+ *   > **Exported:** <date>
+ *   <sub>timestamp</sub>
+ *   ### <emoji> <type>
+ *   content...
+ *   ---
+ */
+
+var AGENT_MAP = {
+  User: "user",
+  Reasoning: "assistant",
+  Info: "system",
+};
+
+var TRACK_MAP = {
+  User: "context",
+  Reasoning: "reasoning",
+  Info: "output",
+};
+
+function parseDuration(durationStr) {
+  if (!durationStr) return 0;
+  var total = 0;
+  var daysMatch = durationStr.match(/(\d+)d/);
+  var hoursMatch = durationStr.match(/(\d+)h/);
+  var minsMatch = durationStr.match(/(\d+)m/);
+  var secsMatch = durationStr.match(/(\d+)s/);
+  if (daysMatch) total += parseInt(daysMatch[1], 10) * 86400;
+  if (hoursMatch) total += parseInt(hoursMatch[1], 10) * 3600;
+  if (minsMatch) total += parseInt(minsMatch[1], 10) * 60;
+  if (secsMatch) total += parseInt(secsMatch[1], 10);
+  return total;
+}
+
+function parseTimestamp(tsStr) {
+  if (!tsStr) return 0;
+  return parseDuration(tsStr);
+}
+
+export function parseSharedMarkdown(text) {
+  if (!text || typeof text !== "string") return null;
+  if (!text.includes("Copilot CLI Session") && !text.includes("copilot-session")) return null;
+
+  var lines = text.split("\n");
+  var events = [];
+  var metadata = {
+    sessionId: null,
+    startedAt: null,
+    duration: null,
+    exportedAt: null,
+  };
+
+  var currentEvent = null;
+  var lastTimestamp = 0;
+  var turnIndex = 0;
+  var turnIndices = [];
+
+  for (var i = 0; i < lines.length; i++) {
+    var line = lines[i];
+
+    // Parse header metadata
+    var sessionIdMatch = line.match(/\*\*Session ID:\*\*\s*`(.+)`/);
+    if (sessionIdMatch) { metadata.sessionId = sessionIdMatch[1]; continue; }
+
+    var startedMatch = line.match(/\*\*Started:\*\*\s*(.+)/);
+    if (startedMatch) { metadata.startedAt = startedMatch[1].trim(); continue; }
+
+    var durationMatch = line.match(/\*\*Duration:\*\*\s*(.+)/);
+    if (durationMatch) { metadata.duration = durationMatch[1].trim(); continue; }
+
+    var exportedMatch = line.match(/\*\*Exported:\*\*\s*(.+)/);
+    if (exportedMatch) { metadata.exportedAt = exportedMatch[1].trim(); continue; }
+
+    // Parse timestamp lines: <sub>timestamp</sub>
+    var tsMatch = line.match(/<sub>\s*\u23F1\uFE0F?\s*(.+?)\s*<\/sub>/);
+    if (tsMatch) {
+      lastTimestamp = parseTimestamp(tsMatch[1]);
+      continue;
+    }
+
+    // Parse turn headers: ### <emoji> <Type> or ### <emoji> `toolName`
+    var turnMatch = line.match(/^###\s+\S+\s+(.+)$/);
+    if (turnMatch) {
+      if (currentEvent) {
+        currentEvent.text = currentEvent.text.trim();
+        events.push(currentEvent);
+      }
+
+      var rawType = turnMatch[1].trim();
+      var toolMatch = rawType.match(/^`(.+)`$/);
+      var toolName = null;
+      var agent = "system";
+      var track = "output";
+
+      if (toolMatch) {
+        toolName = toolMatch[1];
+        agent = "assistant";
+        track = "tool_call";
+      } else if (AGENT_MAP[rawType]) {
+        agent = AGENT_MAP[rawType];
+        track = TRACK_MAP[rawType];
+      }
+
+      if (agent === "user") {
+        turnIndex++;
+      }
+
+      currentEvent = {
+        t: lastTimestamp,
+        agent: agent,
+        track: track,
+        text: "",
+        duration: 1,
+        intensity: track === "tool_call" ? 0.8 : 0.5,
+        toolName: toolName,
+        turnIndex: turnIndex,
+        isError: false,
+      };
+
+      continue;
+    }
+
+    // Separator ends current event
+    if (line.trim() === "---") {
+      if (currentEvent) {
+        currentEvent.text = currentEvent.text.trim();
+        events.push(currentEvent);
+        currentEvent = null;
+      }
+      continue;
+    }
+
+    // Accumulate content
+    if (currentEvent) {
+      // Strip markdown details/summary wrappers
+      if (line.match(/^<details>|^<\/details>|^<summary>.*<\/summary>/)) continue;
+      currentEvent.text += (currentEvent.text ? "\n" : "") + line;
+    }
+  }
+
+  if (currentEvent) {
+    currentEvent.text = currentEvent.text.trim();
+    events.push(currentEvent);
+  }
+
+  if (events.length === 0) return null;
+
+  // Compute durations between events
+  for (var j = 0; j < events.length - 1; j++) {
+    events[j].duration = Math.max(0.1, events[j + 1].t - events[j].t);
+  }
+  if (events.length > 0) {
+    events[events.length - 1].duration = 1;
+  }
+
+  // Check for errors
+  for (var k = 0; k < events.length; k++) {
+    if (events[k].text && (
+      events[k].text.includes("<exited with exit code 1>") ||
+      events[k].text.includes("Error:") ||
+      events[k].text.includes("error:")
+    )) {
+      events[k].isError = true;
+    }
+  }
+
+  // Build turns
+  var turns = [];
+  var currentTurnEvents = [];
+  var currentTurnIndex = 0;
+
+  for (var m = 0; m < events.length; m++) {
+    if (events[m].turnIndex > currentTurnIndex && currentTurnEvents.length > 0) {
+      turns.push({
+        index: currentTurnIndex,
+        startTime: events[currentTurnEvents[0]].t,
+        endTime: events[currentTurnEvents[currentTurnEvents.length - 1]].t,
+        eventIndices: currentTurnEvents.slice(),
+        userMessage: events[currentTurnEvents[0]].agent === "user" ? events[currentTurnEvents[0]].text : null,
+        toolCount: currentTurnEvents.filter(function (idx) { return events[idx].track === "tool_call"; }).length,
+        hasError: currentTurnEvents.some(function (idx) { return events[idx].isError; }),
+      });
+      currentTurnEvents = [];
+      currentTurnIndex = events[m].turnIndex;
+    }
+    currentTurnEvents.push(m);
+  }
+
+  // Push final turn
+  if (currentTurnEvents.length > 0) {
+    turns.push({
+      index: currentTurnIndex,
+      startTime: events[currentTurnEvents[0]].t,
+      endTime: events[currentTurnEvents[currentTurnEvents.length - 1]].t,
+      eventIndices: currentTurnEvents.slice(),
+      userMessage: events[currentTurnEvents[0]].agent === "user" ? events[currentTurnEvents[0]].text : null,
+      toolCount: currentTurnEvents.filter(function (idx) { return events[idx].track === "tool_call"; }).length,
+      hasError: currentTurnEvents.some(function (idx) { return events[idx].isError; }),
+    });
+  }
+
+  // Build metadata
+  var totalDuration = metadata.duration ? parseDuration(metadata.duration) : 0;
+  if (totalDuration === 0 && events.length > 0) {
+    totalDuration = events[events.length - 1].t + events[events.length - 1].duration;
+  }
+
+  var toolCalls = events.filter(function (e) { return e.track === "tool_call"; });
+  var errorCount = events.filter(function (e) { return e.isError; }).length;
+
+  return {
+    events: events,
+    turns: turns,
+    metadata: {
+      totalEvents: events.length,
+      totalTurns: turns.length,
+      totalToolCalls: toolCalls.length,
+      errorCount: errorCount,
+      duration: totalDuration,
+      models: [],
+      primaryModel: null,
+      tokenUsage: null,
+      format: "shared-md",
+      sessionId: metadata.sessionId,
+    },
+  };
+}