instar 1.3.15 → 1.3.16

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

@@ -0,0 +1,40 @@
+/**
+ * verify.ts — TS port of the feedback-factory fix-verification logic.
+ *
+ * Byte-exact port of `can_transition_to_verified` (:1084) from the reference
+ * `the-portal/.claude/scripts/feedback-processor.py`. Decides whether a fixed
+ * cluster has actually stayed fixed (so it may transition to `verified`), via two
+ * strategies: version-anchored (HIGH confidence — no recurrence on the fixed
+ * version) and silence-based (LOW confidence — quiet long enough relative to its
+ * historical report frequency).
+ *
+ * The reference is time- and DB-dependent (`datetime.now()` + a recent-reports
+ * query). This port keeps it PURE by INJECTING both: `now` and the version-
+ * anchored query result (`recentReportsSinceFix`) are passed in by the caller
+ * (the real store adapter does `datetime.now()` + the query). Parity is verified
+ * by monkeypatching the reference's `datetime.now` + `run_prisma_query` to the
+ * same fixed values.
+ */
+import type { Cluster } from './types.js';
+export interface VerifyOptions {
+    /** Injected "now" (ISO string). The reference uses datetime.now(timezone.utc). */
+    now: string;
+    /**
+     * The version-anchored recent-reports query result (items with the cluster's
+     * fingerprint received since fixAppliedAt). Only consulted when the cluster has
+     * BOTH fixedInVersion and fingerprint. The real adapter runs the query; tests
+     * inject it. Treated as empty when omitted.
+     */
+    recentReportsSinceFix?: unknown[];
+}
+export interface VerifyResult {
+    allowed: boolean;
+    evidence: string;
+    recommendation?: string;
+    confidence?: string;
+    verified_by?: string;
+}
+/** Reproduce Python `f"{x:.0f}"` — round-half-to-even to an integer, as a string. */
+export declare function pyFormat0f(x: number): string;
+export declare function canTransitionToVerified(cluster: Cluster, opts: VerifyOptions): VerifyResult;
+//# sourceMappingURL=verify.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"verify.d.ts","sourceRoot":"","sources":["../../../src/feedback-factory/processor/verify.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE1C,MAAM,WAAW,aAAa;IAC5B,kFAAkF;IAClF,GAAG,EAAE,MAAM,CAAC;IACZ;;;;;OAKG;IACH,qBAAqB,CAAC,EAAE,OAAO,EAAE,CAAC;CACnC;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,qFAAqF;AACrF,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAQ5C;AAOD,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,aAAa,GAAG,YAAY,CAwD3F"}

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

