@jackwener/opencli 1.7.22 → 1.8.0

package/clis/twitter/list-create.test.js

@@ -0,0 +1,169 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { buildListCreateRow, parseListCreateArgs } from './list-create.js';
+import './list-create.js';
+
+function createPayload(overrides = {}) {
+    return {
+        ok: true,
+        httpStatus: 200,
+        bodyText: '{}',
+        bodyJson: {
+            data: {
+                list: {
+                    id_str: '123456789',
+                    name: 'My List',
+                    description: 'A list',
+                    mode: 'Private',
+                    ...overrides,
+                },
+            },
+        },
+    };
+}
+
+describe('twitter list-create registration', () => {
+    it('registers the list-create command with the expected shape', () => {
+        const cmd = getRegistry().get('twitter/list-create');
+        expect(cmd?.func).toBeTypeOf('function');
+        expect(cmd?.columns).toEqual(['id', 'name', 'description', 'mode', 'status']);
+        const nameArg = cmd?.args?.find((a) => a.name === 'name');
+        expect(nameArg).toBeTruthy();
+        expect(nameArg?.required).toBe(true);
+        expect(nameArg?.positional).toBe(true);
+        const modeArg = cmd?.args?.find((a) => a.name === 'mode');
+        expect(modeArg?.default).toBe('public');
+        const descArg = cmd?.args?.find((a) => a.name === 'description');
+        expect(descArg?.default).toBe('');
+    });
+
+    it('rejects empty name', async () => {
+        const cmd = getRegistry().get('twitter/list-create');
+        await expect(cmd.func({}, { name: '   ' })).rejects.toBeInstanceOf(ArgumentError);
+    });
+
+    it('rejects names over 25 chars', async () => {
+        const cmd = getRegistry().get('twitter/list-create');
+        await expect(cmd.func({}, { name: 'x'.repeat(26) })).rejects.toBeInstanceOf(ArgumentError);
+    });
+
+    it('rejects descriptions over 100 chars', () => {
+        expect(() => parseListCreateArgs({ name: 'ok', description: 'x'.repeat(101) })).toThrow(ArgumentError);
+    });
+
+    it('rejects invalid mode', async () => {
+        const cmd = getRegistry().get('twitter/list-create');
+        await expect(cmd.func({}, { name: 'ok', mode: 'secret' })).rejects.toBeInstanceOf(ArgumentError);
+    });
+
+    it('reads ct0 from cookies and unwraps Browser Bridge mutation envelopes', async () => {
+        const cmd = getRegistry().get('twitter/list-create');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            getCookies: vi.fn().mockResolvedValue([{ name: 'ct0', value: 'csrf-token' }]),
+            evaluate: vi.fn().mockResolvedValue({ session: 'browser:default', data: createPayload() }),
+        };
+
+        const rows = await cmd.func(page, { name: 'My List', description: 'A list', mode: 'private' });
+
+        expect(page.goto).toHaveBeenCalledWith('https://x.com');
+        expect(page.wait).toHaveBeenCalledWith(3);
+        expect(page.getCookies).toHaveBeenCalledWith({ url: 'https://x.com' });
+        expect(rows).toEqual([{ id: '123456789', name: 'My List', description: 'A list', mode: 'private', status: 'success' }]);
+    });
+
+    it('rejects missing ct0 before mutation', async () => {
+        const cmd = getRegistry().get('twitter/list-create');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            getCookies: vi.fn().mockResolvedValue([]),
+            evaluate: vi.fn(),
+        };
+
+        await expect(cmd.func(page, { name: 'My List' })).rejects.toBeInstanceOf(AuthRequiredError);
+        expect(page.evaluate).not.toHaveBeenCalled();
+    });
+
+    it('keeps non-fatal GraphQL errors when a valid created list payload exists', () => {
+        const row = buildListCreateRow({
+            result: {
+                ...createPayload(),
+                bodyJson: {
+                    ...createPayload().bodyJson,
+                    errors: [{ message: 'DecodeException' }],
+                },
+            },
+            name: 'My List',
+            description: 'A list',
+            mode: 'private',
+        });
+
+        expect(row).toEqual({ id: '123456789', name: 'My List', description: 'A list', mode: 'private', status: 'success' });
+    });
+
+    it('maps mutation auth and HTTP failures to typed errors', () => {
+        expect(() => buildListCreateRow({
+            result: { ok: false, httpStatus: 401, bodyText: 'login' },
+            name: 'My List',
+            description: '',
+            mode: 'public',
+        })).toThrow(AuthRequiredError);
+
+        expect(() => buildListCreateRow({
+            result: { ok: false, httpStatus: 500, bodyText: 'server' },
+            name: 'My List',
+            description: '',
+            mode: 'public',
+        })).toThrow(CommandExecutionError);
+    });
+
+    it('fails typed when the mutation response lacks post-condition evidence', () => {
+        for (const result of [
+            createPayload({ id_str: '', id: '' }),
+            createPayload({ name: '' }),
+            createPayload({ mode: '' }),
+        ]) {
+            expect(() => buildListCreateRow({
+                result,
+                name: 'My List',
+                description: '',
+                mode: 'public',
+            })).toThrow(CommandExecutionError);
+        }
+    });
+
+    it('fails typed when returned list name does not match the requested name', () => {
+        expect(() => buildListCreateRow({
+            result: createPayload({ name: 'Other List' }),
+            name: 'My List',
+            description: '',
+            mode: 'private',
+        })).toThrow(/expected "My List"/);
+    });
+
+    it('fails typed when returned list mode does not match requested mode', () => {
+        expect(() => buildListCreateRow({
+            result: createPayload({ mode: 'Public' }),
+            name: 'My List',
+            description: '',
+            mode: 'private',
+        })).toThrow(/expected private/);
+    });
+
+    it('fails typed when errors appear without a list payload', () => {
+        expect(() => buildListCreateRow({
+            result: {
+                ok: true,
+                httpStatus: 200,
+                bodyText: '{}',
+                bodyJson: { errors: [{ message: 'duplicate name' }] },
+            },
+            name: 'My List',
+            description: '',
+            mode: 'public',
+        })).toThrow(/duplicate name/);
+    });
+});

