@useody/feedback 0.0.1

package/LICENSE

@@ -0,0 +1,198 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to the Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by the Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding any notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format.
+
+   Copyright 2026 Rodyr Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,21 @@
+# @useody/feedback
+
+Interaction signal collection, reputation scoring, and reward derivation for the Ody continuous learning pipeline.
+
+## Features
+
+- **Signal collection** — thumbs up/down, corrections, Slack reactions
+- **Reputation tracking** — per-source confidence scoring based on signal history
+- **Reward derivation** — convert corrections into SFT/DPO training pairs
+- **Conflict detection** — flag contradictory corrections before they enter training
+- **Correction pipeline** — validate, process, and store user corrections
+
+## Usage
+
+```ts
+import { SignalCollector, ReputationTracker, deriveReward } from '@useody/feedback';
+```
+
+## License
+
+Apache-2.0

package/dist/conflict-detector.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Detects conflicting corrections from different users.
+ * @module feedback/conflict-detector
+ */
+import type { InteractionSignal } from './types.js';
+/** A pair of corrections that contradict each other. */
+export interface CorrectionConflict {
+    signalA: InteractionSignal;
+    signalB: InteractionSignal;
+    overlappingNodeIds: string[];
+}
+/**
+ * Detect conflicting corrections: pairs that reference the same topic
+ * (overlapping node IDs) but provide different correction text.
+ */
+export declare function detectConflictingCorrections(corrections: InteractionSignal[]): CorrectionConflict[];
+//# sourceMappingURL=conflict-detector.d.ts.map

package/dist/conflict-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conflict-detector.d.ts","sourceRoot":"","sources":["../src/conflict-detector.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEpD,wDAAwD;AACxD,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,iBAAiB,CAAC;IAC3B,OAAO,EAAE,iBAAiB,CAAC;IAC3B,kBAAkB,EAAE,MAAM,EAAE,CAAC;CAC9B;AAED;;;GAGG;AACH,wBAAgB,4BAA4B,CAC1C,WAAW,EAAE,iBAAiB,EAAE,GAC/B,kBAAkB,EAAE,CAmCtB"}

package/dist/conflict-detector.js

@@ -0,0 +1,34 @@
+/**
+ * Detects conflicting corrections from different users.
+ * @module feedback/conflict-detector
+ */
+/**
+ * Detect conflicting corrections: pairs that reference the same topic
+ * (overlapping node IDs) but provide different correction text.
+ */
+export function detectConflictingCorrections(corrections) {
+    const correctionOnly = corrections.filter((s) => s.signalType === 'corrected' && s.correctionText);
+    const conflicts = [];
+    for (let i = 0; i < correctionOnly.length; i++) {
+        for (let j = i + 1; j < correctionOnly.length; j++) {
+            const a = correctionOnly[i];
+            const b = correctionOnly[j];
+            if (a.userId === b.userId) {
+                continue;
+            }
+            const overlapping = a.questionNodeIds.filter((id) => b.questionNodeIds.includes(id));
+            if (overlapping.length === 0) {
+                continue;
+            }
+            if (a.correctionText !== b.correctionText) {
+                conflicts.push({
+                    signalA: a,
+                    signalB: b,
+                    overlappingNodeIds: overlapping,
+                });
+            }
+        }
+    }
+    return conflicts;
+}
+//# sourceMappingURL=conflict-detector.js.map

package/dist/correction-pipeline.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Continuous correction-to-preference-pair pipeline.
+ * Every user correction becomes an immediate preference pair for Forge training.
+ * @module feedback/correction-pipeline
+ */
+import type { PreferencePair } from '@useody/platform-core';
+import type { PreferencePairStore } from './pair-store.js';
+import type { ReputationTracker } from './reputation.js';
+import type { CorrectionSignal } from './types.js';
+/** Result of a correction pipeline validation. */
+export interface CorrectionValidation {
+    valid: boolean;
+    reason?: string;
+}
+/**
+ * Validate that a correction signal is well-formed and usable.
+ * Rejects empty corrections, identical corrections, and UUID-only prompts.
+ */
+export declare function validateCorrection(correction: CorrectionSignal): CorrectionValidation;
+/**
+ * Process a single correction into a preference pair and store it.
+ * This is the continuous feedback loop: every valid correction from
+ * a sufficiently reputable user becomes an immediate training signal.
+ *
+ * @param correction - The enriched correction signal
+ * @param pairStore - Store for persisting preference pairs
+ * @param reputationTracker - Tracker for user reputation scores
+ * @returns The created preference pair, or null if rejected
+ */
+export declare function processCorrection(correction: CorrectionSignal, pairStore: PreferencePairStore, reputationTracker: ReputationTracker): PreferencePair | null;
+//# sourceMappingURL=correction-pipeline.d.ts.map

package/dist/correction-pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"correction-pipeline.d.ts","sourceRoot":"","sources":["../src/correction-pipeline.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAC3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEzD,OAAO,KAAK,EAAE,gBAAgB,EAAmB,MAAM,YAAY,CAAC;AAEpE,kDAAkD;AAClD,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,gBAAgB,GAAG,oBAAoB,CAwBrF;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,gBAAgB,EAC5B,SAAS,EAAE,mBAAmB,EAC9B,iBAAiB,EAAE,iBAAiB,GACnC,cAAc,GAAG,IAAI,CAkBvB"}

package/dist/correction-pipeline.js

