@telepat/snoopy 0.1.4 → 0.1.8

package/dist/src/services/openrouter/client.js

@@ -16,6 +16,37 @@ const qualifySchema = z.object({
     qualified: z.boolean(),
     reason: z.string().min(1).max(80)
 });
+function toAlphaLabel(index) {
+    const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+    let value = index;
+    let label = '';
+    do {
+        label = `${alphabet[value % 26]}${label}`;
+        value = Math.floor(value / 26) - 1;
+    } while (value >= 0);
+    return label;
+}
+function buildAnonymizedThreadLines(thread, targetAuthor) {
+    const authorLabels = new Map();
+    let nextLabelIndex = 0;
+    return thread.map((comment) => {
+        const author = comment.author || '[deleted]';
+        let displayAuthor = author;
+        if (author !== targetAuthor) {
+            const existingLabel = authorLabels.get(author);
+            if (existingLabel) {
+                displayAuthor = existingLabel;
+            }
+            else {
+                const generatedLabel = `User ${toAlphaLabel(nextLabelIndex)}`;
+                nextLabelIndex += 1;
+                authorLabels.set(author, generatedLabel);
+                displayAuthor = generatedLabel;
+            }
+        }
+        return `- (${displayAuthor}) ${comment.body}`;
+    });
+}
 const QUALIFICATION_TOOL_NAME = 'submit_qualification';
 const QUALIFICATION_TOOL = {
     type: 'function',
@@ -215,17 +246,17 @@ export class OpenRouterClient {
         return this.runQualification(input, userMessage);
     }
     async qualifyCommentThread(input) {
-        const threadText = input.thread
-            .map((comment) => `${comment.author}: ${comment.body}`)
-            .join('\n');
+        const threadText = buildAnonymizedThreadLines(input.thread, input.targetAuthor).join('\n');
         const userMessage = [
             `Post title: ${input.postTitle}`,
             '',
+            `Post body: ${input.postBody}`,
+            '',
             'Comment thread (chronological):',
             threadText,
             '',
-            `Important: decide qualification based on the most recent comment by ${input.targetAuthor}.`,
-            'Use other thread context only for interpretation.'
+            `Important: QUALIFY ONLY the final comment line authored by ${input.targetAuthor}.`,
+            'Treat all earlier lines as context only and do not qualify them.'
         ].join('\n');
         return this.runQualification(input, userMessage);
     }

package/dist/src/services/scheduler/jobRunner.js

@@ -308,6 +308,7 @@ export class JobRunner {
                             modelSettings,
                             qualificationPrompt: job.qualificationPrompt,
                             postTitle: post.title,
+                            postBody: post.body,
                             targetAuthor: author,
                             thread
                         });
