instar 1.3.20 → 1.3.22

package/dist/feedback-factory/processor/process.d.ts

@@ -0,0 +1,26 @@
+/**
+ * process.ts — the feedback-factory processing composition.
+ *
+ * Ties the already-parity'd pure pieces together over a FeedbackStore, mirroring
+ * the reference's cmd_cluster (decide) + cmd_apply_clusters (write) run back-to-back:
+ *
+ *   1. read unprocessed items + active clusters from the store
+ *   2. clusterItems() decides merge/create per item (parity'd, increment 4)
+ *   3. apply each decision to the store (create / merge); when a merge carries a
+ *      "possible regression" note, computeReopen() (parity'd, increment 8) decides
+ *      the reopen and applyReopen writes it
+ *   4. mark each item processed; counters update for observability
+ *
+ * The decision logic is already proven equivalent to the reference; this is the
+ * orchestration over the injected store, verified by the Tier-2 integration test
+ * against InMemoryFeedbackStore.
+ */
+import type { ClusterResult } from './types.js';
+import type { FeedbackStore, FeedbackMetrics } from '../store/FeedbackStore.js';
+export interface ProcessResult {
+    results: ClusterResult[];
+    metrics: FeedbackMetrics;
+}
+/** Run one clustering+apply pass over the store. `now` injected for the reopen audit note. */
+export declare function processUnprocessed(store: FeedbackStore, now: string): ProcessResult;
+//# sourceMappingURL=process.d.ts.map

package/dist/feedback-factory/processor/process.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process.d.ts","sourceRoot":"","sources":["../../../src/feedback-factory/processor/process.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAEhF,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,OAAO,EAAE,eAAe,CAAC;CAC1B;AAED,8FAA8F;AAC9F,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,GAAG,aAAa,CA2BnF"}

package/dist/feedback-factory/processor/process.js

@@ -0,0 +1,47 @@
+/**
+ * process.ts — the feedback-factory processing composition.
+ *
+ * Ties the already-parity'd pure pieces together over a FeedbackStore, mirroring
+ * the reference's cmd_cluster (decide) + cmd_apply_clusters (write) run back-to-back:
+ *
+ *   1. read unprocessed items + active clusters from the store
+ *   2. clusterItems() decides merge/create per item (parity'd, increment 4)
+ *   3. apply each decision to the store (create / merge); when a merge carries a
+ *      "possible regression" note, computeReopen() (parity'd, increment 8) decides
+ *      the reopen and applyReopen writes it
+ *   4. mark each item processed; counters update for observability
+ *
+ * The decision logic is already proven equivalent to the reference; this is the
+ * orchestration over the injected store, verified by the Tier-2 integration test
+ * against InMemoryFeedbackStore.
+ */
+import { clusterItems } from './cluster.js';
+import { computeReopen } from './reopen.js';
+/** Run one clustering+apply pass over the store. `now` injected for the reopen audit note. */
+export function processUnprocessed(store, now) {
+    const items = store.getUnprocessedFeedback();
+    const clusters = store.getActiveClusters();
+    const itemById = new Map(items.map((i) => [i.feedbackId, i]));
+    const results = clusterItems(items, clusters);
+    for (const r of results) {
+        const item = itemById.get(r.feedbackId);
+        if (!item)
+            continue;
+        if (r.action === 'create') {
+            store.upsertClusterFromItem(r.clusterId, item);
+        }
+        else {
+            store.mergeIntoCluster(r.clusterId, item);
+            // A merge that flagged a possible regression auto-reopens the cluster.
+            if (r.note && r.note.includes('possible regression')) {
+                const cluster = store.getCluster(r.clusterId);
+                if (cluster) {
+                    store.applyReopen(r.clusterId, computeReopen(cluster, r.feedbackId, now));
+                }
+            }
+        }
+        store.markProcessed(r.feedbackId, r.clusterId);
+    }
+    return { results, metrics: store.metrics() };
+}
+//# sourceMappingURL=process.js.map