@@ -0,0 +1,71 @@
+/**
+ * Continuous correction-to-preference-pair pipeline.
+ * Every user correction becomes an immediate preference pair for Forge training.
+ * @module feedback/correction-pipeline
+ */
+import { derivePreferencePairFromCorrection, looksLikeUuid } from './reward-derivation.js';
+/**
+ * Validate that a correction signal is well-formed and usable.
+ * Rejects empty corrections, identical corrections, and UUID-only prompts.
+ */
+export function validateCorrection(correction) {
+    const { originalQuestion, originalAnswer, correctedAnswer } = correction;
+    if (!originalQuestion.trim()) {
+        return { valid: false, reason: 'Original question is empty' };
+    }
+    if (!originalAnswer.trim()) {
+        return { valid: false, reason: 'Original answer is empty' };
+    }
+    if (!correctedAnswer.trim()) {
+        return { valid: false, reason: 'Corrected answer is empty' };
+    }
+    if (correctedAnswer.trim() === originalAnswer.trim()) {
+        return { valid: false, reason: 'Corrected answer is identical to original' };
+    }
+    if (looksLikeUuid(originalQuestion)) {
+        return { valid: false, reason: 'Original question is a UUID, not natural language' };
+    }
+    return { valid: true };
+}
+/**
+ * Process a single correction into a preference pair and store it.
+ * This is the continuous feedback loop: every valid correction from
+ * a sufficiently reputable user becomes an immediate training signal.
+ *
+ * @param correction - The enriched correction signal
+ * @param pairStore - Store for persisting preference pairs
+ * @param reputationTracker - Tracker for user reputation scores
+ * @returns The created preference pair, or null if rejected
+ */
+export function processCorrection(correction, pairStore, reputationTracker) {
+    const validation = validateCorrection(correction);
+    if (!validation.valid) {
+        return null;
+    }
+    const reputation = resolveReputation(correction.signal.userId, reputationTracker);
+    const pair = derivePreferencePairFromCorrection(correction, reputation);
+    if (!pair) {
+        return null;
+    }
+    pairStore.save(pair);
+    return pair;
+}
+/**
+ * Resolve reputation for a user, falling back to a default score
+ * if no reputation record exists yet (new users start at 0.5).
+ */
+function resolveReputation(userId, tracker) {
+    const existing = tracker.getScore(userId);
+    if (existing) {
+        return existing;
+    }
+    return {
+        userId,
+        score: 0.5,
+        totalSignals: 0,
+        correctCorrections: 0,
+        overriddenCorrections: 0,
+        lastUpdated: new Date(),
+    };
+}
+//# sourceMappingURL=correction-pipeline.js.map

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @ody/feedback — interaction signals, reputation tracking, and reward derivation.
+ * @module @ody/feedback
+ */
+export * from './types.js';
+export { createFeedbackSchema } from './schema.js';
+export { SignalCollector } from './signal-collector.js';
+export { deriveReward, derivePreferencePair, derivePreferencePairFromCorrection, generateQuestionFromContent, generatePromptFromDetection, looksLikeUuid, } from './reward-derivation.js';
+export { detectConflictingCorrections } from './conflict-detector.js';
+export type { CorrectionConflict } from './conflict-detector.js';
+export { processCorrection, validateCorrection, } from './correction-pipeline.js';
+export type { CorrectionValidation } from './correction-pipeline.js';
+export { ReputationTracker } from './reputation.js';
+export type { ReputationThreshold } from './reputation.js';
+export { PreferencePairStore } from './pair-store.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EACL,YAAY,EACZ,oBAAoB,EACpB,kCAAkC,EAClC,2BAA2B,EAC3B,2BAA2B,EAC3B,aAAa,GACd,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,4BAA4B,EAAE,MAAM,wBAAwB,CAAC;AACtE,YAAY,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,EACL,iBAAiB,EACjB,kBAAkB,GACnB,MAAM,0BAA0B,CAAC;AAClC,YAAY,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AACrE,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACpD,YAAY,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAC3D,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/index.js

@@ -0,0 +1,13 @@
+/**
+ * @ody/feedback — interaction signals, reputation tracking, and reward derivation.
+ * @module @ody/feedback
+ */
+export * from './types.js';
+export { createFeedbackSchema } from './schema.js';
+export { SignalCollector } from './signal-collector.js';
+export { deriveReward, derivePreferencePair, derivePreferencePairFromCorrection, generateQuestionFromContent, generatePromptFromDetection, looksLikeUuid, } from './reward-derivation.js';
+export { detectConflictingCorrections } from './conflict-detector.js';
+export { processCorrection, validateCorrection, } from './correction-pipeline.js';
+export { ReputationTracker } from './reputation.js';
+export { PreferencePairStore } from './pair-store.js';
+//# sourceMappingURL=index.js.map

package/dist/pair-store.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Persists and queries DPO preference pairs in SQLite.
+ * @module feedback/pair-store
+ */
+import type { PreferencePair } from '@useody/platform-core';
+/**
+ * Store for DPO preference pairs backed by SQLite.
+ * Handles persistence, batch operations, and JSONL export.
+ */
+export declare class PreferencePairStore {
+    private readonly db;
+    constructor(db: unknown);
+    /** Save a single preference pair. */
+    save(pair: PreferencePair): void;
+    /** Save multiple preference pairs in a single transaction. */
+    saveBatch(pairs: PreferencePair[]): void;
+    /** Find all preference pairs regardless of export status. */
+    findAll(): PreferencePair[];
+    /** Find all unexported preference pairs. */
+    findUnexported(): PreferencePair[];
+    /** Mark a list of pair IDs as exported. */
+    markExported(ids: string[]): void;
+    /** Count total preference pairs. */
+    count(): number;
+    /** Count unexported preference pairs. */
+    countUnexported(): number;
+    /**
+     * Export unexported pairs to a JSONL file and mark them as exported.
+     * Each line contains: {"prompt", "chosen", "rejected"}.
+     * @returns The number of pairs exported.
+     */
+    exportDpo(outputPath: string): number;
+}
+//# sourceMappingURL=pair-store.d.ts.map

