nexusmem 0.9.1 → 0.10.1

package/dist/cli/index.js

@@ -2,7 +2,7 @@
 
 // src/cli/index.ts
 import { Command } from "commander";
-import pc21 from "picocolors";
+import pc22 from "picocolors";
 
 // src/config/workspace.ts
 import { existsSync } from "fs";
@@ -155,7 +155,26 @@ var ConfigSchema = z.object({
      */
     structure: z.object({
       enabled: z.boolean().default(true)
-    }).default({ enabled: true })
+    }).default({ enabled: true }),
+    /**
+     * Issue and PR threads (title, body, comments) for this repo's
+     * github.com remote, read via the `gh` CLI.
+     *
+     * Opt-in, unlike git/shell/docs/structure -- not for a sensitivity
+     * reason (issue/PR text is usually no more sensitive than a doc file),
+     * but because this is the first source with a real external dependency:
+     * it needs `gh` installed and authenticated, and makes live network
+     * calls instead of reading only what's already on disk. A repo with no
+     * github.com remote at all, or an unauthenticated `gh`, must stay a
+     * silent no-op either way -- see `syncGithub` in sync.ts.
+     */
+    github: z.object({
+      enabled: z.boolean().default(false),
+      /** Threads read per sync, newest-updated first. */
+      maxThreads: z.number().int().positive().default(100),
+      /** Comments read per thread. */
+      maxCommentsPerThread: z.number().int().positive().default(100)
+    }).default({ enabled: false, maxThreads: 100, maxCommentsPerThread: 100 })
   }).default({
     git: { enabled: true, since: null, includeMerges: true },
     shell: { enabled: true, tailLines: 300 },
@@ -169,7 +188,8 @@ var ConfigSchema = z.object({
     },
     docs: { enabled: true, include: ["*.md"] },
     diff: { enabled: true, maxCommits: 200, maxFilesPerCommit: 20, contextLines: 3 },
-    structure: { enabled: true }
+    structure: { enabled: true },
+    github: { enabled: false, maxThreads: 100, maxCommentsPerThread: 100 }
   }),
   limits: z.object({
     maxFilesPerNode: z.number().int().positive().default(40),
@@ -1013,6 +1033,10 @@ INSERT INTO nodes_vec (rowid, project_id, embedding)
 
 DROP TABLE nodes_vec_stage;
 `;
+var V12 = `
+ALTER TABLE nodes ADD COLUMN retrieved_count INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE nodes ADD COLUMN last_retrieved_at INTEGER;
+`;
 var MIGRATIONS = [
   { version: 1, up: (db) => db.exec(V1) },
   { version: 2, up: (db) => db.exec(V2) },
@@ -1024,7 +1048,8 @@ var MIGRATIONS = [
   { version: 8, up: (db) => db.exec(V8) },
   { version: 9, up: (db) => db.exec(V9) },
   { version: 10, up: (db) => db.exec(V10) },
-  { version: 11, up: (db) => db.exec(V11) }
+  { version: 11, up: (db) => db.exec(V11) },
+  { version: 12, up: (db) => db.exec(V12) }
 ];
 var LATEST_SCHEMA_VERSION = MIGRATIONS[MIGRATIONS.length - 1]?.version ?? 0;
 function currentSchemaVersion(db) {
@@ -1123,6 +1148,8 @@ function defaultProvenanceForKind(kind) {
       return "recorded";
     case "session_summary":
       return "derived";
+    case "github_thread":
+      return "recorded";
   }
 }
 
@@ -1294,6 +1321,19 @@ function listStaleCandidates(db, projectId, opts = {}) {
     ageDays: Math.round((now.getTime() - r.tsEpoch) / 864e5)
   }));
 }
+function recordRetrievals(db, ids) {
+  if (ids.length === 0) return;
+  db.prepare(
+    `UPDATE nodes SET retrieved_count = retrieved_count + 1, last_retrieved_at = @now
+     WHERE id IN (SELECT value FROM json_each(@ids))`
+  ).run({ now: Date.now(), ids: JSON.stringify(ids) });
+}
+function getRetrievalStats(db, id) {
+  const row = db.prepare("SELECT retrieved_count AS retrievedCount, last_retrieved_at AS lastRetrievedAt FROM nodes WHERE id = ?").get(
+    id
+  );
+  return row ?? null;
+}
 function countStaleCandidates(db, projectId, opts = {}) {
   const now = opts.now ?? /* @__PURE__ */ new Date();
   const minAgeDays = opts.minAgeDays ?? 45;
@@ -1823,6 +1863,14 @@ var MemoryStore = class _MemoryStore {
   countStaleCandidates(projectId, opts = {}) {
     return countStaleCandidates(this.db, projectId, opts);
   }
+  /** Bump retrieval bookkeeping for nodes actually packed into a query result. See `nodes.ts`'s `recordRetrievals` for why this doesn't touch ranking. */
+  recordRetrievals(ids) {
+    recordRetrievals(this.db, ids);
+  }
+  /** Retrieval bookkeeping for one node, or null if it doesn't exist. Mainly for tests. */
+  getRetrievalStats(id) {
+    return getRetrievalStats(this.db, id);
+  }
   /** Memoize one SLM contradiction judgment (either verdict). Suggest-only: never writes `supersedes`. */
   recordContradictionCheck(input) {
     recordContradictionCheck(this.db, input);
@@ -2790,8 +2838,21 @@ async function runCrossProjectQuery(sources, query, opts) {
     rankHits(hits, { halfLifeDays: opts.halfLifeDays, relevanceScores, supersededIds })
   );
   const packed = packContext(ranked, opts.budget, { query });
+  recordRetrievalsByProject(storeByLabel, packed.nodes);
   return { bm25Count, vectorCount, hits, packed, perProject };
 }
+function recordRetrievalsByProject(storeByLabel, nodes) {
+  const idsByLabel = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    if (!node.project) continue;
+    const ids = idsByLabel.get(node.project) ?? [];
+    ids.push(node.id);
+    idsByLabel.set(node.project, ids);
+  }
+  for (const [label, ids] of idsByLabel) {
+    storeByLabel.get(label)?.recordRetrievals(ids);
+  }
+}
 async function runHybridQuery(store, projectId, query, opts) {
   const bm25Hits = store.search(projectId, query, opts.candidates, { asOfEpoch: opts.asOfEpoch });
   let vectorHits = [];
@@ -2807,6 +2868,7 @@ async function runHybridQuery(store, projectId, query, opts) {
     rankHits(hits, { halfLifeDays: opts.halfLifeDays, relevanceScores, supersededIds })
   );
   const packed = packContext(ranked, opts.budget, { query });
+  store.recordRetrievals(packed.nodes.map((n) => n.id));
   return { bm25Count: bm25Hits.length, vectorCount: vectorHits.length, hits, packed };
 }
 
@@ -3634,6 +3696,63 @@ function collectDocFiles(files, projectId, opts = {}) {
   return files.flatMap((file) => toMemoryNodes3(file, projectId, opts));
 }
 
+// src/collectors/github.ts
+var NOTABLE_LABELS = /\b(bug|help wanted|good first issue)\b/i;
+function scoreGithubThread(thread) {
+  let score = 0.4;
+  if (thread.merged) score += 0.2;
+  else if (thread.state === "closed" && thread.comments.length === 0) score -= 0.15;
+  if (thread.comments.length >= 3) score += 0.15;
+  else if (thread.comments.length >= 1) score += 0.05;
+  if (thread.labels.some((l) => NOTABLE_LABELS.test(l))) score += 0.1;
+  return Number(Math.min(1, Math.max(0.05, score)).toFixed(3));
+}
+var MAX_TITLE_CHARS5 = 200;
+function threadTitle(thread) {
+  const prefix = thread.type === "pull_request" ? "PR" : "Issue";
+  return truncate(`${prefix} #${thread.number}: ${thread.title}`, MAX_TITLE_CHARS5);
+}
+function renderBody(thread) {
+  const status = thread.merged ? "merged" : thread.state;
+  const header = `${thread.title}
+opened by @${thread.author}, ${status}`;
+  const opening = thread.body.trim();
+  const commentsText = thread.comments.map((c) => `--- @${c.author} (${c.createdAt.slice(0, 10)}) ---
+${c.body.trim()}`).join("\n\n");
+  return [header, opening, commentsText].filter(Boolean).join("\n\n");
+}
+var DEFAULT_MAX_BODY_CHARS3 = 4e3;
+function toMemoryNode2(thread, projectId, opts = {}) {
+  const maxBody = opts.maxBodyChars ?? DEFAULT_MAX_BODY_CHARS3;
+  const naturalKey = `${thread.type}:${thread.number}`;
+  const source = thread.type === "pull_request" ? "github:pr" : "github:issue";
+  return {
+    id: makeNodeId(projectId, "github_thread", naturalKey),
+    kind: "github_thread",
+    projectId,
+    ts: thread.updatedAt,
+    source,
+    title: threadTitle(thread),
+    body: truncate(renderBody(thread), maxBody),
+    files: [],
+    signal: scoreGithubThread(thread),
+    provenance: "recorded",
+    // verbatim discourse, same tier as conversation_turn
+    meta: {
+      number: thread.number,
+      type: thread.type,
+      state: thread.state,
+      merged: thread.merged,
+      labels: thread.labels,
+      url: thread.url,
+      commentCount: thread.comments.length
+    }
+  };
+}
+function collectGithubThreads(threads, projectId, opts = {}) {
+  return threads.map((thread) => toMemoryNode2(thread, projectId, opts));
+}
+
 // src/slm/summarize.ts
 var MAX_USER_CHARS = 400;
 var MAX_REPLY_CHARS = 700;
@@ -3725,7 +3844,7 @@ function sessionFallbackTitle(session) {
   const line = redact(opening.userText).text.split(/\r?\n/)[0]?.trim();
   return line && line.length > 0 ? line : "Working session";
 }
-var MAX_TITLE_CHARS5 = 200;
+var MAX_TITLE_CHARS6 = 200;
 var GENERIC_TITLE = /^(a |the )?(session |conversation |project |work )?(summary|update|overview|recap|status)\b/i;
 var ROLE_PREAMBLE_TITLE = /^(role\s*[:：]|you\s*(?:'re|are)\s+(acting as|serving as|playing the role of|a\b)|i\s*(?:'m|am)\s+(acting as|a\b)|acting as\b|บทบาท\s*[:：]|ในฐานะ|คุณ(กำลัง)?(ทำหน้าที่เป็น|เป็น|รับบทบาทเป็น)|(ผม|ฉัน)(กำลัง)?(ทำหน้าที่เป็น|เป็น))/i;
 function cleanTitle(line) {
@@ -3739,12 +3858,12 @@ function parseSummary(raw, fallbackTitle) {
   if (firstIndex === -1) return null;
   const first = lines[firstIndex].trim();
   const labelled = /^TITLE:\s*(.+)$/i.exec(first);
-  const fallback = truncate(cleanTitle(fallbackTitle) || "Working session", MAX_TITLE_CHARS5);
+  const fallback = truncate(cleanTitle(fallbackTitle) || "Working session", MAX_TITLE_CHARS6);
   if (!labelled) return { title: fallback, body: text };
   const candidate = cleanTitle(labelled[1]);
   const rest = lines.slice(firstIndex + 1).join("\n").trim();
   return {
-    title: candidate.length > 0 && !GENERIC_TITLE.test(candidate) && !ROLE_PREAMBLE_TITLE.test(candidate) ? truncate(candidate, MAX_TITLE_CHARS5) : fallback,
+    title: candidate.length > 0 && !GENERIC_TITLE.test(candidate) && !ROLE_PREAMBLE_TITLE.test(candidate) ? truncate(candidate, MAX_TITLE_CHARS6) : fallback,
     // A model that emitted only a title still gets a usable node: the title
     // doubles as the body rather than storing an empty one.
     body: rest.length > 0 ? rest : candidate
@@ -3754,7 +3873,7 @@ function parseSummary(raw, fallbackTitle) {
 // src/collectors/sessions.ts
 var SESSION_SOURCE_PREFIX = "session";
 var DEFAULT_SETTLE_MINUTES = 30;
-var DEFAULT_MAX_BODY_CHARS3 = 2500;
+var DEFAULT_MAX_BODY_CHARS4 = 2500;
 var DEFAULT_MAX_SESSIONS = 10;
 function scoreSession(turnCount) {
   const score = 0.6 + Math.min(0.25, turnCount / 100);
@@ -3798,7 +3917,7 @@ ${t.assistantText}`).join("\n")),
   };
 }
 async function collectSessionSummaries(turns, projectId, provider, opts = {}) {
-  const maxBodyChars = opts.maxBodyChars ?? DEFAULT_MAX_BODY_CHARS3;
+  const maxBodyChars = opts.maxBodyChars ?? DEFAULT_MAX_BODY_CHARS4;
   const maxSessions = opts.maxSessions ?? DEFAULT_MAX_SESSIONS;
   const all = groupTurnsIntoSessions(turns);
   const settled = selectSettledSessions(all, opts.settleMinutes ?? DEFAULT_SETTLE_MINUTES, opts.now);
@@ -3846,8 +3965,8 @@ async function collectSessionSummaries(turns, projectId, provider, opts = {}) {
 }
 
 // src/collectors/shell-history.ts
-var DEFAULT_MAX_BODY_CHARS4 = 1e3;
-var MAX_TITLE_CHARS6 = 200;
+var DEFAULT_MAX_BODY_CHARS5 = 1e3;
+var MAX_TITLE_CHARS7 = 200;
 var NOISE = /^(cd|ls|dir|pwd|clear|cls|exit|history|whoami|date|type|cat|more|less|ll|la)\b/i;
 var BUILD_TEST = /^(npm|pnpm|yarn)\s+(run\s+)?(test|build|lint|typecheck|tsc)\b|^(pytest|go\s+test|cargo\s+(test|build)|mvn\s+test|gradle\s+test|dotnet\s+(test|build))\b/i;
 var INSTALL = /^(npm|pnpm|yarn)\s+(install|add|remove|uninstall|ci)\b|^pip\s+install\b|^(cargo\s+add|go\s+get|composer\s+require)\b/i;
@@ -3870,7 +3989,7 @@ function scoreShellCommand(entry) {
   else if (cmd.length <= 3) score -= 0.05;
   return Number(Math.min(1, Math.max(0.05, score)).toFixed(3));
 }
-function renderBody(entry, maxChars) {
+function renderBody2(entry, maxChars) {
   const parts = [`$ ${entry.command}`];
   const metaLine = [];
   if (entry.cwd) metaLine.push(`cwd: ${entry.cwd}`);
@@ -3879,8 +3998,8 @@ function renderBody(entry, maxChars) {
   if (metaLine.length) parts.push("", metaLine.join("  "));
   return truncate(parts.join("\n"), maxChars);
 }
-function toMemoryNode2(entry, projectId, opts = {}) {
-  const maxBody = opts.maxBodyChars ?? DEFAULT_MAX_BODY_CHARS4;
+function toMemoryNode3(entry, projectId, opts = {}) {
+  const maxBody = opts.maxBodyChars ?? DEFAULT_MAX_BODY_CHARS5;
   const titleLine = entry.command.split(/\r?\n/)[0] ?? entry.command;
   return {
     id: makeNodeId(projectId, "shell_command", entry.naturalKey),
@@ -3888,8 +4007,8 @@ function toMemoryNode2(entry, projectId, opts = {}) {
     projectId,
     ts: entry.ts,
     source: `shell:${entry.shell}`,
-    title: truncate(titleLine, MAX_TITLE_CHARS6),
-    body: renderBody(entry, maxBody),
+    title: truncate(titleLine, MAX_TITLE_CHARS7),
+    body: renderBody2(entry, maxBody),
     files: [],
     signal: scoreShellCommand(entry),
     provenance: "observed",
@@ -3904,7 +4023,7 @@ function toMemoryNode2(entry, projectId, opts = {}) {
   };
 }
 function collectShellHistory(entries, projectId, opts = {}) {
-  return entries.map((entry) => toMemoryNode2(entry, projectId, opts));
+  return entries.map((entry) => toMemoryNode3(entry, projectId, opts));
 }
 
 // src/conversation/claude-code-reader.ts
@@ -4036,6 +4155,112 @@ async function readDocFiles(repoRoot, opts = {}) {
   return { files, unreadable };
 }
 
+// src/github/read.ts
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execFileAsync2 = promisify2(execFile2);
+var GithubUnavailableError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "GithubUnavailableError";
+  }
+  cause;
+};
+function toGithubError(err) {
+  const code = err?.code;
+  if (code === "ENOENT") {
+    return new GithubUnavailableError(
+      "gh CLI not found on PATH -- install it from https://cli.github.com and run `gh auth login`",
+      err
+    );
+  }
+  const stderr = String(err?.stderr ?? "");
+  if (/auth login|not logged into|401/i.test(stderr)) {
+    return new GithubUnavailableError("gh CLI is not authenticated -- run `gh auth login`", err);
+  }
+  const detail = stderr.trim().split("\n")[0] || (err instanceof Error ? err.message : String(err));
+  return new GithubUnavailableError(`gh api call failed: ${detail}`, err);
+}
+function parseGithubSlug(originUrl) {
+  if (!originUrl) return null;
+  const match = originUrl.match(/github\.com[:/]([^/]+)\/(.+?)(?:\.git)?\/?$/i);
+  if (!match) return null;
+  return `${match[1]}/${match[2]}`;
+}
+var GhCliProvider = class {
+  constructor(repoSlug, opts = {}) {
+    this.repoSlug = repoSlug;
+    this.opts = opts;
+  }
+  repoSlug;
+  opts;
+  async listThreads(since) {
+    const maxThreads = this.opts.maxThreads ?? 100;
+    const perPage = Math.min(maxThreads, 100);
+    const params = new URLSearchParams({
+      state: "all",
+      sort: "updated",
+      direction: "desc",
+      per_page: String(perPage)
+    });
+    if (since) params.set("since", since);
+    let items;
+    try {
+      const { stdout } = await execFileAsync2("gh", ["api", `repos/${this.repoSlug}/issues?${params}`], {
+        maxBuffer: 16 * 1024 * 1024
+      });
+      items = JSON.parse(stdout);
+    } catch (err) {
+      throw toGithubError(err);
+    }
+    const bounded = items.slice(0, maxThreads);
+    const threads = [];
+    for (const item of bounded) {
+      const comments = item.comments > 0 ? await this.fetchComments(item.number) : [];
+      threads.push({
+        number: item.number,
+        type: item.pull_request ? "pull_request" : "issue",
+        title: item.title,
+        body: item.body ?? "",
+        author: item.user?.login ?? "unknown",
+        state: item.state,
+        merged: item.pull_request?.merged_at != null,
+        labels: item.labels.map((l) => typeof l === "string" ? l : l.name),
+        createdAt: item.created_at,
+        updatedAt: item.updated_at,
+        url: item.html_url,
+        comments
+      });
+    }
+    return threads;
+  }
+  /**
+   * Fails soft per thread, unlike `listThreads` itself: one comment fetch
+   * failing (a deleted comment, a transient network blip) shouldn't drop the
+   * whole sync the way an unreachable `gh`/no auth does. The thread still
+   * gets ingested, just without that page of discussion this run.
+   */
+  async fetchComments(number) {
+    const maxComments = this.opts.maxCommentsPerThread ?? 100;
+    try {
+      const { stdout } = await execFileAsync2(
+        "gh",
+        ["api", `repos/${this.repoSlug}/issues/${number}/comments?per_page=${Math.min(maxComments, 100)}`],
+        { maxBuffer: 16 * 1024 * 1024 }
+      );
+      const items = JSON.parse(stdout);
+      return items.slice(0, maxComments).map((c) => ({
+        author: c.user?.login ?? "unknown",
+        body: c.body ?? "",
+        createdAt: c.created_at
+      }));
+    } catch {
+      return [];
+    }
+  }
+};
+
 // src/slm/contradiction.ts
 var MAX_BODY_CHARS = 1500;
 var MAX_REASON_CHARS = 200;
@@ -5190,6 +5415,38 @@ async function syncDocs(store, projectId, repoRoot, config, log) {
   }
   return { totals, seen: nodes.length };
 }
+var GITHUB_SOURCE = "github";
+async function syncGithub(store, projectId, opts, repo, config, log) {
+  const totals = { inserted: 0, updated: 0, unchanged: 0, denied: 0 };
+  const enabled = opts.githubOverride ?? config.sources.github.enabled;
+  if (!enabled) return { totals, seen: 0 };
+  const slug = parseGithubSlug(repo.originUrl);
+  if (!slug) {
+    log(`${pc7.dim("github")} no github.com remote found -- skipped`);
+    return { totals, seen: 0 };
+  }
+  const provider = opts.githubProvider ?? new GhCliProvider(slug, {
+    maxThreads: config.sources.github.maxThreads,
+    maxCommentsPerThread: config.sources.github.maxCommentsPerThread
+  });
+  const cursor = opts.full || opts.rebuild ? null : store.getSyncCursor(projectId, GITHUB_SOURCE);
+  const requestedAt = (/* @__PURE__ */ new Date()).toISOString();
+  let threads;
+  try {
+    threads = await provider.listThreads(cursor);
+  } catch (err) {
+    if (err instanceof GithubUnavailableError) {
+      log(`${pc7.dim("github")} ${err.message} -- skipped`);
+      return { totals, seen: 0 };
+    }
+    throw err;
+  }
+  const nodes = collectGithubThreads(threads, projectId, { maxBodyChars: config.limits.maxBodyChars });
+  if (nodes.length > 0) addStats(totals, store.upsertNodes(nodes));
+  store.setSyncCursor(projectId, GITHUB_SOURCE, requestedAt);
+  log(`  ${pc7.dim(`${GITHUB_SOURCE}: ${nodes.length} thread(s) read from ${slug}`)}`);
+  return { totals, seen: nodes.length };
+}
 async function syncStructure(store, projectId, repoRoot, config, log) {
   if (!config.sources.structure.enabled) {
     log(`${pc7.dim("structure")} disabled in config`);
@@ -5312,6 +5569,7 @@ async function runSync(opts) {
     const conversation = syncConversation(store, projectId, turns, config, log, opts.conversationOverride);
     const sessions = await syncSessions(store, projectId, turns, config, log);
     const docs = await syncDocs(store, projectId, repo.root, config, log);
+    const github = await syncGithub(store, projectId, opts, repo, config, log);
     const structure = await syncStructure(store, projectId, repo.root, config, log);
     let embedLine = "";
     let embeddingAvailable = false;
@@ -5354,6 +5612,7 @@ async function runSync(opts) {
     addStats(totals, conversation.totals);
     addStats(totals, sessions.totals);
     addStats(totals, docs.totals);
+    addStats(totals, github.totals);
     const stats2 = store.stats(projectId);
     const elapsed = ((Date.now() - started) / 1e3).toFixed(2);
     const conversationPart = conversationEnabled ? `, ${conversation.seen} conversation exchange(s)` : "";
@@ -5361,10 +5620,12 @@ async function runSync(opts) {
     const docsPart = config.sources.docs.enabled ? `, ${docs.seen} doc section(s)` : "";
     const diffPart = config.sources.diff.enabled ? `, ${diffs.seen} file diff(s)` : "";
     const structurePart = config.sources.structure.enabled ? `, ${structure.edges} import edge(s)` : "";
+    const githubEnabled = opts.githubOverride ?? config.sources.github.enabled;
+    const githubPart = githubEnabled ? `, ${github.seen} github thread(s)` : "";
     const deniedPart = totals.denied > 0 ? `  ${pc7.red(`-${totals.denied} denied`)}` : "";
     out(
       [
-        `${pc7.green("synced")} ${git2.seen} commit(s)${diffPart}, ${shell.seen} shell entr${shell.seen === 1 ? "y" : "ies"}${conversationPart}${sessionPart}${docsPart}${structurePart} in ${elapsed}s`,
+        `${pc7.green("synced")} ${git2.seen} commit(s)${diffPart}, ${shell.seen} shell entr${shell.seen === 1 ? "y" : "ies"}${conversationPart}${sessionPart}${docsPart}${githubPart}${structurePart} in ${elapsed}s`,
         `  ${pc7.green(`+${totals.inserted} new`)}  ${pc7.yellow(`~${totals.updated} updated`)}  ${pc7.dim(`=${totals.unchanged} unchanged`)}${deniedPart}`,
         `  ${pc7.dim(`${stats2.total} node(s) total across ${stats2.distinctFiles} file path(s)`)}`,
         ""
@@ -5482,7 +5743,7 @@ function createServer() {
     "search_memory",
     {
       title: "Search remembered project history",
-      description: "Search a NexusMem-tracked repository's remembered history: git commits, code diffs (the patch of each changed file), shell commands, tracked markdown docs, and (if enabled) conversation transcripts and per-session summaries. Returns a token-budgeted, ranked context block -- not raw search results.",
+      description: "Search a NexusMem-tracked repository's remembered history: git commits, code diffs (the patch of each changed file), shell commands, tracked markdown docs, and (if enabled) conversation transcripts, per-session summaries, and github.com issue/PR threads. Returns a token-budgeted, ranked context block -- not raw search results.",
       inputSchema: {
         projectRoot: z4.string().describe("Absolute path to the repository root"),
         query: z4.string().describe("Free-text question or search terms"),
@@ -5515,7 +5776,7 @@ function createServer() {
     "sync_project",
     {
       title: "Sync remembered history",
-      description: "Ingest new git, diff, shell, docs and (if enabled) conversation history for a NexusMem-tracked repository into its local database. Pass pruneSource or pruneStaleShell instead to delete a dead source's nodes (e.g. the pre-hook shell scrape) rather than syncing -- dry-run unless yes is also true, since this is an irreversible full wipe of that source.",
+      description: "Ingest new git, diff, shell, docs and (if enabled) conversation and github.com issue/PR history for a NexusMem-tracked repository into its local database. Pass pruneSource or pruneStaleShell instead to delete a dead source's nodes (e.g. the pre-hook shell scrape) rather than syncing -- dry-run unless yes is also true, since this is an irreversible full wipe of that source.",
       inputSchema: {
         projectRoot: z4.string().describe("Absolute path to the repository root"),
         pruneSource: z4.string().optional().describe('Delete every node from this exact source (e.g. "shell:pwsh") instead of syncing'),
@@ -5549,7 +5810,7 @@ function createServer() {
     "list_recent_memory",
     {
       title: "List recently remembered items",
-      description: "List the most recently remembered items for a NexusMem-tracked repository -- git commits, code diffs, shell commands, tracked docs, and (if enabled) conversation transcripts and session summaries -- newest first. Chronological, not relevance-ranked: use search_memory instead for a specific question.",
+      description: "List the most recently remembered items for a NexusMem-tracked repository -- git commits, code diffs, shell commands, tracked docs, and (if enabled) conversation transcripts, session summaries, and github.com issue/PR threads -- newest first. Chronological, not relevance-ranked: use search_memory instead for a specific question.",
       inputSchema: {
         projectRoot: z4.string().describe("Absolute path to the repository root"),
         limit: z4.number().int().positive().optional().describe("Max items to return, newest first. Default 20.")
@@ -5655,7 +5916,7 @@ ${pc8.dim("-".repeat(40))}
     out(`  ${pc8.bold(risk.path)}
 `);
     if (risk.unresolvedFailures.length > 0) {
-      out(`    ${pc8.yellow("WARN")}  What already failed here (${risk.unresolvedFailures.length} unresolved):
+      out(`    ${pc8.yellow("WARN")}  commands naming this file failed, still unresolved (${risk.unresolvedFailures.length}):
 `);
       for (const f of risk.unresolvedFailures.slice(0, 3)) {
         out(`           ${pc8.dim(`${f.ts.slice(0, 10)}  ${f.command.slice(0, 90)}`)}
@@ -5667,7 +5928,7 @@ ${pc8.dim("-".repeat(40))}
       }
     }
     if (risk.commitsRecent >= HIGH_CHURN_THRESHOLD) {
-      out(`    ${pc8.yellow("WARN")}  high churn: ${risk.commitsRecent} commits touched this file recently
+      out(`    ${pc8.dim("note")}  high churn (untuned heuristic): ${risk.commitsRecent} commits touched this file recently
 `);
     }
     out("\n");
@@ -5822,6 +6083,7 @@ var SHELL_SIGNAL_BANDS = { high: 0.6, medium: 0.4 };
 var CONVERSATION_SIGNAL_BANDS = { high: 0.55, medium: 0.35 };
 var DOCS_SIGNAL_BANDS = { high: 0.55, medium: 0.35 };
 var DIFF_SIGNAL_BANDS = { high: 0.7, medium: 0.45 };
+var GITHUB_SIGNAL_BANDS = { high: 0.6, medium: 0.4 };
 function signalBand(signal, bands) {
   if (signal >= bands.high) return "high";
   if (signal >= bands.medium) return "medium";
@@ -6029,14 +6291,57 @@ function formatNode4(node) {
   ].join(" ");
 }
 
-// src/cli/commands/scan-session.ts
+// src/cli/commands/scan-github.ts
 import pc16 from "picocolors";
+async function runScanGithub(opts) {
+  const repo = await readRepoInfo(opts.cwd);
+  const projectId = makeProjectId({ root: repo.root, originUrl: repo.originUrl });
+  const slug = parseGithubSlug(repo.originUrl);
+  if (!slug) {
+    process.stderr.write(`${pc16.yellow("no github.com remote found for this repository")}
+`);
+    return 0;
+  }
+  const provider = opts.provider ?? new GhCliProvider(slug);
+  let threads;
+  try {
+    threads = await provider.listThreads(null);
+  } catch (err) {
+    if (err instanceof GithubUnavailableError) {
+      process.stderr.write(`${pc16.yellow(err.message)}
+`);
+      return 0;
+    }
+    throw err;
+  }
+  const nodes = collectGithubThreads(threads, projectId).filter((n) => n.signal >= opts.minSignal);
+  if (opts.json) {
+    process.stdout.write(`${JSON.stringify(nodes, null, 2)}
+`);
+    return 0;
+  }
+  for (const node of nodes) process.stdout.write(`${formatNode5(node)}
+`);
+  const approxTotal = approxTotalTokens(nodes);
+  process.stderr.write(
+    `
+${pc16.bold(String(nodes.length))} thread(s) from ${pc16.dim(slug)} above threshold  ${pc16.dim(`~${approxTotal.toLocaleString()} tokens if sent raw`)}
+`
+  );
+  return 0;
+}
+function formatNode5(node) {
+  return [formatSignal(node.signal, GITHUB_SIGNAL_BANDS), node.title].join(" ");
+}
+
+// src/cli/commands/scan-session.ts
+import pc17 from "picocolors";
 async function runScanSession(opts) {
   const repo = await readRepoInfo(opts.cwd);
   const projectId = makeProjectId({ root: repo.root, originUrl: repo.originUrl });
   const turns = await collectClaudeCodeTranscripts(repo.root);
   if (turns.length === 0) {
-    process.stderr.write(`${pc16.yellow("no transcripts found")} at ${claudeProjectTranscriptDir(repo.root)}
+    process.stderr.write(`${pc17.yellow("no transcripts found")} at ${claudeProjectTranscriptDir(repo.root)}
 `);
     return 0;
   }
@@ -6044,7 +6349,7 @@ async function runScanSession(opts) {
   const settled = selectSettledSessions(sessions, opts.settleMinutes);
   if (!opts.json) {
     process.stderr.write(
-      `${pc16.dim("sessions")} ${sessions.length} found, ${settled.length} settled (quiet ${opts.settleMinutes}m+)
+      `${pc17.dim("sessions")} ${sessions.length} found, ${settled.length} settled (quiet ${opts.settleMinutes}m+)
 
 `
     );
@@ -6070,7 +6375,7 @@ async function runScanSession(opts) {
     }
     for (const preview of previews) {
       process.stdout.write(
-        `${pc16.bold(preview.sessionKey)}  ${preview.startedAt.slice(0, 16).replace("T", " ")}  ${preview.includedTurns}/${preview.turns} turn(s), ${preview.promptChars} chars
+        `${pc17.bold(preview.sessionKey)}  ${preview.startedAt.slice(0, 16).replace("T", " ")}  ${preview.includedTurns}/${preview.turns} turn(s), ${preview.promptChars} chars
 ${preview.prompt}
 
 `
@@ -6082,7 +6387,7 @@ ${preview.prompt}
     settleMinutes: opts.settleMinutes,
     maxSessions: opts.maxSessions,
     onProgress: (done, total) => {
-      if (!opts.json) process.stderr.write(`  ${pc16.dim(`summarizing ${done}/${total}`)}
+      if (!opts.json) process.stderr.write(`  ${pc17.dim(`summarizing ${done}/${total}`)}
 `);
     }
   });
@@ -6092,21 +6397,21 @@ ${preview.prompt}
     return 0;
   }
   for (const node of result.nodes) {
-    process.stdout.write(`${pc16.bold(node.title)}
-${pc16.dim(node.ts.slice(0, 16).replace("T", " "))}
+    process.stdout.write(`${pc17.bold(node.title)}
+${pc17.dim(node.ts.slice(0, 16).replace("T", " "))}
 ${node.body}
 
 `);
   }
   if (result.providerUnavailable) {
     process.stderr.write(
-      `${pc16.yellow("model unavailable")} -- is Ollama running with \`${opts.model}\` pulled? (\`ollama pull ${opts.model}\`)
+      `${pc17.yellow("model unavailable")} -- is Ollama running with \`${opts.model}\` pulled? (\`ollama pull ${opts.model}\`)
 `
     );
     return 0;
   }
   process.stderr.write(
-    `${pc16.bold(String(result.nodes.length))} summarized` + (result.failed > 0 ? `, ${pc16.yellow(`${result.failed} failed`)}` : "") + ` ${pc16.dim(`(model ${opts.model})`)}
+    `${pc17.bold(String(result.nodes.length))} summarized` + (result.failed > 0 ? `, ${pc17.yellow(`${result.failed} failed`)}` : "") + ` ${pc17.dim(`(model ${opts.model})`)}
 `
   );
   return 0;
@@ -6114,16 +6419,16 @@ ${node.body}
 var SCAN_SESSION_DEFAULT_MODEL = DEFAULT_SLM_MODEL;
 
 // src/cli/commands/scan-shell.ts
-import pc17 from "picocolors";
+import pc18 from "picocolors";
 async function runScanShell(opts) {
   const repo = await readRepoInfo(opts.cwd);
   const projectId = makeProjectId({ root: repo.root, originUrl: repo.originUrl });
   const results = await collectAvailableShellHistory({ tailLines: opts.tailLines, repoRoot: repo.root });
   if (!opts.json) {
     process.stderr.write(
-      results.length ? `${pc17.dim("sources found")} ${results.map((r) => r.name).join(", ")}
+      results.length ? `${pc18.dim("sources found")} ${results.map((r) => r.name).join(", ")}
 
-` : `${pc17.yellow("no shell history source found on this machine")}
+` : `${pc18.yellow("no shell history source found on this machine")}
 `
     );
   }
@@ -6132,9 +6437,9 @@ async function runScanShell(opts) {
     const nodes = collectShellHistory(result.entries, projectId).filter((n) => n.signal >= opts.minSignal);
     allNodes.push(...nodes);
     if (!opts.json) {
-      process.stdout.write(`${pc17.bold(`shell:${result.name}`)} ${pc17.dim(`(${nodes.length} of ${result.entries.length} above threshold)`)}
+      process.stdout.write(`${pc18.bold(`shell:${result.name}`)} ${pc18.dim(`(${nodes.length} of ${result.entries.length} above threshold)`)}
 `);
-      for (const node of nodes) process.stdout.write(`${formatNode5(node)}
+      for (const node of nodes) process.stdout.write(`${formatNode6(node)}
 `);
       process.stdout.write("\n");
     }
@@ -6145,19 +6450,19 @@ async function runScanShell(opts) {
     return 0;
   }
   const approxTotal = approxTotalTokens(allNodes);
-  process.stderr.write(`${pc17.bold(String(allNodes.length))} node(s) total  ${pc17.dim(`~${approxTotal.toLocaleString()} tokens if sent raw`)}
+  process.stderr.write(`${pc18.bold(String(allNodes.length))} node(s) total  ${pc18.dim(`~${approxTotal.toLocaleString()} tokens if sent raw`)}
 `);
   return 0;
 }
-function formatNode5(node) {
-  const approx = node.meta.tsApprox ? pc17.dim("~") : " ";
+function formatNode6(node) {
+  const approx = node.meta.tsApprox ? pc18.dim("~") : " ";
   const exit = node.meta.exitCode;
-  const exitLabel = typeof exit === "number" && exit !== 0 ? pc17.red(`exit ${exit}`) : "";
+  const exitLabel = typeof exit === "number" && exit !== 0 ? pc18.red(`exit ${exit}`) : "";
   return [formatSignal(node.signal, SHELL_SIGNAL_BANDS), approx + node.ts.slice(0, 16).replace("T", " "), node.title, exitLabel].filter(Boolean).join(" ");
 }
 
 // src/cli/commands/scan-structure.ts
-import pc18 from "picocolors";
+import pc19 from "picocolors";
 var TRACKED_EXTENSIONS = TRACKED_PATHSPECS.map((p) => p.replace("*", "")).join("/");
 async function runScanStructure(opts) {
   const repo = await readRepoInfo(opts.cwd);
@@ -6168,24 +6473,24 @@ async function runScanStructure(opts) {
     return 0;
   }
   if (unreadable.length > 0) {
-    process.stderr.write(`${pc18.yellow("unreadable")} ${unreadable.join(", ")}
+    process.stderr.write(`${pc19.yellow("unreadable")} ${unreadable.join(", ")}
 
 `);
   }
   for (const edge of edges) {
-    process.stdout.write(`${edge.fromPath} ${pc18.dim("->")} ${edge.toPath}
+    process.stdout.write(`${edge.fromPath} ${pc19.dim("->")} ${edge.toPath}
 `);
   }
   process.stderr.write(
     `
-${pc18.bold(String(edges.length))} edge(s) from ${filesScanned} tracked ${TRACKED_EXTENSIONS} file(s)
+${pc19.bold(String(edges.length))} edge(s) from ${filesScanned} tracked ${TRACKED_EXTENSIONS} file(s)
 `
   );
   return 0;
 }
 
 // src/cli/commands/stale.ts
-import pc19 from "picocolors";
+import pc20 from "picocolors";
 var STALE_DEFAULT_MODEL = DEFAULT_SLM_MODEL;
 async function runStale(opts) {
   const { projectId, ws } = await loadContext(opts.cwd);
@@ -6195,15 +6500,15 @@ async function runStale(opts) {
     if (opts.dismiss) {
       const dismissed = store.dismissContradictionSuggestion(projectId, opts.dismiss);
       out(
-        dismissed > 0 ? `${pc19.green("dismissed")} the contradiction suggestion for ${opts.dismiss} -- it will not resurface
-` : `${pc19.dim("no open contradiction suggestion")} for ${opts.dismiss} -- nothing to dismiss
+        dismissed > 0 ? `${pc20.green("dismissed")} the contradiction suggestion for ${opts.dismiss} -- it will not resurface
+` : `${pc20.dim("no open contradiction suggestion")} for ${opts.dismiss} -- nothing to dismiss
 `
       );
       return 0;
     }
     const candidates = store.listStaleCandidates(projectId, { minAgeDays: opts.minAgeDays, limit: opts.limit });
     if (candidates.length === 0) {
-      out(`${pc19.dim("no stale candidates")} -- no unconfirmed node older than the threshold lacks a successor
+      out(`${pc20.dim("no stale candidates")} -- no unconfirmed node older than the threshold lacks a successor
 `);
       return 0;
     }
@@ -6225,15 +6530,15 @@ async function runStale(opts) {
     for (const s of suggestions) byCandidateId.set(s.candidateId, s);
     out(
       [
-        `${pc19.bold(String(candidates.length))} stale candidate(s) -- oldest first, none of these were changed:`,
+        `${pc20.bold(String(candidates.length))} stale candidate(s) -- oldest first, none of these were changed:`,
         ...candidates.map((c) => {
-          const line = `  ${pc19.dim(c.id)} ${pc19.yellow(`${c.ageDays}d old`)} [${c.kind}] ${c.title}`;
+          const line = `  ${pc20.dim(c.id)} ${pc20.yellow(`${c.ageDays}d old`)} [${c.kind}] ${c.title}`;
           const hit = byCandidateId.get(c.id);
           return hit ? `${line}
-    ${pc19.red("likely superseded by")} ${pc19.dim(hit.againstId)} ${hit.againstTitle} -- ${hit.reason}` : line;
+    ${pc20.red("likely superseded by")} ${pc20.dim(hit.againstId)} ${hit.againstTitle} -- ${hit.reason}` : line;
         }),
         "",
-        `run ${pc19.bold("nexusmem mark-stale <id> --supersedes <newId>")} on any that are actually wrong`
+        `run ${pc20.bold("nexusmem mark-stale <id> --supersedes <newId>")} on any that are actually wrong`
       ].join("\n").concat("\n")
     );
     return 0;
@@ -6245,7 +6550,7 @@ async function runStale(opts) {
 // src/cli/commands/status.ts
 import { basename as basename4 } from "path";
 import { statSync } from "fs";
-import pc20 from "picocolors";
+import pc21 from "picocolors";
 function daySpan(oldest, newest) {
   const oldestDay = Date.parse(oldest.slice(0, 10));
   const newestDay = Date.parse(newest.slice(0, 10));
@@ -6305,34 +6610,34 @@ async function runStatus(opts) {
     const flaggedCount = store.countContradictionSuggestions(projectId);
     const dbBytes = fileSize(ws.dbPath) + fileSize(`${ws.dbPath}-wal`);
     const kinds = Object.entries(stats2.byKind).sort((a, b) => b[1] - a[1]).map(([kind, n]) => `    ${String(n).padStart(6)}  ${kind}`);
-    const staleProjectWarning = otherProjectIds.length ? `${pc20.yellow("stale   ")} ${otherProjectIds.length} prior project ${otherProjectIds.length === 1 ? "identity holds" : "identities hold"} ${otherProjectNodes} node(s) \u2014 run ${pc20.bold(
+    const staleProjectWarning = otherProjectIds.length ? `${pc21.yellow("stale   ")} ${otherProjectIds.length} prior project ${otherProjectIds.length === 1 ? "identity holds" : "identities hold"} ${otherProjectNodes} node(s) \u2014 run ${pc21.bold(
       "nexusmem sync --prune-source <name>"
     )} to remove stale source data` : "";
     out(
       [
-        `${pc20.dim("repo    ")} ${repo.root}`,
-        `${pc20.dim("branch  ")} ${repo.branch ?? pc20.yellow("(detached)")}`,
-        `${pc20.dim("project ")} ${pc20.cyan(projectId)}`,
-        `${pc20.dim("schema  ")} v${schema}${schema === LATEST_SCHEMA_VERSION ? "" : pc20.yellow(` (latest is v${LATEST_SCHEMA_VERSION})`)}`,
-        `${pc20.dim("database")} ${ws.dbPath} ${pc20.dim(`(${humanBytes(dbBytes)})`)}`,
+        `${pc21.dim("repo    ")} ${repo.root}`,
+        `${pc21.dim("branch  ")} ${repo.branch ?? pc21.yellow("(detached)")}`,
+        `${pc21.dim("project ")} ${pc21.cyan(projectId)}`,
+        `${pc21.dim("schema  ")} v${schema}${schema === LATEST_SCHEMA_VERSION ? "" : pc21.yellow(` (latest is v${LATEST_SCHEMA_VERSION})`)}`,
+        `${pc21.dim("database")} ${ws.dbPath} ${pc21.dim(`(${humanBytes(dbBytes)})`)}`,
         staleProjectWarning,
         "",
-        `${pc20.bold(String(stats2.total))} node(s)${stats2.total ? ` ${pc20.dim(`${stats2.oldest?.slice(0, 10)} .. ${stats2.newest?.slice(0, 10)}`)}` : ""}`,
+        `${pc21.bold(String(stats2.total))} node(s)${stats2.total ? ` ${pc21.dim(`${stats2.oldest?.slice(0, 10)} .. ${stats2.newest?.slice(0, 10)}`)}` : ""}`,
         ...kinds,
-        stats2.total ? `    ${pc20.dim(`${stats2.distinctFiles} distinct file path(s)`)}` : "",
+        stats2.total ? `    ${pc21.dim(`${stats2.distinctFiles} distinct file path(s)`)}` : "",
         "",
-        sources.length ? pc20.dim("sources") : pc20.yellow("no sources synced yet"),
+        sources.length ? pc21.dim("sources") : pc21.yellow("no sources synced yet"),
         ...sources.map((s) => {
           const when = s.lastRunAt ? new Date(s.lastRunAt).toISOString().slice(0, 16).replace("T", " ") : "never";
           const cursorLabel = s.source === "git" ? s.cursor?.slice(0, 7) ?? "-" : s.cursor ?? "-";
-          return `    ${s.source.padEnd(14)} ${pc20.dim(`last run ${when}`)}  ${pc20.dim(`cursor ${cursorLabel}`)}`;
+          return `    ${s.source.padEnd(14)} ${pc21.dim(`last run ${when}`)}  ${pc21.dim(`cursor ${cursorLabel}`)}`;
         }),
         "",
-        gitCursor && gitCursor !== repo.head ? `${pc20.yellow("git behind HEAD")} \u2014 run ${pc20.bold("nexusmem sync")}` : "",
-        chains.failuresTotal ? `${pc20.dim("chains  ")} ${pc20.bold(String(chains.resolvedTotal))}/${chains.failuresTotal} failure(s) resolved ${pc20.dim(`(${chains.resolvedByRetry} retry, ${chains.resolvedByDiscussion} discussion)`)}${chains.resolvedTotal < chains.failuresTotal ? ` \u2014 run ${pc20.bold("nexusmem sync --link-failures")} to link more` : ""}` : "",
-        structure.edges ? `${pc20.dim("structure")} ${pc20.bold(String(structure.edges))} import edge(s) across ${structure.files} file(s)` : "",
-        staleCount ? `${pc20.dim("aging   ")} ${pc20.bold(String(staleCount))} unconfirmed node(s) worth a look \u2014 run ${pc20.bold("nexusmem stale")}` : "",
-        flaggedCount ? `${pc20.dim("flagged ")} ${pc20.bold(String(flaggedCount))} likely-superseded node(s) awaiting review \u2014 run ${pc20.bold("nexusmem stale")} for detail` : ""
+        gitCursor && gitCursor !== repo.head ? `${pc21.yellow("git behind HEAD")} \u2014 run ${pc21.bold("nexusmem sync")}` : "",
+        chains.failuresTotal ? `${pc21.dim("chains  ")} ${pc21.bold(String(chains.resolvedTotal))}/${chains.failuresTotal} failure(s) resolved ${pc21.dim(`(${chains.resolvedByRetry} retry, ${chains.resolvedByDiscussion} discussion)`)}${chains.resolvedTotal < chains.failuresTotal ? ` \u2014 run ${pc21.bold("nexusmem sync --link-failures")} to link more` : ""}` : "",
+        structure.edges ? `${pc21.dim("structure")} ${pc21.bold(String(structure.edges))} import edge(s) across ${structure.files} file(s)` : "",
+        staleCount ? `${pc21.dim("aging   ")} ${pc21.bold(String(staleCount))} unconfirmed node(s) worth a look \u2014 run ${pc21.bold("nexusmem stale")}` : "",
+        flaggedCount ? `${pc21.dim("flagged ")} ${pc21.bold(String(flaggedCount))} likely-superseded node(s) awaiting review \u2014 run ${pc21.bold("nexusmem stale")} for detail` : ""
       ].filter((line) => line !== "").join("\n").concat("\n")
     );
     return 0;
@@ -6355,7 +6660,7 @@ function guard(run) {
       process.exitCode = await run();
     } catch (err) {
       if (isExpected(err)) {
-        process.stderr.write(`${pc21.red("error")} ${err.message}
+        process.stderr.write(`${pc22.red("error")} ${err.message}
 `);
         process.exitCode = 1;
         return;
@@ -6371,7 +6676,7 @@ program.command("init").description("Create the .nexusmem workspace and database
     () => runInit({ cwd: options.cwd, force: options.force, hook: options.hook, enableConversation: options.enableConversation })
   )()
 );
-program.command("sync").description("Ingest new history into the local database").option("-C, --cwd <path>", "repository path", process.cwd()).option("--full", "ignore the stored cursor and re-walk all history", false).option("--rebuild", "drop this project's nodes and re-ingest from scratch", false).option("--since <date>", "override the configured git cutoff, e.g. 1.year.ago").option("--shell-lines <count>", "override the configured shell tail-window size", (v) => Number.parseInt(v, 10)).option("--conversation", "force the conversation source on for this run, without persisting it to config", false).option("--no-embed", "skip the vector-embedding pass for this run").option(
+program.command("sync").description("Ingest new history into the local database").option("-C, --cwd <path>", "repository path", process.cwd()).option("--full", "ignore the stored cursor and re-walk all history", false).option("--rebuild", "drop this project's nodes and re-ingest from scratch", false).option("--since <date>", "override the configured git cutoff, e.g. 1.year.ago").option("--shell-lines <count>", "override the configured shell tail-window size", (v) => Number.parseInt(v, 10)).option("--conversation", "force the conversation source on for this run, without persisting it to config", false).option("--github", "force the github issue/PR source on for this run, without persisting it to config", false).option("--no-embed", "skip the vector-embedding pass for this run").option(
   "--embed-limit <count>",
   "stop embedding after this many nodes (default: embed everything pending)",
   (v) => Number.parseInt(v, 10)
@@ -6392,6 +6697,7 @@ program.command("sync").description("Ingest new history into the local database"
       since: options.since,
       shellTailLines: options.shellLines,
       conversationOverride: options.conversation ? true : void 0,
+      githubOverride: options.github ? true : void 0,
       noEmbed: !options.embed,
       embedLimit: options.embedLimit,
       pruneSource: options.pruneSource,
@@ -6523,6 +6829,7 @@ program.command("scan-session").description("Preview the session summaries a loc
   )()
 );
 program.command("scan-docs").description("Preview the MemoryNodes tracked .md files would produce (writes nothing)").option("-C, --cwd <path>", "repository path", process.cwd()).option("--min-signal <score>", "drop nodes below this signal", (v) => Number.parseFloat(v), 0).option("--json", "emit MemoryNodes as JSON on stdout", false).action((options) => guard(() => runScanDocs({ cwd: options.cwd, minSignal: options.minSignal, json: options.json }))());
+program.command("scan-github").description("Preview the MemoryNodes github.com issues/PRs would produce (writes nothing, needs `gh` installed and authenticated)").option("-C, --cwd <path>", "repository path", process.cwd()).option("--min-signal <score>", "drop nodes below this signal", (v) => Number.parseFloat(v), 0).option("--json", "emit MemoryNodes as JSON on stdout", false).action((options) => guard(() => runScanGithub({ cwd: options.cwd, minSignal: options.minSignal, json: options.json }))());
 program.command("precheck").description("Warn about staged files with unresolved past failures or high recent churn (advisory, exits 0 unless --strict)").option("-C, --cwd <path>", "repository path", process.cwd()).option("--files <paths...>", "check exactly these repo-relative paths instead of what is staged").option("--working", "check the working tree (unstaged changes) instead of what is staged for commit", false).option("--strict", "exit 1 when any file has an unresolved failure", false).option("-q, --quiet", "only print output when there is something to warn about", false).action(
   (options) => guard(
     () => runPrecheck({
@@ -6538,7 +6845,7 @@ program.command("scan-structure").description("Preview the JS/TS/Python/Go/Rust/
 program.command("mcp").description("Start the MCP server (stdio transport) for Claude Desktop, Cursor, Windsurf, etc.").action(() => guard(() => runMcpServer().then(() => 0))());
 program.parseAsync(process.argv).catch((err) => {
   const message = err instanceof Error ? err.message : String(err);
-  process.stderr.write(`${pc21.red("error")} ${message}
+  process.stderr.write(`${pc22.red("error")} ${message}
 `);
   process.exitCode = 1;
 });