@konneal/engine 0.1.0

package/workers/worker_public/src/internal_gateway.ts

@@ -0,0 +1,41 @@
+// Internal-tier gateway: fetches FEDERATED passages (OIML + ISO/IEC) from
+// rag-internal via the service binding. rag-public holds NO Vectorize
+// binding to the internal index — this is the only path, member-gated.
+// rag-internal is retrieval-only; the serving pipeline (rerank, grading,
+// generation) stays here — one pipeline, both audiences.
+
+import type { Hit } from "./pipeline";
+
+interface ServiceFetcher {
+  fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
+}
+
+/** Ask rag-internal for RRF-fused passages for the query. Returns [] on
+ *  any failure — the public-only results then serve the member.
+ *  `auth` forwards the caller's session in WHATEVER form it arrived
+ *  (cookie same-origin, Bearer via the bubble bridge) — the internal
+ *  worker's readSession accepts both. */
+export async function retrieveInternal(
+  service: ServiceFetcher,
+  auth: { cookie: string; authorization: string },
+  query: string,
+): Promise<Hit[]> {
+  try {
+    const res = await service.fetch("https://internal/retrieve", {
+      method: "POST",
+      headers: { "content-type": "application/json", cookie: auth.cookie, authorization: auth.authorization },
+      body: JSON.stringify({ query }),
+    });
+    if (!res.ok) return [];
+    const data: any = await res.json();
+    if (!Array.isArray(data?.hits)) return [];
+    return data.hits.map((h: any) => ({
+      id: h.id,
+      score: h.score,
+      metadata: h.metadata ?? {},
+      text: h.text ?? "",
+    }));
+  } catch {
+    return [];
+  }
+}

package/workers/worker_public/src/lexical.ts

@@ -0,0 +1,86 @@
+// G-ETSI-1: full-corpus BM25 prefilter via D1 FTS5 (arXiv:2604.09868 §II-B5).
+// Returns Hits ranked by bm25; caller unions with dense and RRF-fuses.
+// Fail-open: any D1/FTS error → empty list (dense path stands alone).
+
+import type { Hit, ChunkMeta } from "./pipeline";
+
+const LEXICAL_K = 40;
+
+/** Build a safe FTS5 MATCH query from user text: alphanumeric tokens,
+ *  joined with OR so jargon hits don't require full-phrase match. */
+export function ftsMatchQuery(query: string): string | null {
+  const terms = query
+    .toLowerCase()
+    .replace(/[^\p{L}\p{N}\s_-]/gu, " ")
+    .split(/\s+/)
+    .map((t) => t.trim())
+    .filter((t) => t.length >= 2 && t.length <= 40)
+    // drop pure stop-ish tokens that blow up OR-queries on standards text
+    .filter((t) => !STOP.has(t));
+  const uniq = [...new Set(terms)].slice(0, 12);
+  if (!uniq.length) return null;
+  // quote each term; FTS5 bare tokens are fine for alnum, quotes for safety
+  return uniq.map((t) => `"${t.replace(/"/g, "")}"`).join(" OR ");
+}
+
+const STOP = new Set([
+  "the", "a", "an", "of", "and", "or", "to", "in", "for", "on", "is", "are",
+  "was", "were", "be", "by", "with", "as", "at", "from", "that", "this",
+  "what", "how", "when", "where", "which", "who", "does", "do", "did",
+  "can", "could", "should", "would", "may", "might", "shall", "must",
+  "about", "into", "than", "then", "its", "it", "their", "there",
+]);
+
+export async function lexicalPrefilter(env: { DB: D1Database }, query: string, k = LEXICAL_K): Promise<Hit[]> {
+  const match = ftsMatchQuery(query);
+  if (!match) return [];
+  try {
+    // bm25() lower = better; multiply by -1 for descending score convention
+    const res = await env.DB.prepare(
+      `SELECT c.id, c.doc_id, c.docidentifier, c.doctype, c.doc_number, c.edition,
+              c.language, c.clause_anchor, c.clause_title, c.status, c.superseded_by,
+              c.corpus, c.tier, c.text, c.unit_id, c.block, bm25(chunks_fts) AS rank
+         FROM chunks_fts
+         JOIN chunks c ON c.rowid = chunks_fts.rowid
+        WHERE chunks_fts MATCH ?1
+        ORDER BY rank
+        LIMIT ?2`,
+    )
+      .bind(match, k)
+      .all();
+    const rows = res.results ?? [];
+    return rows.map((r: any, i: number) => {
+      const meta: ChunkMeta = {
+        doc_id: String(r.doc_id ?? ""),
+        docidentifier: String(r.docidentifier ?? ""),
+        doctype: String(r.doctype ?? ""),
+        doc_number: String(r.doc_number ?? ""),
+        edition: String(r.edition ?? ""),
+        language: String(r.language ?? "en"),
+        clause_anchor: String(r.clause_anchor ?? ""),
+        clause_title: String(r.clause_title ?? ""),
+        tier: String(r.tier ?? ""),
+        corpus: String(r.corpus ?? ""),
+        text_ref: "",
+        status: String(r.status ?? "unknown"),
+        superseded_by: String(r.superseded_by ?? ""),
+        // contract v2 over the lexical lane: typed chunks arriving via BM25
+        // keep their unit identity ([[u:…]] refs, typed pin, retyping check)
+        unit_id: String(r.unit_id ?? "") || undefined,
+        block: String(r.block ?? "") || undefined,
+      };
+      // rank is bm25 (lower better) → convert to positive score that RRF can ignore
+      // (RRF uses rank position, not score). score kept for logging only.
+      const bm25 = typeof r.rank === "number" ? r.rank : i;
+      return {
+        id: String(r.id),
+        score: 1 / (1 + Math.max(0, bm25)),
+        metadata: meta,
+        text: String(r.text ?? ""),
+      } satisfies Hit;
+    });
+  } catch (e) {
+    console.log("lexical prefilter failed:", String(e).slice(0, 200));
+    return [];
+  }
+}