package/dist/pair-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pair-store.d.ts","sourceRoot":"","sources":["../src/pair-store.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAiB,MAAM,uBAAuB,CAAC;AAsE3E;;;GAGG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAW;gBAElB,EAAE,EAAE,OAAO;IAKvB,qCAAqC;IACrC,IAAI,CAAC,IAAI,EAAE,cAAc,GAAG,IAAI;IAmBhC,8DAA8D;IAC9D,SAAS,CAAC,KAAK,EAAE,cAAc,EAAE,GAAG,IAAI;IA4BxC,6DAA6D;IAC7D,OAAO,IAAI,cAAc,EAAE;IAQ3B,4CAA4C;IAC5C,cAAc,IAAI,cAAc,EAAE;IAQlC,2CAA2C;IAC3C,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,IAAI;IASjC,oCAAoC;IACpC,KAAK,IAAI,MAAM;IAOf,yCAAyC;IACzC,eAAe,IAAI,MAAM;IAOzB;;;;OAIG;IACH,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM;CAsBtC"}

package/dist/pair-store.js

@@ -0,0 +1,122 @@
+/**
+ * Persists and queries DPO preference pairs in SQLite.
+ * @module feedback/pair-store
+ */
+import crypto from 'node:crypto';
+import { writeFileSync } from 'node:fs';
+/** Ensure the preference_pairs table exists. */
+function ensureTable(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS preference_pairs (
+      id TEXT PRIMARY KEY NOT NULL,
+      prompt TEXT NOT NULL,
+      chosen TEXT NOT NULL,
+      rejected TEXT NOT NULL,
+      conflict_type TEXT NOT NULL,
+      resolved_by TEXT NOT NULL DEFAULT 'cli-user',
+      resolved_at TEXT NOT NULL DEFAULT (datetime('now')),
+      confidence REAL NOT NULL DEFAULT 1.0,
+      source_node_ids TEXT NOT NULL DEFAULT '[]',
+      exported INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_pairs_exported
+      ON preference_pairs(exported);
+    CREATE INDEX IF NOT EXISTS idx_pairs_conflict_type
+      ON preference_pairs(conflict_type);
+  `);
+}
+/** Convert a raw row to a PreferencePair. */
+function rowToPair(row) {
+    return {
+        prompt: row.prompt,
+        chosen: row.chosen,
+        rejected: row.rejected,
+        metadata: {
+            conflictType: row.conflict_type,
+            resolvedBy: row.resolved_by,
+            resolvedAt: new Date(row.resolved_at),
+            confidence: row.confidence,
+            sourceNodeIds: JSON.parse(row.source_node_ids),
+        },
+    };
+}
+/**
+ * Store for DPO preference pairs backed by SQLite.
+ * Handles persistence, batch operations, and JSONL export.
+ */
+export class PreferencePairStore {
+    db;
+    constructor(db) {
+        this.db = db;
+        ensureTable(this.db);
+    }
+    /** Save a single preference pair. */
+    save(pair) {
+        const id = crypto.randomUUID();
+        this.db.prepare(`INSERT INTO preference_pairs
+        (id, prompt, chosen, rejected, conflict_type, resolved_by, resolved_at, confidence, source_node_ids)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, pair.prompt, pair.chosen, pair.rejected, pair.metadata.conflictType, pair.metadata.resolvedBy, pair.metadata.resolvedAt.toISOString(), pair.metadata.confidence, JSON.stringify(pair.metadata.sourceNodeIds));
+    }
+    /** Save multiple preference pairs in a single transaction. */
+    saveBatch(pairs) {
+        if (pairs.length === 0)
+            return;
+        const stmt = this.db.prepare(`INSERT INTO preference_pairs
+        (id, prompt, chosen, rejected, conflict_type, resolved_by, resolved_at, confidence, source_node_ids)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+        const insertAll = this.db.transaction((items) => {
+            for (const pair of items) {
+                stmt.run(crypto.randomUUID(), pair.prompt, pair.chosen, pair.rejected, pair.metadata.conflictType, pair.metadata.resolvedBy, pair.metadata.resolvedAt.toISOString(), pair.metadata.confidence, JSON.stringify(pair.metadata.sourceNodeIds));
+            }
+        });
+        insertAll(pairs);
+    }
+    /** Find all preference pairs regardless of export status. */
+    findAll() {
+        const rows = this.db.prepare('SELECT * FROM preference_pairs ORDER BY created_at ASC').all();
+        return rows.map(rowToPair);
+    }
+    /** Find all unexported preference pairs. */
+    findUnexported() {
+        const rows = this.db.prepare('SELECT * FROM preference_pairs WHERE exported = 0 ORDER BY created_at ASC').all();
+        return rows.map(rowToPair);
+    }
+    /** Mark a list of pair IDs as exported. */
+    markExported(ids) {
+        if (ids.length === 0)
+            return;
+        const placeholders = ids.map(() => '?').join(',');
+        this.db.prepare(`UPDATE preference_pairs SET exported = 1 WHERE id IN (${placeholders})`).run(...ids);
+    }
+    /** Count total preference pairs. */
+    count() {
+        const row = this.db.prepare('SELECT COUNT(*) as cnt FROM preference_pairs').get();
+        return row.cnt;
+    }
+    /** Count unexported preference pairs. */
+    countUnexported() {
+        const row = this.db.prepare('SELECT COUNT(*) as cnt FROM preference_pairs WHERE exported = 0').get();
+        return row.cnt;
+    }
+    /**
+     * Export unexported pairs to a JSONL file and mark them as exported.
+     * Each line contains: {"prompt", "chosen", "rejected"}.
+     * @returns The number of pairs exported.
+     */
+    exportDpo(outputPath) {
+        const rows = this.db.prepare('SELECT * FROM preference_pairs WHERE exported = 0 ORDER BY created_at ASC').all();
+        if (rows.length === 0)
+            return 0;
+        const lines = rows.map((row) => JSON.stringify({
+            prompt: row.prompt,
+            chosen: row.chosen,
+            rejected: row.rejected,
+        }));
+        writeFileSync(outputPath, lines.join('\n') + '\n', 'utf-8');
+        const ids = rows.map((r) => r.id);
+        this.markExported(ids);
+        return rows.length;
+    }
+}
+//# sourceMappingURL=pair-store.js.map

package/dist/reputation.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Tracks and computes user reputation scores.
+ * @module feedback/reputation
+ */
+import type Database from 'better-sqlite3';
+import type { ReputationScore } from './types.js';
+/** Threshold label for a user's reputation. */
+export type ReputationThreshold = 'trusted' | 'normal' | 'untrusted';
+/** Tracks user reputation based on interaction signal history. */
+export declare class ReputationTracker {
+    private readonly db;
+    constructor(db: Database.Database);
+    /**
+     * Calculate reputation score from signal history.
+     * Formula: (correctCorrections * 2 + shared - rejected - escalated) / (totalSignals + 10)
+     * Clamped to 0-1.
+     */
+    calculate(userId: string): number;
+    /** Get the stored reputation score for a user. */
+    getScore(userId: string): ReputationScore | null;
+    /** Recalculate and store the reputation score. */
+    update(userId: string): ReputationScore;
+    /** Get the threshold label for a user's reputation. */
+    getThreshold(userId: string): ReputationThreshold;
+}
+//# sourceMappingURL=reputation.d.ts.map

package/dist/reputation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reputation.d.ts","sourceRoot":"","sources":["../src/reputation.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAC;AAC3C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,+CAA+C;AAC/C,MAAM,MAAM,mBAAmB,GAAG,SAAS,GAAG,QAAQ,GAAG,WAAW,CAAC;AAErE,kEAAkE;AAClE,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAoB;gBAE3B,EAAE,EAAE,QAAQ,CAAC,QAAQ;IAIjC;;;;OAIG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAwBjC,kDAAkD;IAClD,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI;IAUhD,kDAAkD;IAClD,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe;IAgCvC,uDAAuD;IACvD,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,mBAAmB;CAMlD"}

package/dist/reputation.js

@@ -0,0 +1,93 @@
+/**
+ * Tracks and computes user reputation scores.
+ * @module feedback/reputation
+ */
+/** Tracks user reputation based on interaction signal history. */
+export class ReputationTracker {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    /**
+     * Calculate reputation score from signal history.
+     * Formula: (correctCorrections * 2 + shared - rejected - escalated) / (totalSignals + 10)
+     * Clamped to 0-1.
+     */
+    calculate(userId) {
+        const rows = this.db.prepare('SELECT signal_type, COUNT(*) as cnt FROM interaction_signals WHERE user_id = ? GROUP BY signal_type').all(userId);
+        const counts = {};
+        let totalSignals = 0;
+        for (const row of rows) {
+            counts[row.signal_type] = row.cnt;
+            totalSignals += row.cnt;
+        }
+        const shared = counts['shared'] ?? 0;
+        const rejected = counts['rejected'] ?? 0;
+        const escalated = counts['escalated'] ?? 0;
+        const corrected = counts['corrected'] ?? 0;
+        const numerator = corrected * 2 + shared - rejected - escalated;
+        const denominator = totalSignals + 10;
+        const raw = numerator / denominator;
+        return Math.min(1, Math.max(0, raw));
+    }
+    /** Get the stored reputation score for a user. */
+    getScore(userId) {
+        const row = this.db.prepare('SELECT * FROM user_reputation WHERE user_id = ?').get(userId);
+        if (!row)
+            return null;
+        return rowToReputation(row);
+    }
+    /** Recalculate and store the reputation score. */
+    update(userId) {
+        const score = this.calculate(userId);
+        const signalCounts = this.db.prepare('SELECT signal_type, COUNT(*) as cnt FROM interaction_signals WHERE user_id = ? GROUP BY signal_type').all(userId);
+        const counts = toCountMap(signalCounts);
+        const totalSignals = Object.values(counts).reduce((a, b) => a + b, 0);
+        const now = new Date();
+        this.db.prepare(`
+      INSERT INTO user_reputation (user_id, score, total_signals, correct_corrections, overridden_corrections, last_updated)
+      VALUES (?, ?, ?, ?, ?, ?)
+      ON CONFLICT(user_id) DO UPDATE SET
+        score = excluded.score,
+        total_signals = excluded.total_signals,
+        correct_corrections = excluded.correct_corrections,
+        overridden_corrections = excluded.overridden_corrections,
+        last_updated = excluded.last_updated
+    `).run(userId, score, totalSignals, counts['corrected'] ?? 0, 0, now.toISOString());
+        return {
+            userId,
+            score,
+            totalSignals,
+            correctCorrections: counts['corrected'] ?? 0,
+            overriddenCorrections: 0,
+            lastUpdated: now,
+        };
+    }
+    /** Get the threshold label for a user's reputation. */
+    getThreshold(userId) {
+        const score = this.calculate(userId);
+        if (score >= 0.8)
+            return 'trusted';
+        if (score >= 0.4)
+            return 'normal';
+        return 'untrusted';
+    }
+}
+function rowToReputation(row) {
+    return {
+        userId: row.user_id,
+        score: row.score,
+        totalSignals: row.total_signals,
+        correctCorrections: row.correct_corrections,
+        overriddenCorrections: row.overridden_corrections,
+        lastUpdated: new Date(row.last_updated),
+    };
+}
+function toCountMap(rows) {
+    const map = {};
+    for (const row of rows) {
+        map[row.signal_type] = row.cnt;
+    }
+    return map;
+}
+//# sourceMappingURL=reputation.js.map

package/dist/reward-derivation.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Derives rewards and preference pairs from interaction signals.
+ * @module feedback/reward-derivation
+ */
+import type { Detection, KnowledgeNode, PreferencePair } from '@useody/platform-core';
+import type { CorrectionSignal, InteractionSignal, ReputationScore, RewardDerivation } from './types.js';
+/**
+ * Derive a reward from an interaction signal, factoring in user reputation.
+ */
+export declare function deriveReward(signal: InteractionSignal, reputation: ReputationScore): RewardDerivation;
+/**
+ * Generate a topic-based question from node content when no original question is available.
+ * Extracts a meaningful topic from the content to create a natural question.
+ */
+export declare function generateQuestionFromContent(content: string): string;
+/**
+ * Generate a natural language prompt from a detection and its referenced nodes.
+ * Extracts the topic from the detection description or node titles to form a question.
+ * Returns null if no meaningful prompt can be derived.
+ */
+export declare function generatePromptFromDetection(detection: Detection, nodes: KnowledgeNode[]): string | null;
+/**
+ * Check whether a string looks like a UUID or a comma-separated list of UUIDs.
+ * Used to prevent UUID-based prompts from leaking into training data.
+ */
+export declare function looksLikeUuid(text: string): boolean;
+/**
+ * Derive a preference pair from a correction signal.
+ * Only generates pairs for 'corrected' signals with sufficient reputation.
+ * Returns null if reputation is below 0.4 (queued for review),
+ * or if no meaningful prompt can be generated (avoids UUID-based prompts).
+ *
+ * @param signal - The interaction signal
+ * @param originalAnswer - The model's original response
+ * @param correctedText - The user's corrected text
+ * @param reputation - The correcting user's reputation
+ * @param originalQuestion - The actual user question (optional)
+ * @param nodeContent - Content from referenced nodes for question generation (optional)
+ */
+export declare function derivePreferencePair(signal: InteractionSignal, originalAnswer: string, correctedText: string, reputation: ReputationScore, originalQuestion?: string, nodeContent?: string): PreferencePair | null;
+/**
+ * Derive a preference pair directly from a correction signal.
+ * Simpler than detection-based pairs: the user already provided
+ * the chosen (corrected) and rejected (original) responses.
+ * No LLM call needed.
+ *
+ * @param correction - The enriched correction signal
+ * @param reputation - The correcting user's reputation score
+ * @returns A preference pair, or null if reputation is too low or prompt is invalid
+ */
+export declare function derivePreferencePairFromCorrection(correction: CorrectionSignal, reputation: ReputationScore): PreferencePair | null;
+//# sourceMappingURL=reward-derivation.d.ts.map

package/dist/reward-derivation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reward-derivation.d.ts","sourceRoot":"","sources":["../src/reward-derivation.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACtF,OAAO,KAAK,EACV,gBAAgB,EAChB,iBAAiB,EACjB,eAAe,EACf,gBAAgB,EACjB,MAAM,YAAY,CAAC;AAMpB;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,iBAAiB,EAAE,UAAU,EAAE,eAAe,GAAG,gBAAgB,CA+CrG;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAInE;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,SAAS,EAAE,SAAS,EACpB,KAAK,EAAE,aAAa,EAAE,GACrB,MAAM,GAAG,IAAI,CA8Bf;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAGnD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,iBAAiB,EACzB,cAAc,EAAE,MAAM,EACtB,aAAa,EAAE,MAAM,EACrB,UAAU,EAAE,eAAe,EAC3B,gBAAgB,CAAC,EAAE,MAAM,EACzB,WAAW,CAAC,EAAE,MAAM,GACnB,cAAc,GAAG,IAAI,CAmCvB;AAED;;;;;;;;;GASG;AACH,wBAAgB,kCAAkC,CAChD,UAAU,EAAE,gBAAgB,EAC5B,UAAU,EAAE,eAAe,GAC1B,cAAc,GAAG,IAAI,CAyBvB"}

package/dist/reward-derivation.js

@@ -0,0 +1,182 @@
+/**
+ * Derives rewards and preference pairs from interaction signals.
+ * @module feedback/reward-derivation
+ */
+import { SIGNAL_WEIGHTS } from './types.js';
+/** UUID v4 pattern used to detect invalid prompt content. */
+const UUID_V4_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/**
+ * Derive a reward from an interaction signal, factoring in user reputation.
+ */
+export function deriveReward(signal, reputation) {
+    const weights = SIGNAL_WEIGHTS[signal.signalType];
+    const adjustedWeight = weights.weight * reputation.score;
+    let reason;
+    switch (signal.signalType) {
+        case 'accepted':
+            reason = 'User accepted the answer';
+            break;
+        case 'rejected':
+            reason = 'User rejected the answer';
+            break;
+        case 'corrected':
+            reason = `User provided correction (reputation: ${reputation.score.toFixed(2)})`;
+            break;
+        case 'escalated':
+            reason = 'User escalated to another source';
+            break;
+        case 'shared':
+            reason = 'User shared the answer with others';
+            break;
+        case 'follow_up':
+            reason = 'User asked a follow-up question';
+            break;
+        case 'emoji_positive':
+            reason = 'Positive emoji reaction (thumbsup, check, heart)';
+            break;
+        case 'emoji_negative':
+            reason = 'Negative emoji reaction (thumbsdown, x, confused)';
+            break;
+        case 'reply_positive':
+            reason = 'Reply with positive sentiment';
+            break;
+        case 'reply_negative':
+            reason = 'Reply with negative sentiment';
+            break;
+        default:
+            reason = `Signal: ${signal.signalType}`;
+    }
+    return {
+        signalId: signal.id,
+        rewardType: weights.type,
+        weight: Math.min(1, Math.max(0, adjustedWeight)),
+        preferencePairGenerated: false,
+        reason,
+    };
+}
+/**
+ * Generate a topic-based question from node content when no original question is available.
+ * Extracts a meaningful topic from the content to create a natural question.
+ */
+export function generateQuestionFromContent(content) {
+    const firstLine = content.split('\n')[0]?.trim() ?? '';
+    const topic = firstLine.length > 80 ? firstLine.slice(0, 80) : firstLine;
+    return `What is the current policy on ${topic}?`;
+}
+/**
+ * Generate a natural language prompt from a detection and its referenced nodes.
+ * Extracts the topic from the detection description or node titles to form a question.
+ * Returns null if no meaningful prompt can be derived.
+ */
+export function generatePromptFromDetection(detection, nodes) {
+    // Try to extract topic from the detection description
+    const desc = detection.description.trim();
+    if (desc.length > 0) {
+        // Use the detection description to form a targeted question
+        const topic = desc.length > 120 ? desc.slice(0, 120) : desc;
+        return `What is the correct information regarding: ${topic}`;
+    }
+    // Fall back to node titles
+    const titles = nodes
+        .filter((n) => detection.nodeIds.includes(n.id))
+        .map((n) => n.title)
+        .filter((t) => t.trim().length > 0);
+    if (titles.length > 0) {
+        return `What is the current policy on ${titles.join(' and ')}?`;
+    }
+    // Fall back to node content summaries
+    const summaries = nodes
+        .filter((n) => detection.nodeIds.includes(n.id))
+        .map((n) => n.content.summary)
+        .filter((s) => s.trim().length > 0);
+    if (summaries.length > 0) {
+        return generateQuestionFromContent(summaries[0]);
+    }
+    return null;
+}
+/**
+ * Check whether a string looks like a UUID or a comma-separated list of UUIDs.
+ * Used to prevent UUID-based prompts from leaking into training data.
+ */
+export function looksLikeUuid(text) {
+    const parts = text.split(/[, ]+/).map((s) => s.trim()).filter((s) => s.length > 0);
+    return parts.length > 0 && parts.every((p) => UUID_V4_PATTERN.test(p));
+}
+/**
+ * Derive a preference pair from a correction signal.
+ * Only generates pairs for 'corrected' signals with sufficient reputation.
+ * Returns null if reputation is below 0.4 (queued for review),
+ * or if no meaningful prompt can be generated (avoids UUID-based prompts).
+ *
+ * @param signal - The interaction signal
+ * @param originalAnswer - The model's original response
+ * @param correctedText - The user's corrected text
+ * @param reputation - The correcting user's reputation
+ * @param originalQuestion - The actual user question (optional)
+ * @param nodeContent - Content from referenced nodes for question generation (optional)
+ */
+export function derivePreferencePair(signal, originalAnswer, correctedText, reputation, originalQuestion, nodeContent) {
+    if (signal.signalType !== 'corrected') {
+        return null;
+    }
+    if (reputation.score < 0.4) {
+        return null;
+    }
+    const confidence = reputation.score >= 0.8 ? 1.0 : 0.6;
+    let prompt = null;
+    if (originalQuestion && !looksLikeUuid(originalQuestion)) {
+        prompt = originalQuestion;
+    }
+    else if (nodeContent) {
+        prompt = generateQuestionFromContent(nodeContent);
+    }
+    // If no prompt could be derived, return null rather than embedding UUIDs
+    if (!prompt) {
+        return null;
+    }
+    return {
+        prompt,
+        chosen: correctedText,
+        rejected: originalAnswer,
+        metadata: {
+            conflictType: 'contradiction',
+            resolvedBy: signal.userId,
+            resolvedAt: signal.createdAt,
+            confidence,
+            sourceNodeIds: signal.questionNodeIds,
+        },
+    };
+}
+/**
+ * Derive a preference pair directly from a correction signal.
+ * Simpler than detection-based pairs: the user already provided
+ * the chosen (corrected) and rejected (original) responses.
+ * No LLM call needed.
+ *
+ * @param correction - The enriched correction signal
+ * @param reputation - The correcting user's reputation score
+ * @returns A preference pair, or null if reputation is too low or prompt is invalid
+ */
+export function derivePreferencePairFromCorrection(correction, reputation) {
+    if (reputation.score < 0.4) {
+        return null;
+    }
+    const { originalQuestion, originalAnswer, correctedAnswer, signal } = correction;
+    if (looksLikeUuid(originalQuestion)) {
+        return null;
+    }
+    const confidence = reputation.score >= 0.8 ? 1.0 : 0.6;
+    return {
+        prompt: originalQuestion,
+        chosen: correctedAnswer,
+        rejected: originalAnswer,
+        metadata: {
+            conflictType: 'contradiction',
+            resolvedBy: signal.userId,
+            resolvedAt: signal.createdAt,
+            confidence,
+            sourceNodeIds: signal.questionNodeIds,
+        },
+    };
+}
+//# sourceMappingURL=reward-derivation.js.map

package/dist/schema.d.ts

@@ -0,0 +1,11 @@
+/**
+ * SQLite schema for the feedback package.
+ * @module feedback/schema
+ */
+import type Database from 'better-sqlite3';
+/**
+ * Create feedback tables in the given SQLite database.
+ * Creates interaction_signals and user_reputation tables.
+ */
+export declare function createFeedbackSchema(db: Database.Database): void;
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAC;AAE3C;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,QAAQ,CAAC,QAAQ,GAAG,IAAI,CA4BhE"}

package/dist/schema.js

@@ -0,0 +1,38 @@
+/**
+ * SQLite schema for the feedback package.
+ * @module feedback/schema
+ */
+/**
+ * Create feedback tables in the given SQLite database.
+ * Creates interaction_signals and user_reputation tables.
+ */
+export function createFeedbackSchema(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS interaction_signals (
+      id TEXT PRIMARY KEY,
+      user_id TEXT NOT NULL,
+      conversation_id TEXT NOT NULL,
+      turn_id TEXT NOT NULL,
+      signal_type TEXT NOT NULL CHECK(signal_type IN ('accepted','rejected','corrected','escalated','shared','follow_up','emoji_positive','emoji_negative','reply_positive','reply_negative')),
+      correction_text TEXT,
+      question_node_ids TEXT NOT NULL DEFAULT '[]',
+      time_to_action_ms INTEGER NOT NULL,
+      reputation_weight REAL NOT NULL DEFAULT 1.0,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_signals_user_id ON interaction_signals(user_id);
+    CREATE INDEX IF NOT EXISTS idx_signals_conversation_id ON interaction_signals(conversation_id);
+    CREATE INDEX IF NOT EXISTS idx_signals_signal_type ON interaction_signals(signal_type);
+
+    CREATE TABLE IF NOT EXISTS user_reputation (
+      user_id TEXT PRIMARY KEY,
+      score REAL NOT NULL DEFAULT 0.5,
+      total_signals INTEGER NOT NULL DEFAULT 0,
+      correct_corrections INTEGER NOT NULL DEFAULT 0,
+      overridden_corrections INTEGER NOT NULL DEFAULT 0,
+      last_updated TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+  `);
+}
+//# sourceMappingURL=schema.js.map

