@pan-sec/notebooklm-mcp 2026.3.3 → 2026.4.1

package/dist/notebook-creation/data-table-manager.js

@@ -16,29 +16,10 @@
  */
 import { log } from "../utils/logger.js";
 import { randomDelay } from "../utils/stealth-utils.js";
-export class DataTableManager {
-    authManager;
-    contextManager;
-    page = null;
-    constructor(authManager, contextManager) {
-        this.authManager = authManager;
-        this.contextManager = contextManager;
-    }
-    /**
-     * Navigate to a notebook and ensure we're on the right page
-     */
-    async navigateToNotebook(notebookUrl) {
-        const context = await this.contextManager.getOrCreateContext();
-        const isAuth = await this.authManager.validateWithRetry(context);
-        if (!isAuth) {
-            throw new Error("Not authenticated. Run setup_auth first.");
-        }
-        this.page = await context.newPage();
-        await this.page.goto(notebookUrl, { waitUntil: "domcontentloaded" });
-        await this.page.waitForLoadState("networkidle").catch(() => { });
-        await randomDelay(2000, 3000);
-        return this.page;
-    }
+import { validateResponse } from "../utils/response-validator.js";
+import { StudioManagerBase, } from "./studio-manager-base.js";
+export class DataTableManager extends StudioManagerBase {
+    logName = "data-table-manager";
     /**
      * Ensure the Studio panel is visible (expand if collapsed).
      *
@@ -105,6 +86,18 @@ export class DataTableManager {
                 if (item.classList.contains("shimmer-blue") || titleText.toLowerCase().includes("generating")) {
                     return { status: "generating", progress: 0 };
                 }
+                // Detect an explicit failure state on THIS artifact before assuming ready.
+                // A failed generation leaves a non-shimmer artifact, which would otherwise be
+                // misreported as "ready". Scope the check to the matched item only — a page-global
+                // alert query could match unrelated UI. Class names are best-effort (unconfirmed
+                // by live inspection); [role="alert"]/error child is the locale-independent signal.
+                const hasErrorChild = !!item.querySelector('[role="alert"], .error-state, .artifact-error');
+                if (hasErrorChild ||
+                    item.classList.contains("error-state") ||
+                    item.classList.contains("artifact-error") ||
+                    item.classList.contains("failed")) {
+                    return { status: "failed" };
+                }
                 // Otherwise it's ready
                 return { status: "ready" };
             }
@@ -214,6 +207,14 @@ export class DataTableManager {
             await randomDelay(500, 800);
             // Check if generation started
             const newStatus = await this.checkDataTableStatusInternal(page);
+            if (newStatus.status === "failed") {
+                log.warning("  Data table generation reported a failed state");
+                return {
+                    success: false,
+                    status: newStatus,
+                    error: "Data table generation failed.",
+                };
+            }
             if (newStatus.status === "generating" || newStatus.status === "ready") {
                 log.success(`  Data table generation ${newStatus.status === "ready" ? "completed" : "started"}`);
                 return { success: true, status: newStatus };
@@ -253,6 +254,12 @@ export class DataTableManager {
                     error: "No data table found. Use generate_data_table first.",
                 };
             }
+            if (status.status === "failed") {
+                return {
+                    success: false,
+                    error: "Data table generation failed. Use generate_data_table to retry.",
+                };
+            }
             // Click the data table artifact to open it
             const artifactClicked = await this.clickDataTableArtifact(page);
             if (!artifactClicked) {
@@ -261,6 +268,12 @@ export class DataTableManager {
                     error: "Could not click on data table artifact.",
                 };
             }
+            // Status is already confirmed "ready" above, so a table is expected to
+            // render after opening the artifact. Wait for the concrete <table> element
+            // that extractTableData() reads, instead of relying on a fixed sleep as the
+            // only readiness gate (M30). Bounded + .catch so a miss degrades to the
+            // prior behavior (fall through to extractTableData, which returns null).
+            await page.waitForSelector("table", { timeout: 10000 }).catch(() => { });
             await randomDelay(2000, 3000);
             // Extract table data from the page
             const table = await this.extractTableData(page);
@@ -270,10 +283,14 @@ export class DataTableManager {
                     error: "Could not extract table data. The table may not be visible yet.",
                 };
             }
-            log.success(`  Extracted data table: ${table.totalColumns} columns x ${table.totalRows} rows`);
+            // Notebook sources are arbitrary documents, so table cell text is untrusted
+            // and a prompt-injection conduit. Sanitize every cell before returning it
+            // to the calling model (mirrors ask_question response validation).
+            const safeTable = await this.sanitizeTable(table);
+            log.success(`  Extracted data table: ${safeTable.totalColumns} columns x ${safeTable.totalRows} rows`);
             return {
                 success: true,
-                table,
+                table: safeTable,
             };
         }
         finally {
@@ -336,19 +353,29 @@ export class DataTableManager {
         });
     }
     /**
-     * Close the page if open
+     * Sanitize extracted table content through the shared response validator.
+     * Each cell originates from untrusted document sources, so any prompt
+     * injection / malicious content is redacted before the table is returned
+     * to the calling model.
      */
-    async closePage() {
-        if (this.page) {
-            try {
-                await this.page.close();
-            }
-            catch (err) {
-                log.debug(`data-table-manager: closing page: ${err instanceof Error ? err.message : String(err)}`);
-                // Ignore close errors
-            }
-            this.page = null;
+    async sanitizeTable(table) {
+        let flagged = false;
+        const sanitizeCell = async (value) => {
+            const validation = await validateResponse(value);
+            if (!validation.safe)
+                flagged = true;
+            return validation.sanitized;
+        };
+        const headers = await Promise.all(table.headers.map(sanitizeCell));
+        const rows = await Promise.all(table.rows.map((row) => Promise.all(row.map(sanitizeCell))));
+        if (flagged) {
+            log.warning("🛡️ Suspicious content detected in extracted data table — sanitized");
         }
+        return {
+            headers,
+            rows,
+            totalRows: table.totalRows,
+            totalColumns: table.totalColumns,
+        };
     }
 }
-//# sourceMappingURL=data-table-manager.js.map

package/dist/notebook-creation/dom-scripts.d.ts

@@ -7,4 +7,3 @@
 export declare function clickCopiedTextSourceOption(): {
     clicked: boolean;
 };
-//# sourceMappingURL=dom-scripts.d.ts.map

package/dist/notebook-creation/dom-scripts.js

@@ -55,4 +55,3 @@ export function clickCopiedTextSourceOption() {
     }
     return { clicked: false };
 }
-//# sourceMappingURL=dom-scripts.js.map

package/dist/notebook-creation/errors.d.ts

@@ -15,4 +15,3 @@ export declare class NotebookCreationError extends Error {
     readonly cause?: unknown;
     constructor(message: string, options: NotebookCreationErrorOptions);
 }
-//# sourceMappingURL=errors.d.ts.map

package/dist/notebook-creation/errors.js

@@ -17,4 +17,3 @@ export class NotebookCreationError extends Error {
         this.cause = options.cause;
     }
 }
-//# sourceMappingURL=errors.js.map

package/dist/notebook-creation/index.d.ts

@@ -12,4 +12,3 @@ export * from "./notebook-creator.js";
 export * from "./notebook-sync.js";
 export * from "./video-manager.js";
 export * from "./data-table-manager.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/notebook-creation/index.js

@@ -12,4 +12,3 @@ export * from "./notebook-creator.js";
 export * from "./notebook-sync.js";
 export * from "./video-manager.js";
 export * from "./data-table-manager.js";
-//# sourceMappingURL=index.js.map

package/dist/notebook-creation/notebook-creator.d.ts

@@ -17,6 +17,14 @@ export declare class NotebookCreator {
     private withOperationLock;
     createNotebook(options: CreateNotebookOptions): Promise<CreatedNotebook>;
     private runCreateNotebook;
+    /**
+     * Best-effort deletion of a freshly-created but empty notebook (no sources
+     * added). Opens the notebook's overflow/options menu and confirms delete.
+     *
+     * Failure to delete is logged but not rethrown: the caller is already
+     * reporting the creation as failed, so we must not mask that with a
+     * secondary error.
+     */
+    private deleteEmptyNotebook;
 }
 export declare function createNotebook(authManager: AuthManager, contextManager: SharedContextManager, options: CreateNotebookOptions): Promise<CreatedNotebook>;
-//# sourceMappingURL=notebook-creator.d.ts.map

package/dist/notebook-creation/notebook-creator.js

@@ -83,6 +83,17 @@ export class NotebookCreator {
                 }
                 await randomDelay(1000, 2000);
             }
