holo-evicted-publish: player +3 object(s)

b/9bbb7ace4be8185e95239e7c58dc63cf66f811531a2aa67c42dd8ec6ca0326e9

@@ -0,0 +1,80 @@
+// holo-flow.mjs — the FLOW PLAN sequencer (F2 of HOLO-FLOW-PROMPT.md). PURE and deterministic:
+// (cards, continue, scores, hour, seed, mood, history) → the next 3 items + why — no DOM, no fetch,
+// no Date.now(). The LLM/voice are garnish ABOVE this; with no brain, no GPU, no network, the channel
+// flows identically. The plan is a κ-object (JCS+sha256 sealed) — inspectable, private, tamper-refusing.
+// All taste lives in ONE weights table below: tunable, witnessable.
+
+import { jcs, sha256hex } from "./holo-media-card.mjs";
+
+export const WEIGHTS = {
+  resume: 100,                    // finish what you started — resume-first is the strongest pull
+  tastePerPlay: 6,                // learned score (bumpPlay/bumpSkip) via scoreOf
+  hourPrior: 30,                  // time-of-day fit (table below)
+  rhythmPenalty: 60,              // same kind as the previous item — variety unless bingeing
+  bingeOverride: 3,               // ≥3 consecutive finishes of one kind = bingeing → rhythm penalty off
+  historyPenalty: 1000,           // already played this session — effectively never within a session
+  skipKindPenalty: 25,            // a kind vetoed this session appears less, immediately
+  wildcard: 40,                   // one discovery slot: boost the least-seen candidate
+  mood: {                         // explicit steering — additive nudges, not filters (never a dead end)
+    calmer:  { audiobook: 45, film: 20, game: -45, live: -25 },
+    short:   { game: 45, live: 25, film: -30, audiobook: -10 },
+    surprise:{ _unseen: 60 },
+  },
+};
+export const HOUR_PRIOR = (h) =>
+  h < 9  ? { live: 1, audiobook: .7, game: .1, film: .1 } :
+  h < 17 ? { audiobook: .8, game: .6, live: .5, film: .3 } :
+  h < 23 ? { film: 1, audiobook: .5, game: .4, live: .3 } :
+           { audiobook: 1, film: .5, game: .2, live: .1 };
+
+const mulberry32 = (a) => () => { a |= 0; a = (a + 0x6d2b79f5) | 0; let t = Math.imul(a ^ (a >>> 15), 1 | a); t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t; return ((t ^ (t >>> 14)) >>> 0) / 4294967296; };
+
+// plan({cards, continueList, scoreOf, hour, seed, mood, history, prevKind, skippedKinds, bingeKind})
+//   cards: [{id, kind, title, ...}] — the whole eligible pool (from the κ-index)
+//   → { items: [card×≤3], why: [string×], seedUsed }
+export function plan(inp) {
+  const { cards = [], continueList = [], scoreOf = () => 0, hour = 20, seed = 1, mood = null,
+          history = [], prevKind = null, skippedKinds = [], bingeKind = null } = inp;
+  const rng = mulberry32(seed);
+  const played = new Set(history);
+  const contById = new Map(continueList.map((r) => [r.id, r]));
+  const seen = new Set(Object.keys(inp.statsAll || {}));
+  const prior = HOUR_PRIOR(hour);
+  const moodW = (mood && WEIGHTS.mood[mood]) || null;
+
+  const items = [], why = [];
+  let lastKind = prevKind;
+  for (let slot = 0; slot < 3; slot++) {
+    let best = null, bestScore = -Infinity, bestWhy = "";
+    for (const c of cards) {
+      if (!c || !c.id || items.includes(c)) continue;
+      let s = rng() * 4;                                             // seeded jitter: ties break deterministically
+      const reasons = [];
+      if (played.has(c.id)) s -= WEIGHTS.historyPenalty;
+      const cont = contById.get(c.id);
+      if (cont) { s += WEIGHTS.resume; reasons.push("you're " + (cont.dur ? Math.round(100 * cont.pos / cont.dur) + "% in" : "mid-way")); }
+      const taste = scoreOf(c.id); if (taste) { s += taste * WEIGHTS.tastePerPlay; if (taste > 0) reasons.push("you come back to this"); }
+      s += (prior[c.kind] || 0) * WEIGHTS.hourPrior; if ((prior[c.kind] || 0) >= 0.8) reasons.push("fits the hour");
+      if (c.kind === lastKind && bingeKind !== c.kind) s -= WEIGHTS.rhythmPenalty;
+      if (skippedKinds.includes(c.kind)) s -= WEIGHTS.skipKindPenalty;
+      if (moodW) { s += moodW[c.kind] || 0; if (moodW._unseen && !seen.has(c.id)) s += moodW._unseen; if ((moodW[c.kind] || 0) > 0) reasons.push("matches “" + mood + "”"); }
+      if (slot === 2 && !seen.has(c.id) && !played.has(c.id)) { s += WEIGHTS.wildcard; reasons.push("something new"); }
+      if (s > bestScore) { bestScore = s; best = c; bestWhy = reasons.join(" · ") || "in your library"; }
+    }
+    if (!best || bestScore <= -WEIGHTS.historyPenalty / 2) break;    // pool exhausted this session — stop honestly
+    items.push(best); why.push(bestWhy); lastKind = best.kind;
+  }
+  return { items, why, seedUsed: seed };
+}
+
+// seal / verify a plan as a κ-object — same discipline as every card in the hub
+export async function sealPlan(p) {
+  const body = { v: 1, kind: "flow-plan", items: p.items.map((c) => c.id), why: p.why, seed: p.seedUsed };
+  const hex = await sha256hex(new TextEncoder().encode(jcs(body)));
+  return { ...body, kappa: "sha256:" + hex };
+}
+export async function verifyPlan(sealed) {
+  const { kappa, ...body } = sealed;
+  const hex = await sha256hex(new TextEncoder().encode(jcs(body)));
+  return "sha256:" + hex === kappa ? body : null;
+}