package/dist/feedback-factory/processor/process.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"process.js","sourceRoot":"","sources":["../../../src/feedback-factory/processor/process.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAS5C,8FAA8F;AAC9F,MAAM,UAAU,kBAAkB,CAAC,KAAoB,EAAE,GAAW;IAClE,MAAM,KAAK,GAAG,KAAK,CAAC,sBAAsB,EAAE,CAAC;IAC7C,MAAM,QAAQ,GAAG,KAAK,CAAC,iBAAiB,EAAE,CAAC;IAC3C,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IAE9D,MAAM,OAAO,GAAG,YAAY,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IAE9C,KAAK,MAAM,CAAC,IAAI,OAAO,EAAE,CAAC;QACxB,MAAM,IAAI,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC;QACxC,IAAI,CAAC,IAAI;YAAE,SAAS;QAEpB,IAAI,CAAC,CAAC,MAAM,KAAK,QAAQ,EAAE,CAAC;YAC1B,KAAK,CAAC,qBAAqB,CAAC,CAAC,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;QACjD,CAAC;aAAM,CAAC;YACN,KAAK,CAAC,gBAAgB,CAAC,CAAC,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;YAC1C,uEAAuE;YACvE,IAAI,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,qBAAqB,CAAC,EAAE,CAAC;gBACrD,MAAM,OAAO,GAAG,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;gBAC9C,IAAI,OAAO,EAAE,CAAC;oBACZ,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,EAAE,aAAa,CAAC,OAAO,EAAE,CAAC,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC,CAAC;gBAC5E,CAAC;YACH,CAAC;QACH,CAAC;QACD,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,UAAU,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC;IACjD,CAAC;IAED,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,EAAE,CAAC;AAC/C,CAAC"}

package/dist/feedback-factory/processor/reportPartition.d.ts

@@ -0,0 +1,42 @@
+/**
+ * reportPartition.ts — TS port of scar (d): lifecycle partitioning + re-report
+ * (cycling) prevention for the operator digest.
+ *
+ * Ports the pure partition decision from the report-generation function (:2747) of
+ * the reference `the-portal/.claude/scripts/feedback-processor.py` — the half of
+ * scar (d) that complements the cluster-level cycling detection already ported in
+ * transitions.ts. Given the current clusters + what was surfaced in the LAST
+ * operator report, it decides what is actionable now: newly-open vs already-known
+ * issues, the same for investigating, and items FIXED since the last report that
+ * haven't been announced before (the re-report/cycling guard — a fix is announced
+ * once, never again). It also decides whether the whole report should be skipped
+ * (nothing new ⇒ no noise).
+ *
+ * Pure: the clusters, the previous-report state, and `now` are injected (the real
+ * reporter does the DB query + state load + Telegram render around this). `now` is
+ * an ISO string. Equivalence is by faithful transcription + both-sides-of-boundary
+ * unit tests (the decision is embedded in a Telegram-rendering function in the
+ * reference, so there is no clean isolated function for a cross-runtime harness).
+ */
+import type { Cluster } from './types.js';
+export interface PreviousReportState {
+    lastReportAt?: string;
+    reportedOpenIds?: string[];
+    reportedInvestigatingIds?: string[];
+    reportedFixedIds?: string[];
+}
+export interface ReportPartition {
+    newIssues: Cluster[];
+    continuingOpen: Cluster[];
+    newInvestigating: Cluster[];
+    continuingInvestigating: Cluster[];
+    fixedNew: Cluster[];
+    /** True when there is nothing new to report (report should be skipped to avoid noise). */
+    shouldSkip: boolean;
+}
+/**
+ * Partition clusters for an operator report. `now` (ISO) is used only for the
+ * first-run window (no prior report → items fixed in the last 4h).
+ */
+export declare function partitionClustersForReport(clusters: Cluster[], prev: PreviousReportState, now: string): ReportPartition;
+//# sourceMappingURL=reportPartition.d.ts.map

package/dist/feedback-factory/processor/reportPartition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reportPartition.d.ts","sourceRoot":"","sources":["../../../src/feedback-factory/processor/reportPartition.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE1C,MAAM,WAAW,mBAAmB;IAClC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,wBAAwB,CAAC,EAAE,MAAM,EAAE,CAAC;IACpC,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC7B;AAED,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,OAAO,EAAE,CAAC;IACrB,cAAc,EAAE,OAAO,EAAE,CAAC;IAC1B,gBAAgB,EAAE,OAAO,EAAE,CAAC;IAC5B,uBAAuB,EAAE,OAAO,EAAE,CAAC;IACnC,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,0FAA0F;IAC1F,UAAU,EAAE,OAAO,CAAC;CACrB;AAUD;;;GAGG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,OAAO,EAAE,EACnB,IAAI,EAAE,mBAAmB,EACzB,GAAG,EAAE,MAAM,GACV,eAAe,CA6BjB"}

