@telepat/snoopy 0.1.13 → 0.1.15

package/dist/src/mcp/server.js

@@ -0,0 +1,299 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { snoopyDoctorToolInputSchema, snoopyDaemonStatusToolInputSchema, snoopyDaemonStartToolInputSchema, snoopyDaemonStopToolInputSchema, snoopyDaemonReloadToolInputSchema, snoopyJobListToolInputSchema, snoopyJobRunsToolInputSchema, snoopyJobAddToolInputSchema, snoopyJobDeleteToolInputSchema, snoopyJobEnableToolInputSchema, snoopyJobDisableToolInputSchema, snoopyJobRunToolInputSchema, snoopyAnalyticsToolInputSchema, snoopyExportToolInputSchema, snoopyConsumeToolInputSchema, snoopyFeedbackReviewToolInputSchema, snoopyFeedbackSubmitToolInputSchema, snoopyFeedbackConsolidateToolInputSchema, snoopyErrorsToolInputSchema, snoopyLogsToolInputSchema, snoopySettingsGetToolInputSchema, snoopySettingsSetToolInputSchema, } from './tools.js';
+import { getSnoopyVersion, formatToolError, formatToolResult, buildDoctorReport, buildDaemonStatusReport, startDaemonReport, stopDaemonReport, reloadDaemonReport, listJobsReport, listJobRunsReport, addJobReport, deleteJobReport, enableJobReport, disableJobReport, runJobReport, analyticsReport, exportReport, consumeReport, feedbackReviewReport, feedbackSubmitReport, feedbackConsolidateReport, errorsReport, logsReport, settingsGetReport, settingsSetReport, } from './helpers.js';
+export async function startSnoopyMcpServer() {
+    const version = getSnoopyVersion();
+    const server = new McpServer({ name: 'snoopy', version });
+    // --- snoopy_doctor ---
+    server.registerTool('snoopy_doctor', {
+        title: 'Health Check',
+        description: 'Run full system health check: database, API key, daemon, jobs, startup, recent errors.',
+        inputSchema: snoopyDoctorToolInputSchema,
+    }, async () => {
+        try {
+            const report = await buildDoctorReport();
+            return formatToolResult(report);
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    // --- snoopy_daemon_status ---
+    server.registerTool('snoopy_daemon_status', {
+        title: 'Daemon Status',
+        description: 'Show whether the Snoopy daemon is running and its PID.',
+        inputSchema: snoopyDaemonStatusToolInputSchema,
+    }, () => {
+        try {
+            return formatToolResult(buildDaemonStatusReport());
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    // --- snoopy_daemon_start ---
+    server.registerTool('snoopy_daemon_start', {
+        title: 'Start Daemon',
+        description: 'Start the Snoopy background daemon.',
+        inputSchema: snoopyDaemonStartToolInputSchema,
+    }, () => {
+        try {
+            return formatToolResult(startDaemonReport());
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    // --- snoopy_daemon_stop ---
+    server.registerTool('snoopy_daemon_stop', {
+        title: 'Stop Daemon',
+        description: 'Stop the Snoopy background daemon.',
+        inputSchema: snoopyDaemonStopToolInputSchema,
+    }, () => {
+        try {
+            return formatToolResult(stopDaemonReport());
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    // --- snoopy_daemon_reload ---
+    server.registerTool('snoopy_daemon_reload', {
+        title: 'Reload Daemon',
+        description: 'Hot-reload daemon job schedules without restart.',
+        inputSchema: snoopyDaemonReloadToolInputSchema,
+    }, () => {
+        try {
+            return formatToolResult(reloadDaemonReport());
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    // --- snoopy_job_list ---
+    server.registerTool('snoopy_job_list', {
+        title: 'List Jobs',
+        description: 'List all monitoring jobs with their state, subreddits, and schedule.',
+        inputSchema: snoopyJobListToolInputSchema,
+    }, () => {
+        try {
+            return formatToolResult(listJobsReport());
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    // --- snoopy_job_runs ---
+    server.registerTool('snoopy_job_runs', {
+        title: 'Job Run History',
+        description: 'List recent run history for a job or all jobs.',
+        inputSchema: snoopyJobRunsToolInputSchema,
+    }, (input) => {
+        try {
+            return formatToolResult(listJobRunsReport(input.jobRef, input.limit));
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    // --- snoopy_job_add ---
+    server.registerTool('snoopy_job_add', {
+        title: 'Add Job',
+        description: 'Create a new monitoring job with subreddits and qualification prompt.',
+        inputSchema: snoopyJobAddToolInputSchema,
+    }, (input) => {
+        try {
+            return formatToolResult(addJobReport(input));
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    // --- snoopy_job_delete ---
+    server.registerTool('snoopy_job_delete', {
+        title: 'Delete Job',
+        description: 'Delete a job and all its runs, scan items, and log files.',
+        inputSchema: snoopyJobDeleteToolInputSchema,
+    }, (input) => {
+        try {
+            return formatToolResult(deleteJobReport(input.jobRef));
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    // --- snoopy_job_enable ---
+    server.registerTool('snoopy_job_enable', {
+        title: 'Enable Job',
+        description: 'Enable scheduling for a monitoring job.',
+        inputSchema: snoopyJobEnableToolInputSchema,
+    }, (input) => {
+        try {
+            return formatToolResult(enableJobReport(input.jobRef));
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    // --- snoopy_job_disable ---
+    server.registerTool('snoopy_job_disable', {
+        title: 'Disable Job',
+        description: 'Disable scheduling for a monitoring job.',
+        inputSchema: snoopyJobDisableToolInputSchema,
+    }, (input) => {
+        try {
+            return formatToolResult(disableJobReport(input.jobRef));
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    // --- snoopy_job_run ---
+    server.registerTool('snoopy_job_run', {
+        title: 'Run Job Now',
+        description: 'Trigger an immediate run for a monitoring job.',
+        inputSchema: snoopyJobRunToolInputSchema,
+    }, (input) => {
+        try {
+            return formatToolResult(runJobReport(input.jobRef, input.limit));
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    // --- snoopy_analytics ---
+    server.registerTool('snoopy_analytics', {
+        title: 'Analytics',
+        description: 'Show analytics for all jobs or a single job (tokens, cost, posts, comments).',
+        inputSchema: snoopyAnalyticsToolInputSchema,
+    }, (input) => {
+        try {
+            return formatToolResult(analyticsReport(input.jobRef, input.days));
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    // --- snoopy_export ---
+    server.registerTool('snoopy_export', {
+        title: 'Export Results',
+        description: 'Export qualified scan items as JSON or CSV for downstream processing.',
+        inputSchema: snoopyExportToolInputSchema,
+    }, (input) => {
+        try {
+            return formatToolResult(exportReport(input.jobRef, input.format, input.lastRun, input.limit));
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    // --- snoopy_consume ---
+    server.registerTool('snoopy_consume', {
+        title: 'Consume Results',
+        description: 'List and mark unconsumed qualified results as consumed.',
+        inputSchema: snoopyConsumeToolInputSchema,
+    }, (input) => {
+        try {
+            return formatToolResult(consumeReport(input.jobRef, input.limit, input.dryRun));
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    // --- snoopy_feedback_review ---
+    server.registerTool('snoopy_feedback_review', {
+        title: 'Review Feedback Queue',
+        description: 'List unvalidated qualified results for user feedback collection.',
+        inputSchema: snoopyFeedbackReviewToolInputSchema,
+    }, (input) => {
+        try {
+            return formatToolResult(feedbackReviewReport(input.jobRef, input.limit));
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    // --- snoopy_feedback_submit ---
+    server.registerTool('snoopy_feedback_submit', {
+        title: 'Submit Feedback',
+        description: 'Submit validity feedback for a qualified result.',
+        inputSchema: snoopyFeedbackSubmitToolInputSchema,
+    }, (input) => {
+        try {
+            return formatToolResult(feedbackSubmitReport(input.resultId, input.isValid, input.reason));
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    // --- snoopy_feedback_consolidate ---
+    server.registerTool('snoopy_feedback_consolidate', {
+        title: 'Consolidate Feedback',
+        description: 'Consolidate feedback into improved qualification prompts.',
+        inputSchema: snoopyFeedbackConsolidateToolInputSchema,
+    }, async (input) => {
+        try {
+            return formatToolResult(await feedbackConsolidateReport(input.jobRef, input.limit));
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    // --- snoopy_errors ---
+    server.registerTool('snoopy_errors', {
+        title: 'Recent Errors',
+        description: 'Show recent failed or errored runs for a job.',
+        inputSchema: snoopyErrorsToolInputSchema,
+    }, (input) => {
+        try {
+            return formatToolResult(errorsReport(input.jobRef, input.hours));
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    // --- snoopy_logs ---
+    server.registerTool('snoopy_logs', {
+        title: 'Run Logs',
+        description: 'View the log output for a specific run.',
+        inputSchema: snoopyLogsToolInputSchema,
+    }, (input) => {
+        try {
+            return formatToolResult(logsReport(input.runId));
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    // --- snoopy_settings_get ---
+    server.registerTool('snoopy_settings_get', {
+        title: 'Get Settings',
+        description: 'Read current Snoopy settings (model, API key status, schedule, notifications).',
+        inputSchema: snoopySettingsGetToolInputSchema,
+    }, async () => {
+        try {
+            const report = await settingsGetReport();
+            return formatToolResult(report);
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    // --- snoopy_settings_set ---
+    server.registerTool('snoopy_settings_set', {
+        title: 'Update Setting',
+        description: 'Update a single Snoopy setting.',
+        inputSchema: snoopySettingsSetToolInputSchema,
+    }, (input) => {
+        try {
+            return formatToolResult(settingsSetReport(input.key, input.value));
+        }
+        catch (error) {
+            return formatToolError(error);
+        }
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+//# sourceMappingURL=server.js.map

package/dist/src/mcp/tools.d.ts

@@ -0,0 +1,90 @@
+import { z } from 'zod';
+export declare const snoopyDoctorToolInputSchema: {};
+export declare const snoopyDaemonStatusToolInputSchema: {};
+export declare const snoopyDaemonStartToolInputSchema: {};
+export declare const snoopyDaemonStopToolInputSchema: {};
+export declare const snoopyDaemonReloadToolInputSchema: {};
+export declare const snoopyJobListToolInputSchema: {};
+export declare const snoopyJobRunsToolInputSchema: {
+    jobRef: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+};
+export declare const snoopyJobAddToolInputSchema: {
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    subreddits: z.ZodArray<z.ZodString>;
+    qualificationPrompt: z.ZodString;
+    scheduleCron: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    monitorComments: z.ZodOptional<z.ZodBoolean>;
+};
+export declare const snoopyJobDeleteToolInputSchema: {
+    jobRef: z.ZodString;
+};
+export declare const snoopyJobEnableToolInputSchema: {
+    jobRef: z.ZodString;
+};
+export declare const snoopyJobDisableToolInputSchema: {
+    jobRef: z.ZodString;
+};
+export declare const snoopyJobRunToolInputSchema: {
+    jobRef: z.ZodString;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+};
+export declare const snoopyAnalyticsToolInputSchema: {
+    jobRef: z.ZodOptional<z.ZodString>;
+    days: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+};
+export declare const snoopyExportToolInputSchema: {
+    jobRef: z.ZodOptional<z.ZodString>;
+    format: z.ZodOptional<z.ZodEnum<{
+        csv: "csv";
+        json: "json";
+    }>>;
+    lastRun: z.ZodOptional<z.ZodBoolean>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+};
+export declare const snoopyConsumeToolInputSchema: {
+    jobRef: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    dryRun: z.ZodOptional<z.ZodBoolean>;
+};
+export declare const snoopyFeedbackReviewToolInputSchema: {
+    jobRef: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+};
+export declare const snoopyFeedbackSubmitToolInputSchema: {
+    resultId: z.ZodString;
+    isValid: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodString>;
+};
+export declare const snoopyFeedbackConsolidateToolInputSchema: {
+    jobRef: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+};
+export declare const snoopyErrorsToolInputSchema: {
+    jobRef: z.ZodString;
+    hours: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+};
+export declare const snoopyLogsToolInputSchema: {
+    runId: z.ZodString;
+};
+export declare const snoopySettingsGetToolInputSchema: {};
+export declare const snoopySettingsSetToolInputSchema: {
+    key: z.ZodEnum<{
+        model: "model";
+        cronIntervalMinutes: "cronIntervalMinutes";
+        temperature: "temperature";
+        maxTokens: "maxTokens";
+        topP: "topP";
+        notificationsEnabled: "notificationsEnabled";
+        jobTimeoutMs: "jobTimeoutMs";
+    }>;
+    value: z.ZodString;
+};
+export interface ToolContract {
+    name: string;
+    required: string[];
+    enums: Record<string, string[]>;
+}
+export declare const snoopyToolContracts: ToolContract[];

package/dist/src/mcp/tools.js

@@ -0,0 +1,106 @@
+import { z } from 'zod';
+export const snoopyDoctorToolInputSchema = {};
+export const snoopyDaemonStatusToolInputSchema = {};
+export const snoopyDaemonStartToolInputSchema = {};
+export const snoopyDaemonStopToolInputSchema = {};
+export const snoopyDaemonReloadToolInputSchema = {};
+export const snoopyJobListToolInputSchema = {};
+export const snoopyJobRunsToolInputSchema = {
+    jobRef: z.string().optional().describe('Job ID or slug. If omitted, returns runs for all jobs.'),
+    limit: z.coerce.number().int().positive().optional().describe('Max runs to return. Default: 20.'),
+};
+export const snoopyJobAddToolInputSchema = {
+    name: z.string().min(1).describe('Job name.'),
+    description: z.string().optional().describe('Job description. Default: empty.'),
+    subreddits: z.array(z.string()).min(1).describe('Subreddits to monitor (e.g. ["startups","SaaS"]).'),
+    qualificationPrompt: z.string().min(1).describe('Plain-language criteria for qualifying posts/comments.'),
+    scheduleCron: z.string().optional().describe('Cron expression. Default: "*/30 * * * *" (every 30 min).'),
+    enabled: z.boolean().optional().describe('Enable scheduling immediately. Default: true.'),
+    monitorComments: z.boolean().optional().describe('Also monitor comments. Default: true.'),
+};
+export const snoopyJobDeleteToolInputSchema = {
+    jobRef: z.string().min(1).describe('Job ID or slug to delete.'),
+};
+export const snoopyJobEnableToolInputSchema = {
+    jobRef: z.string().min(1).describe('Job ID or slug to enable.'),
+};
+export const snoopyJobDisableToolInputSchema = {
+    jobRef: z.string().min(1).describe('Job ID or slug to disable.'),
+};
+export const snoopyJobRunToolInputSchema = {
+    jobRef: z.string().min(1).describe('Job ID or slug to run immediately.'),
+    limit: z.coerce.number().int().positive().optional().describe('Max new items to qualify.'),
+};
+export const snoopyAnalyticsToolInputSchema = {
+    jobRef: z.string().optional().describe('Job ID or slug. If omitted, returns analytics for all jobs.'),
+    days: z.coerce.number().int().positive().optional().describe('Lookback window in days. Default: 30.'),
+};
+export const snoopyExportToolInputSchema = {
+    jobRef: z.string().optional().describe('Job ID or slug. If omitted, exports all jobs.'),
+    format: z.enum(['json', 'csv']).optional().describe('Export format. Default: "json".'),
+    lastRun: z.boolean().optional().describe('Only export items from the latest run.'),
+    limit: z.coerce.number().int().positive().optional().describe('Max rows per job. Default: 100.'),
+};
+export const snoopyConsumeToolInputSchema = {
+    jobRef: z.string().optional().describe('Job ID or slug. If omitted, applies to all jobs.'),
+    limit: z.coerce.number().int().positive().optional().describe('Max results to consume.'),
+    dryRun: z.boolean().optional().describe('Preview without marking consumed.'),
+};
+export const snoopyFeedbackReviewToolInputSchema = {
+    jobRef: z.string().optional().describe('Job ID or slug. If omitted, review queue spans all jobs.'),
+    limit: z.coerce.number().int().positive().optional().describe('Max unvalidated results to return. Default: 10.'),
+};
+export const snoopyFeedbackSubmitToolInputSchema = {
+    resultId: z.string().min(1).describe('Qualified result ID to update.'),
+    isValid: z.boolean().describe('Whether the result should be considered valid.'),
+    reason: z.string().optional().describe('Required when isValid=false; ignored when isValid=true.'),
+};
+export const snoopyFeedbackConsolidateToolInputSchema = {
+    jobRef: z.string().optional().describe('Job ID or slug. If omitted, consolidates across all jobs.'),
+    limit: z.coerce.number().int().positive().optional().describe('Max pending feedback items to process.'),
+};
+export const snoopyErrorsToolInputSchema = {
+    jobRef: z.string().min(1).describe('Job ID or slug.'),
+    hours: z.coerce.number().int().positive().optional().describe('Look back hours. Default: 24.'),
+};
+export const snoopyLogsToolInputSchema = {
+    runId: z.string().min(1).describe('Run ID to view logs for.'),
+};
+export const snoopySettingsGetToolInputSchema = {};
+export const snoopySettingsSetToolInputSchema = {
+    key: z.enum([
+        'model',
+        'temperature',
+        'maxTokens',
+        'topP',
+        'cronIntervalMinutes',
+        'jobTimeoutMs',
+        'notificationsEnabled',
+    ]).describe('Setting key to update.'),
+    value: z.string().describe('New value for the setting.'),
+};
+export const snoopyToolContracts = [
+    { name: 'snoopy_doctor', required: [], enums: {} },
+    { name: 'snoopy_daemon_status', required: [], enums: {} },
+    { name: 'snoopy_daemon_start', required: [], enums: {} },
+    { name: 'snoopy_daemon_stop', required: [], enums: {} },
+    { name: 'snoopy_daemon_reload', required: [], enums: {} },
+    { name: 'snoopy_job_list', required: [], enums: {} },
+    { name: 'snoopy_job_runs', required: [], enums: {} },
+    { name: 'snoopy_job_add', required: ['name', 'subreddits', 'qualificationPrompt'], enums: {} },
+    { name: 'snoopy_job_delete', required: ['jobRef'], enums: {} },
+    { name: 'snoopy_job_enable', required: ['jobRef'], enums: {} },
+    { name: 'snoopy_job_disable', required: ['jobRef'], enums: {} },
+    { name: 'snoopy_job_run', required: ['jobRef'], enums: {} },
+    { name: 'snoopy_analytics', required: [], enums: {} },
+    { name: 'snoopy_export', required: [], enums: { format: ['json', 'csv'] } },
+    { name: 'snoopy_consume', required: [], enums: {} },
+    { name: 'snoopy_feedback_review', required: [], enums: {} },
+    { name: 'snoopy_feedback_submit', required: ['resultId', 'isValid'], enums: {} },
+    { name: 'snoopy_feedback_consolidate', required: [], enums: {} },
+    { name: 'snoopy_errors', required: ['jobRef'], enums: {} },
+    { name: 'snoopy_logs', required: ['runId'], enums: {} },
+    { name: 'snoopy_settings_get', required: [], enums: {} },
+    { name: 'snoopy_settings_set', required: ['key', 'value'], enums: { key: ['model', 'temperature', 'maxTokens', 'topP', 'cronIntervalMinutes', 'jobTimeoutMs', 'notificationsEnabled'] } },
+];
+//# sourceMappingURL=tools.js.map

package/dist/src/services/db/migrations/002_feedback_fields.d.ts

@@ -0,0 +1,7 @@
+import type Database from 'better-sqlite3';
+declare const _default: {
+    id: number;
+    name: string;
+    up(db: Database.Database): void;
+};
+export default _default;

package/dist/src/services/db/migrations/002_feedback_fields.js

@@ -0,0 +1,22 @@
+export default {
+    id: 2,
+    name: 'feedback_fields',
+    up(db) {
+        const safeAddColumn = (table, column, type) => {
+            try {
+                db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${type}`);
+            }
+            catch {
+                // Column already exists or table does not exist.
+            }
+        };
+        safeAddColumn('scan_items', 'is_valid', 'INTEGER NOT NULL DEFAULT 0');
+        safeAddColumn('scan_items', 'is_valid_reason', 'TEXT');
+        safeAddColumn('scan_items', 'feedback_consolidated', 'INTEGER NOT NULL DEFAULT 0');
+        db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_scan_items_feedback_pending
+      ON scan_items(job_id, qualified, validated, feedback_consolidated, created_at DESC)
+    `);
+    }
+};
+//# sourceMappingURL=002_feedback_fields.js.map

package/dist/src/services/db/migrations/index.js

@@ -1,3 +1,4 @@
 import baseline from './001_baseline.js';
-export const migrations = [baseline];
+import feedbackFields from './002_feedback_fields.js';
+export const migrations = [baseline, feedbackFields];
 //# sourceMappingURL=index.js.map

package/dist/src/services/db/repositories/jobsRepo.d.ts

@@ -28,6 +28,8 @@ export declare class JobsRepository {
     listEnabled(): Job[];
     setEnabled(id: string, enabled: boolean): void;
     setEnabledByRef(ref: string, enabled: boolean): Job | null;
+    updateQualificationPromptById(id: string, qualificationPrompt: string): Job | null;
+    updateQualificationPromptByRef(ref: string, qualificationPrompt: string): Job | null;
     remove(id: string): void;
     removeByRef(ref: string): Job | null;
     listWithStats(): JobSummaryRow[];

package/dist/src/services/db/repositories/jobsRepo.js

@@ -141,6 +141,21 @@ export class JobsRepository {
         this.setEnabled(job.id, enabled);
         return this.getById(job.id);
     }
+    updateQualificationPromptById(id, qualificationPrompt) {
+        this.db
+            .prepare(`UPDATE jobs
+         SET qualification_prompt = ?, updated_at = datetime('now')
+         WHERE id = ?`)
+            .run(qualificationPrompt, id);
+        return this.getById(id);
+    }
+    updateQualificationPromptByRef(ref, qualificationPrompt) {
+        const job = this.getByRef(ref);
+        if (!job) {
+            return null;
+        }
+        return this.updateQualificationPromptById(job.id, qualificationPrompt);
+    }
     remove(id) {
         this.removeCascadeStmt(id);
     }

package/dist/src/services/db/repositories/scanItemsRepo.d.ts

@@ -14,6 +14,9 @@ export interface NewScanItem {
     qualified: boolean;
     viewed?: boolean;
     validated?: boolean;
+    isValid?: boolean;
+    isValidReason?: string | null;
+    feedbackConsolidated?: boolean;
     processed?: boolean;
     consumed?: boolean;
     promptTokens?: number;
@@ -39,6 +42,8 @@ export interface QualifiedScanItemRow {
     id: string;
     jobId: string;
     runId: string;
+    type: ScanItemType;
+    subreddit: string;
     author: string;
     title: string | null;
     body: string;
@@ -46,6 +51,9 @@ export interface QualifiedScanItemRow {
     redditPostedAt: string;
     viewed: boolean;
     validated: boolean;
+    isValid: boolean;
+    isValidReason: string | null;
+    feedbackConsolidated: boolean;
     processed: boolean;
     consumed: boolean;
     qualificationReason: string | null;
@@ -67,6 +75,9 @@ export interface ScanItemRow {
     qualified: boolean;
     viewed: boolean;
     validated: boolean;
+    isValid: boolean;
+    isValidReason: string | null;
+    feedbackConsolidated: boolean;
     processed: boolean;
     consumed: boolean;
     qualificationReason: string | null;
@@ -117,6 +128,12 @@ export declare class ScanItemsRepository {
     listAnalyticsByJob(days: number): AnalyticsByJobRow[];
     existsComment(jobId: string, postId: string, commentId: string): boolean;
     listUnconsumedQualified(jobId?: string, limit?: number): QualifiedScanItemRow[];
+    getQualifiedById(id: string): QualifiedScanItemRow | null;
+    listUnvalidatedQualified(jobId?: string, limit?: number): QualifiedScanItemRow[];
+    submitFeedback(resultId: string, isValid: boolean, reason: string | null): boolean;
+    listPendingFeedbackConsolidation(jobId?: string, limit?: number): QualifiedScanItemRow[];
+    countPendingFeedbackConsolidation(jobId?: string): number;
+    markFeedbackConsolidated(ids: string[]): number;
     markConsumed(ids: string[]): number;
     createWithStatus(item: NewScanItem): CreateScanItemResult;
     create(item: NewScanItem): string;