@@ -0,0 +1,85 @@
+/**
+ * verify.ts — TS port of the feedback-factory fix-verification logic.
+ *
+ * Byte-exact port of `can_transition_to_verified` (:1084) from the reference
+ * `the-portal/.claude/scripts/feedback-processor.py`. Decides whether a fixed
+ * cluster has actually stayed fixed (so it may transition to `verified`), via two
+ * strategies: version-anchored (HIGH confidence — no recurrence on the fixed
+ * version) and silence-based (LOW confidence — quiet long enough relative to its
+ * historical report frequency).
+ *
+ * The reference is time- and DB-dependent (`datetime.now()` + a recent-reports
+ * query). This port keeps it PURE by INJECTING both: `now` and the version-
+ * anchored query result (`recentReportsSinceFix`) are passed in by the caller
+ * (the real store adapter does `datetime.now()` + the query). Parity is verified
+ * by monkeypatching the reference's `datetime.now` + `run_prisma_query` to the
+ * same fixed values.
+ */
+/** Reproduce Python `f"{x:.0f}"` — round-half-to-even to an integer, as a string. */
+export function pyFormat0f(x) {
+    const floor = Math.floor(x);
+    const diff = x - floor;
+    let r;
+    if (diff > 0.5)
+        r = floor + 1;
+    else if (diff < 0.5)
+        r = floor;
+    else
+        r = floor % 2 === 0 ? floor : floor + 1;
+    return String(r);
+}
+/** Parse an ISO timestamp to epoch ms (mirrors datetime.fromisoformat(s.replace('Z','+00:00'))). */
+function parseIso(s) {
+    return new Date(s).getTime();
+}
+export function canTransitionToVerified(cluster, opts) {
+    const fingerprint = cluster.fingerprint;
+    const fixedVersion = cluster.fixedInVersion;
+    // Fall back to dispatchedAt when fixAppliedAt is missing (reference comment:
+    // dispatch happens after the fix is applied, so it's a safe proxy timestamp).
+    const fixAppliedAt = cluster.fixAppliedAt || cluster.dispatchedAt;
+    if (!fixAppliedAt) {
+        return {
+            allowed: false,
+            evidence: 'No fixAppliedAt or dispatchedAt timestamp',
+            recommendation: 'set_fix_applied_at',
+        };
+    }
+    const nowMs = parseIso(opts.now);
+    const fixTimeMs = parseIso(fixAppliedAt);
+    const hoursSinceFix = (nowMs - fixTimeMs) / 1000 / 3600;
+    // Strategy 1: Version-anchored (HIGH confidence).
+    if (fixedVersion && fingerprint) {
+        const recentItems = opts.recentReportsSinceFix ?? [];
+        if (recentItems.length > 0) {
+            return { allowed: false, evidence: `Still seeing ${recentItems.length} reports since fix`, recommendation: 'revert_to_investigating' };
+        }
+        if (hoursSinceFix >= 24) {
+            return {
+                allowed: true,
+                evidence: `No recurrence on v${fixedVersion}+ in ${pyFormat0f(hoursSinceFix)}h`,
+                confidence: 'high',
+                verified_by: `auto:version_check:v${fixedVersion}`,
+            };
+        }
+    }
+    // Strategy 2: Silence-based (LOW confidence).
+    const createdAt = cluster.createdAt;
+    const firstSeenMs = parseIso(createdAt);
+    const lastSeenStr = cluster.updatedAt ?? createdAt;
+    const lastSeenMs = parseIso(lastSeenStr);
+    const reportCount = cluster.reportCount ?? 1;
+    const spanHours = (lastSeenMs - firstSeenMs) / 1000 / 3600;
+    const freqHours = (spanHours < 1 || reportCount < 2) ? 24.0 : spanHours / Math.max(reportCount - 1, 1);
+    const silenceRequired = Math.max(freqHours * 3, 48);
+    if (hoursSinceFix < silenceRequired) {
+        return { allowed: false, evidence: `Only ${pyFormat0f(hoursSinceFix)}h since fix, need ${pyFormat0f(silenceRequired)}h`, recommendation: 'wait' };
+    }
+    return {
+        allowed: true,
+        evidence: `No recurrence in ${pyFormat0f(hoursSinceFix)}h (required: ${pyFormat0f(silenceRequired)}h)`,
+        confidence: 'low',
+        verified_by: 'auto:silence_check',
+    };
+}
+//# sourceMappingURL=verify.js.map

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "instar",
-  "version": "1.3.15",
+  "version": "1.3.16",
   "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/scripts/feedback-factory/_py_verify_ref.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+"""Parity reference: run the REAL can_transition_to_verified deterministically.