+            // Fail-safe: if sources were requested but NONE actually succeeded, the
+            // notebook is empty and useless. Discard it (best-effort delete to avoid
+            // burning quota) and throw so the caller never persists a library entry
+            // or counts a successful creation for it. An empty `sources` array (e.g.
+            // an overflow shell notebook) is a legitimate zero-success case and is
+            // left untouched.
+            if (sources.length > 0 && successCount === 0) {
+                log.error(`❌ Notebook creation failed: no sources could be added (${notebookId})`);
+                await this.deleteEmptyNotebook();
+                throw new Error("Notebook creation failed: no sources could be added; empty notebook was discarded");
+            }
             currentStep++;
             await sendProgress?.("Finalizing notebook...", currentStep, totalSteps);
             const notebookUrl = await this.navigation.finalizeAndGetUrl();
@@ -103,9 +114,47 @@ export class NotebookCreator {
             await this.navigation.cleanup();
         }
     }
+    /**
+     * Best-effort deletion of a freshly-created but empty notebook (no sources
+     * added). Opens the notebook's overflow/options menu and confirms delete.
+     *
+     * Failure to delete is logged but not rethrown: the caller is already
+     * reporting the creation as failed, so we must not mask that with a
+     * secondary error.
+     */
+    async deleteEmptyNotebook() {
+        const page = this.navigation.getCurrentPage();
+        if (!page) {
+            log.debug("notebook creator: no page available to delete empty notebook");
+            return;
+        }
+        try {
+            const menuButton = page
+                .locator('button[aria-label*="more" i], button[aria-label*="options" i], button[aria-label*="settings" i]')
+                .first();
+            await menuButton.click({ timeout: 5000 });
+            await randomDelay(500, 1000);
+            const deleteOption = page
+                .locator('button:has-text("Delete"), [role="menuitem"]:has-text("Delete")')
+                .first();
+            await deleteOption.click({ timeout: 5000 });
+            await randomDelay(500, 1000);
+            // Confirm in any follow-up dialog.
+            const confirmButton = page
+                .locator('button:has-text("Delete"), button:has-text("Confirm")')
+                .last();
+            if ((await confirmButton.count()) > 0) {
+                await confirmButton.click({ timeout: 5000 });
+                await randomDelay(500, 1000);
+            }
+            log.info("🗑️  Discarded empty notebook (no sources added)");
+        }
+        catch (error) {
+            log.warning(`⚠️ Could not delete empty notebook: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
 }
 export async function createNotebook(authManager, contextManager, options) {
     const creator = new NotebookCreator(authManager, contextManager);
     return creator.createNotebook(options);
 }
-//# sourceMappingURL=notebook-creator.js.map

package/dist/notebook-creation/notebook-nav.d.ts

@@ -16,4 +16,3 @@ export declare class NotebookNavigation {
     safePageUrl(page: Page): string;
     cleanup(): Promise<void>;
 }
-//# sourceMappingURL=notebook-nav.d.ts.map

package/dist/notebook-creation/notebook-nav.js

@@ -29,7 +29,16 @@ export class NotebookNavigation {
     }
     async initialize(headless) {
         log.info("🌐 Initializing browser for notebook creation...");
-        const context = await this.contextManager.getOrCreateContext(headless === false ? true : undefined);
+        // Map the caller's headless intent to getOrCreateContext's explicit
+        // "show browser" contract (its argument is true = show/visible,
+        // false = headless, undefined = defer to CONFIG.headless).
+        //   - headless === false  -> the caller explicitly wants a VISIBLE browser
+        //                            -> showBrowser = true
+        //   - headless === true / undefined -> no explicit visible request; defer
+        //                            to the configured default
+        //                            -> showBrowser = undefined
+        const showBrowser = headless === false ? true : undefined;
+        const context = await this.contextManager.getOrCreateContext(showBrowser);
         const isAuthenticated = await this.authManager.validateWithRetry(context);
         if (!isAuthenticated) {
             throw new Error("Not authenticated to NotebookLM. Please run setup_auth first.");
@@ -89,16 +98,23 @@ export class NotebookNavigation {
                 log.debug(`notebook-nav: clicking 'New notebook' button selector: ${err instanceof Error ? err.message : String(err)}`);
             }
         }
-        const textPatterns = ["New notebook", "Create notebook", "Create new", "New"];
+        // Specific, multi-word labels only. The previous last-ditch pattern was the
+        // bare word "New", which an includes()-match happily found inside unrelated
+        // controls like "New chat" or "New label" — clicking the wrong button. Match
+        // only full, unambiguous create-notebook labels.
+        const textPatterns = ["New notebook", "Create notebook", "Create new notebook"];
         for (const pattern of textPatterns) {
             try {
                 const clicked = await this.page.evaluate((searchText) => {
                     const browser = globalThis;
+                    const needle = searchText.toLowerCase();
                     const elements = browser.document.querySelectorAll('button, a, [role="button"]');
                     for (const el of elements) {
-                        const elText = el.textContent?.toLowerCase() || "";
-                        const ariaLabel = el.getAttribute("aria-label")?.toLowerCase() || "";
-                        if (elText.includes(searchText.toLowerCase()) || ariaLabel.includes(searchText.toLowerCase())) {
+                        const elText = (el.textContent || "").trim().toLowerCase();
+                        const ariaLabel = (el.getAttribute("aria-label") || "").trim().toLowerCase();
+                        // Exact label match only — never a loose substring — so we cannot
+                        // latch onto "New chat" / "New label" etc.
+                        if (elText === needle || ariaLabel === needle) {
                             el.click();
                             return true;
                         }
@@ -237,4 +253,3 @@ export class NotebookNavigation {
         }
     }
 }
-//# sourceMappingURL=notebook-nav.js.map

package/dist/notebook-creation/notebook-sync.d.ts

@@ -26,6 +26,13 @@ export interface SyncResult {
         libraryName: string;
         libraryUrl: string;
         reason: string;
+        /**
+         * Whether this entry is SAFE to auto-remove. Only true when we have an
+         * exact, UUID-based confirmation that the notebook no longer exists. Entries
+         * that merely failed a fuzzy title match are reported as stale (for the
+         * human to review) but are NOT eligible for destructive auto-fix.
+         */
+        autoFixSafe: boolean;
     }>;
     missingNotebooks: ActualNotebook[];
     suggestions: string[];
@@ -84,7 +91,13 @@ export declare class NotebookSync {
      */
     private titlesMatch;
     /**
-     * Extract notebook ID from URL
+     * Extract a STABLE notebook UUID from a URL, or null if none can be derived.
+     *
+     * Returns null for "pending-*" placeholders and for any URL that does not
+     * carry a real /notebook/UUID segment. A null id must NEVER be treated as a
+     * match key (two unknowns are not "equal") and must NEVER feed a destructive
+     * auto-fix decision — doing so previously let placeholder/garbage ids collide
+     * or let a missing id be (mis)matched and removed.
      */
     private extractNotebookId;
     /**
@@ -115,4 +128,3 @@ export declare function syncLibrary(authManager: AuthManager, contextManager: Sh
     autoFix?: boolean;
     showBrowser?: boolean;
 }): Promise<SyncResult>;
-//# sourceMappingURL=notebook-sync.d.ts.map

package/dist/notebook-creation/notebook-sync.js

@@ -289,10 +289,26 @@ export class NotebookSync {
             return [];
         // Click each row to capture the URL via navigation
         const notebooks = [];
-        const startUrl = this.page.url();
+        // Capture the library root URL ONCE, before any navigation. If the page is
+        // already sitting on a /notebook/ URL (left over from a prior step), the
+        // per-row waitForURL(/\/notebook\//) would resolve immediately against the
+        // pre-existing URL and mislabel every row with the wrong UUID. In that case
+        // navigate back to the library root first so clicks produce real
+        // navigations from a known-good base.
+        let startUrl = this.page.url();
+        if (/\/notebook\//.test(startUrl)) {
+            log.warning("  ⚠️ Not on library root before row scrape — returning to library");
+            await this.page.goto(NOTEBOOKLM_URL, { waitUntil: "domcontentloaded", timeout: CONFIG.browserTimeout });
+            await this.page.waitForLoadState("networkidle").catch(() => { });
+            await randomDelay(1500, 2000);
+            startUrl = this.page.url();
+        }
         for (let i = 0; i < rowData.length; i++) {
             const row = rowData[i];
             try {
+                // Record the URL immediately before the click so we can confirm that a
+                // REAL navigation occurred (and not accept a pre-existing notebook URL).
+                const urlBeforeClick = this.page.url();
                 // Click the data row by index (skip non-data rows in evaluate)
                 await this.page.evaluate((clickIdx) => {
                     const browser = globalThis;
@@ -305,22 +321,32 @@ export class NotebookSync {
                     }
                     dataRows[clickIdx]?.click();
                 }, i);
-                // Wait for navigation to complete
-                await this.page.waitForURL(/\/notebook\//, { timeout: 10000 }).catch(() => { });
+                // Wait for the URL to actually CHANGE to a new /notebook/ page. Using a
+                // predicate (rather than a bare /\/notebook\// regex) prevents resolving
+                // immediately against a pre-existing notebook URL and capturing a stale
+                // UUID for this row.
+                await this.page
+                    .waitForURL((u) => /\/notebook\//.test(u.toString()) && u.toString() !== urlBeforeClick, { timeout: 10000 })
+                    .catch(() => { });
                 await randomDelay(500, 1000);
-                // Capture the URL
+                // Capture the URL — only trust a UUID when a real navigation to a NEW
+                // notebook actually happened.
                 const currentUrl = this.page.url();
                 const notebookMatch = currentUrl.match(/\/notebook\/([a-f0-9-]+)/i);
-                const url = notebookMatch
+                const navigated = currentUrl !== urlBeforeClick && notebookMatch !== null;
+                const url = navigated
                     ? `https://notebooklm.google.com/notebook/${notebookMatch[1]}`
                     : `pending-nav-${notebooks.length}`;
+                if (!navigated) {
+                    log.warning(`  ⚠️ Row click did not navigate to a new notebook: ${row.title}`);
+                }
                 notebooks.push({
                     title: row.title,
                     url,
                     sourceCount: row.sourceCount,
                     createdDate: row.createdDate,
                 });
-                // Navigate back
+                // Navigate back to the library root
                 await this.page.goto(startUrl, { waitUntil: "domcontentloaded", timeout: CONFIG.browserTimeout });
                 await this.page.waitForLoadState("networkidle").catch(() => { });
                 await randomDelay(1500, 2000);
@@ -404,65 +430,108 @@ export class NotebookSync {
         const matched = [];
         const staleEntries = [];
         const suggestions = [];
+        // Is the extraction trustworthy enough to treat "UUID absent from this list"
+        // as positive proof of deletion? Only if we actually saw notebooks AND every
+        // one of them yielded a real UUID. An empty list usually means extraction
+        // failed (page didn't load / strategy missed) — NOT that the account is
+        // empty — and a "pending-*" entry could BE the very notebook we're checking,
+        // so "absent" is not a confirmation. Without this guard a failed scrape would
+        // mark every valid library entry as "confirmed deleted" and autoFix would
+        // wipe the whole library. This is the core data-loss M33 must prevent.
+        const extractionIsAuthoritative = actualNotebooks.length > 0 &&
+            actualNotebooks.every((n) => this.extractNotebookId(n.url) !== null);
         // Track which actual notebooks are matched
         const matchedActualIndices = new Set();
+        // Actual notebooks tied to a library entry by a FUZZY (unconfirmed) title
+        // match. They are not authoritative matches, but we must not auto-ADD them
+        // as "missing" either — that would create a duplicate library entry for a
+        // notebook the human still needs to reconcile. Excluded from auto-add only.
+        const fuzzyReservedIndices = new Set();
         // Check each library entry
         for (const entry of libraryEntries) {
-            // Extract notebook ID from URL
+            // Extract notebook ID from URL (null = pending/garbage, never a match key)
             const libraryNotebookId = this.extractNotebookId(entry.url);
-            // Try to find matching actual notebook
-            let matchingActualIndex = -1;
-            // First try: match by URL/ID
-            for (let i = 0; i < actualNotebooks.length; i++) {
-                const actual = actualNotebooks[i];
-                const actualNotebookId = this.extractNotebookId(actual.url);
-                if (actualNotebookId === libraryNotebookId && !actual.url.startsWith("pending-")) {
-                    matchingActualIndex = i;
-                    break;
+            // First try: EXACT UUID match. This is the only authoritative identity —
+            // and the only signal allowed to drive a destructive auto-fix.
+            let exactMatchIndex = -1;
+            if (libraryNotebookId !== null) {
+                for (let i = 0; i < actualNotebooks.length; i++) {
+                    const actualNotebookId = this.extractNotebookId(actualNotebooks[i].url);
+                    if (actualNotebookId !== null && actualNotebookId === libraryNotebookId) {
+                        exactMatchIndex = i;
+                        break;
+                    }
                 }
             }
-            // Second try: match by title similarity (fuzzy match)
-            if (matchingActualIndex < 0) {
+            // Second try: fuzzy title match. This is a SUGGESTION ONLY. A 60% word
+            // overlap can match the wrong notebook ("Security Notes 2025" vs "...2026"),
+            // so a fuzzy hit must never be fed into removal/relabel — it only avoids
+            // proposing deletion of an entry we can plausibly still see.
+            let fuzzyMatchIndex = -1;
+            if (exactMatchIndex < 0) {
                 const normalizedEntryName = this.normalizeTitle(entry.name);
                 for (let i = 0; i < actualNotebooks.length; i++) {
                     if (matchedActualIndices.has(i))
                         continue; // Already matched
-                    const actual = actualNotebooks[i];
-                    const normalizedActualTitle = this.normalizeTitle(actual.title);
-                    // Check for significant overlap
+                    const normalizedActualTitle = this.normalizeTitle(actualNotebooks[i].title);
                     if (this.titlesMatch(normalizedEntryName, normalizedActualTitle)) {
-                        matchingActualIndex = i;
+                        fuzzyMatchIndex = i;
                         break;
                     }
                 }
             }
-            if (matchingActualIndex >= 0) {
-                const matchingActual = actualNotebooks[matchingActualIndex];
+            if (exactMatchIndex >= 0) {
+                const matchingActual = actualNotebooks[exactMatchIndex];
                 matched.push({
                     libraryId: entry.id,
                     libraryName: entry.name,
                     actualTitle: matchingActual.title,
                     actualUrl: matchingActual.url,
                 });
-                matchedActualIndices.add(matchingActualIndex);
-                // Check if name differs significantly
+                matchedActualIndices.add(exactMatchIndex);
+                // Title drift on a UUID-confirmed match is safe to suggest relabelling.
                 const cleanActualTitle = this.normalizeTitle(matchingActual.title);
                 const cleanEntryName = this.normalizeTitle(entry.name);
                 if (cleanEntryName !== cleanActualTitle) {
                     suggestions.push(`📝 "${entry.name}" matches "${matchingActual.title}" (consider updating library entry)`);
                 }
             }
+            else if (fuzzyMatchIndex >= 0) {
+                // Fuzzy hit: report as a SUGGESTION only. Do not consume the actual
+                // notebook (leave it as "missing" so the human sees both sides) and do
+                // NOT mark the library entry as auto-removable.
+                const fuzzyActual = actualNotebooks[fuzzyMatchIndex];
+                fuzzyReservedIndices.add(fuzzyMatchIndex);
+                suggestions.push(`❓ "${entry.name}" may correspond to "${fuzzyActual.title}" (fuzzy title match — verify manually; not auto-applied)`);
+                staleEntries.push({
+                    libraryId: entry.id,
+                    libraryName: entry.name,
+                    libraryUrl: entry.url,
+                    reason: "No exact UUID match; only a fuzzy title match was found (review manually)",
+                    autoFixSafe: false,
+                });
+            }
             else {
+                // No exact and no fuzzy match. Only safe to auto-remove when we could
+                // actually derive a real UUID for this entry AND positively confirmed it
+                // is absent. If the entry's own URL has no parseable UUID (pending/
+                // garbage), we cannot prove the notebook is gone — never auto-delete it.
                 staleEntries.push({
                     libraryId: entry.id,
                     libraryName: entry.name,
                     libraryUrl: entry.url,
-                    reason: "Notebook not found in NotebookLM (may be deleted or URL changed)",
+                    reason: libraryNotebookId === null
+                        ? "Entry has no resolvable notebook UUID (cannot confirm deletion — review manually)"
+                        : !extractionIsAuthoritative
+                            ? "Notebook not found, but extraction was incomplete (empty or pending results) — cannot confirm deletion; review manually"
+                            : "Notebook UUID not present in NotebookLM (confirmed deleted or moved)",
+                    autoFixSafe: libraryNotebookId !== null && extractionIsAuthoritative,
                 });
             }
         }
-        // Find notebooks not in library
-        const missingNotebooks = actualNotebooks.filter((_, index) => !matchedActualIndices.has(index));
+        // Find notebooks not in library. Exclude fuzzy-reserved actuals so we don't
+        // auto-add a duplicate of a notebook a stale entry probably already denotes.
+        const missingNotebooks = actualNotebooks.filter((_, index) => !matchedActualIndices.has(index) && !fuzzyReservedIndices.has(index));
         // Generate suggestions
         if (staleEntries.length > 0) {
             suggestions.unshift(`🗑️  ${staleEntries.length} stale library entries should be removed`);
@@ -484,8 +553,13 @@ export class NotebookSync {
     normalizeTitle(title) {
         return title
             .toLowerCase()
-            .replace(/[🔓🔒📁📄🔐⚛️🧠🛡️💻📋]/g, "") // Remove emojis
-            .replace(/[\u{1F300}-\u{1F9FF}]/gu, "") // Remove other emojis
+            // Remove emoji across all Unicode ranges (flags, symbols, supplemental
+            // pictographs, etc.) plus the zero-width-joiner and variation selectors
+            // used to compose emoji sequences. A hardcoded set / narrow range missed
+            // common emoji and made otherwise-equal titles normalize differently,
+            // producing false "stale" mismatches.
+            .replace(/\p{Extended_Pictographic}/gu, "")
+            .replace(/[\u{200D}\u{FE0E}\u{FE0F}\u{1F3FB}-\u{1F3FF}]/gu, "") // ZWJ, variation selectors, skin-tone modifiers
             .replace(/[^\w\s]/g, " ") // Remove punctuation
             .replace(/\s+/g, " ") // Normalize whitespace
             .trim();
@@ -511,12 +585,21 @@ export class NotebookSync {
         return overlapRatio >= 0.6;
     }
     /**
-     * Extract notebook ID from URL
+     * Extract a STABLE notebook UUID from a URL, or null if none can be derived.
+     *
+     * Returns null for "pending-*" placeholders and for any URL that does not
+     * carry a real /notebook/UUID segment. A null id must NEVER be treated as a
+     * match key (two unknowns are not "equal") and must NEVER feed a destructive
+     * auto-fix decision — doing so previously let placeholder/garbage ids collide
+     * or let a missing id be (mis)matched and removed.
      */
     extractNotebookId(url) {
+        if (!url || url.startsWith("pending-"))
+            return null;
         // URL format: https://notebooklm.google.com/notebook/UUID?authuser=X
-        const match = url.match(/\/notebook\/([a-f0-9-]+)/i);
-        return match ? match[1] : url;
+        // Require a canonical UUID so a partial/garbage id can't be matched.
+        const match = url.match(/\/notebook\/([a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12})/i);
+        return match ? match[1].toLowerCase() : null;
     }
     /**
      * Auto-fix stale entries by removing them
@@ -524,6 +607,13 @@ export class NotebookSync {
     async autoFixStaleEntries(staleEntries) {
         log.info("🔧 Auto-fixing stale entries...");
         for (const entry of staleEntries) {
+            // DESTRUCTIVE GUARD: only remove entries we could confirm as deleted via
+            // an exact UUID. Fuzzy/unresolvable entries are left for manual review so
+            // a valid library entry is never destroyed on a 60%-title-overlap guess.
+            if (!entry.autoFixSafe) {
+                log.warning(`⏭️  Skipping auto-remove of "${entry.libraryName}" — ${entry.reason}`);
+                continue;
+            }
             try {
                 this.library.removeNotebook(entry.libraryId);
                 log.success(`✅ Removed stale entry: ${entry.libraryName}`);
@@ -623,4 +713,3 @@ export async function syncLibrary(authManager, contextManager, library, options)
     const sync = new NotebookSync(authManager, contextManager, library);
     return await sync.syncLibrary(options);
 }
-//# sourceMappingURL=notebook-sync.js.map

package/dist/notebook-creation/selectors.d.ts

@@ -138,4 +138,3 @@ export type SelectorKey = keyof typeof NOTEBOOKLM_SELECTORS;
  * Get all selectors for a key (primary + fallbacks)
  */
 export declare function getSelectors(key: SelectorKey): string[];
-//# sourceMappingURL=selectors.d.ts.map