@tpsdev-ai/flair 0.29.0 → 0.31.0

package/dist/resources/MemoryBootstrap.js

@@ -1,4 +1,4 @@
-import { Resource, databases } from "@harperfast/harper";
+import { Resource, databases } from "harper";
 import { allowVerified, resolveAgentAuth } from "./agent-auth.js";
 import { getEmbedding } from "./embeddings-provider.js";
 import { wrapUntrusted } from "./content-safety.js";
@@ -11,7 +11,7 @@ import { buildCollisionEntries, buildEntityMatchCondition, freshPresenceByAgent,
 // The bounded HNSW candidate-pool retrieval for the task-relevant/teammate/
 // collision surfaces (flair-bootstrap-scale-fix) — the SAME pure core
 // SemanticSearch.ts's post() wraps, called bare here so an internal
-// bootstrap call never trips SemanticSearch's rate-limit/reranker/
+// bootstrap call never trips SemanticSearch's rate-limit or
 // retrievalCount hit-tracking side effects (see resources/
 // semantic-retrieval-core.ts's module doc for the full boundary).
 import { retrieveCandidates, DEFAULT_SELECT } from "./semantic-retrieval-core.js";
@@ -619,12 +619,11 @@ export class BootstrapMemories extends Resource {
                     queryEmbedding,
                     conditions: [scope.condition],
                     limit: candidatePoolK,
-                    // HNSW-leg pushdown ONLY (K&S verdict): no BM25 fusion, no
-                    // reranker for bootstrap — a different cost profile (BM25 over the
-                    // org corpus for a one-shot session-load could be MORE expensive
-                    // than HNSW-only unless cached across sessions; the reranker is a
-                    // generative call per candidate). Both are explicit opt-in
-                    // follow-ons, gated on their own harness runs.
+                    // HNSW-leg pushdown ONLY (K&S verdict): no BM25 fusion for
+                    // bootstrap — a different cost profile, since BM25 over the org
+                    // corpus for a one-shot session-load could be MORE expensive than
+                    // HNSW-only unless cached across sessions. Turning it on is an
+                    // explicit opt-in follow-on, gated on its own harness run.
                     hybrid: false,
                     // Per-set (this K-bounded pool only, never cross-applied to the
                     // permanent/recent/predicted sets above) — see this function's
@@ -679,7 +678,7 @@ export class BootstrapMemories extends Resource {
                 // `candidates` are already `_score`-sorted best-first, so filtering
                 // preserves that order). `retrieveCandidates()`'s cosine similarity
                 // replaces the raw JS dot product as the ranking signal (HNSW-only,
-                // no BM25/rerank) — the K&S-ratified, closest-to-a-wash choice; the
+                // no BM25) — the K&S-ratified, closest-to-a-wash choice; the
                 // recall harness gates any regression from this ranking-signal
                 // change (magnitude-sensitive dot product → normalized cosine).
                 const scored = candidates

package/dist/resources/MemoryCandidate.js

@@ -0,0 +1,168 @@
+import { databases } from "harper";
+import { resolveAgentAuth } from "./agent-auth.js";
+import { makeAuthGate, makeReadScope, makeByIdReadGate, resolveAuthGate, stampAttribution, FORBIDDEN, UNAUTH, } from "./record-type-kit.js";
+import { RECORD_TYPES } from "./record-types.js";
+// Parameterized from RECORD_TYPES.MemoryCandidate (record-types slice 2,
+// flair#520) rather than a hand-typed "owner-only" literal — the registry is
+// the single source of truth this class draws its read-scope mode from.
+// Exported solely so test/unit/record-types-registry.test.ts's drift
+// tripwire can introspect the composed resolver's tagged `.mode`/
+// `.ownerField` against RECORD_TYPES.MemoryCandidate — not for any other
+// runtime consumer.
+export const memoryCandidateReadScope = makeReadScope(RECORD_TYPES.MemoryCandidate.readScope, RECORD_TYPES.MemoryCandidate.ownerField);
+const memoryCandidateByIdReadGate = makeByIdReadGate(memoryCandidateReadScope);
+// See makeAuthGate's doc (record-type-kit.ts): must be wired as a genuine
+// prototype method below, never a class-field assignment.
+const memoryCandidateAuthGate = makeAuthGate();
+/**
+ * MemoryCandidate resource — closes flair#849.
+ *
+ * The schema (schemas/memory.graphql) declared `@table` for this type with
+ * no `@export` and no resource file at all, so it had NO REST surface —
+ * `flair rem candidates`/`promote`/`reject` (src/cli.ts) all 404'd on every
+ * call, a clean-room dogfood blocker. Adding bare `@export` would have
+ * reopened the exact P0 leak the memory-soul-read-gate family fix closed for
+ * every other agent-facing table: Harper's `Resource` default is
+ * `allowRead/allowCreate/allowUpdate/allowDelete(user) { return
+ * user?.role.permission.super_user }` (test/unit/resource-allow-decision.test.ts
+ * enforces every exported resource makes an explicit allow-decision instead
+ * of falling through to that default), so an unguarded `@export` is reachable
+ * by `authorizeLocal`'s forged loopback super_user and, once the global gate
+ * stops rejecting a genuinely anonymous remote caller, by that caller too.
+ *
+ * Read: identity-gated (allowRead — verified agents, admins, and trusted
+ * internal calls pass; anonymous HTTP denied) AND per-agent scoped
+ * ("owner-only" — see RECORD_TYPES.MemoryCandidate's doc comment for why: a
+ * candidate is an unreviewed draft distillation, not yet promoted, and must
+ * not be org-readable). Same "owner-only" composition Relationship.ts uses,
+ * parameterized from the registry — this is NOT MemoryGrant.ts's bespoke
+ * owner-OR-grantee model (MemoryCandidate has no second-party field).
+ *
+ * Write: post()/put()/delete() all self-enforce inline (no allowCreate/
+ * allowUpdate/allowDelete wrapper — same deliberate omission Memory.ts's
+ * allowRead() doc explains: adding an unverified allow* gate on top of
+ * self-enforcing methods risks regressing owner writes). Non-admin agents
+ * may create/modify only their OWN candidates (`agentId` no-forge
+ * attribution, "validate-truthy" — present+mismatched agentId is rejected,
+ * absent passes through, matching Memory.post()/put()'s exact idiom for the
+ * same single-owner-field shape) and may delete only their own candidates
+ * (mirrors MemoryGrant.ts's delete() ownership check). Internal calls (the
+ * FLAIR-NIGHTLY-REM staging writer — resources/MemoryReflect.ts's
+ * `databases.flair.MemoryCandidate.put(row)` — and resources/health.ts's
+ * pending-count read) and admin agents pass every method unfiltered, exactly
+ * like every other table this pattern covers.
+ */
+export class MemoryCandidate extends databases.flair.MemoryCandidate {
+    /**
+     * Self-authorize now that the global gate is non-rejecting (memory-soul-
+     * read-gate family fix — same pattern as Memory.ts/Relationship.ts/
+     * WorkspaceState.ts/OrgEvent.ts/Soul.ts/MemoryGrant.ts). Harper routes
+     * `GET /MemoryCandidate/<id>` to get() and the collection describe
+     * (`GET /MemoryCandidate`) outside search(), so both must be gated here,
+     * not just search(). Per-record owner scoping happens in get() below; the
+     * collection scope is still in search().
+     */
+    allowRead() { return memoryCandidateAuthGate.call(this); }
+    /**
+     * Override get() to scope by-id reads the same way search() scopes
+     * collection reads. Never distinguishes "doesn't exist" from "exists but
+     * not yours" — both return 404, never 403, so a denied caller can't use
+     * get() to enumerate other agents' candidate ids (same discipline
+     * makeByIdReadGate documents, and MemoryGrant.ts's get() hand-rolls
+     * identically). `flair rem promote`/`flair rem reject` (src/cli.ts) both
+     * fetch a candidate by id before writing back — this is their read path.
+     */
+    async get(target) {
+        // Collection / query reads arrive as a RequestTarget with
+        // `isCollection === true`, and are governed by search() (same owner
+        // scoping). Only a genuine by-id get is ownership-checked below.
+        if (!target || (typeof target === "object" && target.isCollection)) {
+            return this.search(target);
+        }
+        return memoryCandidateByIdReadGate.call(this, target, (t) => super.get(t));
+    }
+    /**
+     * Scope collection reads to the caller's own candidates. This is the
+     * handler `flair rem candidates` reaches via `POST
+     * /MemoryCandidate/search_by_conditions` (src/cli.ts) — the agentId
+     * condition is wrapped as the OUTERMOST `and` block (Relationship.ts's
+     * same "Security Critical" discipline) so a caller-supplied `operator:
+     * "or"` in the request body cannot boolean-inject past the owner scope.
+     */
+    async search(query) {
+        const ctx = this.getContext?.();
+        const gate = await resolveAuthGate(ctx, UNAUTH());
+        if (gate.kind === "denied")
+            return gate.response;
+        if (gate.kind === "unfiltered")
+            return super.search(query);
+        // Non-admin agent: scope to own candidates only.
+        const scope = await memoryCandidateReadScope(gate.agentId);
+        const agentCondition = scope.condition;
+        if (!query?.conditions) {
+            return super.search({ conditions: [agentCondition], ...(query || {}) });
+        }
+        return super.search({
+            ...query,
+            conditions: [agentCondition, { conditions: query.conditions, operator: query.operator || "and" }],
+            operator: "and",
+        });
+    }
+    /**
+     * No shipped CLI path calls POST today (the FLAIR-NIGHTLY-REM staging
+     * writer uses an internal `.put()`, not `.post()` — see MemoryReflect.ts).
+     * Guarded anyway, on the same "don't leave any exported verb unguarded"
+     * discipline the rest of this file follows: anonymous denied; a non-admin
+     * agent may only stage a candidate attributed to itself.
+     */
+    async post(content) {
+        const ctx = this.getContext?.();
+        const auth = await resolveAgentAuth(ctx);
+        if (auth.kind === "anonymous")
+            return UNAUTH();
+        const attr = stampAttribution(auth, content, RECORD_TYPES.MemoryCandidate.ownerField, RECORD_TYPES.MemoryCandidate.attribution.post, "forbidden: cannot stage a memory candidate for another agent");
+        if (attr.denied)
+            return attr.denied;
+        return super.post(content);
+    }
+    /**
+     * `flair rem promote`/`flair rem reject` (src/cli.ts) both PUT the
+     * candidate row back with an updated status/reviewerId/reviewRationale/
+     * decidedAt, spreading the existing record (agentId included, unchanged).
+     * Non-admin: the no-forge attribution check rejects a PRESENT, mismatched
+     * agentId (an agent can't repurpose this endpoint to rewrite another
+     * agent's candidate) but never stamps one in — the promote/reject flow
+     * always carries the original agentId forward untouched.
+     */
+    async put(content) {
+        const ctx = this.getContext?.();
+        const auth = await resolveAgentAuth(ctx);
+        if (auth.kind === "anonymous")
+            return UNAUTH();
+        const attr = stampAttribution(auth, content, RECORD_TYPES.MemoryCandidate.ownerField, RECORD_TYPES.MemoryCandidate.attribution.put, "forbidden: cannot modify a memory candidate owned by another agent");
+        if (attr.denied)
+            return attr.denied;
+        return super.put(content);
+    }
+    /**
+     * No shipped CLI path calls DELETE today. Guarded on the same discipline
+     * as post() above — mirrors MemoryGrant.ts's delete(): owner-only,
+     * admin/internal unfiltered, a genuinely-missing id is a clean no-op
+     * super.delete() rather than a FORBIDDEN (no existence oracle).
+     */
+    async delete(id, context) {
+        const ctx = this.getContext?.();
+        const gate = await resolveAuthGate(ctx, UNAUTH());
+        if (gate.kind === "denied")
+            return gate.response;
+        if (gate.kind === "unfiltered")
+            return super.delete(id, context);
+        const record = await super.get(id);
+        if (!record)
+            return super.delete(id, context);
+        if (record[RECORD_TYPES.MemoryCandidate.ownerField] !== gate.agentId) {
+            return FORBIDDEN("forbidden: cannot delete a memory candidate owned by another agent");
+        }
+        return super.delete(id, context);
+    }
+}

package/dist/resources/MemoryConsolidate.js

@@ -15,7 +15,7 @@
  *   candidates  Array<{ memory, suggestion, reason }>
  *   prompt      string
  */
-import { Resource, databases } from "@harperfast/harper";
+import { Resource, databases } from "harper";
 import { isAdmin, allowVerified } from "./agent-auth.js";
 import { evaluate, parseDuration } from "./memory-consolidate-lib.js";
 export class ConsolidateMemories extends Resource {

package/dist/resources/MemoryDedupStats.js

@@ -52,7 +52,7 @@
  * agent's own memories; this one is never scoped that way — it reads every
  * agent's embeddings — so it follows the admin-gated precedent instead.
  */
-import { Resource, databases } from "@harperfast/harper";
+import { Resource, databases } from "harper";
 import { mkdirSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 import { allowAdmin } from "./agent-auth.js";

package/dist/resources/MemoryFeed.js

@@ -1,4 +1,4 @@
-import { Resource, databases } from "@harperfast/harper";
+import { Resource, databases } from "harper";
 import { allowVerified } from "./agent-auth.js";
 import { computeContentHash, findExistingMemoryByContentHash } from "./memory-feed-lib.js";
 export class FeedMemories extends Resource {

package/dist/resources/MemoryGrant.js

@@ -1,4 +1,4 @@
-import { databases } from "@harperfast/harper";
+import { databases } from "harper";
 import { resolveAgentAuth, allowVerified } from "./agent-auth.js";
 const FORBIDDEN = (msg) => new Response(JSON.stringify({ error: msg }), { status: 403, headers: { "Content-Type": "application/json" } });
 const UNAUTH = () => new Response(JSON.stringify({ error: "authentication required" }), { status: 401, headers: { "Content-Type": "application/json" } });

package/dist/resources/MemoryMaintenance.js

@@ -16,7 +16,7 @@
  * Migrated to the standard `extends Resource` shape with `allowCreate()`
  * to gate auth correctly.
  */
-import { Resource, databases } from "@harperfast/harper";
+import { Resource, databases } from "harper";
 import { isAdmin } from "./agent-auth.js";
 export class MemoryMaintenance extends Resource {
     /** POST requires auth — either an agent acting on its own memories, or admin. */

package/dist/resources/MemoryReflect.js

@@ -36,7 +36,7 @@
  * Resource }` outright — see test/unit/resource-allow.test.ts). This
  * resource is a thin orchestrator over the lib's tested functions.
  */
-import { Resource, databases, models, logger } from "@harperfast/harper";
+import { Resource, databases, models, logger } from "harper";
 import { randomBytes } from "node:crypto";
 import { isAdmin, allowVerified } from "./agent-auth.js";
 import { patchRecordSilent } from "./table-helpers.js";
@@ -143,7 +143,7 @@ export class ReflectMemories extends Resource {
             existingPendingClaims.push(c.claim);
         }
         const toStage = dedupeCandidates(outcome.candidates, existingPendingClaims);
-        // generatedBy: GenerateResult in the pinned @harperfast/harper 5.1.17 has
+        // generatedBy: GenerateResult in the pinned harper 5.1.17 has
         // no model/backend-id field (content/finishReason/usage/toolCalls/trace
         // only) — the "from the generate result if available" branch is
         // unreachable in this version, so this always falls back to the

package/dist/resources/MemoryReindex.js

@@ -23,7 +23,7 @@
  *
  * This endpoint is idempotent: running it again finds zero drift.
  */
-import { Resource, databases } from "@harperfast/harper";
+import { Resource, databases } from "harper";
 import { isAdmin, allowAdmin } from "./agent-auth.js";
 export class MemoryReindex extends Resource {
     // Admin-only: permit verified ADMIN agents (Basic-admin is super_user and

package/dist/resources/MemoryUsage.js

@@ -41,7 +41,7 @@
  * to expose "which agent used which memory" cross-agent, and narrowing this
  * costs nothing.
  */
-import { databases } from "@harperfast/harper";
+import { databases } from "harper";
 import { resolveAgentAuth, allowVerified } from "./agent-auth.js";
 const FORBIDDEN = (msg) => new Response(JSON.stringify({ error: msg }), { status: 403, headers: { "Content-Type": "application/json" } });
 const UNAUTH = () => new Response(JSON.stringify({ error: "authentication required" }), { status: 401, headers: { "Content-Type": "application/json" } });

package/dist/resources/OAuth.js

@@ -1,4 +1,4 @@
-import { Resource, databases } from "@harperfast/harper";
+import { Resource, databases } from "harper";
 import { createHash, randomBytes } from "node:crypto";
 import { handleJwtBearerGrant } from "./XAA.js";
 import { resolveAgentAuth } from "./agent-auth.js";

package/dist/resources/OAuthClient.js

@@ -1,4 +1,4 @@
-import { databases } from "@harperfast/harper";
+import { databases } from "harper";
 import { allowAdmin } from "./agent-auth.js";
 /**
  * OAuthClient holds registered OAuth client records (incl. secrets) — admin/system

package/dist/resources/OrgEvent.js

@@ -10,7 +10,7 @@
  * requests slipped through once the gate stopped rejecting. resolveAgentAuth
  * distinguishes internal/agent/anonymous explicitly.
  */
-import { databases } from "@harperfast/harper";
+import { databases } from "harper";
 import { resolveAgentAuth } from "./agent-auth.js";
 import { invalidEntitiesResponse } from "./entity-vocab.js";
 import { makeAuthGate, resolveAuthGate, stampAttribution, FORBIDDEN, UNAUTH, } from "./record-type-kit.js";

package/dist/resources/OrgEventCatchup.js

@@ -9,7 +9,7 @@
  * Sorted by createdAt ascending (oldest first for in-order processing).
  * Limit 50 events max.
  */
-import { Resource, databases } from "@harperfast/harper";
+import { Resource, databases } from "harper";
 import { allowVerified, resolveAgentAuth } from "./agent-auth.js";
 export class OrgEventCatchup extends Resource {
     // Self-authorize via the Ed25519 agent verify (auth reshape removes the gate's

package/dist/resources/OrgEventMaintenance.js

@@ -4,7 +4,7 @@
  * POST /OrgEventMaintenance/ — deletes all records where expiresAt < now.
  * Auth: admin only.
  */
-import { Resource, databases } from "@harperfast/harper";
+import { Resource, databases } from "harper";
 import { allowAdmin } from "./agent-auth.js";
 export class OrgEventMaintenance extends Resource {
     // Admin-only: permit verified ADMIN agents (Basic-admin is super_user and

package/dist/resources/PairingToken.js

@@ -1,4 +1,4 @@
-import { databases } from "@harperfast/harper";
+import { databases } from "harper";
 import { allowAdmin } from "./agent-auth.js";
 /**
  * PairingToken holds one-time federation pairing secrets — admin/system only,

package/dist/resources/Peer.js

@@ -1,4 +1,4 @@
-import { databases } from "@harperfast/harper";
+import { databases } from "harper";
 import { allowAdmin } from "./agent-auth.js";
 /**
  * Peer holds federation peer records (URLs + credentials) — system/admin data,

package/dist/resources/Presence.js

@@ -26,7 +26,7 @@
  *     content. get() additionally gates currentTask itself to verified
  *     in-org agents only; see get()'s inline comment.
  */
-import { databases } from "@harperfast/harper";
+import { databases } from "harper";
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -80,7 +80,7 @@ function resolveVersion() {
     return process.env.npm_package_version ?? "dev";
 }
 /**
- * Resolve the running @harperfast/harper version. Unlike flair's own
+ * Resolve the running harper version. Unlike flair's own
  * package.json (readable via a plain relative path above), Harper's package
  * only exports "." → dist/index.js — there's no "./package.json" subpath, so
  * requiring it directly throws (Node's exports-map enforcement). Resolve the
@@ -93,7 +93,7 @@ function resolveVersion() {
 function resolveHarperVersion() {
     try {
         const req = createRequire(import.meta.url);
-        const mainPath = req.resolve("@harperfast/harper");
+        const mainPath = req.resolve("harper");
         const pkgPath = join(dirname(mainPath), "..", "package.json");
         if (existsSync(pkgPath)) {
             const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));

package/dist/resources/RecordUsage.js

@@ -93,7 +93,7 @@
  * sanitized (control-character-stripped, length-capped) and stored as-is,
  * for audit/analytics only. Treat it as untrusted data, always.
  */
-import { Resource } from "@harperfast/harper";
+import { Resource } from "harper";
 import { resolveAgentAuth } from "./agent-auth.js";
 import { checkRateLimit, rateLimitResponse } from "./rate-limiter.js";
 import { recordUsageContribution, MAX_USAGE_IDS_PER_CALL } from "./usage-recording.js";

package/dist/resources/Relationship.js

@@ -1,4 +1,4 @@
-import { databases } from "@harperfast/harper";
+import { databases } from "harper";
 import { resolveAgentAuth } from "./agent-auth.js";
 import { checkRateLimit, rateLimitResponse } from "./rate-limiter.js";
 import { localInstanceId } from "./instance-identity.js";

package/dist/resources/SemanticSearch.js

@@ -1,10 +1,9 @@
-import { Resource, databases } from "@harperfast/harper";
+import { Resource, databases } from "harper";
 import { resolveAgentAuth, allowVerified } from "./agent-auth.js";
 import { getEmbedding, getMode } from "./embeddings-provider.js";
 import { patchRecord } from "./table-helpers.js";
 import { checkRateLimit, rateLimitResponse } from "./rate-limiter.js";
 import { resolveReadScope } from "./memory-read-scope.js";
-import { isRerankEnabled, getRerankTopN, getRerankBudgetMs, getRerankMinCandidates, rerankCandidates, } from "./rerank-provider.js";
 // The BM25 + union-RRF hybrid path is feature-flagged via hybridEnabled()
 // (imported from ./bm25 — Harper-free so it's unit-testable). Default is ON as
 // of 2026-07-08 (see ./bm25.ts's hybridEnabled() doc); set
@@ -15,7 +14,7 @@ import { hybridEnabled } from "./bm25.js";
 // supersede/isAllowed) now lives in the pure, side-effect-free
 // retrieveCandidates() core (flair-bootstrap-scale-fix, Kern-approved
 // extraction) — MemoryBootstrap.ts calls the SAME core bare, without
-// tripping this file's rate-limit/reranker/hit-tracking side effects. See
+// tripping this file's rate-limit/hit-tracking side effects. See
 // resources/semantic-retrieval-core.ts's module doc for the full boundary.
 import { retrieveCandidates, DEFAULT_SELECT } from "./semantic-retrieval-core.js";
 import { attachTrust } from "./trust-block.js";
@@ -181,29 +180,18 @@ export class SemanticSearch extends Resource {
             }
         }
         const hybrid = hybridEnabled();
-        // When the reranker is on, widen the legacy HNSW fetch so it has a deeper
-        // pool to re-score (retrieve topN → rerank → slice to limit). Decoupled
-        // from CANDIDATE_MULTIPLIER so composite re-ranking keeps its existing
-        // headroom. Scoped to the legacy (non-hybrid) vector path below — the
-        // hybrid path's candidate pool is already governed by CANDIDATE_MULTIPLIER
-        // (semantic leg) + SEM_LIMIT (BM25 leg) via RRF union; the
-        // reranker still applies to its output further down regardless of which
-        // path produced `filteredResults`.
-        const rerankOn = isRerankEnabled();
-        const rerankTopN = getRerankTopN();
         // The overfetch policy (how many raw candidates to pull from the
         // HNSW/BM25 legs relative to what the caller ultimately wants) is THIS
         // wrapper's decision — retrieveCandidates() never multiplies its `limit`
         // param internally (see resources/semantic-retrieval-core.ts's doc), so
         // every caller (this one, and MemoryBootstrap's own K formula) computes
-        // its own fetch depth. Hybrid's semantic leg is never rerank-widened
-        // (matches the pre-extraction behavior: only the legacy path widened for
-        // rerank).
-        const candidateLimit = hybrid
-            ? limit * CANDIDATE_MULTIPLIER
-            : (rerankOn ? Math.max(limit * CANDIDATE_MULTIPLIER, rerankTopN) : limit * CANDIDATE_MULTIPLIER);
+        // its own fetch depth. Both the hybrid path (CANDIDATE_MULTIPLIER on the
+        // semantic leg + SEM_LIMIT on the BM25 leg, fused by RRF) and the legacy
+        // vector-only path overfetch by the same multiplier, which is what gives
+        // composite re-scoring headroom to reorder before the final slice.
+        const candidateLimit = limit * CANDIDATE_MULTIPLIER;
         const ctx = this.getContext?.();
-        let filteredResults = await retrieveCandidates({
+        const filteredResults = await retrieveCandidates({
             queryEmbedding: qEmb,
             q,
             conditions,
@@ -233,10 +221,10 @@ export class SemanticSearch extends Resource {
             withSemSimilarity: abstain || includeTrust,
         });
         // ─── flair#744 slice 2 — first-class abstention ("no memory covers this")
-        // Opt-in only. Evaluated on the RETRIEVED candidate pool, BEFORE the
-        // reranker / final slice / hit-tracking, so an abstaining recall does no
-        // rerank work and never bumps retrievalCount for memories it declines to
-        // surface. The decision reads ONLY the best absolute semantic similarity
+        // Opt-in only. Evaluated on the RETRIEVED candidate pool, BEFORE the final
+        // slice / hit-tracking, so an abstaining recall never bumps retrievalCount
+        // for memories it declines to surface. The decision reads ONLY the best
+        // absolute semantic similarity
         // (never any principal/authority signal — abstention.ts is pure and
         // authority-free), against the single GLOBAL threshold. Default OFF ⇒ this
         // whole block is skipped and the response is byte-identical to pre-slice-2.
@@ -253,28 +241,12 @@ export class SemanticSearch extends Resource {
                 };
             }
         }
-        // ─── Cross-encoder rerank (best-effort, fail-open to vector order) ───────
-        // Re-scores query+candidate TOGETHER (cross-attention the pooled embedding
-        // can't do) and reorders before the final slice. Reorders whatever
-        // `filteredResults` retrieveCandidates() produced — legacy HNSW-only OR
-        // the BM25+union-RRF hybrid path — since both converge into the same
-        // shape (retrieveCandidates never exposes which leg produced a result).
-        // Still gated on `qEmb` (an embedding was actually generated); the pure
-        // keyword-only fallback (no qEmb at all) is untouched either way. The
-        // reranker overwrites `_score` with the rerank score (so margin
-        // measurement reads it) and preserves the semantic score as `_semScore`;
-        // `_rawScore` is left as-is so recall-bench's scoring:"raw" path stays
-        // reproducible. On init failure, timeout, or any throw, rerankCandidates
-        // returns the input UNCHANGED and we fall through to retrieveCandidates'
-        // own vector-order sort — recall is never blocked. retrieveCandidates
-        // already returns its output sorted best-first, so the non-rerank branch
-        // needs no additional sort here.
-        if (rerankOn && qEmb && q && filteredResults.length >= getRerankMinCandidates()) {
-            filteredResults = await rerankCandidates(String(q), filteredResults, {
-                topN: rerankTopN,
-                budgetMs: getRerankBudgetMs(),
-            });
-        }
+        // retrieveCandidates() already returns its output sorted best-first
+        // (whichever leg produced it — legacy HNSW-only, the BM25+union-RRF hybrid
+        // path, or the keyword-only fallback all converge into the same shape), so
+        // the final slice needs no additional sort. A cross-encoder rerank stage
+        // used to sit here and reorder the pool before this slice; it was removed
+        // in flair#893 after measuring Δp@3 = 0.000 at 4.1× query latency.
         const topResults = filteredResults.slice(0, limit);
         // Async hit tracking — don't block the response
         const now = new Date().toISOString();

package/dist/resources/SkillScan.js

@@ -1,4 +1,4 @@
-import { Resource } from "@harperfast/harper";
+import { Resource } from "harper";
 import { allowVerified } from "./agent-auth.js";
 import { scanSkillContent } from "./scan/skill-scanner.js";
 /**

package/dist/resources/Soul.js

@@ -1,4 +1,4 @@
-import { databases } from "@harperfast/harper";
+import { databases } from "harper";
 import { resolveAgentAuth } from "./agent-auth.js";
 import { localInstanceId } from "./instance-identity.js";
 import { makeAuthGate, stampAttribution, UNAUTH } from "./record-type-kit.js";

package/dist/resources/SoulFeed.js

@@ -1,4 +1,4 @@
-import { Resource, databases } from '@harperfast/harper';
+import { Resource, databases } from 'harper';
 import { allowVerified } from './agent-auth.js';
 export class FeedSouls extends Resource {
     // Self-authorize the subscription via the Ed25519 agent verify (auth reshape

package/dist/resources/WorkspaceLatest.js

@@ -4,7 +4,7 @@
  * GET /WorkspaceLatest/{agentId} — returns most recent WorkspaceState record.
  * Auth: requesting agent must match agentId in path (or be admin).
  */
-import { Resource, databases } from "@harperfast/harper";
+import { Resource, databases } from "harper";
 import { allowVerified, resolveAgentAuth } from "./agent-auth.js";
 export class WorkspaceLatest extends Resource {
     // Self-authorize via the Ed25519 agent verify (auth reshape removes the gate's

package/dist/resources/WorkspaceState.js

@@ -7,7 +7,7 @@
  * Note: Harper's static methods call instance methods with positional args only.
  * Use this.getContext() to access request context (tpsAgent, tpsAgentIsAdmin).
  */
-import { databases } from "@harperfast/harper";
+import { databases } from "harper";
 import { resolveAgentAuth } from "./agent-auth.js";
 import { invalidEntitiesResponse } from "./entity-vocab.js";
 import { makeAuthGate, makeReadScope, makeByIdReadGate, resolveAuthGate, stampAttribution, FORBIDDEN, UNAUTH, } from "./record-type-kit.js";

package/dist/resources/XAA.js

@@ -1,4 +1,4 @@
-import { databases } from "@harperfast/harper";
+import { databases } from "harper";
 import { allowAdmin } from "./agent-auth.js";
 import { createHash, randomBytes } from "node:crypto";
 import { createRemoteJWKSet, jwtVerify } from "jose";

package/dist/resources/a2a-url.js

@@ -6,7 +6,7 @@
 // reflect the REAL listening port, or a remote A2A peer that follows discovery
 // hits a dead port.
 //
-// Kept free of any @harperfast/harper import so the resolution logic is
+// Kept free of any harper import so the resolution logic is
 // unit-testable without spinning up Harper (mirrors agentcard-fields.ts —
 // avoids the simulator-pattern drift that let the AdminInstance predicate be
 // reproduced-not-imported).

package/dist/resources/abstention.js

@@ -100,7 +100,7 @@ export const STRONG_BAND = 0.55;
  * Reads ONLY the `_semSimilarity` number the retrieval core
  * (resources/semantic-retrieval-core.ts) attaches to each semantic-leg result
  * WHEN abstention is requested — an absolute cosine similarity in [0,1],
- * independent of the RRF normalization / rerank that make the ranking `_score`
+ * independent of the RRF normalization that makes the ranking `_score`
  * a *relative* signal (the top RRF-fused result is normalized to 1.0 regardless
  * of how weak the actual match is, so `_score` is unusable as a confidence
  * floor — this is why abstention reads the absolute similarity instead).

package/dist/resources/agent-auth.js

@@ -15,7 +15,7 @@
  * verified against the agent's stored Ed25519 public key. Replay is bounded by a
  * 30s timestamp window + a per-(agent,nonce) seen-set pruned to that window.
  */
-import { databases } from "@harperfast/harper";
+import { databases } from "harper";
 import { WINDOW_MS, isNonceReplay, recordNonce, importEd25519Key, b64ToArrayBuffer, parseTpsEd25519Header } from "./ed25519-auth.js";
 /**
  * Shared Harper user that verified Ed25519 agents resolve to (least-privilege

package/dist/resources/agentcard-fields.js

@@ -7,7 +7,7 @@
 // fallback that could surface a private soul (an operator's internal note,
 // prompt fragment, or credential reminder) on the public endpoint.
 //
-// Kept free of any @harperfast/harper import so the real logic is unit-testable
+// Kept free of any harper import so the real logic is unit-testable
 // without spinning up Harper (avoids the simulator-pattern that let the
 // description-fallback leak ship untested).
 export function readSoulKind(entry) {

package/dist/resources/auth-middleware.js

@@ -1,5 +1,5 @@
 import { patchRecord } from "./table-helpers.js";
-import { server, databases } from "@harperfast/harper";
+import { server, databases } from "harper";
 import { getEmbedding } from "./embeddings-provider.js";
 import { isAdmin, FLAIR_AGENT_USERNAME } from "./agent-auth.js";
 import { WINDOW_MS, isNonceReplay, recordNonce, importEd25519Key, b64ToArrayBuffer, parseTpsEd25519Header } from "./ed25519-auth.js";