package/workers/worker_public/src/lib/hit.ts

@@ -0,0 +1,4 @@
+// Shared Hit construction — the definition lives with the chunk wire
+// contract (workers/shared/chunk.ts); re-exported for worker_public's
+// import graph.
+export { toHits } from "../../../shared/chunk.ts";

package/workers/worker_public/src/lib/http.ts

@@ -0,0 +1,83 @@
+// HTTP wire helpers + request validation + API-key authentication —
+// the vocabulary every route handler speaks (TODO.impl/23).
+import { LIMITS, sha256Hex } from "../config";
+import type { Env } from "../env";
+
+export const json = (body: unknown, status = 200, extra: Record<string, string> = {}) =>
+  new Response(JSON.stringify(body), {
+    status,
+    headers: { "content-type": "application/json", ...extra },
+  });
+
+export const err = (status: number, code: string, message: string) =>
+  json({ error: { code, message } }, status);
+
+export function corsHeaders(req: Request): Record<string, string> {
+  const origin = req.headers.get("origin") ?? "";
+  const allowed =
+    origin === "https://oimlsmart.org" ||
+    /^https:\/\/[a-z0-9-]+\.oimlsmart\.org$/.test(origin) ||
+    // the local dev posture: the platform and the minisites develop on
+    // localhost ports against the live service (the bubble bridge admits
+    // the same class; anon quota is per-IP, member auth needs the token)
+    /^http:\/\/localhost(:\d{1,5})?$/.test(origin) ||
+    /^http:\/\/127\.0\.0\.1(:\d{1,5})?$/.test(origin);
+  return allowed
+    ? {
+        "access-control-allow-origin": origin,
+        // PATCH + DELETE: the conversations API speaks them (rename,
+        // delete) — the embedded panel preflights cross-origin.
+        "access-control-allow-methods": "GET, POST, PATCH, DELETE, OPTIONS",
+        "access-control-allow-headers": "authorization, content-type",
+        "access-control-max-age": "86400",
+      }
+    : {};
+}
+
+/** CORS-complete a handler's response: the browser surface grew
+ *  piecemeal (the SSE ask paths carried the headers; the JSON + error
+ *  paths and the conversations API did not), which an embedded
+ *  cross-origin client reads as opaque network failures. One wrap at
+ *  the router keeps every browser-facing answer readable. */
+export function withCors(res: Response, cors: Record<string, string>): Response {
+  if (!cors["access-control-allow-origin"]) return res;
+  const headers = new Headers(res.headers);
+  for (const [k, v] of Object.entries(cors)) headers.set(k, v);
+  return new Response(res.body, { status: res.status, statusText: res.statusText, headers });
+}
+
+export interface ApiKey {
+  id: string;
+  name: string;
+  day_limit: number;
+}
+
+export async function authenticate(env: Env, req: Request): Promise<ApiKey | null> {
+  const auth = req.headers.get("authorization") ?? "";
+  const m = auth.match(/^Bearer\s+(.+)$/i);
+  if (!m) return null;
+  const keyHash = await sha256Hex(m[1].trim());
+  const row = await env.DB.prepare(
+    "SELECT id, name, day_limit FROM api_keys WHERE key_hash = ?1 AND revoked = 0",
+  )
+    .bind(keyHash)
+    .first<ApiKey>();
+  return row ?? null;
+}
+
+export async function readJson(req: Request): Promise<any | null> {
+  try {
+    const body = await req.json();
+    if (!body || typeof body !== "object") return null;
+    return body;
+  } catch {
+    return null;
+  }
+}
+
+export function validateQuery(body: any): { query: string; lang?: string } | null {
+  const query = typeof body?.query === "string" ? body.query.trim() : "";
+  if (!query || query.length > LIMITS.maxInputChars) return null;
+  const lang = typeof body?.lang === "string" && /^[a-z]{2}$/.test(body.lang) ? body.lang : undefined;
+  return { query, lang };
+}