package/dist/feedback-factory/processor/reportPartition.js

@@ -0,0 +1,55 @@
+/**
+ * reportPartition.ts — TS port of scar (d): lifecycle partitioning + re-report
+ * (cycling) prevention for the operator digest.
+ *
+ * Ports the pure partition decision from the report-generation function (:2747) of
+ * the reference `the-portal/.claude/scripts/feedback-processor.py` — the half of
+ * scar (d) that complements the cluster-level cycling detection already ported in
+ * transitions.ts. Given the current clusters + what was surfaced in the LAST
+ * operator report, it decides what is actionable now: newly-open vs already-known
+ * issues, the same for investigating, and items FIXED since the last report that
+ * haven't been announced before (the re-report/cycling guard — a fix is announced
+ * once, never again). It also decides whether the whole report should be skipped
+ * (nothing new ⇒ no noise).
+ *
+ * Pure: the clusters, the previous-report state, and `now` are injected (the real
+ * reporter does the DB query + state load + Telegram render around this). `now` is
+ * an ISO string. Equivalence is by faithful transcription + both-sides-of-boundary
+ * unit tests (the decision is embedded in a Telegram-rendering function in the
+ * reference, so there is no clean isolated function for a cross-runtime harness).
+ */
+const SEVERITY_ORDER = { critical: 0, high: 1, medium: 2, low: 3 };
+function bySeverity(a, b) {
+    const sa = SEVERITY_ORDER[a.severity ?? ''] ?? 9;
+    const sb = SEVERITY_ORDER[b.severity ?? ''] ?? 9;
+    return sa - sb;
+}
+/**
+ * Partition clusters for an operator report. `now` (ISO) is used only for the
+ * first-run window (no prior report → items fixed in the last 4h).
+ */
+export function partitionClustersForReport(clusters, prev, now) {
+    const prevOpen = new Set(prev.reportedOpenIds ?? []);
+    const prevInvestigating = new Set(prev.reportedInvestigatingIds ?? []);
+    const prevFixed = new Set(prev.reportedFixedIds ?? []);
+    const lastReportTime = prev.lastReportAt ?? '';
+    const allOpen = clusters.filter((c) => c.status === 'open');
+    const allInvestigating = clusters.filter((c) => c.status === 'investigating');
+    const newIssues = allOpen.filter((c) => !prevOpen.has(c.clusterId)).sort(bySeverity);
+    const continuingOpen = allOpen.filter((c) => prevOpen.has(c.clusterId));
+    const newInvestigating = allInvestigating.filter((c) => !prevInvestigating.has(c.clusterId)).sort(bySeverity);
+    const continuingInvestigating = allInvestigating.filter((c) => prevInvestigating.has(c.clusterId));
+    // Fixed since the last report AND not announced before — the re-report guard.
+    let cutoff;
+    if (lastReportTime) {
+        cutoff = lastReportTime;
+    }
+    else {
+        // First run ever — only items fixed in the last 4 hours.
+        cutoff = new Date(new Date(now).getTime() - 4 * 60 * 60 * 1000).toISOString();
+    }
+    const fixedNew = clusters.filter((c) => c.status === 'fixed' && String(c.updatedAt ?? '') > cutoff && !prevFixed.has(c.clusterId));
+    const shouldSkip = newIssues.length === 0 && newInvestigating.length === 0 && fixedNew.length === 0;
+    return { newIssues, continuingOpen, newInvestigating, continuingInvestigating, fixedNew, shouldSkip };
+}
+//# sourceMappingURL=reportPartition.js.map

package/dist/feedback-factory/processor/reportPartition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reportPartition.js","sourceRoot":"","sources":["../../../src/feedback-factory/processor/reportPartition.ts"],"names":[],"mappings":"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"}

package/dist/feedback-factory/store/FeedbackStore.d.ts