b/c8fe5a6a74b6aaeada74254a8d622893345ca5cebbbd563538f1e429151d0429

@@ -0,0 +1,71 @@
+// holo-continue.mjs — ONE continue store + taste stats (F1 of HOLO-FLOW-PROMPT.md; absorbs K5-P1/P4).
+//
+// Three players used to remember separately (film → localStorage "holoplayer.resume.<id>", book →
+// "holo.book.<κ>", game → IndexedDB holo-games/saves). This is the ONE κ-sealed record store they all
+// write, back-filled from the legacy keys at read time so history appears with no migration. Records are
+// JCS-sealed; a tampered record is dropped (named on console), the list lives. Device-local by design —
+// personalization without surveillance. Pure ESM, browser+Node (inject `ls`/`idb` for the witness).
+
+import { jcs, sha256hex } from "./holo-media-card.mjs";
+
+const K_CONT = "holo.continue.v1", K_STATS = "holo.stats.v1", CAP = 40;
+const enc = new TextEncoder();
+const sealOf = async (r) => { const { seal, ...body } = r; return sha256hex(enc.encode(jcs(body))); };
+
+export function makeContinue({ ls, idbFactory } = {}) {
+  const LS = ls || (typeof localStorage !== "undefined" ? localStorage : new Map() && { getItem: () => null, setItem: () => {}, key: () => null, length: 0 });
+  const load = (k) => { try { return JSON.parse(LS.getItem(k) || "null"); } catch { return null; } };
+  const save = (k, v) => { try { LS.setItem(k, JSON.stringify(v)); } catch {} };
+
+  return {
+    // record progress for any kind — call at the same sites the legacy stores are written
+    async record({ kind, id, title, pos = 0, dur = 0, extra = null }) {
+      if (!kind || !id) return;
+      const map = load(K_CONT) || {};
+      const r = { kind, id, title: title || "", pos, dur, extra, ts: Date.now() };
+      r.seal = await sealOf(r);
+      map[id] = r;
+      const keys = Object.keys(map).sort((a, b) => map[b].ts - map[a].ts);
+      for (const k of keys.slice(CAP)) delete map[k];
+      save(K_CONT, map);
+    },
+    // newest-first, seal-verified (tampered → dropped loudly), legacy stores folded in
+    async list() {
+      const out = new Map();
+      const map = load(K_CONT) || {};
+      for (const r of Object.values(map)) {
+        if (r.seal && (await sealOf(r)) !== r.seal) { try { console.warn("[continue] record refused (seal):", r.id); } catch {} continue; }
+        out.set(r.id, r);
+      }
+      // back-fill: films (holoplayer.resume.*) and books (holo.book.*) from localStorage
+      try {
+        for (let i = 0; i < LS.length; i++) {
+          const k = LS.key(i);
+          if (/^holoplayer\.resume\./.test(k)) { const v = load(k); const id = k.slice("holoplayer.resume.".length); if (v && v.pos && !out.has(id)) out.set(id, { kind: "film", id, title: v.title || "", pos: v.pos, dur: v.dur || 0, ts: v.ts || 0 }); }
+          else if (/^holo\.book\./.test(k)) { const v = load(k); const id = k.slice(10); if (v && !out.has("book:" + id)) out.set("book:" + id, { kind: "audiobook", id: "book:" + id, kappa: id, title: "", pos: v.t || 0, extra: { chapter: v.i || 0 }, ts: v.ts || 0 }); }
+        }
+      } catch {}
+      // back-fill: game κ-saves (same-origin IndexedDB holo-games/saves), latest per game
+      try {
+        const req = (idbFactory || (typeof indexedDB !== "undefined" ? indexedDB : null));
+        if (req) {
+          const db = await new Promise((res) => { const r = req.open("holo-games", 3); r.onsuccess = () => res(r.result); r.onerror = () => res(null); r.onupgradeneeded = () => { try { r.transaction.abort(); } catch {} res(null); }; });
+          if (db && db.objectStoreNames.contains("saves")) {
+            const rows = await new Promise((res) => { const o = []; const c = db.transaction("saves", "readonly").objectStore("saves").openCursor(); c.onsuccess = () => { const cur = c.result; if (cur) { o.push(cur.value); cur.continue(); } else res(o); }; c.onerror = () => res(o); });
+            const latest = new Map();
+            for (const s of rows) { const cur = latest.get(s.kappa); if (!cur || s.ts > cur.ts) latest.set(s.kappa, s); }
+            for (const s of latest.values()) if (!out.has("game:" + s.kappa)) out.set("game:" + s.kappa, { kind: "game", id: "game:" + s.kappa, kappa: s.kappa, title: s.title || "", pos: 0, ts: s.ts || 0, extra: { system: s.system || "" } });
+          }
+          try { db && db.close(); } catch {}
+        }
+      } catch {}
+      return [...out.values()].sort((a, b) => (b.ts || 0) - (a.ts || 0));
+    },
+    // taste stats — every κ-play bumps; scores order rows and feed the flow sequencer
+    bumpPlay(id, kind) { const s = load(K_STATS) || {}; const r = s[id] || { n: 0, kind }; r.n++; r.kind = kind || r.kind; r.last = Date.now(); s[id] = r; save(K_STATS, s); },
+    bumpSkip(id, kind) { const s = load(K_STATS) || {}; const r = s[id] || { n: 0, kind }; r.skips = (r.skips || 0) + 1; r.kind = kind || r.kind; r.last = Date.now(); s[id] = r; save(K_STATS, s); },
+    scoreOf(id) { const s = load(K_STATS) || {}; const r = s[id]; return r ? r.n * 2 - (r.skips || 0) * 3 : 0; },
+    kindScore(kind) { const s = load(K_STATS) || {}; let n = 0; for (const r of Object.values(s)) if (r.kind === kind) n += r.n * 2 - (r.skips || 0) * 3; return n; },
+    stats() { return load(K_STATS) || {}; },
+  };
+}