+
+The reference is time- and DB-dependent. We monkeypatch the processor's
+`datetime` (so .now() returns the case's fixed `now`) and `run_prisma_query` (so
+the version-anchored query returns the case's recentReportsSinceFix), then call
+the actual, unmodified can_transition_to_verified. Emits JSON {case, result}.
+
+Usage: python3 _py_verify_ref.py <processor_path> <corpus_path>
+"""
+import sys
+import json
+import importlib.util
+import datetime as _dt
+
+
+def load_processor(path):
+    spec = importlib.util.spec_from_file_location("_feedback_processor_ref_vf", path)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+def make_fake_datetime(fixed_now_iso):
+    real = _dt.datetime
+
+    class FakeDateTime:
+        @staticmethod
+        def now(tz=None):
+            return real.fromisoformat(fixed_now_iso.replace('Z', '+00:00'))
+
+        @staticmethod
+        def fromisoformat(s):
+            return real.fromisoformat(s)
+    return FakeDateTime
+
+
+def main():
+    if len(sys.argv) != 3:
+        print("usage: _py_verify_ref.py <processor_path> <corpus_path>", file=sys.stderr)
+        sys.exit(2)
+    processor_path, corpus_path = sys.argv[1], sys.argv[2]
+    proc = load_processor(processor_path)
+    with open(corpus_path, encoding="utf-8") as f:
+        corpus = json.load(f)
+
+    out = []
+    for case in corpus["cases"]:
+        proc.datetime = make_fake_datetime(case["now"])
+        recent = case.get("recentReportsSinceFix", [])
+        proc.run_prisma_query = lambda *a, **k: json.dumps(recent)
+        result = proc.can_transition_to_verified(case["cluster"])
+        out.append({"clusterId": case["cluster"]["clusterId"], "result": result})
+
+    sys.stdout.write(json.dumps(out, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    main()

package/scripts/feedback-factory/verify-corpus.json

@@ -0,0 +1,14 @@
+{
+  "_comment": "Parity corpus for can_transition_to_verified. Each case fixes `now` and the version-anchored query result (recentReportsSinceFix) so the time/DB-dependent reference is deterministic. The Python ref monkeypatches datetime.now + run_prisma_query to these. Timestamps are UTC (Z).",
+  "cases": [
+    { "_name": "no fix timestamp", "now": "2026-05-27T00:00:00Z", "cluster": { "clusterId": "c1", "title": "t", "description": "d", "createdAt": "2026-05-20T00:00:00Z" } },
+    { "_name": "silence: too soon → wait", "now": "2026-05-27T00:00:00Z", "cluster": { "clusterId": "c2", "title": "t", "description": "d", "createdAt": "2026-05-20T00:00:00Z", "updatedAt": "2026-05-26T00:00:00Z", "reportCount": 1, "fixAppliedAt": "2026-05-26T14:00:00Z" } },
+    { "_name": "silence: quiet long enough → verified low", "now": "2026-05-27T00:00:00Z", "cluster": { "clusterId": "c3", "title": "t", "description": "d", "createdAt": "2026-05-20T00:00:00Z", "updatedAt": "2026-05-22T00:00:00Z", "reportCount": 1, "fixAppliedAt": "2026-05-22T20:00:00Z" } },
+    { "_name": "version-anchored: recent reports → revert", "now": "2026-05-27T00:00:00Z", "recentReportsSinceFix": [ { "instarVersion": "1.2.4", "receivedAt": "2026-05-26T00:00:00Z" } ], "cluster": { "clusterId": "c4", "title": "t", "description": "d", "createdAt": "2026-05-20T00:00:00Z", "fixedInVersion": "1.2.3", "fingerprint": "abc123", "fixAppliedAt": "2026-05-25T18:00:00Z" } },
+    { "_name": "version-anchored: no recent, >=24h → verified high", "now": "2026-05-27T00:00:00Z", "recentReportsSinceFix": [], "cluster": { "clusterId": "c5", "title": "t", "description": "d", "createdAt": "2026-05-20T00:00:00Z", "fixedInVersion": "1.2.3", "fingerprint": "abc123", "fixAppliedAt": "2026-05-25T18:00:00Z" } },
+    { "_name": "version-anchored: no recent, <24h → falls through to silence (wait)", "now": "2026-05-27T00:00:00Z", "recentReportsSinceFix": [], "cluster": { "clusterId": "c6", "title": "t", "description": "d", "createdAt": "2026-05-20T00:00:00Z", "updatedAt": "2026-05-26T00:00:00Z", "reportCount": 1, "fixedInVersion": "1.2.3", "fingerprint": "abc123", "fixAppliedAt": "2026-05-26T14:00:00Z" } },
+    { "_name": "dispatchedAt fallback when no fixAppliedAt", "now": "2026-05-27T00:00:00Z", "cluster": { "clusterId": "c7", "title": "t", "description": "d", "createdAt": "2026-05-20T00:00:00Z", "updatedAt": "2026-05-22T00:00:00Z", "reportCount": 1, "dispatchedAt": "2026-05-22T20:00:00Z" } },
+    { "_name": "fractional hours exercises :.0f rounding", "now": "2026-05-27T00:00:00Z", "cluster": { "clusterId": "c8", "title": "t", "description": "d", "createdAt": "2026-05-20T00:00:00Z", "updatedAt": "2026-05-25T00:00:00Z", "reportCount": 1, "fixAppliedAt": "2026-05-24T23:30:00Z" } },
+    { "_name": "multi-report frequency drives silence_required", "now": "2026-05-27T00:00:00Z", "cluster": { "clusterId": "c9", "title": "t", "description": "d", "createdAt": "2026-05-20T00:00:00Z", "updatedAt": "2026-05-26T00:00:00Z", "reportCount": 7, "fixAppliedAt": "2026-05-26T20:00:00Z" } }
+  ]
+}

package/scripts/feedback-factory/verify-parity.mjs

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+/**
+ * verify-parity.mjs — LOCAL parity gate for the fix-verification port.
+ *
+ * Runs the REAL can_transition_to_verified (datetime.now + DB query monkeypatched
+ * deterministically to each case) and the TS canTransitionToVerified over the same
+ * fixed `now` + recentReportsSinceFix, and asserts the full result object matches
+ * (allowed, evidence, recommendation, confidence, verified_by). LOCAL evidence
+ * gate, not CI.
+ *
+ * Exit 0 = parity; exit 1 = mismatch.
+ */
+
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ROOT = path.resolve(__dirname, '..', '..');
+
+const PROCESSOR = process.env.PORTAL_PROCESSOR
+  || '/Users/justin/Documents/Projects/the-portal/.claude/scripts/feedback-processor.py';
+const CORPUS = path.join(__dirname, 'verify-corpus.json');
+const PY_REF = path.join(__dirname, '_py_verify_ref.py');
+
+if (!fs.existsSync(PROCESSOR)) {
+  console.error(`[verify-parity] reference processor not found: ${PROCESSOR}`);
+  process.exit(2);
+}
+
+const py = spawnSync('python3', [PY_REF, PROCESSOR, CORPUS], { encoding: 'utf8' });
+if (py.status !== 0) {
+  console.error('[verify-parity] python reference failed:\n', py.stderr || py.stdout);
+  process.exit(2);
+}
+const reference = JSON.parse(py.stdout);
+
+const corpus = JSON.parse(fs.readFileSync(CORPUS, 'utf8'));
+const distUrl = new URL('file://' + path.join(ROOT, 'dist', 'feedback-factory', 'processor', 'verify.js'));
+const { canTransitionToVerified } = await import(distUrl.href);
+
+const norm = (r) => JSON.stringify({
+  allowed: r.allowed, evidence: r.evidence,
+  recommendation: r.recommendation ?? null, confidence: r.confidence ?? null,
+  verified_by: r.verified_by ?? null,
+});
+
+let mismatches = 0;
+for (let i = 0; i < corpus.cases.length; i++) {
+  const c = corpus.cases[i];
+  const got = canTransitionToVerified(c.cluster, { now: c.now, recentReportsSinceFix: c.recentReportsSinceFix });
+  const want = reference[i].result;
+  if (norm(got) !== norm(want)) {
+    mismatches++;
+    console.error(`[MISMATCH] ${c._name || c.cluster.clusterId}`);
+    console.error(`   python: ${norm(want)}`);
+    console.error(`   ts    : ${norm(got)}`);
+  }
+}
+
+const total = corpus.cases.length;
+if (mismatches === 0) {
+  console.error(`[verify-parity] ✓ ${total}/${total} verification results match the reference can_transition_to_verified.`);
+  process.exit(0);
+} else {
+  console.error(`[verify-parity] ✗ ${mismatches}/${total} mismatches — the TS port diverges from the reference.`);
+  process.exit(1);
+}

package/src/data/builtin-manifest.json

@@ -1,8 +1,8 @@
 {
   "$schema": "./builtin-manifest.schema.json",
   "schemaVersion": 1,
-  "generatedAt": "2026-05-27T06:27:48.836Z",
-  "instarVersion": "1.3.15",
+  "generatedAt": "2026-05-27T06:41:15.968Z",
+  "instarVersion": "1.3.16",
   "entryCount": 192,
   "entries": {
     "hook:session-start": {

package/upgrades/1.3.16.md

@@ -0,0 +1,26 @@
+# Upgrade Guide — vNEXT
+
+<!-- bump: patch -->
+
+## What Changed
+
+Fifth increment of the **Feedback Factory Migration** (Dawn → Echo; spec `docs/specs/feedback-factory-migration.md`, approved). Ports the **fix verifier** — `can_transition_to_verified` — from the reference Python (`the-portal/.claude/scripts/feedback-processor.py`) to TypeScript at `src/feedback-factory/processor/verify.ts`.
+
+This is the logic that decides whether a bug marked "fixed" has actually stayed fixed before it's allowed to move to "verified": a high-confidence check (no recurrence on the fixed version) and a low-confidence fallback (quiet long enough relative to how often the bug used to be reported). The clock and the recent-reports lookup are passed in by the caller, so the decision itself is pure and deterministic. **Not wired into any route or job yet** — no behavioral change.
+
+## What to Tell Your User
+
+- The part of the feedback brain that guards against declaring a bug fixed too early is now ported — it won't mark something verified while reports are still coming in, or before enough quiet time has passed.
+- Proven against Dawn's original by feeding both the same fixed clock and the same recent-report data: identical verdicts, 9 for 9 — including the exact wording of the "how many hours" explanations.
+
+## Summary of New Capabilities
+
+| Capability | How to Use |
+|-----------|-----------|
+| Fix verifier (TS port) | Internal module `src/feedback-factory/processor/verify.ts` — not yet wired |
+| Verifier parity harness | `node scripts/feedback-factory/verify-parity.mjs` (local; set `PORTAL_PROCESSOR`) |
+
+## Evidence
+
+- **Parity vs the REAL `can_transition_to_verified`:** the harness monkeypatches the reference's clock (`datetime.now`) and database query to fixed per-case values and runs the actual function, then compares the full verdict (allowed, evidence text, recommendation, confidence, verified-by) to the TS port. Result: **9/9 identical** across no-fix-timestamp, silence too-soon vs quiet-enough, version-anchored (recent reports / clean / under-24h fallthrough), the dispatched-at fallback, and a fractional-hours case that exercises Python's round-half-to-even number formatting.
+- **CI anchors:** unit tests assert each branch plus the half-to-even rounding, so a regression fails in CI even without the reference checkout.

package/upgrades/side-effects/feedback-factory-verify.md

@@ -0,0 +1,31 @@
+# Side-Effects Review — feedback-factory fix verifier (Phase 1, increment 5)
+
+**Slug:** `feedback-factory-verify`
+**Date:** `2026-05-27`
+**Author:** Echo (autonomous)
+**Spec:** `docs/specs/feedback-factory-migration.md` (converged v2, approved by Justin 2026-05-26)
+**Scope:** `can_transition_to_verified` (:1084) — decide whether a fixed cluster has stayed fixed (version-anchored HIGH-confidence + silence-based LOW-confidence). The real `datetime.now()` + recent-reports query are injected by the caller; this is the pure decision.
+
+## Summary of the change
+
+Byte-exact port of `can_transition_to_verified` from `the-portal/.claude/scripts/feedback-processor.py` to `src/feedback-factory/processor/verify.ts` (`canTransitionToVerified`). Pure: `now` and the version-anchored query result (`recentReportsSinceFix`) are injected via `VerifyOptions` (the real store adapter does `datetime.now()` + the query). Adds `pyFormat0f` (Python `:.0f` round-half-to-even), the parity harness, and Tier-1 unit tests. **Not wired into any route/job yet** — no behavioral change.
+
+## Equivalence verification
+
+- **9/9 cases match the REAL `can_transition_to_verified`.** The parity harness monkeypatches the reference's `datetime` (so `.now()` returns each case's fixed `now`) and `run_prisma_query` (so the version-anchored query returns each case's `recentReportsSinceFix`), then runs the actual, unmodified function — full result object compared (allowed, evidence, recommendation, confidence, verified_by). Cases cover: no-fix-timestamp, silence too-soon/quiet-enough, version-anchored recent-reports/clean/under-24h-fallthrough, the `dispatchedAt` fallback, fractional-hours `:.0f` rounding, and multi-report frequency.
+
+## Seven-dimension review
+
+1. **Over/under-reach** — Pure deterministic function (given injected now + reports), no I/O, no global state, not imported by any runtime path.
+2. **Level-of-abstraction fit** — Processor-logic layer. Time + DB are injected at the function boundary (dependency injection), keeping the decision pure + the real query/clock in the adapter — the cleanest seam.
+3. **Signal vs Authority** — N/A; produces a recommendation object. The actual transition is still gated by `canTransition` (increment 3) + the curated lifecycle.
+4. **Interactions** — None. New isolated module. Parity scripts LOCAL-only.
+5. **Rollback cost** — Trivial: delete the module + tests + scripts.
+6. **Migration parity** — N/A. New internal library code; no agent-installed file touched.
+7. **Failure modes** — (a) Port diverges → parity harness (9/9, against the real function) + unit tests. (b) `:.0f` half-rounding divergence → `pyFormat0f` unit-tested on exact-half cases + parity (fractional-hours case). (c) Timezone/ISO parse divergence → both sides parse to epoch ms (UTC); corpus uses tz-aware Z timestamps; parity verifies. (d) Caller forgets to inject `recentReportsSinceFix` when version+fingerprint present → treated as empty (no recent reports), matching "no recurrence"; documented in the type.
+
+## Tests
+
+- Tier-1 unit (CI): `tests/unit/feedback-factory/verify.test.ts` — pyFormat0f (half-to-even), no-timestamp, version-anchored revert/high/fallthrough, silence verified, dispatchedAt fallback. 7 tests.
+- Parity (local gate, evidence): `scripts/feedback-factory/verify-parity.mjs` → **9/9** vs the real `can_transition_to_verified`.
+- No integration/E2E this increment: not wired to a route/job; those tiers attach when the transition driver + job land. Reasoned decision, documented.