@kaelio/ktx 0.5.0 → 0.7.0

package/dist/context/ingest/adapters/looker/client.test.js

@@ -1,407 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { LookerClient } from './client.js';
-const clientSecretParam = 'client_secret'; // pragma: allowlist secret
-function params() {
-    return {
-        base_url: 'https://example.looker.com',
-        client_id: 'id',
-        [clientSecretParam]: 'credential', // pragma: allowlist secret
-    };
-}
-function sdk(overrides = {}) {
-    const port = {
-        me: vi.fn().mockResolvedValue({ id: '1', display_name: 'API User', email: 'api@example.com' }),
-        search_dashboards: vi.fn().mockResolvedValue([{ id: '10' }]),
-        dashboard: vi.fn().mockResolvedValue({
-            id: '10',
-            title: 'Revenue Dashboard',
-            description: 'Revenue concepts',
-            folder_id: '20',
-            user_id: '1',
-            updated_at: '2026-04-30T00:00:00.000Z',
-            dashboard_elements: [
-                {
-                    id: '99',
-                    title: 'ARR',
-                    look_id: null,
-                    query: {
-                        id: 'q1',
-                        model: 'b2b',
-                        view: 'sales_pipeline',
-                        fields: ['opportunities.arr', 'opportunities.stage'],
-                        filters: { 'opportunities.stage': 'open' },
-                        sorts: ['opportunities.arr desc'],
-                        limit: '500',
-                    },
-                },
-            ],
-        }),
-        search_looks: vi.fn().mockResolvedValue([{ id: '30' }]),
-        search_scheduled_plans: vi.fn().mockResolvedValue([]),
-        look: vi.fn().mockResolvedValue({
-            id: '30',
-            title: 'Open Pipeline ARR',
-            description: 'ARR for open opportunities',
-            folder_id: '20',
-            user_id: '1',
-            updated_at: '2026-04-30T00:00:00.000Z',
-            query: {
-                id: 'q2',
-                model: 'b2b',
-                view: 'sales_pipeline',
-                fields: ['opportunities.arr'],
-                filters: { 'opportunities.stage': 'open' },
-            },
-        }),
-        all_folders: vi.fn().mockResolvedValue([{ id: '20', name: 'Executive', parent_id: null }]),
-        all_users: vi.fn().mockResolvedValue([{ id: '1', display_name: 'API User', email: 'api@example.com' }]),
-        all_groups: vi.fn().mockResolvedValue([{ id: '2', name: 'Finance' }]),
-        all_connections: vi.fn().mockResolvedValue([
-            {
-                name: 'b2b_sandbox_bq',
-                host: 'warehouse.example.com',
-                database: 'analytics',
-                schema: 'public',
-                dialect_name: 'bigquery_standard_sql',
-            },
-        ]),
-        all_lookml_models: vi
-            .fn()
-            .mockResolvedValue([
-            { name: 'b2b', label: 'B2B', explores: [{ name: 'sales_pipeline', label: 'Sales Pipeline' }] },
-        ]),
-        lookml_model_explore: vi.fn().mockResolvedValue({
-            name: 'sales_pipeline',
-            label: 'Sales Pipeline',
-            description: 'Opportunity pipeline',
-            sql_table_name: 'proj.dataset.opportunities AS opportunities',
-            connection_name: 'b2b_sandbox_bq',
-            view_name: 'opportunities',
-            fields: {
-                dimensions: [{ name: 'opportunities.stage', label: 'Stage', type: 'string', sql: '$' + '{TABLE}.stage' }],
-                measures: [{ name: 'opportunities.arr', label: 'ARR', type: 'sum', sql: '$' + '{TABLE}.arr' }],
-            },
-            joins: [
-                {
-                    name: 'accounts',
-                    type: 'left_outer',
-                    relationship: 'many_to_one',
-                    sql_table_name: 'proj.dataset.accounts',
-                    sql_on: '$' + '{opportunities.account_id} = $' + '{accounts.id}',
-                    from: null,
-                },
-            ],
-        }),
-        run_inline_query: vi.fn().mockResolvedValue('[]'),
-        logout: vi.fn().mockResolvedValue(undefined),
-        ...overrides,
-    };
-    return port;
-}
-describe('LookerClient', () => {
-    it('validates credentials with me()', async () => {
-        const client = new LookerClient(params(), { sdkFactory: () => sdk() });
-        await expect(client.testConnection()).resolves.toEqual({
-            success: true,
-            metadata: { userId: '1', displayName: 'API User', email: 'api@example.com' },
-        });
-    });
-    it('does not warn to console when optional prioritization inputs fail by default', async () => {
-        const warn = vi.spyOn(console, 'warn').mockImplementation(() => undefined);
-        const fakeSdk = sdk({
-            search_dashboards: vi.fn().mockRejectedValue(new Error('dashboards unavailable')),
-            search_looks: vi.fn().mockRejectedValue(new Error('looks unavailable')),
-        });
-        const client = new LookerClient(params(), { sdkFactory: () => fakeSdk });
-        await expect(client.getSignals()).resolves.toMatchObject({
-            dashboardUsage: [],
-            lookUsage: [],
-            scheduledPlans: [],
-            favorites: [],
-        });
-        expect(warn).not.toHaveBeenCalled();
-    });
-    it('maps dashboards, looks, folders, models, explores, users, and groups to staged DTOs', async () => {
-        const fakeSdk = sdk();
-        const client = new LookerClient(params(), { sdkFactory: () => fakeSdk });
-        await expect(client.listDashboards()).resolves.toEqual([{ id: '10', updatedAt: null }]);
-        await expect(client.getDashboard('10')).resolves.toMatchObject({
-            lookerId: '10',
-            title: 'Revenue Dashboard',
-            tiles: [{ id: '99', query: { model: 'b2b', view: 'sales_pipeline' } }],
-        });
-        await expect(client.listLooks()).resolves.toEqual([{ id: '30', updatedAt: null }]);
-        await expect(client.getLook('30')).resolves.toMatchObject({
-            lookerId: '30',
-            title: 'Open Pipeline ARR',
-            query: { model: 'b2b', view: 'sales_pipeline' },
-        });
-        await expect(client.listFolders()).resolves.toEqual({
-            folders: [{ id: '20', name: 'Executive', parentId: null, path: ['Executive'] }],
-        });
-        await expect(client.listLookmlModels()).resolves.toEqual({
-            models: [{ name: 'b2b', label: 'B2B', explores: [{ name: 'sales_pipeline', label: 'Sales Pipeline' }] }],
-        });
-        await expect(client.listLookerConnections()).resolves.toEqual([
-            {
-                name: 'b2b_sandbox_bq',
-                host: 'warehouse.example.com',
-                database: 'analytics',
-                schema: 'public',
-                dialect: 'bigquery_standard_sql',
-            },
-        ]);
-        await expect(client.getExplore('b2b', 'sales_pipeline')).resolves.toMatchObject({
-            modelName: 'b2b',
-            exploreName: 'sales_pipeline',
-            rawSqlTableName: 'proj.dataset.opportunities AS opportunities',
-            connectionName: 'b2b_sandbox_bq',
-            viewName: 'opportunities',
-            fields: { dimensions: [{ name: 'opportunities.stage' }], measures: [{ name: 'opportunities.arr' }] },
-            joins: [
-                {
-                    name: 'accounts',
-                    rawSqlTableName: 'proj.dataset.accounts',
-                    sqlOn: '$' + '{opportunities.account_id} = $' + '{accounts.id}',
-                    from: null,
-                    targetTable: null,
-                },
-            ],
-            targetWarehouseConnectionId: null,
-            targetTable: null,
-        });
-        expect(fakeSdk.dashboard).toHaveBeenCalledWith('10', 'id,title,description,folder_id,user_id,updated_at,dashboard_elements(id,title,look_id,query(id,model,view,fields,filters,sorts,limit,dynamic_fields))');
-        expect(fakeSdk.look).toHaveBeenCalledWith('30', 'id,title,description,folder_id,user_id,updated_at,query(id,model,view,fields,filters,sorts,limit,dynamic_fields)');
-        expect(fakeSdk.lookml_model_explore).toHaveBeenCalledWith('b2b', 'sales_pipeline', 'name,label,description,sql_table_name,connection_name,view_name,fields,joins(name,type,relationship,sql_table_name,sql_on,from)');
-        expect(fakeSdk.all_connections).toHaveBeenCalledWith('name,host,database,schema,dialect_name');
-    });
-    it('returns empty usage signals when system activity access fails', async () => {
-        const client = new LookerClient(params(), {
-            sdkFactory: () => sdk({
-                run_inline_query: vi.fn().mockRejectedValue(new Error('access denied')),
-                search_dashboards: vi.fn().mockResolvedValue([{ id: '10', favorite_count: 4 }]),
-                search_looks: vi.fn().mockResolvedValue([{ id: '30', favorite_count: 2 }]),
-                search_scheduled_plans: vi.fn().mockResolvedValue([]),
-            }),
-        });
-        await expect(client.getSignals()).resolves.toEqual({
-            dashboardUsage: [],
-            lookUsage: [],
-            scheduledPlans: [],
-            favorites: [
-                { contentId: '10', contentType: 'dashboard', favoriteCount: 4 },
-                { contentId: '30', contentType: 'look', favoriteCount: 2 },
-            ],
-        });
-    });
-    it('paginates dashboard and Look searches', async () => {
-        const dashboardPageOne = Array.from({ length: 500 }, (_, index) => ({ id: String(index + 1) }));
-        const lookPageOne = Array.from({ length: 500 }, (_, index) => ({ id: String(index + 1001) }));
-        const fakeSdk = sdk({
-            search_dashboards: vi
-                .fn()
-                .mockResolvedValueOnce(dashboardPageOne)
-                .mockResolvedValueOnce([{ id: '501' }]),
-            search_looks: vi
-                .fn()
-                .mockResolvedValueOnce(lookPageOne)
-                .mockResolvedValueOnce([{ id: '1501' }]),
-        });
-        const client = new LookerClient(params(), { sdkFactory: () => fakeSdk });
-        await expect(client.listDashboards()).resolves.toHaveLength(501);
-        await expect(client.listLooks()).resolves.toHaveLength(501);
-        expect(fakeSdk.search_dashboards).toHaveBeenNthCalledWith(1, expect.objectContaining({
-            deleted: false,
-            fields: 'id,updated_at',
-            limit: 500,
-            offset: 0,
-            sorts: 'id',
-        }));
-        expect(fakeSdk.search_dashboards).toHaveBeenNthCalledWith(2, expect.objectContaining({
-            limit: 500,
-            offset: 500,
-        }));
-        expect(fakeSdk.search_looks).toHaveBeenNthCalledWith(1, expect.objectContaining({
-            deleted: false,
-            fields: 'id,updated_at',
-            limit: 500,
-            offset: 0,
-            sorts: 'id',
-        }));
-        expect(fakeSdk.search_looks).toHaveBeenNthCalledWith(2, expect.objectContaining({
-            limit: 500,
-            offset: 500,
-        }));
-    });
-    it('returns updatedAt cursors from dashboard and Look listing rows', async () => {
-        const fakeSdk = sdk({
-            search_dashboards: vi.fn().mockResolvedValue([{ id: '10', updated_at: '2026-04-30T12:00:00.000Z' }]),
-            search_looks: vi.fn().mockResolvedValue([{ id: '30', updated_at: '2026-04-30T11:00:00.000Z' }]),
-        });
-        const client = new LookerClient(params(), { sdkFactory: () => fakeSdk });
-        await expect(client.listDashboards()).resolves.toEqual([{ id: '10', updatedAt: '2026-04-30T12:00:00.000Z' }]);
-        await expect(client.listLooks()).resolves.toEqual([{ id: '30', updatedAt: '2026-04-30T11:00:00.000Z' }]);
-    });
-    it('logs out the SDK session during cleanup', async () => {
-        const fakeSdk = sdk();
-        const client = new LookerClient(params(), { sdkFactory: () => fakeSdk });
-        await client.testConnection();
-        await client.cleanup();
-        expect(fakeSdk.logout).toHaveBeenCalledTimes(1);
-    });
-    it('aggregates usage, scheduled-plan, and favorite signals', async () => {
-        const runInlineQuery = vi
-            .fn()
-            .mockResolvedValueOnce(JSON.stringify([
-            {
-                'dashboard.id': '10',
-                'history.query_run_count': 3,
-                'history.created_date': '2026-04-30',
-                'user.id': 'user-1',
-            },
-            {
-                'dashboard.id': '10',
-                'history.query_run_count': '2',
-                'history.created_date': '2026-04-29',
-                'user.id': 'user-2',
-            },
-        ]))
-            .mockResolvedValueOnce(JSON.stringify([
-            {
-                'look.id': '30',
-                'history.query_run_count': 7,
-                'history.created_date': '2026-04-28',
-                'user.id': 'user-1',
-            },
-        ]));
-        const fakeSdk = sdk({
-            run_inline_query: runInlineQuery,
-            search_dashboards: vi.fn().mockResolvedValueOnce([{ id: '10', favorite_count: 4 }]),
-            search_looks: vi.fn().mockResolvedValueOnce([{ id: '30', favorite_count: 2 }]),
-            search_scheduled_plans: vi.fn().mockResolvedValueOnce([
-                {
-                    id: 'sp-dashboard',
-                    dashboard_id: '10',
-                    look_id: null,
-                    enabled: true,
-                    scheduled_plan_destination: [{ id: 'dest-1' }, { id: 'dest-2' }],
-                },
-                {
-                    id: 'sp-look',
-                    dashboard_id: null,
-                    look_id: '30',
-                    enabled: true,
-                    scheduled_plan_destination: [{ id: 'dest-3' }],
-                },
-            ]),
-        });
-        const client = new LookerClient(params(), { sdkFactory: () => fakeSdk });
-        await expect(client.getSignals()).resolves.toEqual({
-            dashboardUsage: [
-                {
-                    contentId: '10',
-                    queryCount30d: 5,
-                    uniqueUsers30d: 2,
-                    lastRunAt: '2026-04-30',
-                    topUsers: ['user-1', 'user-2'],
-                },
-            ],
-            lookUsage: [
-                {
-                    contentId: '30',
-                    queryCount30d: 7,
-                    uniqueUsers30d: 1,
-                    lastRunAt: '2026-04-28',
-                    topUsers: ['user-1'],
-                },
-            ],
-            scheduledPlans: [
-                {
-                    contentId: '10',
-                    contentType: 'dashboard',
-                    isScheduled: true,
-                    scheduleCount: 1,
-                    recipientCount: 2,
-                },
-                {
-                    contentId: '30',
-                    contentType: 'look',
-                    isScheduled: true,
-                    scheduleCount: 1,
-                    recipientCount: 1,
-                },
-            ],
-            favorites: [
-                { contentId: '10', contentType: 'dashboard', favoriteCount: 4 },
-                { contentId: '30', contentType: 'look', favoriteCount: 2 },
-            ],
-        });
-        expect(runInlineQuery).toHaveBeenNthCalledWith(1, expect.objectContaining({
-            result_format: 'json',
-            body: expect.objectContaining({
-                model: 'system__activity',
-                view: 'history',
-                fields: ['dashboard.id', 'history.query_run_count', 'history.created_date', 'user.id'],
-            }),
-        }));
-        expect(fakeSdk.search_scheduled_plans).toHaveBeenCalledWith(expect.objectContaining({
-            all_users: true,
-            fields: 'id,dashboard_id,look_id,enabled,scheduled_plan_destination',
-            limit: 500,
-            offset: 0,
-            sorts: 'id',
-        }));
-    });
-    it('retries a 429 response once using Retry-After seconds', async () => {
-        const sleep = vi.fn().mockResolvedValue(undefined);
-        const rateLimitError = new Error('rate limited');
-        Object.assign(rateLimitError, { statusCode: 429, headers: { 'retry-after': '2' } });
-        const fakeSdk = sdk({
-            search_dashboards: vi
-                .fn()
-                .mockRejectedValueOnce(rateLimitError)
-                .mockResolvedValueOnce([{ id: '10' }]),
-        });
-        const client = new LookerClient(params(), { sdkFactory: () => fakeSdk, sleep });
-        await expect(client.listDashboards()).resolves.toEqual([{ id: '10', updatedAt: null }]);
-        expect(sleep).toHaveBeenCalledWith(2000);
-        expect(fakeSdk.search_dashboards).toHaveBeenCalledTimes(2);
-    });
-    it('does not retry non-429 errors', async () => {
-        const sleep = vi.fn().mockResolvedValue(undefined);
-        const error = new Error('broken dashboard');
-        Object.assign(error, { statusCode: 500 });
-        const fakeSdk = sdk({ dashboard: vi.fn().mockRejectedValue(error) });
-        const client = new LookerClient(params(), { sdkFactory: () => fakeSdk, sleep });
-        await expect(client.getDashboard('10')).rejects.toThrow('broken dashboard');
-        expect(sleep).not.toHaveBeenCalled();
-        expect(fakeSdk.dashboard).toHaveBeenCalledTimes(1);
-    });
-    it('initializes the real @looker/sdk-node SDK with inline credentials without throwing', async () => {
-        const client = new LookerClient(params());
-        const result = await client.testConnection();
-        // Without injected sdkFactory the real SDK is constructed via InlineLookerSettings.
-        // This used to throw "Missing required configuration values like base_url" because
-        // the parent NodeSettingsIniFile constructor validated config before the override
-        // could supply credentials. Whatever happens now (auth/network failure against the
-        // bogus example URL is fine) — what must NOT happen is a synchronous SDK-init throw.
-        expect(result.success).toBe(false);
-        expect(result.error).toBeDefined();
-        expect(result.error).not.toMatch(/Missing required configuration values/i);
-        await client.cleanup();
-    });
-    it('strips trailing /api/4.0 from base_url so the SDK does not double-prefix it', async () => {
-        const clientWithSuffix = new LookerClient({
-            base_url: 'https://example.looker.com/api/4.0',
-            client_id: 'id',
-            [clientSecretParam]: 'credential', // pragma: allowlist secret
-        });
-        const result = await clientWithSuffix.testConnection();
-        expect(result.success).toBe(false);
-        // If base_url is double-prefixed the SDK would hit /api/4.0/api/4.0/login. Either
-        // the URL is correctly normalized (transport-level network failure) or we'd see a
-        // 404/HTML response — either way the stack must not be a config-validation throw.
-        expect(result.error).not.toMatch(/Missing required configuration values/i);
-        await clientWithSuffix.cleanup();
-    });
-});