package/clis/twitter/list-remove.js

@@ -1,7 +1,7 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
 import { AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
 import { resolveTwitterQueryId } from './shared.js';
-import { parseListsManagement } from './lists.js';
+import { getListsManagementInstructions, parseListsManagement } from './lists.js';
 import { TWITTER_BEARER_TOKEN } from './utils.js';
 
 const USER_BY_SCREEN_NAME_QUERY_ID = 'qRednkZG-rn1P6b48NINmQ';
@@ -274,11 +274,18 @@ cli({
                 if (!r.ok) return { __error: 'HTTP ' + r.status };
                 return await r.json();
             }`);
-            const parsedAfter = listsAfter && !listsAfter.__error
-                ? parseListsManagement(listsAfter, new Set())
-                : [];
+            if (listsAfter && listsAfter.__error) {
+                throw new CommandExecutionError(`Could not verify list removal: ${listsAfter.__error}`);
+            }
+            if (!getListsManagementInstructions(listsAfter)) {
+                throw new CommandExecutionError('Could not verify list removal: unexpected lists payload shape');
+            }
+            const parsedAfter = parseListsManagement(listsAfter, new Set());
             const afterList = parsedAfter.find((l) => l.id === listId);
-            const memberCountAfter = afterList ? Number(afterList.members) || 0 : -1;
+            if (!afterList) {
+                throw new CommandExecutionError(`Could not verify list removal: list ${listId} missing from post-delete payload`);
+            }
+            const memberCountAfter = Number(afterList.members) || 0;
             if (memberCountAfter < memberCountBefore) {
                 verifiedBy = `member_count ${memberCountBefore} → ${memberCountAfter}`;
             } else {

package/clis/twitter/list-remove.test.js

@@ -1,7 +1,57 @@
 import { describe, expect, it, vi } from 'vitest';
 import { getRegistry } from '@jackwener/opencli/registry';
+import { CommandExecutionError } from '@jackwener/opencli/errors';
 import './list-remove.js';
 
+function buildListsPayload(listId = '123', memberCount = 10) {
+    return {
+        data: {
+            viewer: {
+                list_management_timeline: {
+                    timeline: {
+                        instructions: [{
+                            entries: [{
+                                entryId: 'owned-subscribed-list-module-0',
+                                content: {
+                                    items: [{
+                                        item: {
+                                            itemContent: {
+                                                list: {
+                                                    id_str: listId,
+                                                    name: 'My List',
+                                                    member_count: memberCount,
+                                                    subscriber_count: 0,
+                                                    mode: 'Public',
+                                                },
+                                            },
+                                        },
+                                    }],
+                                },
+                            }],
+                        }],
+                    },
+                },
+            },
+        },
+    };
+}
+
+function buildRemovePage(afterPayload) {
+    return {
+        goto: vi.fn().mockResolvedValue(undefined),
+        wait: vi.fn().mockResolvedValue(undefined),
+        getCookies: vi.fn().mockResolvedValue([{ name: 'ct0', value: 'token' }]),
+        nativeClick: vi.fn().mockResolvedValue(undefined),
+        evaluate: vi.fn()
+            .mockResolvedValueOnce(null) // UserByScreenName queryId fallback
+            .mockResolvedValueOnce('user-1')
+            .mockResolvedValueOnce(null) // ListsManagement queryId fallback
+            .mockResolvedValueOnce(buildListsPayload('123', 10))
+            .mockResolvedValueOnce({ ok: true, needsNativeInteraction: true, rowClickX: 1, rowClickY: 2, saveClickX: 3, saveClickY: 4 })
+            .mockResolvedValueOnce(afterPayload),
+    };
+}
+
 describe('twitter list-remove registration', () => {
     it('registers the list-remove command with the expected shape', () => {
         const cmd = getRegistry().get('twitter/list-remove');
@@ -33,4 +83,28 @@ describe('twitter list-remove registration', () => {
         expect(page.wait).toHaveBeenCalledWith(3);
         expect(page.getCookies).toHaveBeenCalledWith({ url: 'https://x.com' });
     });
+
+    it('does not treat post-delete fetch failure as successful member_count decrease', async () => {
+        const cmd = getRegistry().get('twitter/list-remove');
+        const page = buildRemovePage({ __error: 'HTTP 500' });
+
+        await expect(cmd.func(page, { listId: '123', username: 'alice' }))
+            .rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('does not treat malformed post-delete payload as successful member_count decrease', async () => {
+        const cmd = getRegistry().get('twitter/list-remove');
+        const page = buildRemovePage({ data: {} });
+
+        await expect(cmd.func(page, { listId: '123', username: 'alice' }))
+            .rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('does not treat a missing target list in post-delete payload as success', async () => {
+        const cmd = getRegistry().get('twitter/list-remove');
+        const page = buildRemovePage(buildListsPayload('456', 1));
+
+        await expect(cmd.func(page, { listId: '123', username: 'alice' }))
+            .rejects.toBeInstanceOf(CommandExecutionError);
+    });
 });

package/clis/twitter/list-tweets.js

@@ -1,6 +1,6 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
 import { AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
-import { extractMedia } from './shared.js';
+import { extractMedia, extractCard, extractQuotedTweet } from './shared.js';
 import { TWITTER_BEARER_TOKEN, applyTopByEngagement } from './utils.js';
 
 const LIST_TWEETS_QUERY_ID = 'RlZzktZY_9wJynoepm8ZsA';
@@ -61,11 +61,13 @@ export function extractTimelineTweet(result, seen) {
     const user = tw.core?.user_results?.result;
     const screenName = user?.legacy?.screen_name || user?.core?.screen_name || 'unknown';
     const displayName = user?.legacy?.name || user?.core?.name || '';
+    const bio = user?.legacy?.description || '';
     const noteText = tw.note_tweet?.note_tweet_results?.result?.text;
     return {
         id: tw.rest_id,
         author: screenName,
         name: displayName,
+        bio,
         text: noteText || legacy.full_text || '',
         likes: legacy.favorite_count || 0,
         retweets: legacy.retweet_count || 0,
@@ -73,6 +75,8 @@ export function extractTimelineTweet(result, seen) {
         created_at: legacy.created_at || '',
         url: `https://x.com/${screenName}/status/${tw.rest_id}`,
         ...extractMedia(legacy),
+        card: extractCard(tw),
+        quoted_tweet: extractQuotedTweet(tw),
     };
 }
 