@@ -334,7 +335,15 @@ export class JobRunner {
                             promptTokens: result.promptTokens,
                             completionTokens: result.completionTokens,
                             estimatedCostUsd: this.estimateCost(result.promptTokens, result.completionTokens),
-                            qualificationReason: result.reason
+                            qualificationReason: result.reason,
+                            commentThreadNodes: thread.map((threadComment, index) => ({
+                                redditCommentId: threadComment.id,
+                                parentRedditCommentId: index === 0 ? null : thread[index - 1]?.id ?? null,
+                                author: threadComment.author,
+                                body: threadComment.body,
+                                depth: index,
+                                isTarget: index === thread.length - 1
+                            }))
                         });
                         runStats.itemsNew += 1;
                         if (result.qualified) {

package/dist/src/services/startup/index.js

@@ -5,8 +5,7 @@ import { execSync } from 'node:child_process';
 import { hasSystemdUser, installLinuxSystemd, uninstallLinuxSystemd } from './linuxSystemd.js';
 import { installLinuxCronFallback, uninstallLinuxCronFallback } from './linuxCronFallback.js';
 import { installMacStartup, uninstallMacStartup } from './macosLaunchd.js';
-import { installWindowsRunFallback, uninstallWindowsRunFallback } from './windowsRunFallback.js';
-import { installWindowsTask, uninstallWindowsTask } from './windowsTaskScheduler.js';
+import { hasWindowsTaskInstalled, installWindowsTask, uninstallWindowsTask } from './windowsTaskScheduler.js';
 export function installStartup(commandPath) {
     if (process.platform === 'darwin') {
         const detail = installMacStartup(commandPath);
@@ -21,13 +20,19 @@ export function installStartup(commandPath) {
         return { success: true, method: 'cron-@reboot', detail: 'crontab entry installed' };
     }
     if (process.platform === 'win32') {
+        // On Windows we intentionally use a single explicit method.
+        // If task creation fails, we do not silently fall back to registry persistence.
         try {
             installWindowsTask(commandPath);
             return { success: true, method: 'task-scheduler', detail: 'Task Scheduler job created' };
         }
-        catch {
-            installWindowsRunFallback(commandPath);
-            return { success: true, method: 'registry-run', detail: 'Registry startup entry created' };
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                success: false,
+                method: 'task-scheduler',
+                detail: `Task Scheduler startup setup failed: ${message}`
+            };
         }
     }
     return { success: false, method: 'unsupported', detail: 'Unsupported platform' };
@@ -42,7 +47,6 @@ export function uninstallStartup() {
     }
     if (process.platform === 'win32') {
         uninstallWindowsTask();
-        uninstallWindowsRunFallback();
     }
 }
 export function getStartupStatus() {
@@ -82,34 +86,18 @@ export function getStartupStatus() {
         }
     }
     if (process.platform === 'win32') {
-        try {
-            execSync('schtasks /query /tn "Snoopy\\Daemon"', { shell: 'cmd.exe', stdio: 'ignore' });
+        if (hasWindowsTaskInstalled()) {
             return {
                 enabled: true,
                 method: 'task-scheduler',
                 detail: 'Scheduled task exists'
             };
         }
-        catch {
-            try {
-                execSync('reg query "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run" /v "SnoopyDaemon"', {
-                    shell: 'cmd.exe',
-                    stdio: 'ignore'
-                });
-                return {
-                    enabled: true,
-                    method: 'registry-run',
-                    detail: 'Registry startup entry exists'
-                };
-            }
-            catch {
-                return {
-                    enabled: false,
-                    method: 'task-scheduler',
-                    detail: 'No startup registration found'
-                };
-            }
-        }
+        return {
+            enabled: false,
+            method: 'task-scheduler',
+            detail: 'No startup registration found'
+        };
     }
     return {
         enabled: false,

package/dist/src/services/startup/windowsTaskScheduler.d.ts

@@ -1,2 +1,3 @@
 export declare function installWindowsTask(commandPath: string): void;
 export declare function uninstallWindowsTask(): void;
+export declare function hasWindowsTaskInstalled(): boolean;

package/dist/src/services/startup/windowsTaskScheduler.js

@@ -1,16 +1,36 @@
-import { execSync } from 'node:child_process';
+import { execFileSync } from 'node:child_process';
 const TASK_NAME = 'Snoopy\\Daemon';
+function validateWindowsStartupCommandPath(commandPath) {
+    const trimmedPath = commandPath.trim();
+    const isAbsoluteWindowsPath = /^[a-zA-Z]:[\\/]/.test(trimmedPath);
+    if (!trimmedPath || !isAbsoluteWindowsPath || /["\r\n]/.test(trimmedPath)) {
+        throw new Error('Startup command path must be an absolute Windows path without quotes or newlines.');
+    }
+}
 export function installWindowsTask(commandPath) {
+    // Startup persistence is explicit user opt-in through startup commands.
+    // Use execFileSync argument arrays to avoid cmd.exe parsing/injection risks.
+    validateWindowsStartupCommandPath(commandPath);
     const runTarget = `"${commandPath}" daemon run`;
-    const command = `schtasks /create /tn "${TASK_NAME}" /tr ${JSON.stringify(runTarget)} /sc onlogon /f`;
-    execSync(command, { shell: 'cmd.exe' });
+    execFileSync('schtasks', ['/create', '/tn', TASK_NAME, '/tr', runTarget, '/sc', 'onlogon', '/f'], {
+        stdio: 'pipe'
+    });
 }
 export function uninstallWindowsTask() {
     try {
-        execSync(`schtasks /delete /tn "${TASK_NAME}" /f`, { shell: 'cmd.exe' });
+        execFileSync('schtasks', ['/delete', '/tn', TASK_NAME, '/f'], { stdio: 'pipe' });
     }
     catch {
         // Ignore when task does not exist.
     }
 }
+export function hasWindowsTaskInstalled() {
+    try {
+        execFileSync('schtasks', ['/query', '/tn', TASK_NAME], { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 //# sourceMappingURL=windowsTaskScheduler.js.map

package/dist/src/ui/components/JobsTable.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { JobSummaryRow } from '../../services/db/repositories/jobsRepo.js';
+interface JobsTableProps {
+    jobs: JobSummaryRow[];
+    onExit: () => void;
+}
+export declare function JobsTable({ jobs, onExit }: JobsTableProps): React.JSX.Element;
+export {};

package/dist/src/ui/components/JobsTable.js

@@ -0,0 +1,78 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, Text, useInput, useStdout } from 'ink';
+import { uiTheme } from '../theme.js';
+import { AppFrame, Panel } from './AppFrame.js';
+import { buildJobDetailLines, computeJobColumnWidths, computeScrollWindow, formatJobHeaderRow, formatJobTableRow } from './jobsTableModel.js';
+const WINDOW_SIZE = 10;
+const COL_SEP = '  ';
+export function JobsTable({ jobs, onExit }) {
+    const { stdout } = useStdout();
+    const terminalRows = stdout?.rows ?? 24;
+    const maxWindow = Math.max(1, Math.min(WINDOW_SIZE, terminalRows - 8));
+    const [view, setView] = useState('list');
+    const [cursor, setCursor] = useState(0);
+    const [scrollTop, setScrollTop] = useState(0);
+    const widths = computeJobColumnWidths(jobs);
+    const header = formatJobHeaderRow(widths);
+    const { scrollTop: nextScrollTop, visibleStart, visibleEnd } = computeScrollWindow(cursor, scrollTop, jobs.length, maxWindow);
+    if (nextScrollTop !== scrollTop) {
+        setScrollTop(nextScrollTop);
+    }
+    const visibleJobs = jobs.slice(visibleStart, visibleEnd);
+    const aboveCount = visibleStart;
+    const belowCount = jobs.length - visibleEnd;
+    useInput((input, key) => {
+        if (view === 'list') {
+            if (key.upArrow) {
+                const next = Math.max(0, cursor - 1);
+                setCursor(next);
+                setScrollTop(computeScrollWindow(next, scrollTop, jobs.length, maxWindow).scrollTop);
+                return;
+            }
+            if (key.downArrow) {
+                const next = Math.min(jobs.length - 1, cursor + 1);
+                setCursor(next);
+                setScrollTop(computeScrollWindow(next, scrollTop, jobs.length, maxWindow).scrollTop);
+                return;
+            }
+            if (key.return) {
+                setView('detail');
+                return;
+            }
+            if (input === 'q' || input === 'Q') {
+                onExit();
+            }
+            return;
+        }
+        // detail view
+        if (key.escape || key.leftArrow) {
+            setView('list');
+            return;
+        }
+        if (input === 'q' || input === 'Q') {
+            onExit();
+        }
+    });
+    if (view === 'detail') {
+        const job = jobs[cursor];
+        if (!job)
+            return _jsx(_Fragment, {});
+        const detailLines = buildJobDetailLines(job);
+        return (_jsx(AppFrame, { subtitle: "Jobs", statusText: `${cursor + 1} / ${jobs.length}`, statusTone: "info", hints: ['← back', 'q quit'], children: _jsx(Panel, { title: job.jobName, children: detailLines.map((line) => (_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: uiTheme.ink.info, children: line.label.padEnd(12) }), _jsx(Text, { color: uiTheme.ink.textPrimary, children: line.value })] }, line.label))) }) }));
+    }
+    return (_jsx(AppFrame, { subtitle: "Jobs", statusText: `${cursor + 1} / ${jobs.length}`, statusTone: "info", hints: ['↑↓ navigate', '↵ details', 'q quit'], children: _jsxs(Box, { flexDirection: "column", marginTop: 1, paddingLeft: 1, children: [_jsx(Box, { flexDirection: "row", children: header.map((cell, i) => (_jsxs(Text, { bold: true, color: uiTheme.ink.accent, children: [i > 0 ? COL_SEP : '', cell] }, i))) }), aboveCount > 0 && (_jsxs(Text, { color: uiTheme.ink.textMuted, children: ["  \u2191 ", aboveCount, " more"] })), visibleJobs.map((job, idx) => {
+                    const absoluteIndex = visibleStart + idx;
+                    const isSelected = absoluteIndex === cursor;
+                    const cells = formatJobTableRow(job, widths);
+                    return (_jsx(Box, { flexDirection: "row", children: cells.map((cell, i) => {
+                            const color = isSelected
+                                ? uiTheme.ink.focus
+                                : i === 0
+                                    ? uiTheme.ink.textPrimary
+                                    : uiTheme.ink.textMuted;
+                            return (_jsxs(Text, { color: color, inverse: isSelected && i === 0, bold: isSelected && i === 0, children: [i > 0 ? COL_SEP : '', cell] }, i));
+                        }) }, job.jobId));
+                }), belowCount > 0 && (_jsxs(Text, { color: uiTheme.ink.textMuted, children: ["  \u2193 ", belowCount, " more"] }))] }) }));
+}
+//# sourceMappingURL=JobsTable.js.map

package/dist/src/ui/components/ResultsViewer.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { type ResultsViewerItem } from './resultsViewerModel.js';
+interface ResultsViewerProps {
+    jobName: string;
+    jobSlug: string;
+    totalItems: number;
+    getItemAt: (index: number) => ResultsViewerItem | null;
+    onExit: () => void;
+}
+export declare function ResultsViewer({ jobName, jobSlug, totalItems, getItemAt, onExit }: ResultsViewerProps): React.JSX.Element;
+export {};

package/dist/src/ui/components/ResultsViewer.js

@@ -0,0 +1,81 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React, { useMemo, useState } from 'react';
+import { Text, useInput, useStdout } from 'ink';
+import { uiTheme } from '../theme.js';
+import { AppFrame, Panel } from './AppFrame.js';
+import { buildScrollableResultLines, nextContentScrollTop, nextItemIndex } from './resultsViewerModel.js';
+export function ResultsViewer({ jobName, jobSlug, totalItems, getItemAt, onExit }) {
+    const { stdout } = useStdout();
+    const terminalRows = stdout?.rows ?? 24;
+    const terminalCols = stdout?.columns ?? 80;
+    const [cursor, setCursor] = useState(0);
+    const [contentScrollTop, setContentScrollTop] = useState(0);
+    const item = useMemo(() => getItemAt(cursor), [cursor, getItemAt]);
+    const resultLines = useMemo(() => {
+        if (!item) {
+            return [];
+        }
+        return buildScrollableResultLines(item, Math.max(20, terminalCols - 8));
+    }, [item, terminalCols]);
+    // Most of the terminal height is allocated to one scrollable result pane.
+    const contentWindowSize = Math.max(5, terminalRows - 10);
+    const visibleContent = resultLines.slice(contentScrollTop, contentScrollTop + contentWindowSize);
+    const aboveCount = contentScrollTop;
+    const belowCount = Math.max(0, resultLines.length - (contentScrollTop + contentWindowSize));
+    const metadataStartIndex = resultLines.indexOf('Metadata');
+    useInput((input, key) => {
+        if (key.leftArrow) {
+            const next = nextItemIndex(cursor, 'left', totalItems);
+            if (next !== cursor) {
+                setCursor(next);
+                setContentScrollTop(0);
+            }
+            return;
+        }
+        if (key.rightArrow) {
+            const next = nextItemIndex(cursor, 'right', totalItems);
+            if (next !== cursor) {
+                setCursor(next);
+                setContentScrollTop(0);
+            }
+            return;
+        }
+        if (key.upArrow) {
+            setContentScrollTop((prev) => nextContentScrollTop(prev, 'up', resultLines.length, contentWindowSize));
+            return;
+        }
+        if (key.downArrow) {
+            setContentScrollTop((prev) => nextContentScrollTop(prev, 'down', resultLines.length, contentWindowSize));
+            return;
+        }
+        if (key.escape || input === 'q' || input === 'Q') {
+            onExit();
+        }
+    });
+    if (!item) {
+        return (_jsx(AppFrame, { subtitle: "Results", statusText: "No items", statusTone: "warning", hints: ['q quit'], children: _jsx(Panel, { title: "No Results", children: _jsx(Text, { color: uiTheme.ink.warning, children: "No results available." }) }) }));
+    }
+    const qualificationMark = item.qualified ? '✓' : 'x';
+    const qualificationText = item.qualified ? 'Qualified' : 'Not Qualified';
+    const qualificationColor = item.qualified ? uiTheme.ink.success : uiTheme.ink.danger;
+    const contentLinkLabel = item.type === 'comment' ? 'Comment URL' : 'Post URL';
+    const renderLine = (line, absoluteIndex) => {
+        const isMetadataLine = metadataStartIndex !== -1 && absoluteIndex > metadataStartIndex;
+        if (isMetadataLine) {
+            const match = line.match(/^([^:]+):(\s*)(.*)$/);
+            if (match) {
+                const [, label, gap, value] = match;
+                return (_jsxs(Text, { color: uiTheme.ink.textPrimary, children: [_jsx(Text, { color: uiTheme.ink.info, children: `${label}:` }), `${gap}${value}`] }));
+            }
+            if (line.startsWith(' ')) {
+                return _jsx(Text, { color: uiTheme.ink.textMuted, children: line });
+            }
+        }
+        if (line === 'Metadata' || line === 'Title' || line === 'Body' || line === 'Thread (root -> target)' || line === 'Target Comment Body') {
+            return (_jsx(Text, { color: uiTheme.ink.accent, bold: true, children: line }));
+        }
+        return _jsx(Text, { color: uiTheme.ink.textPrimary, children: line });
+    };
+    return (_jsxs(AppFrame, { subtitle: "Results", description: `${jobName} (${jobSlug})`, statusText: `${cursor + 1} / ${totalItems}`, statusTone: "info", hints: ['←→ result', '↑↓ scroll', 'q quit'], children: [_jsx(Text, { color: qualificationColor, children: `${qualificationMark} ${qualificationText}` }), _jsxs(Text, { color: uiTheme.ink.info, children: [`${contentLinkLabel}: `, _jsx(Text, { color: uiTheme.ink.textPrimary, children: item.url })] }), _jsxs(Panel, { title: "Result", children: [aboveCount > 0 ? _jsxs(Text, { color: uiTheme.ink.textMuted, children: ["\u2191 ", aboveCount, " more"] }) : null, visibleContent.map((line, index) => (_jsx(React.Fragment, { children: renderLine(line, contentScrollTop + index) }, `${index}:${line.slice(0, 24)}`))), belowCount > 0 ? _jsxs(Text, { color: uiTheme.ink.textMuted, children: ["\u2193 ", belowCount, " more"] }) : null] })] }));
+}
+//# sourceMappingURL=ResultsViewer.js.map

package/dist/src/ui/components/RunsTable.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { RunRow } from '../../services/db/repositories/runsRepo.js';
+interface RunsTableProps {
+    totalRuns: number;
+    getRunAt: (index: number) => RunRow | null;
+    onExit: () => void;
+}
+export declare function RunsTable({ totalRuns, getRunAt, onExit }: RunsTableProps): React.JSX.Element;
+export {};

package/dist/src/ui/components/RunsTable.js

@@ -0,0 +1,99 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, Text, useInput, useStdout } from 'ink';
+import { formatRunDisplayTimestamp } from '../../cli/ui/time.js';
+import { uiTheme } from '../theme.js';
+import { AppFrame, Panel } from './AppFrame.js';
+import { buildDetailLines, computeColumnWidths, computeScrollWindow, formatHeaderRow, formatTableRow } from './runsTableModel.js';
+const WINDOW_SIZE = 10;
+const COL_SEP = '  ';
+export function RunsTable({ totalRuns, getRunAt, onExit }) {
+    const { stdout } = useStdout();
+    const terminalRows = stdout?.rows ?? 24;
+    // Respect terminal height: cap window so we leave room for header + footer
+    const maxWindow = Math.max(1, Math.min(WINDOW_SIZE, terminalRows - 8));
+    const [view, setView] = useState('list');
+    const [cursor, setCursor] = useState(0);
+    const [scrollTop, setScrollTop] = useState(0);
+    const currentRun = getRunAt(cursor);
+    const { scrollTop: nextScrollTop, visibleStart, visibleEnd } = computeScrollWindow(cursor, scrollTop, totalRuns, maxWindow);
+    const visibleRuns = [];
+    for (let index = visibleStart; index < visibleEnd; index += 1) {
+        const run = getRunAt(index);
+        if (run) {
+            visibleRuns.push(run);
+        }
+    }
+    const widthSample = currentRun ? [currentRun, ...visibleRuns] : visibleRuns;
+    const widths = computeColumnWidths(widthSample);
+    const header = formatHeaderRow(widths);
+    if (nextScrollTop !== scrollTop) {
+        setScrollTop(nextScrollTop);
+    }
+    const aboveCount = visibleStart;
+    const belowCount = totalRuns - visibleEnd;
+    useInput((input, key) => {
+        if (view === 'list') {
+            if (key.upArrow) {
+                const next = Math.max(0, cursor - 1);
+                setCursor(next);
+                const win = computeScrollWindow(next, scrollTop, totalRuns, maxWindow);
+                setScrollTop(win.scrollTop);
+                return;
+            }
+            if (key.downArrow) {
+                const next = Math.min(totalRuns - 1, cursor + 1);
+                setCursor(next);
+                const win = computeScrollWindow(next, scrollTop, totalRuns, maxWindow);
+                setScrollTop(win.scrollTop);
+                return;
+            }
+            if (key.return) {
+                setView('detail');
+                return;
+            }
+            if (input === 'q' || input === 'Q') {
+                onExit();
+            }
+            return;
+        }
+        // detail view
+        if (key.escape || key.leftArrow || input === 'q' || input === 'Q') {
+            if (key.escape || key.leftArrow) {
+                setView('list');
+            }
+            else {
+                onExit();
+            }
+        }
+    });
+    if (view === 'detail') {
+        const run = currentRun;
+        if (!run)
+            return _jsx(_Fragment, {});
+        const detailLines = buildDetailLines(run);
+        const title = `${formatRunDisplayTimestamp(run)} — ${run.jobName ?? run.jobId}`;
+        return (_jsx(AppFrame, { subtitle: "Run History", statusText: `${cursor + 1} / ${totalRuns}`, statusTone: "info", hints: ['Esc / ← back', 'q quit'], children: _jsx(Panel, { title: title, children: detailLines.map((line) => (_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: uiTheme.ink.info, children: line.label.padEnd(12) }), _jsx(Text, { color: uiTheme.ink.textPrimary, children: line.value })] }, line.label))) }) }));
+    }
+    return (_jsx(AppFrame, { subtitle: "Run History", statusText: `${cursor + 1} / ${totalRuns}`, statusTone: "info", hints: ['↑↓ navigate', '↵ details', 'q quit'], children: _jsxs(Box, { flexDirection: "column", marginTop: 1, paddingLeft: 1, children: [_jsx(Box, { flexDirection: "row", children: header.map((cell, i) => (_jsxs(Text, { bold: true, color: uiTheme.ink.accent, children: [i > 0 ? COL_SEP : '', cell] }, i))) }), aboveCount > 0 && (_jsxs(Text, { color: uiTheme.ink.textMuted, children: ["  \u2191 ", aboveCount, " more"] })), visibleRuns.map((run, idx) => {
+                    const absoluteIndex = visibleStart + idx;
+                    const isSelected = absoluteIndex === cursor;
+                    const cells = formatTableRow(run, widths);
+                    const statusColor = run.status === 'completed'
+                        ? uiTheme.ink.success
+                        : run.status === 'failed'
+                            ? uiTheme.ink.danger
+                            : uiTheme.ink.textMuted;
+                    return (_jsx(Box, { flexDirection: "row", children: cells.map((cell, i) => {
+                            const color = isSelected
+                                ? uiTheme.ink.focus
+                                : i === 5 // status column
+                                    ? statusColor
+                                    : i === 0
+                                        ? uiTheme.ink.textPrimary
+                                        : uiTheme.ink.textMuted;
+                            return (_jsxs(Text, { color: color, inverse: isSelected && i === 0, bold: isSelected && i === 0, children: [i > 0 ? COL_SEP : '', cell] }, i));
+                        }) }, run.id));
+                }), belowCount > 0 && (_jsxs(Text, { color: uiTheme.ink.textMuted, children: ["  \u2193 ", belowCount, " more"] }))] }) }));
+}
+//# sourceMappingURL=RunsTable.js.map