package/dist/context/ingest/adapters/looker/daemon-table-identifier-parser.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/context/ingest/adapters/looker/daemon-table-identifier-parser.test.js

@@ -1,40 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { createDaemonLookerTableIdentifierParser } from './daemon-table-identifier-parser.js';
-describe('createDaemonLookerTableIdentifierParser', () => {
-    it('posts parse items to the daemon endpoint', async () => {
-        const requestJson = vi.fn(async () => ({
-            results: {
-                orders: {
-                    ok: true,
-                    catalog: null,
-                    schema: 'public',
-                    name: 'orders',
-                    canonical_table: 'public.orders',
-                },
-            },
-        }));
-        const parser = createDaemonLookerTableIdentifierParser({
-            baseUrl: 'http://127.0.0.1:8765',
-            requestJson,
-        });
-        await expect(parser.parse([{ key: 'orders', sql_table_name: 'public.orders', dialect: 'postgres' }])).resolves.toEqual({
-            orders: {
-                ok: true,
-                catalog: null,
-                schema: 'public',
-                name: 'orders',
-                canonical_table: 'public.orders',
-            },
-        });
-        expect(requestJson).toHaveBeenCalledWith('/sql/parse-table-identifier', {
-            items: [{ key: 'orders', sql_table_name: 'public.orders', dialect: 'postgres' }],
-        });
-    });
-    it('rejects non-object daemon responses', async () => {
-        const parser = createDaemonLookerTableIdentifierParser({
-            baseUrl: 'http://127.0.0.1:8765',
-            requestJson: async () => ({ results: null }),
-        });
-        await expect(parser.parse([])).rejects.toThrow('ktx-daemon table identifier parser returned invalid results');
-    });
-});