package/dist/signal-collector.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Collects and queries interaction signals from users.
+ * @module feedback/signal-collector
+ */
+import type Database from 'better-sqlite3';
+import type { InteractionSignal, SignalType } from './types.js';
+/** Collects user interaction signals into SQLite. */
+export declare class SignalCollector {
+    private readonly db;
+    constructor(db: Database.Database);
+    /** Record a new interaction signal. */
+    record(signal: Omit<InteractionSignal, 'id' | 'createdAt'>): InteractionSignal;
+    /** Find all signals for a conversation. */
+    findByConversation(conversationId: string): InteractionSignal[];
+    /** Find recent signals for a user. */
+    findByUser(userId: string, limit?: number): InteractionSignal[];
+    /** Count signals by type for a user. */
+    countByType(userId: string): Record<SignalType, number>;
+}
+//# sourceMappingURL=signal-collector.d.ts.map

package/dist/signal-collector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signal-collector.d.ts","sourceRoot":"","sources":["../src/signal-collector.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAC;AAE3C,OAAO,KAAK,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAEhE,qDAAqD;AACrD,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAoB;gBAE3B,EAAE,EAAE,QAAQ,CAAC,QAAQ;IAIjC,uCAAuC;IACvC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,iBAAiB,EAAE,IAAI,GAAG,WAAW,CAAC,GAAG,iBAAiB;IAwB9E,2CAA2C;IAC3C,kBAAkB,CAAC,cAAc,EAAE,MAAM,GAAG,iBAAiB,EAAE;IAQ/D,sCAAsC;IACtC,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,SAAM,GAAG,iBAAiB,EAAE;IAQ5D,wCAAwC;IACxC,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC;CAkBxD"}