@@ -120,7 +124,7 @@ cli({
         { name: 'limit', type: 'int', default: 50 },
         { name: 'top-by-engagement', type: 'int', default: 0, help: 'When set to N>0, re-rank the list timeline by weighted engagement (likes×1 + retweets×3 + replies×2 + bookmarks×5 + log10(views+1)×0.5) and return the top N. Default 0 keeps the list\'s native (recency) ordering.' },
     ],
-    columns: ['id', 'author', 'text', 'likes', 'retweets', 'replies', 'created_at', 'url', 'has_media', 'media_urls'],
+    columns: ['id', 'author', 'bio', 'text', 'likes', 'retweets', 'replies', 'created_at', 'url', 'has_media', 'media_urls', 'card', 'quoted_tweet'],
     func: async (page, kwargs) => {
         const listId = String(kwargs.listId || '').trim();
         if (!listId || !/^\d+$/.test(listId)) {

package/clis/twitter/list-tweets.test.js

@@ -15,7 +15,7 @@ describe('twitter list-tweets parser', () => {
             core: {
                 user_results: {
                     result: {
-                        legacy: { screen_name: 'bob', name: 'Bob' },
+                        legacy: { screen_name: 'bob', name: 'Bob', description: 'List author bio' },
                     },
                 },
             },
@@ -24,6 +24,7 @@ describe('twitter list-tweets parser', () => {
             id: '99',
             author: 'bob',
             name: 'Bob',
+            bio: 'List author bio',
             text: 'hello list',
             likes: 3,
             retweets: 1,
@@ -32,6 +33,45 @@ describe('twitter list-tweets parser', () => {
             url: 'https://x.com/bob/status/99',
             has_media: false,
             media_urls: [],
+            card: null,
+            quoted_tweet: null,
+        });
+    });
+
+    it('surfaces quoted_tweet field on quote tweets (mini-tweet shape)', () => {
+        // 1778721843 stale-snapshot case from ml-scout — downstream consumers
+        // need quote-tweet content to render the embedded preview card.
+        const tweet = extractTimelineTweet({
+            rest_id: '500',
+            legacy: {
+                full_text: '总的来说，还是有个好爹',
+                is_quote_status: true,
+                quoted_status_id_str: '499',
+            },
+            core: { user_results: { result: { legacy: { screen_name: 'rwayne' } } } },
+            quoted_status_result: {
+                result: {
+                    rest_id: '499',
+                    legacy: {
+                        full_text: '罗某官二代背景考',
+                        created_at: 'Wed May 13 22:00:00 +0000 2026',
+                        extended_entities: {
+                            media: [{ type: 'photo', media_url_https: 'https://pbs.twimg.com/media/x.jpg' }],
+                        },
+                    },
+                    core: { user_results: { result: { legacy: { screen_name: 'alice', name: 'Alice' } } } },
+                },
+            },
+        }, new Set());
+        expect(tweet?.quoted_tweet).toEqual({
+            id: '499',
+            author: 'alice',
+            name: 'Alice',
+            text: '罗某官二代背景考',
+            created_at: 'Wed May 13 22:00:00 +0000 2026',
+            url: 'https://x.com/alice/status/499',
+            has_media: true,
+            media_urls: ['https://pbs.twimg.com/media/x.jpg'],
         });
     });
 

package/clis/twitter/lists.js

@@ -1,5 +1,5 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
-import { AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
 import { TWITTER_BEARER_TOKEN } from './utils.js';
 
 const LISTS_QUERY_ID = '78UbkyXwXBD98IgUWXOy9g';
@@ -62,14 +62,35 @@ export function extractListEntry(entry, seen) {
     };
 }
 
-export function parseListsManagement(data, seen) {
-    const lists = [];
+// X 的 ListsManagementPageTimeline 把 /<user>/lists 整个页面的所有 section
+// 都塞在同一个 TimelineAddEntries instruction 里，靠 entry.entryId 前缀区分：
+//   - `owned-subscribed-list-module-*`  → 用户的 owned + subscribed list（要保留）
+//   - `list-to-follow-module-*`         → "Discover new Lists" 算法推荐（要剔除）
+//   - `cursor-*`                         → 分页游标（无 list 数据）
+// 旧版 parser 忽略 entryId 一律下钻，导致推荐 list 被当成自建/订阅泄漏出来。
+const OWNED_SUBSCRIBED_ENTRY_PREFIX = 'owned-subscribed-list-module-';
+
+export function isOwnedSubscribedEntry(entry) {
+    return typeof entry?.entryId === 'string'
+        && entry.entryId.startsWith(OWNED_SUBSCRIBED_ENTRY_PREFIX);
+}
+
+export function getListsManagementInstructions(data) {
     const instructions = data?.data?.viewer?.list_management_timeline?.timeline?.instructions
         || data?.data?.viewer_v2?.user_results?.result?.list_management_timeline?.timeline?.instructions
         || data?.data?.list_management_timeline?.timeline?.instructions
-        || [];
+        || data?.data?.data?.viewer?.list_management_timeline?.timeline?.instructions
+        || data?.data?.data?.viewer_v2?.user_results?.result?.list_management_timeline?.timeline?.instructions
+        || data?.data?.data?.list_management_timeline?.timeline?.instructions;
+    return Array.isArray(instructions) ? instructions : null;
+}
+
+export function parseListsManagement(data, seen) {
+    const lists = [];
+    const instructions = getListsManagementInstructions(data) || [];
     for (const inst of instructions) {
         for (const entry of inst.entries || []) {
+            if (!isOwnedSubscribedEntry(entry)) continue;
             const direct = extractListEntry(entry, seen);
             if (direct) {
                 lists.push(direct);
@@ -144,7 +165,13 @@ export const command = cli({
             throw new CommandExecutionError(`HTTP ${data.error}: Failed to fetch lists. queryId may have expired.`);
         }
         const seen = new Set();
+        if (!getListsManagementInstructions(data)) {
+            throw new CommandExecutionError('Twitter lists returned an unexpected payload shape');
+        }
         const lists = parseListsManagement(data, seen);
+        if (lists.length === 0) {
+            throw new EmptyResultError('twitter lists', 'No owned or subscribed lists found');
+        }
         return lists.slice(0, limit);
     },
 });

package/clis/twitter/lists.test.js

@@ -1,5 +1,7 @@
 import { describe, expect, it } from 'vitest';
-import { extractListEntry, parseListsManagement } from './lists.js';
+import { CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { extractListEntry, isOwnedSubscribedEntry, parseListsManagement } from './lists.js';
 
 describe('twitter lists parser', () => {
     it('extracts a list entry with full metadata', () => {
@@ -56,7 +58,7 @@ describe('twitter lists parser', () => {
         expect(extractListEntry({ content: { itemContent: {} } }, new Set())).toBeNull();
     });
 
-    it('parses ListsManagementPageTimeline payload instructions', () => {
+    it('parses ListsManagementPageTimeline payload instructions (real shape: nested module items)', () => {
         const payload = {
             data: {
                 viewer: {
@@ -64,23 +66,92 @@ describe('twitter lists parser', () => {
                         timeline: {
                             instructions: [
                                 {
+                                    type: 'TimelineAddEntries',
                                     entries: [
                                         {
-                                            entryId: 'owned-list-1',
+                                            entryId: 'owned-subscribed-list-module-0',
                                             content: {
-                                                itemContent: {
-                                                    list: { id_str: '1', name: 'Crypto', member_count: 44, subscriber_count: 8747, mode: 'Public' },
-                                                },
+                                                entryType: 'TimelineTimelineModule',
+                                                items: [
+                                                    {
+                                                        entryId: 'owned-subscribed-list-module-0-list-1',
+                                                        item: {
+                                                            itemContent: {
+                                                                itemType: 'TimelineTwitterList',
+                                                                list: { id_str: '1', name: 'AI & Agents', member_count: 33, subscriber_count: 0, mode: 'Private' },
+                                                            },
+                                                        },
+                                                    },
+                                                    {
+                                                        entryId: 'owned-subscribed-list-module-0-list-2',
+                                                        item: {
+                                                            itemContent: {
+                                                                itemType: 'TimelineTwitterList',
+                                                                list: { id_str: '2', name: 'Anthropic Team', member_count: 10, subscriber_count: 0, mode: 'Public' },
+                                                            },
+                                                        },
+                                                    },
+                                                ],
+                                            },
+                                        },
+                                    ],
+                                },
+                            ],
+                        },
+                    },
+                },
+            },
+        };
+        const result = parseListsManagement(payload, new Set());
+        expect(result).toHaveLength(2);
+        expect(result[0]).toMatchObject({ id: '1', name: 'AI & Agents', mode: 'private' });
+        expect(result[1]).toMatchObject({ id: '2', name: 'Anthropic Team', mode: 'public' });
+    });
+
+    it('skips "Discover new Lists" recommendations (list-to-follow-module-*)', () => {
+        // 真实 X.com /<user>/lists 响应：Discover 推荐 + Your Lists 同 instruction，
+        // 区别只在 entry.entryId 前缀。Parser 必须按前缀剔除推荐。
+        const payload = {
+            data: {
+                viewer: {
+                    list_management_timeline: {
+                        timeline: {
+                            instructions: [
+                                {
+                                    type: 'TimelineAddEntries',
+                                    entries: [
+                                        {
+                                            entryId: 'list-to-follow-module-2050754937725386752',
+                                            content: {
+                                                entryType: 'TimelineTimelineModule',
+                                                items: [
+                                                    {
+                                                        entryId: 'list-to-follow-module-XYZ-list-1597593475389984769',
+                                                        item: { itemContent: { itemType: 'TimelineTwitterList', list: { id_str: '1597593475389984769', name: 'Crypto', member_count: 44, subscriber_count: 8947, mode: 'Public' } } },
+                                                    },
+                                                    {
+                                                        entryId: 'list-to-follow-module-XYZ-list-1499395616262217730',
+                                                        item: { itemContent: { itemType: 'TimelineTwitterList', list: { id_str: '1499395616262217730', name: 'Crypto Blockchain', member_count: 24, subscriber_count: 1166, mode: 'Public' } } },
+                                                    },
+                                                ],
                                             },
                                         },
                                         {
-                                            entryId: 'subscribed-list-2',
+                                            entryId: 'owned-subscribed-list-module-0',
                                             content: {
-                                                itemContent: {
-                                                    list: { id_str: '2', name: 'AI', member_count: 15, subscriber_count: 0, mode: 'Private' },
-                                                },
+                                                entryType: 'TimelineTimelineModule',
+                                                items: [
+                                                    {
+                                                        entryId: 'owned-subscribed-list-module-0-list-2044679538156912976',
+                                                        item: { itemContent: { itemType: 'TimelineTwitterList', list: { id_str: '2044679538156912976', name: 'AI & Agents', member_count: 33, subscriber_count: 0, mode: 'Private' } } },
+                                                    },
+                                                ],
                                             },
                                         },
+                                        {
+                                            entryId: 'cursor-bottom-2050754937725386750',
+                                            content: { entryType: 'TimelineTimelineCursor' },
+                                        },
                                     ],
                                 },
                             ],
@@ -90,9 +161,19 @@ describe('twitter lists parser', () => {
             },
         };
         const result = parseListsManagement(payload, new Set());
-        expect(result).toHaveLength(2);
-        expect(result[0]).toMatchObject({ id: '1', name: 'Crypto', mode: 'public' });
-        expect(result[1]).toMatchObject({ id: '2', name: 'AI', mode: 'private' });
+        expect(result).toHaveLength(1);
+        expect(result[0]).toMatchObject({ id: '2044679538156912976', name: 'AI & Agents' });
+        // No Crypto/Blockchain leakage
+        expect(result.find(l => l.name === 'Crypto')).toBeUndefined();
+        expect(result.find(l => l.name === 'Crypto Blockchain')).toBeUndefined();
+    });
+
+    it('isOwnedSubscribedEntry classifies entryIds', () => {
+        expect(isOwnedSubscribedEntry({ entryId: 'owned-subscribed-list-module-0' })).toBe(true);
+        expect(isOwnedSubscribedEntry({ entryId: 'list-to-follow-module-2050754937725386752' })).toBe(false);
+        expect(isOwnedSubscribedEntry({ entryId: 'cursor-bottom-XYZ' })).toBe(false);
+        expect(isOwnedSubscribedEntry({})).toBe(false);
+        expect(isOwnedSubscribedEntry({ entryId: null })).toBe(false);
     });
 
     it('returns empty list for malformed payload', () => {
@@ -100,13 +181,23 @@ describe('twitter lists parser', () => {
         expect(parseListsManagement({ data: {} }, new Set())).toEqual([]);
     });
 
-    it('dedupes across repeated entries', () => {
-        const entryA = { content: { itemContent: { list: { id_str: '1', name: 'A' } } } };
+    it('dedupes across repeated entries within owned-subscribed module', () => {
+        const itemA = {
+            entryId: 'owned-subscribed-list-module-0-list-1',
+            item: { itemContent: { list: { id_str: '1', name: 'A' } } },
+        };
         const payload = {
             data: {
                 viewer: {
                     list_management_timeline: {
-                        timeline: { instructions: [{ entries: [entryA, entryA] }] },
+                        timeline: {
+                            instructions: [{
+                                entries: [{
+                                    entryId: 'owned-subscribed-list-module-0',
+                                    content: { items: [itemA, itemA] },
+                                }],
+                            }],
+                        },
                     },
                 },
             },
@@ -114,4 +205,49 @@ describe('twitter lists parser', () => {
         const result = parseListsManagement(payload, new Set());
         expect(result).toHaveLength(1);
     });
+
+    it('fails malformed command payloads as parser drift instead of empty success', async () => {
+        const command = getRegistry().get('twitter/lists');
+        const page = {
+            getCookies: async () => [{ name: 'ct0', value: 'token' }],
+            evaluate: async (script) => {
+                if (script.includes('placeholder.json')) return null;
+                return { data: {} };
+            },
+        };
+
+        await expect(command.func(page, { limit: 10 })).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('treats a recommendation-only timeline as a true empty result', async () => {
+        const command = getRegistry().get('twitter/lists');
+        const page = {
+            getCookies: async () => [{ name: 'ct0', value: 'token' }],
+            evaluate: async (script) => {
+                if (script.includes('placeholder.json')) return null;
+                return {
+                    data: {
+                        viewer: {
+                            list_management_timeline: {
+                                timeline: {
+                                    instructions: [{
+                                        entries: [{
+                                            entryId: 'list-to-follow-module-1',
+                                            content: {
+                                                items: [{
+                                                    item: { itemContent: { list: { id_str: '9', name: 'Recommended' } } },
+                                                }],
+                                            },
+                                        }],
+                                    }],
+                                },
+                            },
+                        },
+                    },
+                };
+            },
+        };
+
+        await expect(command.func(page, { limit: 10 })).rejects.toBeInstanceOf(EmptyResultError);
+    });
 });