package/dist/src/ui/components/jobsTableModel.d.ts

@@ -0,0 +1,15 @@
+import type { JobSummaryRow } from '../../services/db/repositories/jobsRepo.js';
+import type { DetailLine } from './runsTableModel.js';
+export { computeScrollWindow } from './runsTableModel.js';
+export type { DetailLine };
+export interface JobColumnWidths {
+    slug: number;
+    lastRun: number;
+    scanned: number;
+    qualified: number;
+    cost: number;
+}
+export declare function computeJobColumnWidths(rows: JobSummaryRow[]): JobColumnWidths;
+export declare function formatJobTableRow(row: JobSummaryRow, widths: JobColumnWidths): string[];
+export declare function formatJobHeaderRow(widths: JobColumnWidths): string[];
+export declare function buildJobDetailLines(row: JobSummaryRow): DetailLine[];

package/dist/src/ui/components/jobsTableModel.js

@@ -0,0 +1,79 @@
+import { formatLocalTimestamp } from '../../cli/ui/time.js';
+export { computeScrollWindow } from './runsTableModel.js';
+const COL_MIN = { slug: 8, lastRun: 10, scanned: 7, qualified: 9, cost: 9 };
+const COL_MAX = { slug: 32, lastRun: 22, scanned: 7, qualified: 9, cost: 12 };
+function pad(value, width) {
+    if (value.length >= width)
+        return value.slice(0, width);
+    return value + ' '.repeat(width - value.length);
+}
+export function computeJobColumnWidths(rows) {
+    const clamp = (v, key) => Math.min(COL_MAX[key], Math.max(COL_MIN[key], v));
+    let slug = COL_MIN.slug;
+    let lastRun = COL_MIN.lastRun;
+    for (const row of rows) {
+        const slugLen = row.jobSlug.length;
+        if (slugLen > slug)
+            slug = slugLen;
+        const dateLen = row.lastRunAt ? formatLocalTimestamp(row.lastRunAt).length : 5; // 'never'
+        if (dateLen > lastRun)
+            lastRun = dateLen;
+    }
+    return {
+        slug: clamp(slug, 'slug'),
+        lastRun: clamp(lastRun, 'lastRun'),
+        scanned: COL_MIN.scanned,
+        qualified: COL_MIN.qualified,
+        cost: COL_MIN.cost
+    };
+}
+function formatCost(totalCostUsd) {
+    if (totalCostUsd === 0)
+        return '-';
+    return `$${totalCostUsd.toFixed(6)}`;
+}
+export function formatJobTableRow(row, widths) {
+    const lastRun = row.lastRunAt ? formatLocalTimestamp(row.lastRunAt) : 'never';
+    const cost = formatCost(row.totalCostUsd);
+    return [
+        pad(row.jobSlug, widths.slug),
+        pad(lastRun, widths.lastRun),
+        pad(String(row.totalScanned), widths.scanned),
+        pad(String(row.totalQualified), widths.qualified),
+        pad(cost, widths.cost)
+    ];
+}
+export function formatJobHeaderRow(widths) {
+    return [
+        pad('Job Slug', widths.slug),
+        pad('Last Run', widths.lastRun),
+        pad('Scanned', widths.scanned),
+        pad('Qualified', widths.qualified),
+        pad('Cost', widths.cost)
+    ];
+}
+// ── Detail view ───────────────────────────────────────────────────────────────
+export function buildJobDetailLines(row) {
+    let subreddits = '-';
+    try {
+        const parsed = JSON.parse(row.subredditsJson);
+        subreddits = parsed.map((s) => `r/${s}`).join(', ');
+    }
+    catch {
+        subreddits = row.subredditsJson;
+    }
+    return [
+        { label: 'Slug', value: row.jobSlug },
+        { label: 'Name', value: row.jobName },
+        { label: 'Enabled', value: row.enabled !== 0 ? 'Yes' : 'No' },
+        { label: 'Description', value: row.description },
+        { label: 'Subreddits', value: subreddits },
+        { label: 'Schedule', value: row.scheduleCron },
+        { label: 'Runs', value: String(row.runCount) },
+        { label: 'Last Run', value: row.lastRunAt ? formatLocalTimestamp(row.lastRunAt) : 'never' },
+        { label: 'Scanned', value: String(row.totalScanned) },
+        { label: 'Qualified', value: String(row.totalQualified) },
+        { label: 'Cost', value: formatCost(row.totalCostUsd) }
+    ];
+}
+//# sourceMappingURL=jobsTableModel.js.map

package/dist/src/ui/components/resultsViewerModel.d.ts

@@ -0,0 +1,14 @@
+import type { CommentThreadNodeRow, ScanItemRow } from '../../services/db/repositories/scanItemsRepo.js';
+export interface ResultsViewerItem extends ScanItemRow {
+    commentThreadNodes: CommentThreadNodeRow[];
+}
+export interface DetailLine {
+    label: string;
+    value: string;
+}
+export declare function wrapTextBlock(value: string, width: number): string[];
+export declare function buildMetadataLines(item: ResultsViewerItem): DetailLine[];
+export declare function buildContentLines(item: ResultsViewerItem, width: number): string[];
+export declare function buildScrollableResultLines(item: ResultsViewerItem, width: number): string[];
+export declare function nextItemIndex(current: number, direction: 'left' | 'right', total: number): number;
+export declare function nextContentScrollTop(current: number, direction: 'up' | 'down', totalLines: number, windowSize: number): number;