@@ -0,0 +1,66 @@
+/**
+ * FeedbackStore.ts — the data-access seam for the feedback factory.
+ *
+ * The ported processor logic (fingerprint / similarity / cluster / verify /
+ * reopen) is pure; the *stateful* operations (read unprocessed items, read active
+ * clusters, create/merge/reopen clusters, mark processed, count) live behind this
+ * interface so the canonical instance's real adapter (Prisma cloud DB — the
+ * blocked, credentials-gated piece) is a thin shim, while everything is buildable
+ * and testable today against `InMemoryFeedbackStore`.
+ *
+ * This is the dependency-injection boundary called out in the migration spec:
+ * front → Vercel, processor → Instar job, DB → cloud (Prisma). The interface
+ * shape is driven by what the ported drivers + the composition (process.ts) need.
+ */
+import type { FeedbackItem, Cluster, ClusterResult } from '../processor/types.js';
+import type { ReopenDecision } from '../processor/reopen.js';
+/** Read-only observability counters for the capture→cluster→reopen loop (spec §2.7). */
+export interface FeedbackMetrics {
+    captured: number;
+    created: number;
+    merged: number;
+    reopened: number;
+}
+export interface FeedbackStore {
+    /** Unprocessed feedback, oldest first (mirrors the reference's `status:'unprocessed'` query). */
+    getUnprocessedFeedback(): FeedbackItem[];
+    /** Active clusters (status != 'resolved'), the merge candidates. */
+    getActiveClusters(): Cluster[];
+    getCluster(clusterId: string): Cluster | undefined;
+    /** Create a new cluster from an item (or bump reportCount if it already exists). */
+    upsertClusterFromItem(clusterId: string, item: FeedbackItem): void;
+    /** Merge an item into an existing cluster (bump reportCount). */
+    mergeIntoCluster(clusterId: string, item: FeedbackItem): void;
+    /** Apply an auto-reopen decision (status, recurrence bump, audit-note append). */
+    applyReopen(clusterId: string, decision: ReopenDecision): void;
+    /** Mark a feedback item processed + linked to its cluster. */
+    markProcessed(feedbackId: string, clusterId: string): void;
+    metrics(): FeedbackMetrics;
+}
+/**
+ * In-memory FeedbackStore — the test/reference implementation. Faithfully mirrors
+ * the reference's create/merge/reopen field mutations (reportCount increment,
+ * recurrenceCount bump on regression, status change, note append) so the
+ * composition can be integration-tested without a database.
+ */
+export declare class InMemoryFeedbackStore implements FeedbackStore {
+    private feedback;
+    private clusters;
+    private counts;
+    constructor(seed?: {
+        feedback?: FeedbackItem[];
+        clusters?: Cluster[];
+    });
+    getUnprocessedFeedback(): FeedbackItem[];
+    getActiveClusters(): Cluster[];
+    getCluster(clusterId: string): Cluster | undefined;
+    upsertClusterFromItem(clusterId: string, item: FeedbackItem): void;
+    mergeIntoCluster(clusterId: string, _item: FeedbackItem): void;
+    applyReopen(clusterId: string, decision: ReopenDecision): void;
+    markProcessed(feedbackId: string, clusterId: string): void;
+    metrics(): FeedbackMetrics;
+    /** Test helper: snapshot all clusters. */
+    allClusters(): Cluster[];
+}
+export type { ClusterResult };
+//# sourceMappingURL=FeedbackStore.d.ts.map

package/dist/feedback-factory/store/FeedbackStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FeedbackStore.d.ts","sourceRoot":"","sources":["../../../src/feedback-factory/store/FeedbackStore.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAClF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAE7D,wFAAwF;AACxF,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,aAAa;IAC5B,iGAAiG;IACjG,sBAAsB,IAAI,YAAY,EAAE,CAAC;IACzC,oEAAoE;IACpE,iBAAiB,IAAI,OAAO,EAAE,CAAC;IAC/B,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC;IACnD,oFAAoF;IACpF,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,GAAG,IAAI,CAAC;IACnE,iEAAiE;IACjE,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,GAAG,IAAI,CAAC;IAC9D,kFAAkF;IAClF,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,GAAG,IAAI,CAAC;IAC/D,8DAA8D;IAC9D,aAAa,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3D,OAAO,IAAI,eAAe,CAAC;CAC5B;AAED;;;;;GAKG;AACH,qBAAa,qBAAsB,YAAW,aAAa;IACzD,OAAO,CAAC,QAAQ,CAAmC;IACnD,OAAO,CAAC,QAAQ,CAA8B;IAC9C,OAAO,CAAC,MAAM,CAAwE;gBAE1E,IAAI,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,YAAY,EAAE,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAA;KAAE;IAKtE,sBAAsB,IAAI,YAAY,EAAE;IAMxC,iBAAiB,IAAI,OAAO,EAAE;IAI9B,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS;IAIlD,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,GAAG,IAAI;IAYlE,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,IAAI;IAM9D,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,GAAG,IAAI;IAW9D,aAAa,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI;IAM1D,OAAO,IAAI,eAAe;IAI1B,0CAA0C;IAC1C,WAAW,IAAI,OAAO,EAAE;CAGzB;AAED,YAAY,EAAE,aAAa,EAAE,CAAC"}