package/dist/context/ingest/adapters/looker/detect.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/context/ingest/adapters/looker/detect.test.js

@@ -1,39 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { detectLookerStagedDir } from './detect.js';
-async function touch(stagedDir, relPath, body = '{}\n') {
-    const abs = join(stagedDir, relPath);
-    await mkdir(join(abs, '..'), { recursive: true });
-    await writeFile(abs, body, 'utf-8');
-}
-describe('detectLookerStagedDir', () => {
-    let stagedDir;
-    beforeEach(async () => {
-        stagedDir = await mkdtemp(join(tmpdir(), 'looker-detect-'));
-    });
-    afterEach(async () => {
-        await rm(stagedDir, { recursive: true, force: true });
-    });
-    it('returns true when sync-config.json and at least one runtime entity are present', async () => {
-        await touch(stagedDir, 'sync-config.json');
-        await touch(stagedDir, 'explores/b2b/sales_pipeline.json');
-        expect(await detectLookerStagedDir(stagedDir)).toBe(true);
-    });
-    it('returns true for dashboard-only staged dirs', async () => {
-        await touch(stagedDir, 'sync-config.json');
-        await touch(stagedDir, 'dashboards/10.json');
-        expect(await detectLookerStagedDir(stagedDir)).toBe(true);
-    });
-    it('returns false without sync-config.json', async () => {
-        await touch(stagedDir, 'looks/20.json');
-        expect(await detectLookerStagedDir(stagedDir)).toBe(false);
-    });
-    it('returns false when only control files are present', async () => {
-        await touch(stagedDir, 'sync-config.json');
-        await touch(stagedDir, 'lookml_models.json');
-        await touch(stagedDir, 'signals/dashboard_usage.json', '[]\n');
-        expect(await detectLookerStagedDir(stagedDir)).toBe(false);
-    });
-});