b/d79ee97c9de8ee50c5e5578c333bf79a7ca8458d863b9f3ea44a8db10d8e1ab6

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+// holo-flow-witness.mjs — Gate F2 (HOLO-FLOW-PROMPT.md). The sequencer is PURE: prove determinism,
+// resume-first, kind-rhythm, mood steering, session dedupe, and plan-κ tamper refusal — 1,000 seeded runs.
+
+import { plan, sealPlan, verifyPlan } from "./holo-flow.mjs";
+
+const R = { pass: 0, fail: 0 };
+const check = (n, ok, note = "") => { R[ok ? "pass" : "fail"]++; console.log(`${ok ? "✓" : "✗"} ${n}${note ? " — " + note : ""}`); };
+
+// synthetic pool: 4 kinds × 6 cards
+const KINDS = ["film", "game", "live", "audiobook"];
+const cards = KINDS.flatMap((k) => Array.from({ length: 6 }, (_, i) => ({ id: k + ":" + i, kind: k, title: k + " " + i })));
+const base = { cards, hour: 20, seed: 42, history: [], scoreOf: () => 0 };
+
+// 1. determinism — same inputs → byte-identical plan
+{
+  const a = plan(base), b = plan(base);
+  check("deterministic", JSON.stringify(a.items.map((c) => c.id)) === JSON.stringify(b.items.map((c) => c.id)), a.items.map((c) => c.id).join(" → "));
+}
+// 2. resume-first — a continue-record leads the plan
+{
+  const p = plan({ ...base, continueList: [{ id: "audiobook:3", pos: 100, dur: 400 }] });
+  check("resume-first", p.items[0] && p.items[0].id === "audiobook:3", "why: " + p.why[0]);
+}
+// 3. kind-rhythm — across 1,000 seeds, never three identical kinds in one plan (no binge signal)
+{
+  let bad = 0;
+  for (let s = 1; s <= 1000; s++) { const p = plan({ ...base, seed: s }); const k = p.items.map((c) => c.kind); if (k.length === 3 && k[0] === k[1] && k[1] === k[2]) bad++; }
+  check("kind-rhythm (1000 seeds)", bad === 0, bad + " violations");
+}
+// 4. binge override — 3 finishes of one kind → repeats allowed
+{
+  const p = plan({ ...base, bingeKind: "film", prevKind: "film", continueList: [{ id: "film:1" }], scoreOf: (id) => (id.startsWith("film") ? 8 : 0) });
+  check("binge override", p.items.filter((c) => c.kind === "film").length >= 2, p.items.map((c) => c.kind).join(","));
+}
+// 5. mood steers — "calmer" removes games from the front of the plan; plans differ
+{
+  const a = plan({ ...base, seed: 7 }), b = plan({ ...base, seed: 7, mood: "calmer" });
+  const changed = JSON.stringify(a.items.map((c) => c.id)) !== JSON.stringify(b.items.map((c) => c.id));
+  check("mood re-plans", changed && b.items[0].kind !== "game", b.items.map((c) => c.kind).join(","));
+}
+// 6. session dedupe — played ids never reappear; exhausted pool stops honestly
+{
+  const hist = cards.slice(0, 21).map((c) => c.id);
+  const p = plan({ ...base, history: hist });
+  check("session dedupe", p.items.every((c) => !hist.includes(c.id)), p.items.length + " fresh items from a nearly-drained pool");
+}
+// 7. plan is a κ-object — seal verifies; one flipped byte refuses
+{
+  const sealed = await sealPlan(plan(base));
+  check("plan seals + verifies", !!(await verifyPlan(sealed)), sealed.kappa.slice(0, 20) + "…");
+  const tampered = { ...sealed, why: [...sealed.why] }; tampered.why[0] = (tampered.why[0] || "") + "!";
+  check("tampered plan REFUSED", (await verifyPlan(tampered)) === null);
+}
+// 8. hour priors — morning plans lead with live/book, evening with film (aggregate over seeds)
+{
+  let am = 0, pm = 0;
+  for (let s = 1; s <= 200; s++) {
+    if (["live", "audiobook"].includes(plan({ ...base, seed: s, hour: 7 }).items[0].kind)) am++;
+    if (plan({ ...base, seed: s, hour: 20 }).items[0].kind === "film") pm++;
+  }
+  check("hour priors", am > 150 && pm > 150, `7am live/book ${am}/200 · 8pm film ${pm}/200`);
+}
+
+console.log(`\nF2 ${R.fail === 0 ? "GREEN" : "RED"} — ${R.pass}/${R.pass + R.fail}`);
+process.exit(R.fail === 0 ? 0 : 1);