package/dist/feedback-factory/store/FeedbackStore.js

@@ -0,0 +1,88 @@
+/**
+ * FeedbackStore.ts — the data-access seam for the feedback factory.
+ *
+ * The ported processor logic (fingerprint / similarity / cluster / verify /
+ * reopen) is pure; the *stateful* operations (read unprocessed items, read active
+ * clusters, create/merge/reopen clusters, mark processed, count) live behind this
+ * interface so the canonical instance's real adapter (Prisma cloud DB — the
+ * blocked, credentials-gated piece) is a thin shim, while everything is buildable
+ * and testable today against `InMemoryFeedbackStore`.
+ *
+ * This is the dependency-injection boundary called out in the migration spec:
+ * front → Vercel, processor → Instar job, DB → cloud (Prisma). The interface
+ * shape is driven by what the ported drivers + the composition (process.ts) need.
+ */
+/**
+ * In-memory FeedbackStore — the test/reference implementation. Faithfully mirrors
+ * the reference's create/merge/reopen field mutations (reportCount increment,
+ * recurrenceCount bump on regression, status change, note append) so the
+ * composition can be integration-tested without a database.
+ */
+export class InMemoryFeedbackStore {
+    feedback = new Map();
+    clusters = new Map();
+    counts = { captured: 0, created: 0, merged: 0, reopened: 0 };
+    constructor(seed) {
+        for (const f of seed?.feedback ?? [])
+            this.feedback.set(f.feedbackId, { status: 'unprocessed', ...f });
+        for (const c of seed?.clusters ?? [])
+            this.clusters.set(c.clusterId, { ...c });
+    }
+    getUnprocessedFeedback() {
+        return [...this.feedback.values()]
+            .filter((f) => (f.status ?? 'unprocessed') === 'unprocessed')
+            .sort((a, b) => String(a.receivedAt ?? '').localeCompare(String(b.receivedAt ?? '')));
+    }
+    getActiveClusters() {
+        return [...this.clusters.values()].filter((c) => c.status !== 'resolved');
+    }
+    getCluster(clusterId) {
+        return this.clusters.get(clusterId);
+    }
+    upsertClusterFromItem(clusterId, item) {
+        const existing = this.clusters.get(clusterId);
+        if (existing) {
+            existing.reportCount = (existing.reportCount ?? 0) + 1;
+        }
+        else {
+            this.clusters.set(clusterId, {
+                clusterId, title: item.title, description: item.description, type: item.type, reportCount: 1,
+            });
+            this.counts.created++;
+        }
+    }
+    mergeIntoCluster(clusterId, _item) {
+        const c = this.clusters.get(clusterId);
+        if (c)
+            c.reportCount = (c.reportCount ?? 0) + 1;
+        this.counts.merged++;
+    }
+    applyReopen(clusterId, decision) {
+        const c = this.clusters.get(clusterId);
+        if (!c)
+            return;
+        c.status = decision.newStatus;
+        if (decision.bumpRecurrence)
+            c.recurrenceCount = (c.recurrenceCount ?? 0) + 1;
+        const field = decision.annotateField;
+        const prior = c[field] ? `${c[field]}\n\n` : '';
+        c[field] = prior + decision.note;
+        this.counts.reopened++;
+    }
+    markProcessed(feedbackId, clusterId) {
+        const f = this.feedback.get(feedbackId);
+        if (f) {
+            f.status = 'processing';
+            f.clusterId = clusterId;
+        }
+        this.counts.captured++;
+    }
+    metrics() {
+        return { ...this.counts };
+    }
+    /** Test helper: snapshot all clusters. */
+    allClusters() {
+        return [...this.clusters.values()].map((c) => ({ ...c }));
+    }
+}
+//# sourceMappingURL=FeedbackStore.js.map