package/dist/signal-collector.js

@@ -0,0 +1,62 @@
+/**
+ * Collects and queries interaction signals from users.
+ * @module feedback/signal-collector
+ */
+import crypto from 'node:crypto';
+/** Collects user interaction signals into SQLite. */
+export class SignalCollector {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    /** Record a new interaction signal. */
+    record(signal) {
+        const id = crypto.randomUUID();
+        const createdAt = new Date();
+        this.db.prepare(`
+      INSERT INTO interaction_signals
+        (id, user_id, conversation_id, turn_id, signal_type, correction_text, question_node_ids, time_to_action_ms, reputation_weight, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(id, signal.userId, signal.conversationId, signal.turnId, signal.signalType, signal.correctionText ?? null, JSON.stringify(signal.questionNodeIds), signal.timeToActionMs, signal.reputationWeight, createdAt.toISOString());
+        return { id, createdAt, ...signal };
+    }
+    /** Find all signals for a conversation. */
+    findByConversation(conversationId) {
+        const rows = this.db.prepare('SELECT * FROM interaction_signals WHERE conversation_id = ? ORDER BY created_at ASC').all(conversationId);
+        return rows.map(rowToSignal);
+    }
+    /** Find recent signals for a user. */
+    findByUser(userId, limit = 100) {
+        const rows = this.db.prepare('SELECT * FROM interaction_signals WHERE user_id = ? ORDER BY created_at DESC LIMIT ?').all(userId, limit);
+        return rows.map(rowToSignal);
+    }
+    /** Count signals by type for a user. */
+    countByType(userId) {
+        const rows = this.db.prepare('SELECT signal_type, COUNT(*) as cnt FROM interaction_signals WHERE user_id = ? GROUP BY signal_type').all(userId);
+        const result = {
+            accepted: 0, rejected: 0, corrected: 0,
+            escalated: 0, shared: 0, follow_up: 0,
+            emoji_positive: 0, emoji_negative: 0,
+            reply_positive: 0, reply_negative: 0,
+        };
+        for (const row of rows) {
+            result[row.signal_type] = row.cnt;
+        }
+        return result;
+    }
+}
+function rowToSignal(row) {
+    return {
+        id: row.id,
+        userId: row.user_id,
+        conversationId: row.conversation_id,
+        turnId: row.turn_id,
+        signalType: row.signal_type,
+        correctionText: row.correction_text ?? undefined,
+        questionNodeIds: JSON.parse(row.question_node_ids),
+        timeToActionMs: row.time_to_action_ms,
+        reputationWeight: row.reputation_weight,
+        createdAt: new Date(row.created_at),
+    };
+}
+//# sourceMappingURL=signal-collector.js.map

package/dist/types.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Feedback package types for interaction signals, reputation, and rewards.
+ * @module feedback/types
+ */
+/** Types of user interaction signals. */
+export type SignalType = 'accepted' | 'rejected' | 'corrected' | 'escalated' | 'shared' | 'follow_up' | 'emoji_positive' | 'emoji_negative' | 'reply_positive' | 'reply_negative';
+/** A recorded user interaction signal. */
+export interface InteractionSignal {
+    id: string;
+    userId: string;
+    conversationId: string;
+    turnId: string;
+    signalType: SignalType;
+    correctionText?: string;
+    questionNodeIds: string[];
+    timeToActionMs: number;
+    reputationWeight: number;
+    createdAt: Date;
+}
+/** A user's reputation score and history. */
+export interface ReputationScore {
+    userId: string;
+    score: number;
+    totalSignals: number;
+    correctCorrections: number;
+    overriddenCorrections: number;
+    lastUpdated: Date;
+}
+/** Derived reward from an interaction signal. */
+export interface RewardDerivation {
+    signalId: string;
+    rewardType: 'positive' | 'negative' | 'neutral';
+    weight: number;
+    preferencePairGenerated: boolean;
+    reason: string;
+}
+/**
+ * A correction signal with the full context needed for preference pair creation.
+ * This is the enriched version of an InteractionSignal with type 'corrected'.
+ */
+export interface CorrectionSignal {
+    /** The underlying interaction signal. */
+    signal: InteractionSignal;
+    /** The original question the user asked. */
+    originalQuestion: string;
+    /** Colleague's original answer (becomes the rejected response). */
+    originalAnswer: string;
+    /** The user's corrected answer (becomes the chosen response). */
+    correctedAnswer: string;
+}
+/** Signal weights for reward derivation. */
+export declare const SIGNAL_WEIGHTS: Record<SignalType, {
+    type: 'positive' | 'negative' | 'neutral';
+    weight: number;
+}>;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,yCAAyC;AACzC,MAAM,MAAM,UAAU,GAClB,UAAU,GACV,UAAU,GACV,WAAW,GACX,WAAW,GACX,QAAQ,GACR,WAAW,GACX,gBAAgB,GAChB,gBAAgB,GAChB,gBAAgB,GAChB,gBAAgB,CAAC;AAErB,0CAA0C;AAC1C,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,UAAU,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB,EAAE,MAAM,CAAC;IACzB,SAAS,EAAE,IAAI,CAAC;CACjB;AAED,6CAA6C;AAC7C,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,CAAC;IACrB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,qBAAqB,EAAE,MAAM,CAAC;IAC9B,WAAW,EAAE,IAAI,CAAC;CACnB;AAED,iDAAiD;AACjD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,UAAU,GAAG,UAAU,GAAG,SAAS,CAAC;IAChD,MAAM,EAAE,MAAM,CAAC;IACf,uBAAuB,EAAE,OAAO,CAAC;IACjC,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,yCAAyC;IACzC,MAAM,EAAE,iBAAiB,CAAC;IAC1B,4CAA4C;IAC5C,gBAAgB,EAAE,MAAM,CAAC;IACzB,mEAAmE;IACnE,cAAc,EAAE,MAAM,CAAC;IACvB,iEAAiE;IACjE,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,4CAA4C;AAC5C,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,UAAU,EAAE;IAAE,IAAI,EAAE,UAAU,GAAG,UAAU,GAAG,SAAS,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAa5G,CAAC"}

package/dist/types.js

@@ -0,0 +1,20 @@
+/**
+ * Feedback package types for interaction signals, reputation, and rewards.
+ * @module feedback/types
+ */
+/** Signal weights for reward derivation. */
+export const SIGNAL_WEIGHTS = {
+    // Explicit interaction signals
+    accepted: { type: 'positive', weight: 0.3 },
+    rejected: { type: 'negative', weight: 0.6 },
+    corrected: { type: 'negative', weight: 0.9 },
+    escalated: { type: 'negative', weight: 0.5 },
+    shared: { type: 'positive', weight: 0.8 },
+    follow_up: { type: 'neutral', weight: 0.1 },
+    // Passive sentiment signals (emoji reactions, reply tone)
+    emoji_positive: { type: 'positive', weight: 0.4 },
+    emoji_negative: { type: 'negative', weight: 0.5 },
+    reply_positive: { type: 'positive', weight: 0.5 },
+    reply_negative: { type: 'negative', weight: 0.6 },
+};
+//# sourceMappingURL=types.js.map

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@useody/feedback",
+  "description": "Interaction signal collection, reputation scoring, and reward derivation for continuous learning",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src/",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "pnpm build"
+  },
+  "dependencies": {
+    "@useody/platform-core": "workspace:*",
+    "better-sqlite3": "^11.8.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.0",
+    "vitest": "^3.0.0",
+    "typescript": "^5.7.0"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ufukkaraca/ody-platform.git",
+    "directory": "packages/feedback"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "dist/**/*.d.ts.map",
+    "README.md",
+    "LICENSE"
+  ]
+}