package/workers/worker_public/src/lib/router.ts

@@ -0,0 +1,4 @@
+// The router lives with the shared cross-worker modules
+// (workers/shared/router.ts) — re-exported for worker_public's imports.
+export { matchRoute } from "../../../shared/router.ts";
+export type { RouteContext, Route, RouteHandler } from "../../../shared/router.ts";

package/workers/worker_public/src/livedata.ts

@@ -0,0 +1,334 @@
+// The live-data tool (TODO.ai-platform/03) — the "my account" context's
+// service half. The user opted the message into their OWN live platform
+// data; the service reads the platform EXACTLY as the user, never wider:
+//
+//   1. The sign-in (auth.ts) retains the OP's access token for the
+//      SESSION's window only (KV, keyed by the session token's hash,
+//      TTL = the OP token's own expiry — never D1, never past it).
+//   2. The exchange (the identity service's RFC 8693 session delegation,
+//      RP guide §9b) trades that subject token for a narrowly-scoped OP
+//      JWT: `<platform>:read`, the account's standing RE-JUDGED at the
+//      exchange (a role lost mid-session narrows the next answer
+//      honestly), the actor claim naming THIS service.
+//   3. The platform reads ride that JWT; the platform enforces the cones
+//      exactly as for the user's own browser (smart's bearer cone). THE
+//      MUST-NOT IS STRUCTURAL HERE: this module maps the platform's
+//      answers 1:1 into records — it cannot invent a row the platform
+//      did not return, and a store the cone refuses simply contributes
+//      nothing.
+//
+// The exchanged JWT is cached for its own short life (KV, TTL-bounded)
+// so an ask burst costs one exchange; nothing outlives the session's
+// exchange window.
+
+/** SHA-256 hex — config.ts's helper, inlined so this module stays
+ *  dependency-free (context.ts's pattern: the unit tests load it on
+ *  plain node's type stripping, which never resolves extensionless
+ *  relative imports). */
+async function sha256Hex(s: string): Promise<string> {
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(s));
+  return [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+// ── configuration ────────────────────────────────────────────────────
+
+export interface LiveDataConfig {
+  /** The platform instance's API base (the hub's origin). */
+  platformApi: string;
+  /** The platform's client id at the OP (the delegation's scope target
+   *  + the exchanged token's audience). */
+  platformClientId: string;
+  /** The OP's issuer (the exchange endpoint lives there). */
+  issuer: string;
+  /** THIS service's client credentials (the delegation's caller auth —
+   *  the subject token binds to the client it was issued to). */
+  clientId: string;
+  clientSecret?: string;
+}
+
+export function liveDataConfig(env: any): LiveDataConfig | null {
+  const platformApi = (env.SMART_PLATFORM_API ?? "").trim().replace(/\/$/, "");
+  const platformClientId = (env.SMART_PLATFORM_CLIENT_ID ?? "").trim();
+  const issuer = (env.OIDC_ISSUER ?? "https://id.oimlsmart.org").trim().replace(/\/$/, "");
+  const clientId = (env.OIDC_CLIENT_ID ?? "").trim();
+  if (!platformApi || !platformClientId || !clientId) return null;
+  return { platformApi, platformClientId, issuer, clientId, clientSecret: env.OIDC_CLIENT_SECRET };
+}
+
+// ── the session's exchange window (the retained OP access token) ─────
+
+const SUBJECT_KEY = (sessionHash: string) => `opat:${sessionHash}`;
+const EXCHANGED_KEY = (sessionHash: string) => `ossx:${sessionHash}`;
+
+/** Retain the sign-in's OP access token for the session's exchange
+ *  window (the OP token's own TTL, minus a small margin). Called ONCE
+ *  per sign-in from the auth callback; the token never persists past
+ *  the window. */
+export async function retainOpAccessToken(
+  env: any,
+  sessionRaw: string,
+  opAccessToken: string,
+  expiresInSec: number,
+): Promise<void> {
+  const ttl = Math.max(30, Math.floor(expiresInSec) - 30);
+  try {
+    await env.CACHE.put(SUBJECT_KEY(await sha256Hex(sessionRaw)), JSON.stringify({ token: opAccessToken }), { expirationTtl: ttl });
+  } catch {
+    // a KV hiccup degrades the live window honestly (the chip answers
+    // "live data unavailable"), never blocks the sign-in
+  }
+}
+
+/** Drop the retained subject + the cached exchanged token (the sign-out
+ *  closes the window deliberately, never by expiry alone). */
+export async function dropOpAccessToken(env: any, sessionRaw: string): Promise<void> {
+  const h = await sha256Hex(sessionRaw);
+  try {
+    await env.CACHE.delete(SUBJECT_KEY(h));
+    await env.CACHE.delete(EXCHANGED_KEY(h));
+  } catch {
+    /* the TTL closes the window regardless */
+  }
+}
+
+// ── the RFC 8693 delegation exchange ─────────────────────────────────
+
+export type LiveTokenVerdict =
+  | { ok: true; token: string }
+  | { ok: false; reason: "not_configured" | "window_expired" | "refused" | "op_unreachable" };
+
+/** Exchange the session's retained OP access token for the
+ *  platform-scoped JWT (identity's §9b). The exchanged token caches for
+ *  its own short life; the refusal lattice is honest per leg. */
+export async function exchangeForLiveToken(env: any, sessionRaw: string): Promise<LiveTokenVerdict> {
+  const cfg = liveDataConfig(env);
+  if (!cfg) return { ok: false, reason: "not_configured" };
+  const h = await sha256Hex(sessionRaw);
+
+  const cached = await env.CACHE.get(EXCHANGED_KEY(h));
+  if (cached) return { ok: true, token: cached };
+
+  const subjectRow = await env.CACHE.get(SUBJECT_KEY(h), "json") as { token?: string } | null;
+  if (!subjectRow?.token) return { ok: false, reason: "window_expired" };
+
+  const body = new URLSearchParams({
+    grant_type: "urn:ietf:params:oauth:grant-type:token-exchange",
+    subject_token_type: "urn:ietf:params:oauth:token-type:access_token",
+    subject_token: subjectRow.token,
+    scope: `${cfg.platformClientId}:read`,
+  });
+  const headers: Record<string, string> = { "content-type": "application/x-www-form-urlencoded" };
+  if (cfg.clientSecret) {
+    headers.authorization = `Basic ${btoa(`${encodeURIComponent(cfg.clientId)}:${encodeURIComponent(cfg.clientSecret)}`)}`;
+  } else {
+    body.set("client_id", cfg.clientId);
+  }
+  let res: Response;
+  try {
+    res = await fetch(`${cfg.issuer}/op/token`, { method: "POST", headers, body });
+  } catch {
+    return { ok: false, reason: "op_unreachable" };
+  }
+  if (!res.ok) {
+    // The refusal's code is logged, NEVER the subject token: a refused
+    // exchange narrows the answer honestly (the window lapsed, the
+    // standing fell away, or the deployment refuses).
+    const code = await res.json().then((j: any) => j?.error ?? "unknown").catch(() => "unknown");
+    console.log("live-data exchange refused:", res.status, code);
+    return { ok: false, reason: code === "invalid_grant" ? "window_expired" : "refused" };
+  }
+  const granted = (await res.json()) as { access_token?: string; expires_in?: number; scope?: string };
+  if (!granted.access_token) return { ok: false, reason: "refused" };
+  // The exchange's own answer states the granted scope — read it, never
+  // assume it (the standing re-judgment may have narrowed honestly).
+  const ttl = Math.max(30, Math.floor(granted.expires_in ?? 300) - 60);
+  try {
+    await env.CACHE.put(EXCHANGED_KEY(h), granted.access_token, { expirationTtl: ttl });
+  } catch {
+    /* the exchange simply re-runs next ask */
+  }
+  return { ok: true, token: granted.access_token };
+}
+
+// ── the platform reads (the records the answer grounds in) ───────────
+
+export interface LiveRecord {
+  /** the platform store the record came from */
+  store: string;
+  id: string;
+  /** the display label ("Application APP-2026-001 — R 60") */
+  label: string;
+  /** the platform page the record links to */
+  url: string;
+  status?: string;
+  date?: string;
+  /** the coarse one-line state ("evaluation in progress", "3 test
+   *  requests dispatched") — the progress projection's summary */
+  detail?: string;
+}
+
+export type LiveRead =
+  | { ok: true; records: LiveRecord[]; stores: string[]; readAt: string }
+  | { ok: false; reason: "platform_refused" | "platform_unreachable" };
+
+/** The platform page for a record — the role family decides the console
+ *  (the same page the user's own browser would open). */
+function recordUrl(cfg: LiveDataConfig, roleFamily: string, store: string, row: any): string {
+  const std = typeof row.standard_id === "string" ? row.standard_id.replace(/^oiml-/, "") : null;
+  if (store === "certificates") {
+    if (roleFamily === "applicant") return `${cfg.platformApi}/app/portal/certificates/${row.id}`;
+    if (std) return `${cfg.platformApi}/app/standards/${std}/certificates/${row.id}`;
+    return `${cfg.platformApi}/app/portal/certificates/${row.id}`;
+  }
+  // applications + testRequests resolve to their application page (the
+  // request is visible within its project on every console).
+  const appId = store === "applications" ? row.id : (row.application_id ?? row.id);
+  if (roleFamily === "ia") return `${cfg.platformApi}/app/ia/applications/${appId}`;
+  if (roleFamily === "lab") return `${cfg.platformApi}/app/lab/projects/${appId}`;
+  return `${cfg.platformApi}/app/portal/applications/${appId}`;
+}
+
+/** The exchanged JWT's primary platform role (the service's OWN fetched
+ *  token — decoded, never re-validated) decides the console family. */
+function roleFamilyOf(token: string, platformClientId: string): string {
+  try {
+    const payload = JSON.parse(atob(token.split(".")[1].replace(/-/g, "+").replace(/_/g, "/")));
+    const roles: string[] = payload?.service_roles?.[platformClientId] ?? [];
+    const primary = roles[0] ?? "";
+    if (["ia_officer", "case_officer", "certification_officer", "signatory"].includes(primary)) return "ia";
+    if (primary === "tl_operator") return "lab";
+    return "applicant";
+  } catch {
+    return "applicant";
+  }
+}
+
+const MAX_RECORDS = 12;
+const PROGRESS_FOR = 3;
+
+/** Read the account's live surface: the bounded store lists (the cone
+ *  filters server-side — a refused store contributes NOTHING, never an
+ *  error into the answer) + the progress projection for the freshest
+ *  applications. Every record maps 1:1 from a platform row. */
+export async function readMyAccount(_env: any, cfg: LiveDataConfig, token: string): Promise<LiveRead> {
+  const auth = { authorization: `Bearer ${token}` };
+  const readAt = new Date().toISOString();
+  const family = roleFamilyOf(token, cfg.platformClientId);
+  const records: LiveRecord[] = [];
+  const storesRead: string[] = [];
+
+  async function readStore(store: string): Promise<any[]> {
+    let res: Response;
+    try {
+      res = await fetch(`${cfg.platformApi}/api/entities/${store}`, { headers: auth });
+    } catch {
+      throw new Error("unreachable");
+    }
+    if (!res.ok) {
+      // The cone's honest refusal (403) or an unauthenticated read (401):
+      // the store contributes nothing — the records stay exactly what the
+      // account may see.
+      console.log(`live-data: ${store} answered ${res.status} — skipped`);
+      return [];
+    }
+    storesRead.push(store);
+    const rows = (await res.json()) as any[];
+    return Array.isArray(rows) ? rows : [];
+  }
+
+  let applications: any[] = [];
+  try {
+    applications = await readStore("applications");
+    const certificates = await readStore("certificates");
+    const requests = await readStore("testRequests");
+    for (const row of applications) {
+      records.push({
+        store: "applications",
+        id: String(row.id),
+        label: `Application ${row.application_number ?? row.id}${row.standard_id ? ` — ${String(row.standard_id).replace(/^oiml-/, "").toUpperCase().replace(/^R(\d)/, "R $1")}` : ""}`,
+        url: recordUrl(cfg, family, "applications", row),
+        status: row.status,
+        date: row.submitted_date ?? row.date_of_application,
+      });
+    }
+    for (const row of certificates) {
+      records.push({
+        store: "certificates",
+        id: String(row.id),
+        label: `Certificate ${row.certificate_number ?? row.id}`,
+        url: recordUrl(cfg, family, "certificates", row),
+        status: row.status,
+        date: row.issue_date ?? row.registered_copy_of?.registered_date,
+      });
+    }
+    for (const row of requests) {
+      records.push({
+        store: "testRequests",
+        id: String(row.id),
+        label: `Test request ${row.request_number ?? row.id}`,
+        url: recordUrl(cfg, family, "testRequests", row),
+        status: row.status,
+        date: row.issued_date,
+      });
+    }
+  } catch {
+    return { ok: false, reason: "platform_unreachable" };
+  }
+
+  // The progress projection for the freshest applications (the "where is
+  // my application" answer's own surface — the same coarse projection the
+  // portal renders, never the work-in-flight stores).
+  const freshest = applications
+    .slice()
+    .sort((a, b) => String(b.submitted_date ?? b.date_of_application ?? "").localeCompare(String(a.submitted_date ?? a.date_of_application ?? "")))
+    .slice(0, PROGRESS_FOR);
+  for (const row of freshest) {
+    try {
+      const res = await fetch(`${cfg.platformApi}/api/entities/applications/${encodeURIComponent(row.id)}/progress`, { headers: auth });
+      if (!res.ok) continue;
+      const p = (await res.json()) as any;
+      const rec = records.find((r) => r.store === "applications" && r.id === String(row.id));
+      if (rec) {
+        const parts: string[] = [];
+        if (p.evaluation?.state === "concluded") parts.push(`evaluation concluded${p.evaluation.decision ? ` (${p.evaluation.decision})` : ""}`);
+        else if (p.evaluation?.state === "in_progress") parts.push("evaluation in progress");
+        else parts.push("evaluation not started");
+        if (Array.isArray(p.requests) && p.requests.length) parts.push(`${p.requests.length} test request${p.requests.length === 1 ? "" : "s"} dispatched`);
+        if (p.certificate) parts.push(`certificate ${p.certificate.certificate_number ?? ""} ${p.certificate.status ?? ""}`.trim());
+        rec.detail = parts.join("; ");
+      }
+    } catch {
+      /* the projection is additive — the record stands without it */
+    }
+  }
+
+  // The freshest surface first, bounded (the newest dates lead; a record
+  // without a date sorts last).
+  records.sort((a, b) => String(b.date ?? "").localeCompare(String(a.date ?? "")));
+  return { ok: true, records: records.slice(0, MAX_RECORDS), stores: storesRead, readAt };
+}
+
+// ── the ask path's composed resolution ───────────────────────────────
+
+export type LiveAccount =
+  | { status: "ok"; records: LiveRecord[]; stores: string[]; readAt: string }
+  | { status: "unavailable"; reason: "sign_in_required" | "not_configured" | "window_expired" | "refused" | "op_unreachable" | "platform_refused" | "platform_unreachable" };
+
+/** Resolve the "my account" context for one ask: the member's session →
+ *  the exchange → the platform reads. Every failure is an honest reason
+ *  the context line can state — never a silent widening, never an
+ *  invented record. */
+export async function resolveLiveAccount(
+  env: any,
+  sessionRaw: string | null,
+  member: { sub: string } | null,
+): Promise<LiveAccount> {
+  if (!member || !sessionRaw) return { status: "unavailable", reason: "sign_in_required" };
+  const cfg = liveDataConfig(env);
+  if (!cfg) return { status: "unavailable", reason: "not_configured" };
+  const exchanged = await exchangeForLiveToken(env, sessionRaw);
+  if (!exchanged.ok) return { status: "unavailable", reason: exchanged.reason };
+  const read = await readMyAccount(env, cfg, exchanged.token);
+  if (!read.ok) return { status: "unavailable", reason: read.reason };
+  return { status: "ok", records: read.records, stores: read.stores, readAt: read.readAt };
+}

package/workers/worker_public/src/memories.ts

@@ -0,0 +1,81 @@
+// Personalized memory files (#171): per-member context documents the
+// ask path injects when selected. Member-scoped CRUD — every query is
+// owner-filtered by the session's sub; content is user-authored text,
+// never corpus. Caps: 10 files, 8k chars each (the ask path further
+// bounds the injected total).
+
+import { json, err } from "./lib/http";
+
+const MAX_FILES = 10;
+const MAX_CONTENT = 8_000;
+const MAX_NAME = 64;
+const ID_RE = /^m:[a-f0-9]{16}$/;
+
+const newId = () => "m:" + [...crypto.getRandomValues(new Uint8Array(8))].map((b) => b.toString(16).padStart(2, "0")).join("");
+
+export async function handleMemories(env: any, sub: string, req: Request, route: { method: string; id?: string }): Promise<Response> {
+  const { method, id } = route;
+  if (method === "GET") {
+    const rows = (await env.DB.prepare("SELECT id, name, content, enabled, updated_at FROM memories WHERE sub = ?1 ORDER BY updated_at DESC").bind(sub).all()).results ?? [];
+    return json({ memories: rows });
+  }
+  if (method === "DELETE") {
+    if (!id || !ID_RE.test(id)) return err(400, "invalid_input", "bad memory id");
+    await env.DB.prepare("DELETE FROM memories WHERE id = ?1 AND sub = ?2").bind(id, sub).run();
+    return json({ ok: true });
+  }
+  if (method === "POST") {
+    const body: any = await req.json().catch(() => null);
+    const name = typeof body?.name === "string" ? body.name.trim().slice(0, MAX_NAME) : "";
+    const content = typeof body?.content === "string" ? body.content.slice(0, MAX_CONTENT) : "";
+    if (!name || !content.trim()) return err(400, "invalid_input", "name and content are required");
+    const now = Date.now();
+    if (typeof body?.id === "string" && ID_RE.test(body.id)) {
+      const r = await env.DB.prepare(
+        "UPDATE memories SET name = ?1, content = ?2, updated_at = ?3 WHERE id = ?4 AND sub = ?5",
+      ).bind(name, content, now, body.id, sub).run();
+      if (!r.meta?.changes) return err(404, "not_found", "no such memory");
+      return json({ ok: true, id: body.id });
+    }
+    const count = Number((await env.DB.prepare("SELECT COUNT(*) AS n FROM memories WHERE sub = ?1").bind(sub).first() as any)?.n ?? 0);
+    if (count >= MAX_FILES) return err(400, "quota_exceeded", `at most ${MAX_FILES} memory files`);
+    const mid = newId();
+    await env.DB.prepare(
+      "INSERT INTO memories (id, sub, name, content, enabled, created_at, updated_at) VALUES (?1, ?2, ?3, ?4, 1, ?5, ?5)",
+    ).bind(mid, sub, name, content, now).run();
+    return json({ ok: true, id: mid });
+  }
+  return err(405, "method_not_allowed", "GET, POST or DELETE");
+}
+
+/** The ask path's memory injection: fetch the SELECTED, OWNED files and
+ *  render them as one bounded note. Ids may be personal (m:…) or the
+ *  user's project files (pf:…) — ownership resolves both ways, and a
+ *  foreign id silently drops (a stale selection is never an error, and
+ *  never another user's memory). Returns [note, idsActuallyUsed]. */
+export async function memoryNote(env: any, sub: string, ids: string[]): Promise<[string | null, string[]]> {
+  const wanted = [...new Set(ids.filter((x) => typeof x === "string" && (ID_RE.test(x) || /^pf:[a-f0-9]{16}$/.test(x))))].slice(0, 4);
+  if (!wanted.length) return [null, []];
+  const ph = wanted.map((_, i) => `?${i + 2}`).join(",");
+  const rows = [
+    ...((await env.DB.prepare(`SELECT id, name, content FROM memories WHERE sub = ?1 AND id IN (${ph})`).bind(sub, ...wanted).all()).results ?? []),
+    ...((await env.DB.prepare(
+      `SELECT f.id, f.name, f.content FROM project_files f JOIN projects p ON p.id = f.project_id WHERE p.sub = ?1 AND f.id IN (${ph})`,
+    ).bind(sub, ...wanted).all()).results ?? []),
+  ];
+  if (!rows.length) return [null, []];
+  let budget = 4_000;
+  const parts: string[] = [];
+  const used: string[] = [];
+  for (const r of rows as any[]) {
+    if (budget <= 200) break;
+    const body = String(r.content).slice(0, budget);
+    budget -= body.length;
+    parts.push(`### ${r.name}\n${body}`);
+    used.push(String(r.id));
+  }
+  return [
+    "The user's own memory files — their stated context. Treat as trusted user facts (their lab, instruments, preferences); blend with the passages, never contradict them silently:\n" + parts.join("\n\n"),
+    used,
+  ];
+}