package/dist/feedback-factory/store/FeedbackStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FeedbackStore.js","sourceRoot":"","sources":["../../../src/feedback-factory/store/FeedbackStore.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "instar",
-  "version": "1.3.20",
+  "version": "1.3.22",
   "description": "Coherence infrastructure for self-evolving AI agents — on the Claude Code or Codex subscription you already have.",
   "type": "module",
   "main": "dist/index.js",

package/src/data/builtin-manifest.json

@@ -1,8 +1,8 @@
 {
   "$schema": "./builtin-manifest.schema.json",
   "schemaVersion": 1,
-  "generatedAt": "2026-05-27T07:58:06.900Z",
-  "instarVersion": "1.3.20",
+  "generatedAt": "2026-05-27T08:47:50.347Z",
+  "instarVersion": "1.3.22",
   "entryCount": 192,
   "entries": {
     "hook:session-start": {

package/upgrades/1.3.21.md

@@ -0,0 +1,26 @@
+# Upgrade Guide — vNEXT
+
+<!-- bump: patch -->
+
+## What Changed
+
+Ninth increment of the **Feedback Factory Migration** (Dawn → Echo; spec `docs/specs/feedback-factory-migration.md`, approved) — the piece that assembles the ported brain. Adds the data-access seam (`FeedbackStore` interface + an in-memory implementation) at `src/feedback-factory/store/`, the processing composition `processUnprocessed` at `src/feedback-factory/processor/process.ts` (which wires the already-ported clustering + auto-reopen together, mirroring the reference's "decide then apply" steps), and the factory's own observability counters (captured / created / merged / reopened).
+
+The real database adapter is a thin shim that implements the same interface — left for cutover since it needs cloud credentials and the hosting decision. **Nothing is wired into a route or job yet** — no behavioral change.
+
+## What to Tell Your User
+
+- The individual pieces of the feedback brain now snap together into one working pipeline (read new reports → group them → reopen regressions → count what happened), proven end-to-end against an in-memory test database.
+- It also keeps its own running tally — how many reports came in, how many new bug-piles were created, how many merged, how many reopened — the start of the factory's self-monitoring.
+
+## Summary of New Capabilities
+
+| Capability | How to Use |
+|-----------|-----------|
+| FeedbackStore seam + in-memory store | `src/feedback-factory/store/FeedbackStore.ts` — the DB-adapter boundary (real adapter at cutover) |
+| Processing composition | `processUnprocessed(store, now)` in `src/feedback-factory/processor/process.ts` — not yet wired |
+| Observability counters | `store.metrics()` — captured / created / merged / reopened |
+
+## Evidence
+
+- The decision logic inside (clustering, auto-reopen) is each already proven identical to Dawn's original in earlier increments. This increment adds the integration-level proof that they **compose** correctly: a Tier-2 test runs the whole pipeline over a real in-memory store and asserts new clusters are created, duplicates merge (order-dependent), the false-merge guard blocks a mid-similarity merge into a fixed bug, a genuine regression auto-reopens (status → investigating, recurrence bumped, audit note written), the counters tally, and empty input is a clean no-op.

package/upgrades/1.3.22.md

@@ -0,0 +1,25 @@
+# Upgrade Guide — vNEXT
+
+<!-- bump: patch -->
+
+## What Changed
+
+Tenth increment of the **Feedback Factory Migration** (Dawn → Echo; spec `docs/specs/feedback-factory-migration.md`, approved). Ports the remaining half of "scar (d)" — the operator-report **lifecycle partitioning with re-report prevention** — from the reference Python (`the-portal/.claude/scripts/feedback-processor.py`, `:2747`) into a pure function at `src/feedback-factory/processor/reportPartition.ts`.
+
+Given the current bug-clusters and what was surfaced in the last operator report, it decides what is actionable now: which issues are newly-open versus already-known, the same for in-progress work, and which bugs were fixed since the last report — announcing each fix exactly once (the re-report guard that stops the digest from repeating itself). It also decides when there's nothing new and the report should be skipped entirely. Pure function; **not wired into any route or job yet** — no behavioral change.
+
+This completes scar (d): the cluster-level cycling was ported earlier (in the state-machine increment); this is the digest-level partitioning + re-report prevention Dawn specifically flagged.
+
+## What to Tell Your User
+
+- The last piece of the feedback "brain" Dawn flagged is now ported — the logic that decides what goes into a status report and, crucially, doesn't re-announce the same fix over and over.
+
+## Summary of New Capabilities
+
+| Capability | How to Use |
+|-----------|-----------|
+| Report partition + re-report guard (TS port) | Internal module `src/feedback-factory/processor/reportPartition.ts` — not yet wired |
+
+## Evidence
+
+- The decision is embedded in a Telegram-rendering function in the reference, so equivalence is by faithful transcription plus both-sides-of-boundary tests (6 unit tests): new vs continuing open/investigating; severity ordering; the re-report guard (a fix updated after the last report and not previously announced is included; one before the last report or already announced is excluded); the first-run 4-hour window; and skip-only-when-nothing-new.

package/upgrades/side-effects/feedback-factory-report-partition.md

@@ -0,0 +1,33 @@
+# Side-Effects Review — scar (d) report partitioning + re-report guard (Phase 1, increment 10)
+
+**Slug:** `feedback-factory-report-partition`
+**Date:** `2026-05-27`
+**Author:** Echo (autonomous)
+**Spec:** `docs/specs/feedback-factory-migration.md` (converged v2, approved by Justin 2026-05-26)
+**Scope:** The pure partition decision of scar (d) — the half Dawn flagged at `:2747` that complements the cluster-level cycling already ported in transitions.ts. The Telegram rendering + report-state persistence stay in the (later) notification layer.
+
+## Summary of the change
+
+Ports the operator-report partition decision into `src/feedback-factory/processor/reportPartition.ts` (`partitionClustersForReport(clusters, prev, now)`). Given the current clusters + what was surfaced in the last report, it decides: newly-open vs already-known open issues; new vs continuing investigating; items FIXED since the last report not announced before (the **re-report / cycling guard** — a fix is announced once, never again); severity ordering of the new buckets; and `shouldSkip` (nothing new ⇒ no noisy report). Pure — clusters, previous-report state, and `now` are injected. **Not wired into any route/job yet** — no behavioral change.
+
+This completes scar (d): increment 3 ported the cluster-level cycling (`detect_cycling` + the chronic circuit-breaker); this ports the digest-level lifecycle partitioning + re-report prevention.
+
+## Equivalence verification
+
+The decision is embedded in a Telegram-rendering function in the reference, so equivalence is by faithful transcription + both-sides-of-boundary unit tests (6): new vs continuing open/investigating; severity sort (critical→low); the re-report guard (fix after last-report not-previously-announced included; before-last-report or already-announced excluded); the first-run 4-hour window; and `shouldSkip` true only when nothing is new. The set-membership, the `updatedAt > cutoff` comparison, the 4h first-run window, and the skip condition are transcribed verbatim.
+
+## Seven-dimension review
+
+1. **Over/under-reach** — Pure function, no I/O, no state, not imported by any runtime path. The state load + Telegram render are correctly excluded (notification layer).
+2. **Level-of-abstraction fit** — Processor-logic layer; produces a partition the notification layer renders. The report-state persistence (`_save_last_report_state`) + Telegram formatting attach later, around this pure decision.
+3. **Signal vs Authority** — N/A; produces buckets + a skip flag. No authority over cluster lifecycle.
+4. **Interactions** — None. New isolated module; nothing imports it yet.
+5. **Rollback cost** — Trivial: delete the module + tests.
+6. **Migration parity** — N/A. New internal library code; no agent-installed file touched.
+7. **Failure modes** — (a) Re-report guard inverted (announce a fix twice / never) → both-sides tests on prevFixed + updatedAt-vs-cutoff. (b) First-run window wrong → tested at the 4h boundary. (c) Skip-when-something-new → tested both directions. (d) Severity sort → tested.
+
+## Tests
+
+- Tier-1 unit (CI): `tests/unit/feedback-factory/reportPartition.test.ts` — 6 tests.
+- No cross-runtime parity harness (decision embedded in a Telegram-rendering function; equivalence by transcription + boundary tests).
+- No integration/E2E this increment: the digest rendering + state persistence are the notification layer, which attaches at cutover. Reasoned, documented.

package/upgrades/side-effects/feedback-factory-store-compose.md

@@ -0,0 +1,36 @@
+# Side-Effects Review — store seam + processing composition + observability (Phase 1, increment 9)
+
+**Slug:** `feedback-factory-store-compose`
+**Date:** `2026-05-27`
+**Author:** Echo (autonomous)
+**Spec:** `docs/specs/feedback-factory-migration.md` (converged v2, approved by Justin 2026-05-26)
+**Scope:** The data-access seam (`FeedbackStore` interface + `InMemoryFeedbackStore`), the processing composition (`processUnprocessed` = clusterItems + computeReopen over the store), and the observability counters. The REAL Prisma adapter + the HTTP/app placement remain the blocked, credentials/decision-gated pieces.
+
+## Summary of the change
+
+Adds:
+- `src/feedback-factory/store/FeedbackStore.ts` — the dependency-injection boundary (interface + `FeedbackMetrics` counters + `InMemoryFeedbackStore`).
+- `src/feedback-factory/processor/process.ts` — `processUnprocessed(store, now)`, which composes the already-parity'd pieces, mirroring the reference's `cmd_cluster` (decide) + `cmd_apply_clusters` (write) run back-to-back: read unprocessed + active clusters → `clusterItems` decides → apply create/merge → on a "possible regression" merge, `computeReopen` + `applyReopen` → mark processed → update counters.
+- Observability: the `FeedbackMetrics` surface (captured / created / merged / reopened) the store maintains (spec §2.7's "meter the loop", minimal form).
+
+This is the glue that assembles the ported brain. The real Prisma adapter is a thin shim that implements the same interface; **nothing is wired into a route/job yet** — no behavioral change.
+
+## Equivalence / verification
+
+The constituent decision logic (`clusterItems`, `computeReopen`) is each already parity-verified against the reference (increments 4 + 8). This increment adds the **Tier-2 integration test** proving they COMPOSE correctly over the data seam: new clusters created, duplicates merged (order-dependent), the 0.55 false-merge guard blocks a mid-similarity merge into a fixed cluster, a real regression auto-reopens (status → investigating, recurrence bump, audit note), counters tally, and empty input is a no-op. `InMemoryFeedbackStore`'s field mutations (reportCount increment, recurrence bump on regression, note append with blank-line separator) mirror the reference's prisma `update` shapes.
+
+## Seven-dimension review
+
+1. **Over/under-reach** — Pure logic + an in-memory store; not wired to any route/job. The interface is shaped by what the ported drivers + composition need (not speculative). `InMemoryFeedbackStore` mutates only its own Maps.
+2. **Level-of-abstraction fit** — `store/` is the data-access layer; `process.ts` is the composition; the real DB adapter (Prisma) implements the interface later. Correct seam — the blocked app/DB decisions sit cleanly behind it.
+3. **Signal vs Authority** — The composition applies the decisions the parity'd pieces produce; the evidence gate / curated lifecycle still hold terminal authority (unchanged). Counters are read-only observability.
+4. **Interactions** — First module to IMPORT the others (`cluster`, `reopen`, `types`) — but only in `process.ts`, which nothing else imports yet. No runtime path touched.
+5. **Rollback cost** — Trivial: delete the store + process + tests. Additive.
+6. **Migration parity** — N/A. New internal library code; no agent-installed file touched. (The real-adapter wiring + sender repoint are the separate Migration-Parity'd cutover steps, blocked.)
+7. **Failure modes** — (a) Composition mis-wires create vs merge vs reopen → the Tier-2 integration test covers all branches. (b) Order-dependence lost → integration test asserts fb-2 merges fb-1's fresh cluster. (c) Reopen not triggered on regression → asserted (status/recurrence/note). (d) Counter drift → asserted per-branch + empty-input no-op.
+
+## Tests
+
+- Tier-1 unit (CI): `tests/unit/feedback-factory/store.test.ts` — 6 tests (read filters, create/merge/reopen mutations, aged vs regression recurrence).
+- **Tier-2 integration (CI): `tests/integration/feedback-factory-process.test.ts` — 4 tests** composing the full pipeline over the real `InMemoryFeedbackStore` (the integration tier the pure-logic increments deferred until a store existed).
+- E2E (feature-alive) attaches when the processor job + canonical front are wired — that's gated on the blocked app-placement + Prisma-adapter decisions. Reasoned, documented.