package/dist/context/ingest/adapters/looker/evidence-documents.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/context/ingest/adapters/looker/evidence-documents.test.js

@@ -1,178 +0,0 @@
-import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { getLookerTriageSignals, writeLookerEvidenceDocuments } from './evidence-documents.js';
-async function writeJson(root, relPath, value) {
-    const target = join(root, relPath);
-    await mkdir(dirname(target), { recursive: true });
-    await writeFile(target, `${JSON.stringify(value, null, 2)}\n`, 'utf-8');
-}
-async function readJson(root, relPath) {
-    return JSON.parse(await readFile(join(root, relPath), 'utf-8'));
-}
-describe('Looker evidence documents', () => {
-    let stagedDir;
-    beforeEach(async () => {
-        stagedDir = await mkdtemp(join(tmpdir(), 'looker-evidence-docs-'));
-        await writeJson(stagedDir, 'explores/b2b/sales_pipeline.json', {
-            modelName: 'b2b',
-            exploreName: 'sales_pipeline',
-            label: 'Sales Pipeline',
-            description: 'Pipeline analysis explore.',
-            fields: {
-                dimensions: [
-                    { name: 'opportunities.stage', label: 'Stage', type: 'string', sql: '${TABLE}.stage', description: null },
-                ],
-                measures: [
-                    {
-                        name: 'opportunities.arr',
-                        label: 'ARR',
-                        type: 'sum',
-                        sql: '${TABLE}.arr',
-                        description: 'Annual recurring revenue.',
-                    },
-                ],
-            },
-            joins: [{ name: 'accounts', type: 'left_outer', relationship: 'many_to_one' }],
-        });
-        await writeJson(stagedDir, 'dashboards/10.json', {
-            lookerId: '10',
-            title: 'Sales Pipeline Overview',
-            description: 'Executive dashboard for open pipeline ARR.',
-            folderId: '7',
-            ownerId: '3',
-            updatedAt: '2026-04-30T10:00:00.000Z',
-            tiles: [
-                {
-                    id: '100',
-                    title: 'Open Pipeline ARR',
-                    lookId: null,
-                    query: {
-                        model: 'b2b',
-                        view: 'sales_pipeline',
-                        fields: ['opportunities.arr', 'opportunities.stage'],
-                        filters: { 'opportunities.stage': 'open' },
-                        sorts: ['opportunities.arr desc'],
-                        limit: '500',
-                    },
-                },
-            ],
-        });
-        await writeJson(stagedDir, 'looks/20.json', {
-            lookerId: '20',
-            title: 'Active Opportunity Pipeline',
-            description: 'Saved Look for active opportunity pipeline review.',
-            folderId: '7',
-            ownerId: '3',
-            updatedAt: '2026-04-30T11:00:00.000Z',
-            query: {
-                model: 'b2b',
-                view: 'sales_pipeline',
-                fields: ['opportunities.arr'],
-                filters: { 'opportunities.stage': 'open' },
-                sorts: [],
-                limit: '500',
-            },
-        });
-        await writeJson(stagedDir, 'signals/dashboard_usage.json', [
-            {
-                contentId: '10',
-                queryCount30d: 80,
-                uniqueUsers30d: 12,
-                lastRunAt: '2026-04-30T09:00:00.000Z',
-                topUsers: ['3'],
-            },
-        ]);
-        await writeJson(stagedDir, 'signals/look_usage.json', [
-            {
-                contentId: '20',
-                queryCount30d: 2,
-                uniqueUsers30d: 1,
-                lastRunAt: '2026-04-29T09:00:00.000Z',
-                topUsers: ['3'],
-            },
-        ]);
-        await writeJson(stagedDir, 'signals/scheduled_plans.json', [
-            { contentId: '10', contentType: 'dashboard', isScheduled: true, scheduleCount: 2, recipientCount: 5 },
-        ]);
-        await writeJson(stagedDir, 'signals/favorites.json', [
-            { contentId: '10', contentType: 'dashboard', favoriteCount: 4 },
-        ]);
-    });
-    afterEach(async () => {
-        await rm(stagedDir, { recursive: true, force: true });
-    });
-    it('writes indexable metadata and markdown for explores, dashboards, and Looks', async () => {
-        await writeLookerEvidenceDocuments(stagedDir);
-        await expect(readJson(stagedDir, 'evidence/explores/b2b/sales_pipeline/metadata.json')).resolves.toMatchObject({
-            objectType: 'looker_explore',
-            id: 'looker:explore:b2b.sales_pipeline',
-            title: 'Sales Pipeline',
-            path: 'Looker / Explores / b2b.sales_pipeline',
-            properties: {
-                rawPath: 'explores/b2b/sales_pipeline.json',
-                modelName: 'b2b',
-                exploreName: 'sales_pipeline',
-            },
-        });
-        await expect(readJson(stagedDir, 'evidence/dashboards/10/metadata.json')).resolves.toMatchObject({
-            objectType: 'looker_dashboard',
-            id: 'looker:dashboard:10',
-            title: 'Sales Pipeline Overview',
-            path: 'Looker / Dashboards / Sales Pipeline Overview',
-            lastEditedAt: '2026-04-30T10:00:00.000Z',
-            properties: {
-                rawPath: 'dashboards/10.json',
-                lookerId: '10',
-            },
-        });
-        await expect(readJson(stagedDir, 'evidence/looks/20/metadata.json')).resolves.toMatchObject({
-            objectType: 'looker_look',
-            id: 'looker:look:20',
-            title: 'Active Opportunity Pipeline',
-            path: 'Looker / Looks / Active Opportunity Pipeline',
-            properties: {
-                rawPath: 'looks/20.json',
-                lookerId: '20',
-            },
-        });
-        const dashboardMarkdown = await readFile(join(stagedDir, 'evidence/dashboards/10/page.md'), 'utf-8');
-        expect(dashboardMarkdown).toContain('# Sales Pipeline Overview');
-        expect(dashboardMarkdown).toContain('Executive dashboard for open pipeline ARR.');
-        expect(dashboardMarkdown).toContain('## Tile: Open Pipeline ARR');
-        expect(dashboardMarkdown).toContain('- model: b2b');
-        expect(dashboardMarkdown).toContain('- explore: sales_pipeline');
-        expect(dashboardMarkdown).toContain('- opportunities.stage = open');
-        expect(dashboardMarkdown).not.toContain('80');
-        expect(dashboardMarkdown).not.toContain('queryCount30d');
-        expect(dashboardMarkdown).not.toContain('recipient');
-        expect(dashboardMarkdown).not.toContain('favorite');
-        expect(dashboardMarkdown).not.toContain('owner');
-    });
-    it('returns usage-aware triage signals without exposing usage as document prose', async () => {
-        await writeLookerEvidenceDocuments(stagedDir);
-        await expect(getLookerTriageSignals(stagedDir, 'looker:dashboard:10')).resolves.toEqual({
-            objectType: 'looker_dashboard',
-            propertyHints: {
-                contentType: 'dashboard',
-                queryCount30d: '80',
-                uniqueUsers30d: '12',
-                isScheduled: 'true',
-                favoriteCount: '4',
-            },
-            lastEditedAt: '2026-04-30T10:00:00.000Z',
-        });
-        await expect(getLookerTriageSignals(stagedDir, 'looker:look:20')).resolves.toEqual({
-            objectType: 'looker_look',
-            propertyHints: {
-                contentType: 'look',
-                queryCount30d: '2',
-                uniqueUsers30d: '1',
-                isScheduled: 'false',
-                favoriteCount: '0',
-            },
-            lastEditedAt: '2026-04-30T11:00:00.000Z',
-        });
-    });
-});