diff --git a/scripts/test-shared-db.mjs b/scripts/test-shared-db.mjs
index 0523ddd..c18e90b 100644
--- a/scripts/test-shared-db.mjs
+++ b/scripts/test-shared-db.mjs
@@ -7,7 +7,15 @@ import { fileURLToPath, pathToFileURL } from 'node:url'
 
 const shadowMateRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
 const merchantAdminRoot = path.resolve(shadowMateRoot, '..', 'shadow-size', 'merchant-admin')
-const testPath = path.join(shadowMateRoot, 'supabase', 'tests', 'learning_rls_test.sql')
+const testsDir = path.join(shadowMateRoot, 'supabase', 'tests')
+
+function collectTestFiles() {
+  return fs
+    .readdirSync(testsDir)
+    .filter((entry) => entry.endsWith('.sql'))
+    .sort()
+    .map((entry) => path.join(testsDir, entry))
+}
 
 function validateLocalDatabaseUrl(databaseUrl, source) {
   let parsedUrl
@@ -75,8 +83,13 @@ export { buildTestDatabaseUrl }
 if (process.argv[1] && pathToFileURL(process.argv[1]).href === import.meta.url) {
   const databaseUrl = getDatabaseUrl()
   const testDatabaseUrl = buildTestDatabaseUrl(databaseUrl)
+  const testFiles = collectTestFiles()
+
+  if (testFiles.length === 0) {
+    throw new Error(`在 ${testsDir} 中没有找到任何 SQL 测试文件。`)
+  }
 
-  console.log('🧪 运行 Shadow Mate learning RLS 测试（目标：loopback 本地数据库）')
+  console.log(`🧪 运行 ${testFiles.length} 个 pgTAP 测试文件（目标：loopback 本地数据库）`)
   execFileSync(
     'npx',
     [
@@ -85,7 +98,7 @@ if (process.argv[1] && pathToFileURL(process.argv[1]).href === import.meta.url)
       'db',
       '--db-url',
       testDatabaseUrl,
-      testPath,
+      ...testFiles,
     ],
     {
       cwd: shadowMateRoot,
diff --git a/src/app.css b/src/app.css
index 94f831e..56371f3 100644
--- a/src/app.css
+++ b/src/app.css
@@ -271,6 +271,26 @@
   .pts-card.sub .pts-toggle{background:#e08a8a;}
   .pts-card.sub.done .pts-toggle{background:#d9534f;}
 
+  .growth-form{display:grid;grid-template-columns:minmax(0,1fr) 120px auto;gap:8px;align-items:end;margin-top:10px;}
+  .growth-form label{display:flex;flex-direction:column;gap:5px;color:var(--green-deep);font-size:12px;font-weight:800;}
+  .growth-form input{width:100%;box-sizing:border-box;border:1px solid var(--line);border-radius:12px;background:var(--card);color:var(--ink);padding:10px 11px;font:inherit;font-size:14px;}
+  .growth-form .checkin{width:auto;white-space:nowrap;padding:10px 14px;font-size:13px;}
+  .growth-custom-card{background:linear-gradient(135deg,var(--card),var(--green-soft));}
+  .growth-reward-card{background:linear-gradient(135deg,var(--card),#fff7dc);}
+  .reward-list{margin-top:14px;display:grid;gap:9px;}
+  .reward-card{display:flex;align-items:center;gap:9px;border:1px solid var(--line);border-radius:16px;background:var(--card);padding:9px 10px;}
+  .reward-icon{width:34px;height:34px;border-radius:12px;background:#fff2bc;color:#a26c00;display:flex;align-items:center;justify-content:center;flex:0 0 auto;}
+  .reward-info{display:flex;flex:1;min-width:0;flex-direction:column;gap:2px;}
+  .reward-info strong{font-size:13px;color:var(--ink);}
+  .reward-info span{font-size:11px;color:var(--ink-soft);white-space:nowrap;overflow:hidden;text-overflow:ellipsis;}
+  .reward-card .pts-badge{margin-left:0;}
+  .reward-redeem{width:auto;padding:8px 10px;font-size:12px;}
+  .reward-redeem:disabled{opacity:.55;cursor:not-allowed;}
+  @media (max-width:360px){
+    .growth-form{grid-template-columns:1fr;}
+    .growth-form .checkin{width:100%;}
+  }
+
   .cal{display:grid;grid-template-columns:repeat(7,minmax(0,1fr));gap:6px;}
   .cal-chip{width:100%;height:auto;aspect-ratio:1;border-radius:10px;display:flex;align-items:center;justify-content:center;font-size:14px;font-weight:800;background:#f1f7f2;border:2px solid transparent;cursor:pointer;color:var(--ink-soft);transition:transform .15s ease,background-color .15s ease,border-color .15s ease,box-shadow .15s ease;font-family:inherit;appearance:none;}
   .cal-chip:active{transform:scale(.96);}
diff --git a/src/app.js b/src/app.js
index 831c2a3..905f70d 100644
--- a/src/app.js
+++ b/src/app.js
@@ -16,9 +16,14 @@ import {
   CHECKIN_GROUPS,
   createLearningState,
   hasCheckin,
-  isPointMarked,
   transitionLearningState,
 } from "./learning-state.js";
+import { getLearningStateStorageKey } from "./learning-state-envelope.js";
+import { loadLearningStateEnvelope, adoptPendingLearningState } from "./learning-state-storage.js";
+import { createIndexedDbLearningDb } from "./learning-local-db.js";
+import { createGrowthLoopController } from "./learning-growth-loop-controller.js";
+import { ACTIVITY_EVENT_TYPES, activityEventIdFor } from "./learning-analytics.js";
+import { getActivePointAction, getBalance, getPointDayTotal, getPointPeriodTotal } from "./learning-growth-loop.js";
 
 const CHECKIN_MODULES = Object.keys(CHECKIN_GROUPS);
 
@@ -130,31 +135,90 @@ const PEANUT_BOOKS = [
    ========================================================= */
 const STORE_KEY = "shadow_mate_workbench_v1";
 
+const growthLoopDb = createIndexedDbLearningDb();
+const growthLoopController = createGrowthLoopController({ db: growthLoopDb });
+let growthLoopSnapshot = growthLoopController.getSnapshot();
+let CURRENT_MOD = "home";
+window.growthLoop = growthLoopController;
+
+function clientRequestId(prefix = "growth") {
+  if (typeof globalThis.crypto?.randomUUID === "function") return globalThis.crypto.randomUUID();
+  return `${prefix}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+
+function queueGrowthActivity(event_type, payload = {}, bucket = "once") {
+  const scope = growthLoopController.getScope();
+  if (!scope.household_id || !scope.profile_id) return Promise.resolve(null);
+  return growthLoopController.queueActivity({
+    event_type,
+    event_id: activityEventIdFor({ ...scope, event_type, bucket }),
+    payload,
+    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    client_version: document.documentElement.dataset.version || null,
+  }).catch((error) => {
+    console.warn("Growth Loop activity event queued locally but could not be written:", error);
+    return null;
+  });
+}
+
+growthLoopController.subscribe((nextSnapshot) => {
+  growthLoopSnapshot = nextSnapshot;
+  if (CURRENT_MOD === "points" || CURRENT_MOD === "grow") switchMod(CURRENT_MOD);
+});
+
+function learningStateFromEnvelope(envelope) {
+  return envelope?.schema_version === 2 && envelope.learning ? envelope.learning : envelope;
+}
+
 function readStoredState(){
-  const raw = localStorage.getItem(STORE_KEY);
-  if(raw === null) return {};
-  try{
-    const parsed = JSON.parse(raw);
-    return parsed && typeof parsed === "object" ? parsed : {};
-  }catch(error){
-    console.warn("忽略无法解析的本地存档", error);
-  }
-  return {};
+  return learningStateFromEnvelope(loadLearningStateEnvelope(localStorage, {}));
 }
 
 let store = createLearningState(readStoredState());
 if(!store.checkins) store.checkins = {};   // {date: {module:true}}
 if(!store.extra) store.extra = {};         // 扩展记录（如数学题数）
-if(!store.points) store.points = {};       // {ym: {itemIdx: {day:1}}} 积分打卡记录
+if(!store.points) store.points = {};       // 仅保留旧积分历史；新 Growth Loop 不再写入此字段
 if(!store.bookShelf) store.bookShelf = {};  // {bookIdx:1} 绘本已读标记
 if(!store.peanutLog) store.peanutLog = [];  // [{title,date,rating}] 小花生阅读记录
 if(!store.peanutRead) store.peanutRead = {}; // {bookIdx:1} 小花生书单已读标记
 
+let learningEnvelope = loadLearningStateEnvelope(localStorage, {});
+
+function persistLearningState(){
+  learningEnvelope = {
+    ...learningEnvelope,
+    schema_version: 2,
+    product_id: "shadow-mate",
+    learning: structuredClone(store),
+  };
+  const scope = learningEnvelope.scope || {};
+  localStorage.setItem(getLearningStateStorageKey(scope), JSON.stringify(learningEnvelope));
+  // 兼容旧版本的低风险学习状态读取和既有冲突测试；新 Growth Loop
+  // 账本永远不写入旧 state.points。
+  localStorage.setItem(STORE_KEY, JSON.stringify({ ...store, points: {} }));
+}
+
 function save(){
-  localStorage.setItem(STORE_KEY, JSON.stringify(store));
+  persistLearningState();
   window.cloudSync?.schedule();
 }
 
+async function setLearningScope(scope, { adoptPending = false } = {}) {
+  learningEnvelope = adoptPending
+    ? adoptPendingLearningState(localStorage, scope)
+    : loadLearningStateEnvelope(localStorage, scope);
+  store = createLearningState(learningStateFromEnvelope(learningEnvelope));
+  if(!store.checkins) store.checkins = {};
+  if(!store.extra) store.extra = {};
+  if(!store.points) store.points = {};
+  if(!store.bookShelf) store.bookShelf = {};
+  if(!store.peanutLog) store.peanutLog = [];
+  if(!store.peanutRead) store.peanutRead = {};
+  persistLearningState();
+  switchMod(CURRENT_MOD);
+  return structuredClone(learningEnvelope);
+}
+
 function todayKey(){
   const d = new Date();
   return `${d.getFullYear()}-${String(d.getMonth()+1).padStart(2,"0")}-${String(d.getDate()).padStart(2,"0")}`;
@@ -181,6 +245,12 @@ function toggleCheckin(mod){
     key: mod,
   });
   save();
+  void queueGrowthActivity(
+    ACTIVITY_EVENT_TYPES.GROWTH_ACTIVITY_RECORDED,
+    { source: "checkin", entry_type: "manual" },
+    `${todayKey()}:${mod}`,
+  );
+  window.cloudSync?.scheduleGrowthLoop?.();
 }
 function streak(mod){
   let s = 0;
@@ -199,37 +269,69 @@ function totalChecked(mod){
 
 /* 积分打卡辅助 */
 function ymKey(){ const d=new Date(); return d.getFullYear()+"-"+(d.getMonth()+1); }
-function pointOn(itemIdx, day){
-  const ym = ymKey();
-  return isPointMarked(store, ym, itemIdx, day);
+function dateKeyForDay(day){
+  const d = new Date();
+  d.setHours(0, 0, 0, 0);
+  d.setDate(Number(day));
+  return `${d.getFullYear()}-${String(d.getMonth()+1).padStart(2,"0")}-${String(d.getDate()).padStart(2,"0")}`;
 }
-function togglePoint(itemIdx, day){
-  store = transitionLearningState(store, {
-    type: "POINT_TOGGLED",
-    month: ymKey(),
-    itemIndex: itemIdx,
-    day,
+function visiblePointItems(){
+  const items = window.growthLoop?.getPointItems?.() || [];
+  if(items.length) return items;
+  return POINT_ITEMS.map((item, index) => ({
+    id: `recommended:${index}`,
+    name: item.name,
+    description: item.desc,
+    default_points: item.pts,
+    icon_key: PTS_ICON[item.name] || "star",
+    item_kind: "recommended",
+  }));
+}
+function pointItemAt(itemId){
+  return visiblePointItems().find((item) => item.id === itemId) || null;
+}
+function pointOn(itemId, day){
+  const item = pointItemAt(itemId);
+  if(!item?.id || item.id.startsWith("recommended:")) return false;
+  return getActivePointAction(growthLoopSnapshot, item.id, dateKeyForDay(day));
+}
+function togglePoint(itemId, day){
+  const item = pointItemAt(itemId);
+  if(!item) return;
+  const requestId = clientRequestId("point");
+  void window.growthLoop.recordPoint({ item, occurred_on: dateKeyForDay(day), request_id: requestId }).then(() => {
+    void queueGrowthActivity(
+      ACTIVITY_EVENT_TYPES.GROWTH_ACTIVITY_RECORDED,
+      { source: "point_item", entry_type: Number(item.default_points ?? item.pts) < 0 ? "adjustment" : "manual" },
+      requestId,
+    );
+    void queueGrowthActivity(ACTIVITY_EVENT_TYPES.CORE_ACTIVATION, { source: "point_item" }, "once");
+    window.cloudSync?.scheduleGrowthLoop?.();
+    renderPoints();
+  }).catch((error) => {
+    console.error("Growth Loop local point write failed:", error);
+    alert("本机记录没有保存成功，请稍后重试。");
   });
-  save();
 }
-function itemMonthTotal(itemIdx){
-  const ym = ymKey();
-  const rec = store.points[ym] && store.points[ym][itemIdx];
-  if(!rec) return 0;
-  return POINT_ITEMS[itemIdx].pts * Object.keys(rec).length;
+function itemMonthTotal(itemId){
+  const item = pointItemAt(itemId);
+  if(!item?.id || item.id.startsWith("recommended:")) return 0;
+  return getPointPeriodTotal(growthLoopSnapshot, item.id, currentPeriodKey());
 }
 function monthTotal(){
-  let s = 0;
-  for(let i=0;i<POINT_ITEMS.length;i++) s += itemMonthTotal(i);
-  return s;
+  return visiblePointItems().reduce((total, item) => total + itemMonthTotal(item.id), 0);
+}
+function currentPeriodKey(){
+  const d = new Date();
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}`;
 }
 function pointDayState(day){
   let total = 0;
   let positive = false;
   let negative = false;
-  for(let i=0;i<POINT_ITEMS.length;i++){
-    if(!pointOn(i,day)) continue;
-    const points = POINT_ITEMS[i].pts;
+  for(const item of visiblePointItems()){
+    if(!pointOn(item.id,day)) continue;
+    const points = Number(item?.default_points || 0);
     total += points;
     if(points > 0) positive = true;
     if(points < 0) negative = true;
@@ -337,6 +439,12 @@ async function speak(t, button){
     button.innerHTML = buttonContent("alert", message);
     button.title = message.startsWith("未检测到系统语音") ? voiceHelp : message;
     button.dataset.speechFailure = "true";
+    const errorCode = message.includes("超时") ? "timeout" : message.includes("下载") ? "download_failed" : "synthesis_failed";
+    void queueGrowthActivity(ACTIVITY_EVENT_TYPES.TTS_FAILED, {
+      source: "offline_tts",
+      error_code: errorCode,
+      retryable: true,
+    }, `${errorCode}:${Date.now()}`);
     showSpeechGuide();
     window.setTimeout(() => {
       if (button.dataset.speechFailure === "true") restore();
@@ -856,6 +964,74 @@ function renderGrow(){
   main.appendChild(card);
   card.querySelector(".progressbar i").style.width = Math.min(100,total/30*100)+"%";
 
+  const balance = getBalance(growthLoopSnapshot);
+  const rewards = window.growthLoop?.getRewards?.() || [];
+  const pendingRedemptions = growthLoopSnapshot.redemptions.filter((item) => item.status === "pending").length;
+  const rewardCards = rewards.map((reward) => {
+    const cost = Number(reward.cost_points || 0);
+    const latest = growthLoopSnapshot.redemptions
+      .filter((item) => item.reward_id === reward.id)
+      .sort((left, right) => String(right.created_at || "").localeCompare(String(left.created_at || "")))[0];
+    const status = latest?.status === "pending" ? "待联网确认" : latest?.status === "fulfilled" ? "已兑现" : "";
+    return `<div class="reward-card">
+      <div class="reward-icon">${icon(reward.icon_key || "gift")}</div>
+      <div class="reward-info"><strong>${escapeHtml(reward.name)}</strong><span>${escapeHtml(reward.description || "家长和孩子一起约定")}</span></div>
+      <span class="pts-badge">${cost}分</span>
+      <button class="checkin reward-redeem" type="button" data-reward-id="${escapeHtml(reward.id)}" ${balance < cost ? "disabled" : ""}>${status || "兑换"}</button>
+    </div>`;
+  }).join("");
+  const rewardCard = $(`<div class="card growth-reward-card">
+      <h3>${icon("gift")} 奖励兑换</h3>
+      <div class="stat-grid">
+        <div class="stat"><div class="n">${balance}</div><div class="t">当前可用积分</div></div>
+        <div class="stat"><div class="n">${pendingRedemptions}</div><div class="t">待联网确认</div></div>
+      </div>
+      <div class="desc">离线兑换会先记为“待联网确认”，联网并完成服务端确认前不代表最终成功。</div>
+      <form id="rewardForm" class="growth-form">
+        <label>奖励名称<input name="name" maxlength="60" required placeholder="例如：周末去公园"></label>
+        <label>所需积分<input name="cost" type="number" min="1" max="100000" step="1" required placeholder="例如：10"></label>
+        <button class="checkin" type="submit">${icon("plus")} 添加奖励</button>
+      </form>
+      <div class="reward-list">${rewardCards || '<div class="desc">还没有奖励，先添加一个约定吧。</div>'}</div>
+    </div>`);
+  main.appendChild(rewardCard);
+  rewardCard.querySelector("#rewardForm").onsubmit = async (event) => {
+    event.preventDefault();
+    const form = new FormData(event.currentTarget);
+    const name = String(form.get("name") || "").trim();
+    const cost = Number(form.get("cost"));
+    if (!name || !Number.isInteger(cost) || cost < 1 || cost > 100000) {
+      alert("请填写奖励名称，并输入 1 到 100000 的整数积分。");
+      return;
+    }
+    try {
+      await window.growthLoop.createReward({
+        request_id: clientRequestId("reward"),
+        reward: { name, description: "家庭约定奖励", cost_points: cost, category: "family", icon_key: "gift" },
+      });
+      window.cloudSync?.scheduleGrowthLoop?.();
+      renderGrow();
+    } catch (error) {
+      console.error("Growth Loop reward creation failed:", error);
+      alert("奖励没有保存成功，请稍后重试。");
+    }
+  };
+  rewardCard.querySelectorAll("[data-reward-id]").forEach((button) => {
+    button.onclick = async () => {
+      const requestId = clientRequestId("redemption");
+      button.disabled = true;
+      const result = await window.growthLoop.redeemReward({ reward_id: button.dataset.rewardId, request_id: requestId });
+      if (result.error) {
+        button.disabled = false;
+        alert(result.error === "insufficient_points" ? "积分还不够，继续积累后再兑换吧。" : "这个奖励暂时不能兑换，请刷新后重试。");
+        return;
+      }
+      void queueGrowthActivity(ACTIVITY_EVENT_TYPES.REWARD_REDEEMED, { source: "reward" }, requestId);
+      window.cloudSync?.scheduleGrowthLoop?.();
+      renderGrow();
+    };
+  });
+
   // 日历式最近记录
   let cells="";
   for(let i=29;i>=0;i--){
@@ -892,18 +1068,20 @@ function renderGrow(){
 /* 积分卡片辅助 */
 const PTS_ICON = {"一起做家务":"house","认真完成学习":"bookCheck","帮带带弟弟":"learner","古诗词跟读":"bookMarked","撒谎":"circleX","白天摸当众摸鸡鸡":"alert","不收玩具":"eraser"};
 let PT_DAY = null;
-function ptsCardHTML(it, i, day){
-  const done = pointOn(i, day);
-  const sub = it.pts < 0;
-  const ptsIcon = PTS_ICON[it.name] || (sub ? "alert" : "star");
+function ptsCardHTML(it, day){
+  const done = pointOn(it.id, day);
+  const points = Number(it.default_points ?? it.pts ?? 0);
+  const description = it.description ?? it.desc ?? "";
+  const sub = points < 0;
+  const ptsIcon = it.icon_key || PTS_ICON[it.name] || (sub ? "alert" : "star");
   return `<div class="pts-card ${sub?'sub':''} ${done?'done':''}">
     <div class="pts-ic">${icon(ptsIcon)}</div>
     <div class="pts-info">
-      <div class="pts-name">${it.name}</div>
-      ${it.desc?`<div class="pts-desc">${it.desc}</div>`:""}
+      <div class="pts-name">${escapeHtml(it.name)}</div>
+      ${description?`<div class="pts-desc">${escapeHtml(description)}</div>`:""}
     </div>
-    <div class="pts-badge">${it.pts>0?'+':'-'}${Math.abs(it.pts)}分</div>
-    <button class="pts-toggle" type="button" data-i="${i}" aria-pressed="${done}" aria-label="${done?"取消":"记录"}${it.name}">${done?icon("check"):icon("plus")}</button>
+    <div class="pts-badge">${points>0?'+':'-'}${Math.abs(points)}分</div>
+    <button class="pts-toggle" type="button" data-item-id="${escapeHtml(it.id)}" aria-pressed="${done}" aria-label="${done?"取消":"记录"}${escapeHtml(it.name)}">${done?icon("check"):icon("plus")}</button>
   </div>`;
 }
 
@@ -919,7 +1097,8 @@ function renderPoints(){
   if(PT_DAY===null || PT_DAY > daysInMonth) PT_DAY = Math.min(today, daysInMonth);
   const activeDay = PT_DAY;
   const mt = monthTotal();
-  const dt = dayTotal(activeDay);
+  const dt = getPointDayTotal(growthLoopSnapshot, dateKeyForDay(activeDay));
+  const pointItems = visiblePointItems();
 
   // 挖掘机主题横幅
   main.appendChild($(`<div class="exc-banner">
@@ -967,20 +1146,70 @@ function renderPoints(){
       <div class="pts-sec">${icon("checkCircle")} 为 ${new Date().getMonth()+1}月${activeDay}日打卡 ${isToday?'<span class="pill">今天</span>':''}</div>
       ${isToday?"":`<button class="checkin danger mb-12" id="backtoday">${icon("rotate")} 回到今天</button>`}
       <div class="pts-sec">${icon("plus")} 加分项</div>
-      ${POINT_ITEMS.filter(it=>it.group==="加分项").map((it)=>ptsCardHTML(it,POINT_ITEMS.indexOf(it),activeDay)).join("")}
+      ${pointItems.filter((it) => Number(it.default_points ?? it.pts) > 0).map((it)=>ptsCardHTML(it,activeDay)).join("")}
       <div class="pts-sec">${icon("minus")} 减分项目</div>
-      ${POINT_ITEMS.filter(it=>it.group==="减分项目").map((it)=>ptsCardHTML(it,POINT_ITEMS.indexOf(it),activeDay)).join("")}
+      ${pointItems.filter((it) => Number(it.default_points ?? it.pts) < 0).map((it)=>ptsCardHTML(it,activeDay)).join("")}
     </div>`);
   main.appendChild(head);
-  head.querySelectorAll(".pts-toggle").forEach(b=>b.onclick=()=>{ togglePoint(+b.dataset.i, activeDay); renderPoints(); });
+  head.querySelectorAll(".pts-toggle").forEach((button)=>{
+    button.onclick=()=>{
+      togglePoint(button.dataset.itemId, activeDay);
+      button.disabled = true;
+    };
+  });
   const bt = el("backtoday"); if(bt) bt.onclick=()=>{PT_DAY=today; renderPoints();};
 
-  // 清空
-  main.appendChild($(`<div class="card"><button class="checkin danger" id="ptclear">${icon("trash")} 清空本月积分</button></div>`));
-  el("ptclear").onclick=()=>{
-    if(confirm("确定清空本月所有积分打卡记录？")){
-      store = transitionLearningState(store, { type: "POINTS_CLEARED", month: ymKey() });
-      save(); PT_DAY=today; renderPoints();
+  const customCard = $(`<div class="card growth-custom-card">
+      <h3>${icon("pencil")} 自定义积分项</h3>
+      <div class="desc">把成长任务纳入积分管理：正数是加分，负数是扣分；每个孩子可以有自己的分值。</div>
+      <form id="pointItemForm" class="growth-form">
+        <label>项目名称<input name="name" maxlength="60" required placeholder="例如：自己刷牙"></label>
+        <label>分值<input name="points" type="number" min="-1000" max="1000" step="1" required placeholder="例如：2"></label>
+        <button class="checkin" type="submit">${icon("plus")} 添加积分项</button>
+      </form>
+    </div>`);
+  main.appendChild(customCard);
+  customCard.querySelector("#pointItemForm").onsubmit = async (event) => {
+    event.preventDefault();
+    const form = new FormData(event.currentTarget);
+    const name = String(form.get("name") || "").trim();
+    const points = Number(form.get("points"));
+    if (!name || !Number.isInteger(points) || points === 0 || Math.abs(points) > 1000) {
+      alert("请填写名称，并输入 1 到 1000 的整数分值（可填负数）。");
+      return;
+    }
+    try {
+      await window.growthLoop.createPointItem({
+        request_id: clientRequestId("point-item"),
+        item: {
+          name,
+          description: "自定义成长任务",
+          default_points: points,
+          category: "growth",
+          icon_key: points > 0 ? "star" : "alert",
+          item_kind: "custom",
+        },
+      });
+      window.cloudSync?.scheduleGrowthLoop?.();
+      renderPoints();
+    } catch (error) {
+      console.error("Growth Loop custom point item creation failed:", error);
+      alert("积分项没有保存成功，请稍后重试。");
+    }
+  };
+
+  // 结束当前积分周期：保留历史，通过不可变的反向调整归零当前月。
+  main.appendChild($(`<div class="card"><button class="checkin danger" id="ptclear">${icon("trash")} 结束本月积分周期</button><div class="desc">不会删除历史记录，会追加反向调整，让本月重新开始。</div></div>`));
+  el("ptclear").onclick=async()=>{
+    if(confirm("确定结束本月积分周期？历史记录会保留，但本月积分会归零。")){
+      try {
+        await window.growthLoop.closePeriod({ period_key: currentPeriodKey(), request_id: clientRequestId("period-close") });
+        window.cloudSync?.scheduleGrowthLoop?.();
+        PT_DAY=today; renderPoints();
+      } catch (error) {
+        console.error("Growth Loop point period close failed:", error);
+        alert("积分周期没有结束成功，请稍后重试。");
+      }
     }
   };
   main.appendChild($(`<div class="footer">${icon("star")} 每日按日期记录 · 本机离线保存并可同步云端</div>`));
@@ -1195,7 +1424,6 @@ function checkinBtn(mod,label){
 /* =========================================================
    导航切换
    ========================================================= */
-let CURRENT_MOD = "home";
 function switchMod(mod){
   CURRENT_MOD = mod;
   document.querySelectorAll(".navbtn").forEach(b=>{
@@ -1261,19 +1489,41 @@ window.learningDesk = {
   getState(){
     return JSON.parse(JSON.stringify(store));
   },
+  getEnvelope(){
+    return structuredClone({
+      ...learningEnvelope,
+      schema_version: 2,
+      product_id: "shadow-mate",
+      learning: store,
+    });
+  },
+  async setScope(scope, options = {}){
+    return setLearningScope(scope, options);
+  },
+  getPendingState(){
+    const pending = loadLearningStateEnvelope(localStorage, {});
+    return structuredClone(pending);
+  },
   replaceState(next, options = {}){
-    store = transitionLearningState(store, { type: "STATE_REPLACED", state: next });
-    if(options.persist) localStorage.setItem(STORE_KEY, JSON.stringify(store));
+    store = transitionLearningState(store, { type: "STATE_REPLACED", state: learningStateFromEnvelope(next) });
+    if(options.persist) persistLearningState();
     switchMod(CURRENT_MOD);
   },
   clearLocalData(){
     const { reload = true } = arguments[0] || {};
     localStorage.removeItem(STORE_KEY);
+    localStorage.removeItem(getLearningStateStorageKey({}));
+    localStorage.removeItem(getLearningStateStorageKey(learningEnvelope.scope || {}));
     if (reload) {
       window.location.reload();
       return;
     }
+    learningEnvelope = loadLearningStateEnvelope(localStorage, {});
     store = createLearningState();
     switchMod(CURRENT_MOD);
   }
 };
+
+void growthLoopController.hydrate().catch((error) => {
+  console.warn("Growth Loop 本地数据库初始化失败，已保持只读推荐项：", error);
+});
diff --git a/src/cloud.js b/src/cloud.js
index 1af1b97..ad499b0 100644
--- a/src/cloud.js
+++ b/src/cloud.js
@@ -3,6 +3,11 @@ import { CLOUD_CONFIG } from "./config.js";
 import { escapeHtml, formatAuthError, formatCloudError, passwordStrength, stateHasData, mergeObjects, mergeState, latestUpdatedAt, GRADE_OPTIONS, gradeLabel, gradeOptionsSelected } from "./lib.js";
 import { runLockedAction } from "./action-lock.js";
 import { icon } from "./icons.js";
+import { buildCloudSavePayload, normalizeCloudLearningState } from "./learning-cloud-state.js";
+import { createGrowthLoopTransport, fetchGrowthLoopSnapshot } from "./learning-growth-cloud.js";
+import { buildHouseholdExport } from "./learning-export.js";
+import { ACTIVITY_EVENT_TYPES, activityEventIdFor } from "./learning-analytics.js";
+import { mergeGrowthLoopSnapshot } from "./learning-growth-loop.js";
 
 const PRODUCT_ID = CLOUD_CONFIG.productId;
 const AUTH_PRODUCT_NAME = "影伴 Shadow Mate";
@@ -29,6 +34,7 @@ const supabase = cloudEnabled
       },
     })
   : null;
+const growthLoopTransport = cloudEnabled ? createGrowthLoopTransport({ client: supabase }) : null;
 
 let session = null;
 let memberships = [];
@@ -51,6 +57,7 @@ let localResetInProgress = false;
 let lastAuthSessionKey = null;
 let passwordRecoveryActive = false;
 let passwordStatusCheckedForSession = null;
+let growthLoopSyncTimer = null;
 
 const accountButton = document.querySelector("#accountButton");
 const dialog = document.querySelector("#cloudDialog");
@@ -88,6 +95,67 @@ function showToast(message, duration = 2800) {
   toastTimer = setTimeout(hideToast, duration);
 }
 
+async function loadGrowthLoopProfile(profile, { adoptPending = false } = {}) {
+  if (!profile || !window.growthLoop || !window.learningDesk) return;
+  const scope = { household_id: profile.household_id, profile_id: profile.id };
+  await window.growthLoop.loadScope(scope, { adoptPending });
+  await queueGrowthCloudActivity(profile, ACTIVITY_EVENT_TYPES.HOUSEHOLD_ACTIVATED, {}, "once");
+  if (!growthLoopTransport) return;
+  const remote = await fetchGrowthLoopSnapshot(supabase, {
+    householdId: profile.household_id,
+    profileId: profile.id,
+  });
+  if (window.growthLoop.getScope().profile_id !== profile.id) return;
+  // A not-yet-migrated environment must not overwrite local records with an
+  // empty fallback snapshot. Release-time migrations enable this path.
+  if (remote.errors.length) return;
+  await window.growthLoop.mergeRemote(remote.snapshot);
+  if (window.growthLoop.getScope().profile_id !== profile.id) return;
+  const report = await window.growthLoop.sync({ transport: growthLoopTransport });
+  if (report.retryable || report.conflict || report.rejected) {
+    await queueGrowthCloudActivity(profile, ACTIVITY_EVENT_TYPES.SYNC_FAILED, {
+      source: "growth_loop_sync",
+      error_code: report.conflict ? "conflict" : report.rejected ? "rejected" : "retryable",
+      retryable: Boolean(report.retryable),
+    }, `sync:${new Date().toISOString().slice(0, 13)}`);
+    scheduleGrowthLoopSync();
+  }
+}
+
+async function queueGrowthCloudActivity(profile, event_type, payload = {}, bucket = "once", { ensureScope = false } = {}) {
+  if (!profile || !window.growthLoop) return null;
+  const scope = { household_id: profile.household_id, profile_id: profile.id };
+  if (!scope.household_id || !scope.profile_id) return null;
+  try {
+    const currentScope = window.growthLoop.getScope();
+    if (currentScope.household_id !== scope.household_id || currentScope.profile_id !== scope.profile_id) {
+      if (!ensureScope) return null;
+      await window.growthLoop.loadScope(scope, { adoptPending: false });
+    }
+    if (window.growthLoop.getScope().profile_id !== scope.profile_id) return null;
+    const event = await window.growthLoop.queueActivity({
+      event_type,
+      event_id: activityEventIdFor({ ...scope, event_type, bucket }),
+      payload,
+      timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+      client_version: document.documentElement.dataset.version || null,
+    });
+    return event;
+  } catch (error) {
+    console.warn("Growth Loop cloud activity event deferred:", error);
+    return null;
+  }
+}
+
+function scheduleGrowthLoopSync() {
+  clearTimeout(growthLoopSyncTimer);
+  growthLoopSyncTimer = setTimeout(() => {
+    if (activeProfile) void loadGrowthLoopProfile(activeProfile).catch((error) => {
+      console.warn("Growth Loop cloud sync deferred:", error);
+    });
+  }, 500);
+}
+
 function guardianConsentField() {
   return `<label class="cloud-consent cloud-field">
     <input type="checkbox" name="guardianConsent" value="on" required>
@@ -114,6 +182,7 @@ async function clearLocalAccountState() {
   }
   if (AUTH_STORAGE_KEY) sessionStorage.clear();
   localStorage.removeItem(ACTIVE_PROFILE_KEY);
+  await window.growthLoop?.clearAllLocalData?.();
   window.learningDesk.clearLocalData({ reload: false });
   session = null;
   memberships = [];
@@ -524,10 +593,11 @@ function renderSignedOut(mode = "otp", prefillEmail = "") {
     });
   });
   panel.querySelector("[data-close]").onclick = closeDialog;
-  panel.querySelector("[data-clear-local]").onclick = () => {
+  panel.querySelector("[data-clear-local]").onclick = async () => {
     const confirmed = window.confirm("将清除此设备上的影伴学习记录。此操作不可撤销，是否继续？");
     if (!confirmed) return;
     localStorage.removeItem(ACTIVE_PROFILE_KEY);
+    await window.growthLoop?.clearAllLocalData?.();
     window.learningDesk.clearLocalData();
   };
   panel.querySelector("[data-toggle-login-password]")?.addEventListener("click", (event) => {
@@ -671,6 +741,13 @@ function renderSetup() {
         return;
       }
       await loadWorkspace(profileId, { migrateLocal: true });
+      await queueGrowthCloudActivity(
+        { household_id: householdId, id: profileId },
+        ACTIVITY_EVENT_TYPES.LEARNER_CREATED,
+        { source: "household_setup" },
+        `learner:${profileId}`,
+        { ensureScope: true },
+      );
       showToast("家庭学习空间已建立，正在同步本机记录");
       renderPanel();
       const prompted = await maybePromptPasswordSetup({ force: true });
@@ -751,7 +828,11 @@ function renderAccount() {
   panel.querySelectorAll("[data-profile]").forEach((button) => {
     button.onclick = async () => {
       await runLockedAction(button, async () => {
-        await selectProfile(button.dataset.profile);
+        let migrateLocal = false;
+        if (button.dataset.profile !== activeProfile?.id && await window.growthLoop?.hasPendingData?.()) {
+          migrateLocal = window.confirm("发现这台设备上还有未关联学习记录。是否将它们导入到这个孩子的档案？");
+        }
+        await selectProfile(button.dataset.profile, { migrateLocal });
         renderAccount();
       }, { busyText: "正在切换…" });
     };
@@ -772,6 +853,7 @@ function renderAccount() {
           return;
         }
         const deletingActive = activeProfile?.id === profile.id;
+        await window.growthLoop?.clearScope?.({ household_id: profile.household_id, profile_id: profile.id });
         profiles = profiles.filter((item) => item.id !== profile.id);
         if (deletingActive) {
           activeProfile = null;
@@ -821,7 +903,10 @@ function renderAccount() {
     };
   });
   panel.querySelector("[data-sync]")?.addEventListener("click", async (event) => {
-    await runLockedAction(event.currentTarget, () => saveCloudState(true), { busyText: "正在同步…" });
+    await runLockedAction(event.currentTarget, async () => {
+      await saveCloudState(true);
+      if (activeProfile) await loadGrowthLoopProfile(activeProfile);
+    }, { busyText: "正在同步…" });
   });
   panel.querySelector("[data-export]")?.addEventListener("click", async (event) => {
     await runLockedAction(event.currentTarget, exportWorkspace, { busyText: "正在导出…" });
@@ -917,6 +1002,13 @@ function renderAccount() {
       }
       profiles.push(data);
       await selectProfile(data.id);
+      await queueGrowthCloudActivity(
+        data,
+        ACTIVITY_EVENT_TYPES.LEARNER_CREATED,
+        { source: "add_learner" },
+        `learner:${data.id}`,
+        { ensureScope: true },
+      );
       renderAccount();
       showToast("已添加新的学习者");
     }, { busyText: "正在添加…" });
@@ -1002,22 +1094,58 @@ async function exportWorkspace() {
     stateRows = data || [];
   }
   const statesByProfile = new Map(stateRows.map((row) => [row.profile_id, row]));
+  const consentResult = await supabase
+    .from("learning_guardian_consents")
+    .select("household_id, consent_type, policy_version, consented_at, created_at")
+    .in("household_id", householdIds)
+    .eq("user_id", session.user.id);
+  const consents = consentResult.error ? [] : (consentResult.data || []);
+  const growthResults = await Promise.all(profilesForExport.map(async (profile) => ({
+    profile,
+    result: await fetchGrowthLoopSnapshot(supabase, {
+      householdId: profile.household_id,
+      profileId: profile.id,
+    }),
+  })));
+  const growthLoop = growthResults.reduce((result, current) => {
+    const localSnapshot = current.profile.id === activeProfile?.id && window.growthLoop?.getSnapshot?.();
+    const snapshot = localSnapshot
+      ? mergeGrowthLoopSnapshot(current.result.snapshot, localSnapshot)
+      : current.result.snapshot;
+    for (const item of snapshot.point_items) result.pointItems.set(item.id, item);
+    for (const reward of snapshot.rewards) result.rewards.set(reward.id, reward);
+    for (const binding of snapshot.profile_point_items) result.profilePointItems.set(`${binding.profile_id}:${binding.point_item_id}`, binding);
+    for (const binding of snapshot.profile_rewards) result.profileRewards.set(`${binding.profile_id}:${binding.reward_id}`, binding);
+    result.ledger.push(...snapshot.ledger);
+    result.redemptions.push(...snapshot.redemptions);
+    return result;
+  }, {
+    pointItems: new Map(),
+    profilePointItems: new Map(),
+    rewards: new Map(),
+    profileRewards: new Map(),
+    ledger: [],
+    redemptions: [],
+  });
+  growthLoop.pointItems = [...growthLoop.pointItems.values()];
+  growthLoop.profilePointItems = [...growthLoop.profilePointItems.values()];
+  growthLoop.rewards = [...growthLoop.rewards.values()];
+  growthLoop.profileRewards = [...growthLoop.profileRewards.values()];
   const household = {
     id: householdIds[0],
     name: householdName || "家庭",
   };
-  const payload = {
-    schema_version: 1,
-    product_id: PRODUCT_ID,
-    exported_at: new Date().toISOString(),
+  const payload = buildHouseholdExport({
     household,
+    consents,
     learners: profilesForExport.map((profile) => ({
       ...profile,
       state: statesByProfile.get(profile.id)?.state || {},
       state_version: statesByProfile.get(profile.id)?.version || null,
       state_updated_at: statesByProfile.get(profile.id)?.updated_at || null,
     })),
-  };
+    growthLoop,
+  });
   const blob = new Blob([JSON.stringify(payload, null, 2)], { type: "application/json" });
   const url = URL.createObjectURL(blob);
   const link = document.createElement("a");
@@ -1052,6 +1180,10 @@ async function selectProfile(profileId, { migrateLocal = false } = {}) {
   activeProfile = profile;
   cloudSyncBlocked = false;
   localStorage.setItem(ACTIVE_PROFILE_KEY, profile.id);
+  await window.learningDesk.setScope(
+    { household_id: profile.household_id, profile_id: profile.id },
+    { adoptPending: migrateLocal },
+  );
   const localState = window.learningDesk.getState();
   const { data, error } = await supabase
     .from("learning_profile_states")
@@ -1068,15 +1200,27 @@ async function selectProfile(profileId, { migrateLocal = false } = {}) {
       await saveCloudState(true);
     }
   } else {
+    const normalizedRemote = normalizeCloudLearningState(data, {
+      household_id: profile.household_id,
+      profile_id: profile.id,
+    });
+    if (normalizedRemote.scope_mismatch) {
+      showToast("云端记录作用域不一致，已停止加载以保护孩子数据。", 6000);
+      return;
+    }
     lastSyncAt = latestUpdatedAt([{ updated_at: data.updated_at }, { updated_at: lastSyncAt }]);
-    cloudVersion = data.version;
-    const merged = stateHasData(localState) ? mergeState(localState, data.state) : data.state;
+    cloudVersion = normalizedRemote.version;
+    const remoteLearningState = normalizedRemote.state.learning;
+    const merged = stateHasData(localState) ? mergeState(localState, remoteLearningState) : remoteLearningState;
     window.learningDesk.replaceState(merged, { persist: true });
-    if (JSON.stringify(merged) !== JSON.stringify(data.state)) {
+    if (JSON.stringify(merged) !== JSON.stringify(remoteLearningState)) {
       await saveCloudState(true);
     }
   }
   setAccountState();
+  void loadGrowthLoopProfile(profile, { adoptPending: migrateLocal }).catch((growthError) => {
+    console.warn("Growth Loop cloud data unavailable until release migration:", growthError);
+  });
 }
 
 async function saveCloudState(manual = false) {
@@ -1091,11 +1235,10 @@ async function saveCloudState(manual = false) {
   let conflictRetries = 0;
   try {
     while (true) {
-      const currentState = window.learningDesk.getState();
+      const currentState = window.learningDesk.getEnvelope();
       const { data, error } = await supabase.rpc("learning_save_state", {
         p_profile_id: activeProfile.id,
-        p_state: currentState,
-        p_expected_version: cloudVersion,
+        ...buildCloudSavePayload(currentState, cloudVersion),
       });
       if (error) {
         if (error.message.includes("learning_rate_limited")) {
@@ -1163,13 +1306,14 @@ async function saveCloudState(manual = false) {
 function scheduleSave() {
   if (cloudSyncBlocked) {
     clearTimeout(saveTimer);
-    return;
+  } else {
+    clearTimeout(saveTimer);
+    saveTimer = setTimeout(() => saveCloudState(false), 500);
   }
-  clearTimeout(saveTimer);
-  saveTimer = setTimeout(() => saveCloudState(false), 500);
+  scheduleGrowthLoopSync();
 }
 
-window.cloudSync = { schedule: scheduleSave };
+window.cloudSync = { schedule: scheduleSave, scheduleGrowthLoop: scheduleGrowthLoopSync };
 
 async function maybePromptPasswordSetup(options = {}) {
   if (!session || passwordRecoveryActive) return false;
diff --git a/src/learning-analytics.js b/src/learning-analytics.js
new file mode 100644
index 0000000..a45e19e
--- /dev/null
+++ b/src/learning-analytics.js
@@ -0,0 +1,77 @@
+export const ACTIVITY_EVENT_TYPES = Object.freeze({
+  HOUSEHOLD_ACTIVATED: "household_activated",
+  LEARNER_CREATED: "learner_created",
+  CORE_ACTIVATION: "core_activation",
+  GROWTH_ACTIVITY_RECORDED: "growth_activity_recorded",
+  RETENTION_QUALIFIED: "retention_qualified",
+  REWARD_REDEEMED: "reward_redeemed",
+  SYNC_FAILED: "sync_failed",
+  TTS_FAILED: "tts_failed",
+});
+
+const ALLOWED_TYPES = new Set(Object.values(ACTIVITY_EVENT_TYPES));
+const COMMON_PAYLOAD_KEYS = new Set(["source", "entry_type", "error_code", "retryable", "client", "days", "count"]);
+
+function clone(value) {
+  return structuredClone(value);
+}
+
+function createId() {
+  if (typeof globalThis.crypto?.randomUUID === "function") return globalThis.crypto.randomUUID();
+  return `activity-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+
+function hash32(value, seed) {
+  let hash = (2166136261 ^ seed) >>> 0;
+  for (const character of String(value)) {
+    hash ^= character.codePointAt(0);
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+
+export function activityEventIdFor({ household_id, profile_id, event_type, bucket = "once" } = {}) {
+  const input = `${household_id || ""}:${profile_id || ""}:${event_type || ""}:${bucket}`;
+  const hex = [0, 1, 2, 3].map((seed) => hash32(input, seed)).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-4${hex.slice(13, 16)}-8${hex.slice(17, 20)}-${hex.slice(20, 32)}`;
+}
+
+function sanitizePayload(payload = {}) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) return {};
+  return Object.entries(payload).reduce((result, [key, value]) => {
+    if (!COMMON_PAYLOAD_KEYS.has(key)) return result;
+    if (typeof value === "string") result[key] = value.slice(0, 80);
+    else if (typeof value === "number" || typeof value === "boolean") result[key] = value;
+    return result;
+  }, {});
+}
+
+export function buildActivityEvent({
+  event_type,
+  household_id,
+  profile_id,
+  occurred_at = new Date().toISOString(),
+  client_version = null,
+  timezone = null,
+  payload = {},
+  event_id = null,
+} = {}) {
+  if (!ALLOWED_TYPES.has(event_type)) throw new Error("activity_event_type_invalid");
+  if (!household_id || !profile_id) throw new Error("activity_event_scope_required");
+  return {
+    event_id: event_id || createId(),
+    scope_key: `${household_id}:${profile_id}`,
+    product_id: "shadow-mate",
+    event_type,
+    household_id,
+    profile_id,
+    occurred_at,
+    timezone: timezone ? String(timezone).slice(0, 64) : null,
+    client_version: client_version ? String(client_version).slice(0, 32) : null,
+    payload: clone(sanitizePayload(payload)),
+  };
+}
+
+export function isAllowedActivityEvent(eventType) {
+  return ALLOWED_TYPES.has(eventType);
+}
diff --git a/src/learning-cloud-state.js b/src/learning-cloud-state.js
new file mode 100644
index 0000000..255fd59
--- /dev/null
+++ b/src/learning-cloud-state.js
@@ -0,0 +1,54 @@
+import { migrateLegacyLearningState } from "./learning-state-envelope.js";
+
+function normalizeScope(scope = {}) {
+  return {
+    household_id: scope.householdId ?? scope.household_id ?? null,
+    profile_id: scope.profileId ?? scope.profile_id ?? null,
+  };
+}
+
+function sameScope(left, right) {
+  return left?.household_id === right.household_id
+    && left?.profile_id === right.profile_id;
+}
+
+function emptyState(scope) {
+  return migrateLegacyLearningState({}, scope);
+}
+
+/**
+ * Normalize a remote row without conflating its cloud optimistic-lock
+ * version with the schema version inside the portable learning state.
+ */
+export function normalizeCloudLearningState(row = {}, scope = {}) {
+  const requestedScope = normalizeScope(scope);
+  const rawState = row?.state;
+  const state = migrateLegacyLearningState(rawState, requestedScope);
+  const isVersionedEnvelope = rawState?.schema_version === 2 && rawState?.learning;
+
+  if (isVersionedEnvelope && !sameScope(state.scope, requestedScope)) {
+    return {
+      state: emptyState(requestedScope),
+      version: null,
+      updated_at: null,
+      scope_mismatch: true,
+    };
+  }
+
+  return {
+    state,
+    version: row?.version ?? null,
+    updated_at: row?.updated_at ?? null,
+    scope_mismatch: false,
+  };
+}
+
+/**
+ * Keep the RPC optimistic-lock input beside, but outside, the state envelope.
+ */
+export function buildCloudSavePayload(state, expectedVersion = null) {
+  return {
+    p_state: structuredClone(state),
+    p_expected_version: expectedVersion,
+  };
+}
diff --git a/src/learning-export.js b/src/learning-export.js
new file mode 100644
index 0000000..d13e0e0
--- /dev/null
+++ b/src/learning-export.js
@@ -0,0 +1,108 @@
+const EXPORT_SCHEMA_VERSION = 1;
+const PRODUCT_ID = "shadow-mate";
+
+const SENSITIVE_KEY_PATTERNS = [
+  /auth/i,
+  /email/i,
+  /session/i,
+  /secret/i,
+  /token/i,
+  /password/i,
+  /device/i,
+  /sound/i,
+  /activity.?event/i,
+  /analytics/i,
+  /server.?audit/i,
+  /internal.?audit/i,
+  /audit.?log/i,
+];
+
+function isSensitiveKey(key) {
+  return SENSITIVE_KEY_PATTERNS.some((pattern) => pattern.test(key));
+}
+
+function sanitizeForExport(value) {
+  if (Array.isArray(value)) {
+    return value.map(sanitizeForExport);
+  }
+
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+
+  return Object.entries(value).reduce((result, [key, entry]) => {
+    if (!isSensitiveKey(key)) {
+      result[key] = sanitizeForExport(entry);
+    }
+    return result;
+  }, {});
+}
+
+function pick(source, keys) {
+  return keys.reduce((result, key) => {
+    if (source && source[key] !== undefined) {
+      result[key] = sanitizeForExport(source[key]);
+    }
+    return result;
+  }, {});
+}
+
+function exportLearner(learner) {
+  return pick(learner, [
+    "id",
+    "household_id",
+    "display_name",
+    "grade_level",
+    "age_band",
+    "avatar_key",
+    "created_at",
+    "updated_at",
+    "state",
+    "state_version",
+    "state_updated_at",
+  ]);
+}
+
+function exportConsent(consent) {
+  return pick(consent, [
+    "household_id",
+    "profile_id",
+    "consent_type",
+    "policy_version",
+    "consented_at",
+    "created_at",
+    "revoked_at",
+    "source",
+  ]);
+}
+
+function exportRows(rows) {
+  return Array.isArray(rows) ? rows.map(sanitizeForExport) : [];
+}
+
+/**
+ * Build the user-owned data export. The field allowlists keep credentials,
+ * device preferences, raw analytics, and server-only audit data out of the
+ * portable product history.
+ */
+export function buildHouseholdExport(input = {}) {
+  const household = input.household || {};
+  const growthLoop = input.growthLoop || {};
+
+  return {
+    export_schema_version: EXPORT_SCHEMA_VERSION,
+    product_id: PRODUCT_ID,
+    exported_at: input.exportedAt || new Date().toISOString(),
+    household: pick(household, ["id", "name"]),
+    learners: Array.isArray(input.learners) ? input.learners.map(exportLearner) : [],
+    consents: Array.isArray(input.consents) ? input.consents.map(exportConsent) : [],
+    growth_loop: {
+      point_items: exportRows(growthLoop.pointItems),
+      profile_point_items: exportRows(growthLoop.profilePointItems),
+      rewards: exportRows(growthLoop.rewards),
+      profile_rewards: exportRows(growthLoop.profileRewards),
+      ledger: exportRows(growthLoop.ledger),
+      redemptions: exportRows(growthLoop.redemptions),
+    },
+  };
+}
diff --git a/src/learning-growth-cloud.js b/src/learning-growth-cloud.js
new file mode 100644
index 0000000..3473708
--- /dev/null
+++ b/src/learning-growth-cloud.js
@@ -0,0 +1,122 @@
+function classifyError(error = {}) {
+  const status = Number(error.status || error.code);
+  const message = String(error.message || error.error_description || "").toLowerCase();
+  if (status === 409 || message.includes("conflict") || message.includes("idempotency")) {
+    return { status: "conflict", error_code: message.includes("idempotency") ? "idempotency_conflict" : "cloud_conflict", error_message: error.message || null };
+  }
+  if (status === 401 || status === 403 || message.includes("forbidden") || message.includes("auth_required") || message.includes("scope_invalid")) {
+    return { status: "rejected", error_code: "permission_denied", error_message: error.message || null };
+  }
+  if (status >= 400 && status < 500 && status !== 408 && status !== 429) {
+    return { status: "rejected", error_code: error.code || "request_rejected", error_message: error.message || null };
+  }
+  return { status: "retryable", error_code: status === 429 ? "rate_limited" : "network_or_server_error", error_message: error.message || null };
+}
+
+async function rpc(client, name, args) {
+  const { data, error } = await client.rpc(name, args);
+  if (error) return classifyError(error);
+  const normalized = Array.isArray(data) ? data[0] : data;
+  return { status: "confirmed", data: normalized || null };
+}
+
+async function upsert(client, table, values) {
+  const result = await client.from(table).upsert(values, { onConflict: "id" }).select().single();
+  if (result.error) return classifyError(result.error);
+  return { status: "confirmed", data: result.data };
+}
+
+function publicDefinition(values, fields) {
+  return fields.reduce((result, field) => {
+    if (values?.[field] !== undefined) result[field] = values[field];
+    return result;
+  }, {});
+}
+
+const POINT_ITEM_FIELDS = ["id", "household_id", "name", "description", "default_points", "item_kind", "category", "icon_key", "is_active"];
+const PROFILE_POINT_ITEM_FIELDS = ["household_id", "profile_id", "point_item_id", "points_override", "enabled"];
+const REWARD_FIELDS = ["id", "household_id", "name", "description", "cost_points", "reward_kind", "category", "icon_key", "is_active"];
+const PROFILE_REWARD_FIELDS = ["household_id", "profile_id", "reward_id", "cost_override", "enabled"];
+
+export function createGrowthLoopTransport({ client } = {}) {
+  if (!client) throw new Error("growth_loop_cloud_client_required");
+  return {
+    async send(event) {
+      const payload = event.payload || {};
+      switch (event.type) {
+        case "point_item_upsert":
+          return upsert(client, "learning_point_items", publicDefinition(payload.point_item, POINT_ITEM_FIELDS));
+        case "profile_point_item_upsert": {
+          const result = await client.from("learning_profile_point_items").upsert(publicDefinition(payload.profile_point_item, PROFILE_POINT_ITEM_FIELDS), { onConflict: "profile_id,point_item_id" }).select().single();
+          return result.error ? classifyError(result.error) : { status: "confirmed", data: result.data };
+        }
+        case "point_record":
+          return rpc(client, "learning_record_points", {
+            p_profile_id: payload.profile_id,
+            p_point_item_id: payload.point_item_id,
+            p_delta: payload.delta,
+            p_request_id: event.request_id,
+            p_entry_type: payload.entry_type || "manual",
+            p_note: payload.note || null,
+            p_occurred_on: payload.occurred_on || new Date().toISOString().slice(0, 10),
+          });
+        case "reward_upsert":
+          return upsert(client, "learning_rewards", publicDefinition(payload.reward, REWARD_FIELDS));
+        case "profile_reward_upsert": {
+          const result = await client.from("learning_profile_rewards").upsert(publicDefinition(payload.profile_reward, PROFILE_REWARD_FIELDS), { onConflict: "profile_id,reward_id" }).select().single();
+          return result.error ? classifyError(result.error) : { status: "confirmed", data: result.data };
+        }
+        case "reward_redeem":
+          return rpc(client, "learning_redeem_reward", {
+            p_profile_id: payload.profile_id,
+            p_reward_id: payload.reward_id,
+            p_request_id: event.request_id,
+          });
+        case "redemption_fulfill":
+          return rpc(client, "learning_fulfill_redemption", { p_redemption_id: payload.redemption_id });
+        case "redemption_cancel":
+          return rpc(client, "learning_cancel_redemption", {
+            p_redemption_id: payload.redemption_id,
+            p_request_id: event.request_id,
+            p_note: payload.note || null,
+          });
+        case "activity_event":
+          return rpc(client, "learning_record_activity_event", { p_event: payload.event });
+        default:
+          return { status: "rejected", error_code: "event_type_invalid", error_message: event.type };
+      }
+    },
+  };
+}
+
+function rowsOrEmpty(result) {
+  return result?.error ? [] : result?.data || [];
+}
+
+export async function fetchGrowthLoopSnapshot(client, { householdId, profileId }) {
+  const profileFilter = (query) => query.eq("profile_id", profileId);
+  const [pointItems, profilePointItems, rewards, profileRewards, ledger, redemptions] = await Promise.all([
+    client.from("learning_point_items").select("*").eq("household_id", householdId).eq("is_active", true),
+    profileFilter(client.from("learning_profile_point_items").select("*")),
+    client.from("learning_rewards").select("*").eq("household_id", householdId).eq("is_active", true),
+    profileFilter(client.from("learning_profile_rewards").select("*")),
+    profileFilter(client.from("learning_point_ledger").select("*")),
+    profileFilter(client.from("learning_redemptions").select("*")),
+  ]);
+  const errors = [pointItems, profilePointItems, rewards, profileRewards, ledger, redemptions]
+    .map((result) => result?.error)
+    .filter(Boolean);
+  return {
+    snapshot: {
+      schema_version: 1,
+      scope: { household_id: householdId, profile_id: profileId },
+      point_items: rowsOrEmpty(pointItems),
+      profile_point_items: rowsOrEmpty(profilePointItems),
+      rewards: rowsOrEmpty(rewards),
+      profile_rewards: rowsOrEmpty(profileRewards),
+      ledger: rowsOrEmpty(ledger).map((row) => ({ ...row, status: "confirmed" })),
+      redemptions: rowsOrEmpty(redemptions),
+    },
+    errors,
+  };
+}
diff --git a/src/learning-growth-loop-controller.js b/src/learning-growth-loop-controller.js
new file mode 100644
index 0000000..99c9e16
--- /dev/null
+++ b/src/learning-growth-loop-controller.js
@@ -0,0 +1,345 @@
+import {
+  applyPointAction,
+  applyPointItemCreation,
+  applyRedemption,
+  applyRewardCreation,
+  closePointPeriod,
+  createGrowthLoopState,
+  mergeGrowthLoopSnapshot,
+  normalizeGrowthLoopState,
+  recommendedPointItems,
+  recommendedRewards,
+  scopeKeyForGrowthLoop,
+} from "./learning-growth-loop.js";
+import { buildActivityEvent } from "./learning-analytics.js";
+import { createOutboxSync } from "./learning-growth-loop-sync.js";
+
+function clone(value) {
+  return structuredClone(value);
+}
+
+function createId() {
+  if (typeof globalThis.crypto?.randomUUID === "function") return globalThis.crypto.randomUUID();
+  return `growth-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+
+function pendingStatuses() {
+  return ["pending", "retryable", "conflict", "rejected"];
+}
+
+function rebindSnapshotScope(input, scope) {
+  const next = normalizeGrowthLoopState(input, scope);
+  next.scope = { ...scope };
+  next.point_items = next.point_items.map((item) => ({
+    ...item,
+    household_id: item.household_id || scope.household_id,
+  }));
+  next.profile_point_items = next.profile_point_items.map((item) => ({
+    ...item,
+    household_id: item.household_id || scope.household_id,
+    profile_id: item.profile_id || scope.profile_id,
+  }));
+  next.rewards = next.rewards.map((reward) => ({
+    ...reward,
+    household_id: reward.household_id || scope.household_id,
+  }));
+  next.profile_rewards = next.profile_rewards.map((reward) => ({
+    ...reward,
+    household_id: reward.household_id || scope.household_id,
+    profile_id: reward.profile_id || scope.profile_id,
+  }));
+  next.ledger = next.ledger.map((entry) => ({
+    ...entry,
+    household_id: entry.household_id || scope.household_id,
+    profile_id: entry.profile_id || scope.profile_id,
+  }));
+  next.redemptions = next.redemptions.map((redemption) => ({
+    ...redemption,
+    household_id: redemption.household_id || scope.household_id,
+    profile_id: redemption.profile_id || scope.profile_id,
+  }));
+  return next;
+}
+
+export function createGrowthLoopController({ db } = {}) {
+  if (!db) throw new Error("growth_loop_local_db_required");
+  let scope = { household_id: null, profile_id: null };
+  let scopeKey = scopeKeyForGrowthLoop(scope);
+  let snapshot = createGrowthLoopState(scope);
+  const listeners = new Set();
+
+  function notify() {
+    const value = clone(snapshot);
+    for (const listener of listeners) listener(value);
+  }
+
+  async function persist(nextSnapshot, events = []) {
+    // The local event and its outbox entry are durable before the projection
+    // becomes visible to the UI. A failed local write must not look successful.
+    for (const event of events) await db.appendOutbox(event);
+    await db.putSnapshot(scopeKey, nextSnapshot);
+    snapshot = normalizeGrowthLoopState(nextSnapshot, scope);
+    notify();
+    return clone(snapshot);
+  }
+
+  async function loadScope(nextScope = {}, { adoptPending = false } = {}) {
+    const normalizedScope = {
+      household_id: nextScope.household_id ?? nextScope.householdId ?? null,
+      profile_id: nextScope.profile_id ?? nextScope.profileId ?? null,
+    };
+    const nextScopeKey = scopeKeyForGrowthLoop(normalizedScope);
+    let nextSnapshot = await db.getSnapshot(nextScopeKey);
+    if (adoptPending && nextScopeKey !== "pending:pending") {
+      const pending = await db.getSnapshot("pending:pending");
+      if (pending) {
+        const reboundPending = rebindSnapshotScope(pending, normalizedScope);
+        await db.moveScope("pending:pending", nextScopeKey, normalizedScope);
+        nextSnapshot = nextSnapshot
+          ? mergeGrowthLoopSnapshot(nextSnapshot, reboundPending)
+          : reboundPending;
+      }
+    }
+    if (!nextSnapshot) {
+      nextSnapshot = createGrowthLoopState(normalizedScope);
+    }
+    await db.putSnapshot(nextScopeKey, nextSnapshot);
+    scope = normalizedScope;
+    scopeKey = nextScopeKey;
+    snapshot = normalizeGrowthLoopState(nextSnapshot, scope);
+    notify();
+    return clone(snapshot);
+  }
+
+  async function hydrate() {
+    return loadScope(scope);
+  }
+
+  function getSnapshot() {
+    return clone(snapshot);
+  }
+
+  function getScope() {
+    return { ...scope };
+  }
+
+  function getPointItems({ includeRecommendations = true } = {}) {
+    if (!includeRecommendations) return clone(snapshot.point_items);
+    const existingNames = new Set(snapshot.point_items.map((item) => item.name));
+    const recommendations = recommendedPointItems.filter((item) => !existingNames.has(item.name)).map((item, index) => ({
+      ...clone(item),
+      id: `recommended:${index}:${item.name}`,
+      item_kind: "recommended",
+      source: "recommendation",
+    }));
+    return [...clone(snapshot.point_items), ...recommendations];
+  }
+
+  function getRewards({ includeRecommendations = true } = {}) {
+    if (!includeRecommendations) return clone(snapshot.rewards);
+    const existingNames = new Set(snapshot.rewards.map((item) => item.name));
+    const recommendations = recommendedRewards.filter((item) => !existingNames.has(item.name)).map((item, index) => ({
+      ...clone(item),
+      id: `recommended-reward:${index}:${item.name}`,
+      reward_kind: "recommended",
+      source: "recommendation",
+    }));
+    return [...clone(snapshot.rewards), ...recommendations];
+  }
+
+  async function recordPoint({ item, occurred_on, request_id = createId() }) {
+    const inputItem = String(item?.id || "").startsWith("recommended:") ? { ...item, id: undefined } : item;
+    const result = applyPointAction(snapshot, { scope, item: inputItem, occurred_on, request_id });
+    return persist(result.snapshot, result.events);
+  }
+
+  async function createPointItem({ item, request_id = createId() }) {
+    const result = applyPointItemCreation(snapshot, { scope, item, request_id });
+    return persist(result.snapshot, result.events);
+  }
+
+  async function closePeriod({ period_key, request_id = createId() }) {
+    const result = closePointPeriod(snapshot, { scope, period_key, request_id });
+    return persist(result.snapshot, result.events);
+  }
+
+  async function createReward({ reward, request_id = createId() }) {
+    const inputReward = String(reward?.id || "").startsWith("recommended-reward:") ? { ...reward, id: undefined } : reward;
+    const result = applyRewardCreation(snapshot, { scope, reward: inputReward, request_id });
+    return persist(result.snapshot, result.events);
+  }
+
+  async function redeemReward({ reward_id, request_id = createId() }) {
+    let actualRewardId = reward_id;
+    if (String(reward_id || "").startsWith("recommended-reward:")) {
+      const recommendation = getRewards().find((reward) => reward.id === reward_id);
+      if (!recommendation) return { ...clone(snapshot), error: "reward_not_enabled" };
+      const definition = applyRewardCreation(snapshot, {
+        scope,
+        reward: { ...recommendation, id: undefined },
+        request_id: `${request_id}:definition`,
+      });
+      actualRewardId = definition.reward.id;
+      await persist(definition.snapshot, definition.events);
+    }
+    const result = applyRedemption(snapshot, { scope, reward_id: actualRewardId, request_id });
+    if (result.error) return { ...clone(snapshot), error: result.error };
+    await persist(result.snapshot, result.events);
+    return clone(snapshot);
+  }
+
+  async function queueActivity({ event_type, payload = {}, occurred_at, client_version, timezone, event_id }) {
+    const event = buildActivityEvent({
+      event_type,
+      household_id: scope.household_id,
+      profile_id: scope.profile_id,
+      payload,
+      occurred_at,
+      client_version,
+      timezone,
+      event_id,
+    });
+    const outboxEvent = {
+      event_id: event.event_id,
+      request_id: event.event_id,
+      scope_key: scopeKey,
+      household_id: scope.household_id,
+      profile_id: scope.profile_id,
+      type: "activity_event",
+      payload: { event },
+    };
+    await db.putActivityEvent(event);
+    await db.appendOutbox(outboxEvent);
+    return event;
+  }
+
+  async function mergeRemote(remoteSnapshot) {
+    const merged = mergeGrowthLoopSnapshot(remoteSnapshot, snapshot);
+    await db.putSnapshot(scopeKey, merged);
+    snapshot = merged;
+    notify();
+    return clone(snapshot);
+  }
+
+  async function reconcileConfirmed(event, result) {
+    const next = normalizeGrowthLoopState(snapshot, scope);
+    const remote = result?.data;
+    if (event.type === "point_record") {
+      const row = next.ledger.find((entry) => entry.request_id === event.request_id);
+      if (row) {
+        Object.assign(row, remote || {}, { status: "confirmed" });
+      }
+    } else if (event.type === "point_item_upsert" && remote?.id) {
+      const row = next.point_items.find((item) => item.id === event.payload.point_item?.id);
+      if (row) Object.assign(row, remote);
+    } else if (event.type === "reward_upsert" && remote?.id) {
+      const row = next.rewards.find((reward) => reward.id === event.payload.reward?.id);
+      if (row) Object.assign(row, remote);
+    } else if (event.type === "reward_redeem") {
+      const redemption = next.redemptions.find((entry) => entry.request_id === event.request_id);
+      if (redemption) {
+        Object.assign(redemption, remote || {}, { status: remote?.status || "pending" });
+        const debit = next.ledger.find((entry) => entry.redemption_id === redemption.id);
+        if (debit && remote?.id) debit.redemption_id = remote.id;
+      }
+    }
+    await db.putSnapshot(scopeKey, next);
+    snapshot = next;
+    notify();
+  }
+
+  async function reconcileRejected(event, result) {
+    const next = normalizeGrowthLoopState(snapshot, scope);
+    if (event.type === "point_record") {
+      const row = next.ledger.find((entry) => entry.request_id === event.request_id);
+      if (row) Object.assign(row, { status: result.status, sync_error: result.error_code || "rejected" });
+    }
+    if (event.type === "reward_redeem") {
+      const redemption = next.redemptions.find((entry) => entry.request_id === event.request_id);
+      if (redemption) Object.assign(redemption, { status: result.status, sync_error: result.error_code || "rejected" });
+      const debit = next.ledger.find((entry) => entry.request_id === `${event.request_id}:debit`);
+      if (debit) Object.assign(debit, { status: result.status, sync_error: result.error_code || "rejected" });
+    }
+    await db.putSnapshot(scopeKey, next);
+    snapshot = next;
+    notify();
+  }
+
+  async function sync({ transport, limit = 100 } = {}) {
+    if (!transport) return { skipped: true, reason: "cloud_unavailable" };
+    const syncEngine = createOutboxSync({
+      db,
+      transport,
+      onConfirmed: reconcileConfirmed,
+      onRejected: reconcileRejected,
+    });
+    const report = await syncEngine.syncScope(scopeKey, { limit });
+    snapshot.sync = { ...snapshot.sync, blocked: report.blocked, last_sync_report: report, last_server_sync_at: report.blocked ? snapshot.sync.last_server_sync_at : new Date().toISOString() };
+    await db.putSnapshot(scopeKey, snapshot);
+    notify();
+    return report;
+  }
+
+  async function pendingOutbox() {
+    return db.listOutbox(scopeKey, { statuses: pendingStatuses(), now: Number.MAX_SAFE_INTEGER });
+  }
+
+  async function clearScope(targetScope = null) {
+    if (targetScope) {
+      await db.clearScope(scopeKeyForGrowthLoop(targetScope));
+      if (scopeKeyForGrowthLoop(targetScope) !== scopeKey) return;
+    } else {
+      await db.clearScope(scopeKey);
+    }
+    snapshot = createGrowthLoopState(scope);
+    notify();
+  }
+
+  async function clearAllLocalData() {
+    await db.clearAll();
+    scope = { household_id: null, profile_id: null };
+    scopeKey = scopeKeyForGrowthLoop(scope);
+    snapshot = createGrowthLoopState(scope);
+    notify();
+  }
+
+  async function hasPendingData() {
+    const pending = await db.getSnapshot("pending:pending");
+    if (pending) {
+      return Boolean(
+        pending.point_items?.length
+        || pending.rewards?.length
+        || pending.ledger?.length
+        || pending.redemptions?.length,
+      );
+    }
+    return false;
+  }
+
+  function subscribe(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+  }
+
+  return {
+    hydrate,
+    loadScope,
+    getSnapshot,
+    getScope,
+    getPointItems,
+    getRewards,
+    createPointItem,
+    recordPoint,
+    closePeriod,
+    createReward,
+    redeemReward,
+    queueActivity,
+    mergeRemote,
+    sync,
+    pendingOutbox,
+    clearScope,
+    clearAllLocalData,
+    hasPendingData,
+    subscribe,
+  };
+}
diff --git a/src/learning-growth-loop-sync.js b/src/learning-growth-loop-sync.js
new file mode 100644
index 0000000..2bb80ca
--- /dev/null
+++ b/src/learning-growth-loop-sync.js
@@ -0,0 +1,100 @@
+const DEFAULT_RETRY_BASE_MS = 1000;
+const MAX_RETRY_DELAY_MS = 15 * 60 * 1000;
+
+function createWorkerId() {
+  if (typeof globalThis.crypto?.randomUUID === "function") return globalThis.crypto.randomUUID();
+  return `growth-sync-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+
+function retryDelay(attempts, base, jitter, random = Math.random) {
+  const exponential = Math.min(MAX_RETRY_DELAY_MS, base * (2 ** Math.max(0, attempts - 1)));
+  const spread = Math.max(0, Math.min(1, jitter));
+  const multiplier = 1 - spread + (random() * spread * 2);
+  return Math.round(exponential * multiplier);
+}
+
+export function createOutboxSync({
+  db,
+  transport,
+  now = () => Date.now(),
+  retryBaseMs = DEFAULT_RETRY_BASE_MS,
+  jitter = 0.2,
+  random = Math.random,
+  workerId = createWorkerId(),
+  leaseMs = 30_000,
+  onConfirmed = async () => {},
+  onRejected = async () => {},
+} = {}) {
+  if (!db || !transport?.send) throw new Error("outbox_sync_dependencies_required");
+
+  async function syncScope(scopeKey, options = {}) {
+    const limit = options.limit || 100;
+    const events = await db.listOutbox(scopeKey, {
+      statuses: ["pending", "retryable"],
+      now: now(),
+      limit,
+    });
+    const report = { confirmed: 0, duplicate: 0, retryable: 0, conflict: 0, rejected: 0, pending: events.length, blocked: false };
+    for (const event of events) {
+      const claimed = await db.claimOutbox?.(event.event_id, {
+        worker_id: workerId,
+        now: now(),
+        lease_ms: leaseMs,
+      });
+      if (db.claimOutbox && !claimed) continue;
+      let result;
+      try {
+        result = await transport.send(event);
+      } catch (error) {
+        result = { status: "retryable", error_code: "network_error", error_message: error?.message || "network_error" };
+      }
+      const status = result?.status || "retryable";
+      if (status === "confirmed" || status === "duplicate") {
+        await db.updateOutbox(event.event_id, {
+          status: "confirmed",
+          confirmed_at: new Date(now()).toISOString(),
+          error_code: null,
+          error_message: null,
+          response: result?.data || null,
+          processing_by: null,
+          lease_until: 0,
+        });
+        await onConfirmed(event, result);
+        report[status] += 1;
+        report.pending -= 1;
+        continue;
+      }
+      if (status === "retryable") {
+        const attempts = Number(event.attempts || 0) + 1;
+        await db.updateOutbox(event.event_id, {
+          status: "retryable",
+          attempts,
+          next_attempt_at: now() + retryDelay(attempts, retryBaseMs, jitter, random),
+          error_code: result?.error_code || "retryable_error",
+          error_message: result?.error_message || null,
+          processing_by: null,
+          lease_until: 0,
+        });
+        report.retryable += 1;
+        report.blocked = true;
+        break;
+      }
+      const terminalStatus = status === "conflict" ? "conflict" : "rejected";
+      await db.updateOutbox(event.event_id, {
+        status: terminalStatus,
+        error_code: result?.error_code || `${terminalStatus}_error`,
+        error_message: result?.error_message || null,
+        processing_by: null,
+        lease_until: 0,
+      });
+      await onRejected(event, { ...result, status: terminalStatus });
+      report[terminalStatus] += 1;
+      report.pending -= 1;
+      report.blocked = true;
+      break;
+    }
+    return report;
+  }
+
+  return { syncScope };
+}
diff --git a/src/learning-growth-loop.js b/src/learning-growth-loop.js
new file mode 100644
index 0000000..6016e07
--- /dev/null
+++ b/src/learning-growth-loop.js
@@ -0,0 +1,518 @@
+export const GROWTH_LOOP_SCHEMA_VERSION = 1;
+
+export const recommendedPointItems = [
+  { name: "一起做家务", description: "收拾 / 洗碗", default_points: 2, category: "family", icon_key: "house" },
+  { name: "认真完成学习", description: "完成约定的学习时间", default_points: 3, category: "learning", icon_key: "bookCheck" },
+  { name: "帮助家人", description: "主动帮助弟弟或家人", default_points: 2, category: "family", icon_key: "learner" },
+  { name: "古诗词跟读", description: "完成一次跟读", default_points: 3, category: "learning", icon_key: "bookMarked" },
+  { name: "撒谎", description: "需要和家长一起复盘", default_points: -10, category: "growth", icon_key: "circleX" },
+  { name: "不爱护身体", description: "需要温和提醒", default_points: -2, category: "growth", icon_key: "alert" },
+  { name: "不收玩具", description: "完成整理后再记录", default_points: -3, category: "family", icon_key: "eraser" },
+];
+
+export const recommendedRewards = [
+  { name: "一起去公园", description: "和家长安排一次户外时间", cost_points: 10, category: "activity", icon_key: "trees" },
+  { name: "选择今晚的绘本", description: "由孩子选择睡前故事", cost_points: 6, category: "family", icon_key: "book" },
+  { name: "亲子游戏 20 分钟", description: "安排一段专属亲子时间", cost_points: 15, category: "activity", icon_key: "party" },
+];
+
+let fallbackId = 0;
+
+function createId(prefix = "growth") {
+  if (typeof globalThis.crypto?.randomUUID === "function") return globalThis.crypto.randomUUID();
+  fallbackId += 1;
+  return `${prefix}-${Date.now()}-${fallbackId}`;
+}
+
+function clone(value) {
+  return structuredClone(value);
+}
+
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+function normalizeScope(scope = {}) {
+  return {
+    household_id: scope.household_id ?? scope.householdId ?? null,
+    profile_id: scope.profile_id ?? scope.profileId ?? null,
+  };
+}
+
+function scopeKey(scope = {}) {
+  const normalized = normalizeScope(scope);
+  return `${normalized.household_id || "pending"}:${normalized.profile_id || "pending"}`;
+}
+
+function normalizePointItem(item = {}) {
+  const defaultPoints = Number(item.default_points ?? item.pts ?? 0);
+  return {
+    id: item.id || createId("point-item"),
+    household_id: item.household_id ?? null,
+    name: String(item.name || "未命名项目").slice(0, 60),
+    description: item.description ?? item.desc ?? null,
+    default_points: Number.isFinite(defaultPoints) && defaultPoints !== 0 ? Math.max(-1000, Math.min(1000, defaultPoints)) : 1,
+    item_kind: item.item_kind || "custom",
+    category: item.category || "growth",
+    icon_key: item.icon_key || "star",
+    is_active: item.is_active !== false,
+    source: item.source || "local",
+  };
+}
+
+function normalizeReward(reward = {}) {
+  const cost = Number(reward.cost_points ?? reward.cost ?? 1);
+  return {
+    id: reward.id || createId("reward"),
+    household_id: reward.household_id ?? null,
+    name: String(reward.name || "未命名奖励").slice(0, 60),
+    description: reward.description ?? null,
+    cost_points: Number.isFinite(cost) && cost > 0 ? Math.min(100000, Math.trunc(cost)) : 1,
+    reward_kind: reward.reward_kind || "custom",
+    category: reward.category || "family",
+    icon_key: reward.icon_key || "gift",
+    is_active: reward.is_active !== false,
+    source: reward.source || "local",
+  };
+}
+
+function activeLedgerEntries(snapshot) {
+  return (snapshot.ledger || []).filter((entry) => !["rejected", "conflict"].includes(entry.status));
+}
+
+function latestCreated(entries) {
+  return entries.slice().sort((left, right) => String(left.created_at || "").localeCompare(String(right.created_at || ""))).at(-1);
+}
+
+function resolvePointItem(snapshot, pointItemId) {
+  return snapshot.point_items.find((item) => item.id === pointItemId) || null;
+}
+
+function resolvePointValue(snapshot, profileId, pointItemId) {
+  const item = resolvePointItem(snapshot, pointItemId);
+  const binding = snapshot.profile_point_items.find(
+    (entry) => entry.profile_id === profileId && entry.point_item_id === pointItemId,
+  );
+  return Number(binding?.points_override ?? item?.default_points ?? 0);
+}
+
+function addUniqueById(rows, row) {
+  const index = rows.findIndex((item) => item.id === row.id);
+  if (index === -1) rows.push(row);
+  else rows[index] = { ...rows[index], ...row };
+}
+
+function localEvent({ type, scope, request_id, payload, depends_on = [] }) {
+  return {
+    event_id: request_id || createId("event"),
+    request_id: request_id || null,
+    scope_key: scopeKey(scope),
+    household_id: normalizeScope(scope).household_id,
+    profile_id: normalizeScope(scope).profile_id,
+    schema_version: GROWTH_LOOP_SCHEMA_VERSION,
+    type,
+    payload: clone(payload || {}),
+    depends_on: [...depends_on],
+    created_at: new Date().toISOString(),
+  };
+}
+
+function normalizeLedgerEntry(entry, scope) {
+  const normalizedScope = normalizeScope(scope);
+  return {
+    id: entry.id || createId("ledger"),
+    household_id: entry.household_id ?? normalizedScope.household_id,
+    profile_id: entry.profile_id ?? normalizedScope.profile_id,
+    point_item_id: entry.point_item_id ?? null,
+    delta: Number(entry.delta || 0),
+    entry_type: entry.entry_type || "manual",
+    item_name_snapshot: String(entry.item_name_snapshot || "积分调整").slice(0, 60),
+    note: entry.note ?? null,
+    request_id: entry.request_id || createId("request"),
+    occurred_on: entry.occurred_on || new Date().toISOString().slice(0, 10),
+    created_at: entry.created_at || new Date().toISOString(),
+    status: entry.status || "confirmed",
+    metadata: isRecord(entry.metadata) ? clone(entry.metadata) : {},
+    redemption_id: entry.redemption_id ?? null,
+  };
+}
+
+export function createGrowthLoopState(scope = {}) {
+  return {
+    schema_version: GROWTH_LOOP_SCHEMA_VERSION,
+    scope: normalizeScope(scope),
+    point_items: [],
+    profile_point_items: [],
+    rewards: [],
+    profile_rewards: [],
+    ledger: [],
+    redemptions: [],
+    sync: {
+      last_server_sync_at: null,
+      blocked: false,
+    },
+  };
+}
+
+export function normalizeGrowthLoopState(input = {}, scope = input.scope || {}) {
+  const base = createGrowthLoopState(scope);
+  const source = isRecord(input) ? input : {};
+  return {
+    ...base,
+    ...clone(source),
+    schema_version: GROWTH_LOOP_SCHEMA_VERSION,
+    scope: normalizeScope(source.scope || scope),
+    point_items: Array.isArray(source.point_items) ? source.point_items.map(normalizePointItem) : [],
+    profile_point_items: Array.isArray(source.profile_point_items) ? clone(source.profile_point_items) : [],
+    rewards: Array.isArray(source.rewards) ? source.rewards.map(normalizeReward) : [],
+    profile_rewards: Array.isArray(source.profile_rewards) ? clone(source.profile_rewards) : [],
+    ledger: Array.isArray(source.ledger) ? source.ledger.map((entry) => normalizeLedgerEntry(entry, scope)) : [],
+    redemptions: Array.isArray(source.redemptions) ? clone(source.redemptions) : [],
+    sync: { ...base.sync, ...(isRecord(source.sync) ? clone(source.sync) : {}) },
+  };
+}
+
+export function getBalance(snapshot) {
+  return activeLedgerEntries(snapshot).reduce((total, entry) => total + Number(entry.delta || 0), 0);
+}
+
+export function getActivePointAction(snapshot, pointItemId, occurredOn) {
+  const entries = activeLedgerEntries(snapshot).filter(
+    (entry) => entry.point_item_id === pointItemId && entry.occurred_on === occurredOn,
+  );
+  return entries.reduce((total, entry) => total + Number(entry.delta || 0), 0) !== 0;
+}
+
+export function getPointDayTotal(snapshot, occurredOn) {
+  return activeLedgerEntries(snapshot)
+    .filter((entry) => entry.occurred_on === occurredOn)
+    .reduce((total, entry) => total + Number(entry.delta || 0), 0);
+}
+
+export function getPointItemTotal(snapshot, pointItemId) {
+  return activeLedgerEntries(snapshot)
+    .filter((entry) => entry.point_item_id === pointItemId)
+    .reduce((total, entry) => total + Number(entry.delta || 0), 0);
+}
+
+export function getPointPeriodTotal(snapshot, pointItemId, periodKey) {
+  const prefix = String(periodKey || "");
+  return activeLedgerEntries(snapshot)
+    .filter((entry) => entry.point_item_id === pointItemId && String(entry.occurred_on || "").startsWith(prefix))
+    .reduce((total, entry) => total + Number(entry.delta || 0), 0);
+}
+
+function ensurePointItem(snapshot, scope, item) {
+  const normalizedScope = normalizeScope(scope);
+  const pointItem = normalizePointItem({ ...item, household_id: item.household_id ?? normalizedScope.household_id });
+  const isNew = !snapshot.point_items.some((row) => row.id === pointItem.id);
+  addUniqueById(snapshot.point_items, pointItem);
+  const binding = snapshot.profile_point_items.find(
+    (row) => row.profile_id === normalizedScope.profile_id && row.point_item_id === pointItem.id,
+  );
+  const bindingIsNew = !binding;
+  if (bindingIsNew) {
+    snapshot.profile_point_items.push({
+      household_id: normalizedScope.household_id,
+      profile_id: normalizedScope.profile_id,
+      point_item_id: pointItem.id,
+      points_override: null,
+      enabled: true,
+      source: "local",
+    });
+  }
+  return { pointItem, isNew, bindingIsNew };
+}
+
+function buildPointEvents(scope, pointItem, binding, ledgerEntry, requestId, dependencies = []) {
+  const events = [];
+  if (binding?.isNew) {
+    events.push(localEvent({
+      type: "point_item_upsert",
+      scope,
+      request_id: `${requestId}:item`,
+      payload: { point_item: pointItem },
+    }));
+    if (binding.row) {
+      events.push(localEvent({
+        type: "profile_point_item_upsert",
+        scope,
+        request_id: `${requestId}:binding`,
+        depends_on: [`${requestId}:item`],
+        payload: { profile_point_item: binding.row },
+      }));
+      dependencies = [...dependencies, `${requestId}:binding`];
+    }
+  }
+  events.push(localEvent({
+    type: "point_record",
+    scope,
+    request_id: requestId,
+    depends_on: dependencies,
+    payload: {
+      profile_id: ledgerEntry.profile_id,
+      point_item_id: ledgerEntry.point_item_id,
+      delta: ledgerEntry.delta,
+      entry_type: ledgerEntry.entry_type,
+      note: ledgerEntry.note,
+      item_name_snapshot: ledgerEntry.item_name_snapshot,
+      occurred_on: ledgerEntry.occurred_on,
+    },
+  }));
+  return events;
+}
+
+function buildDefinitionEvents(scope, definition, binding, requestId, definitionType) {
+  const events = [];
+  if (definitionType === "point_item") {
+    events.push(localEvent({
+      type: "point_item_upsert",
+      scope,
+      request_id: `${requestId}:item`,
+      payload: { point_item: definition },
+    }));
+    if (binding) {
+      events.push(localEvent({
+        type: "profile_point_item_upsert",
+        scope,
+        request_id: `${requestId}:binding`,
+        depends_on: [`${requestId}:item`],
+        payload: { profile_point_item: binding },
+      }));
+    }
+  }
+  return events;
+}
+
+export function applyPointItemCreation(current, { scope = current.scope, item, request_id = createId("point-item") }) {
+  const snapshot = normalizeGrowthLoopState(current, scope);
+  const normalizedScope = normalizeScope(scope);
+  const ensured = ensurePointItem(snapshot, normalizedScope, item);
+  const binding = snapshot.profile_point_items.find(
+    (row) => row.profile_id === normalizedScope.profile_id && row.point_item_id === ensured.pointItem.id,
+  );
+  return {
+    snapshot,
+    item: ensured.pointItem,
+    events: ensured.isNew
+      ? buildDefinitionEvents(normalizedScope, ensured.pointItem, binding, request_id, "point_item")
+      : [],
+  };
+}
+
+export function applyPointAction(current, { scope = current.scope, item, occurred_on, request_id = createId("point") }) {
+  const snapshot = normalizeGrowthLoopState(current, scope);
+  const normalizedScope = normalizeScope(scope);
+  const ensured = ensurePointItem(snapshot, normalizedScope, item);
+  const pointItem = ensured.pointItem;
+  const existingEntries = activeLedgerEntries(snapshot).filter(
+    (entry) => entry.point_item_id === pointItem.id && entry.occurred_on === occurred_on,
+  );
+  const net = existingEntries.reduce((total, entry) => total + Number(entry.delta || 0), 0);
+  const delta = net === 0
+    ? resolvePointValue(snapshot, normalizedScope.profile_id, pointItem.id)
+    : -net;
+  const previous = latestCreated(existingEntries);
+  const ledgerEntry = normalizeLedgerEntry({
+    id: createId("ledger"),
+    household_id: normalizedScope.household_id,
+    profile_id: normalizedScope.profile_id,
+    point_item_id: pointItem.id,
+    delta,
+    entry_type: net === 0 ? "manual" : "adjustment",
+    item_name_snapshot: pointItem.name,
+    note: net === 0 ? null : "撤销上一条本地记录",
+    request_id,
+    occurred_on,
+    status: "pending",
+    metadata: net === 0 ? {} : { undo_of: previous?.request_id || null },
+  }, normalizedScope);
+  snapshot.ledger.push(ledgerEntry);
+  const binding = ensured.isNew
+    ? {
+        isNew: true,
+        row: snapshot.profile_point_items.find(
+          (row) => row.profile_id === normalizedScope.profile_id && row.point_item_id === pointItem.id,
+        ),
+      }
+    : { isNew: false, row: null };
+  return {
+    snapshot,
+    ledgerEntry,
+    events: buildPointEvents(normalizedScope, pointItem, binding, ledgerEntry, request_id),
+  };
+}
+
+export function closePointPeriod(current, { scope = current.scope, period_key, request_id = createId("period-close") }) {
+  const snapshot = normalizeGrowthLoopState(current, scope);
+  const normalizedScope = normalizeScope(scope);
+  const grouped = new Map();
+  for (const entry of activeLedgerEntries(snapshot)) {
+    if (!entry.point_item_id || !String(entry.occurred_on || "").startsWith(String(period_key || ""))) continue;
+    const key = `${entry.point_item_id}:${entry.occurred_on}`;
+    const currentGroup = grouped.get(key) || { point_item_id: entry.point_item_id, occurred_on: entry.occurred_on, entries: [], net: 0 };
+    currentGroup.entries.push(entry);
+    currentGroup.net += Number(entry.delta || 0);
+    grouped.set(key, currentGroup);
+  }
+  const events = [];
+  for (const group of grouped.values()) {
+    if (!group.net) continue;
+    const item = resolvePointItem(snapshot, group.point_item_id);
+    const entryRequestId = createId("period-entry");
+    const ledgerEntry = normalizeLedgerEntry({
+      id: createId("ledger"),
+      household_id: normalizedScope.household_id,
+      profile_id: normalizedScope.profile_id,
+      point_item_id: group.point_item_id,
+      delta: -group.net,
+      entry_type: "adjustment",
+      item_name_snapshot: item?.name || "积分周期调整",
+      note: `结束 ${period_key} 积分周期`,
+      request_id: entryRequestId,
+      occurred_on: group.occurred_on,
+      status: "pending",
+      metadata: {
+        period_close: period_key,
+        undo_of: group.entries.at(-1)?.request_id || null,
+      },
+    }, normalizedScope);
+    snapshot.ledger.push(ledgerEntry);
+    events.push(localEvent({
+      type: "point_record",
+      scope: normalizedScope,
+      request_id: entryRequestId,
+      payload: {
+        profile_id: normalizedScope.profile_id,
+        point_item_id: group.point_item_id,
+        delta: ledgerEntry.delta,
+        entry_type: "adjustment",
+        note: ledgerEntry.note,
+        item_name_snapshot: ledgerEntry.item_name_snapshot,
+        occurred_on: group.occurred_on,
+      },
+    }));
+  }
+  return { snapshot, events };
+}
+
+export function applyRewardCreation(current, { scope = current.scope, reward, request_id = createId("reward") }) {
+  const snapshot = normalizeGrowthLoopState(current, scope);
+  const normalizedScope = normalizeScope(scope);
+  const normalizedReward = normalizeReward({ ...reward, household_id: reward.household_id ?? normalizedScope.household_id });
+  const isNew = !snapshot.rewards.some((row) => row.id === normalizedReward.id);
+  addUniqueById(snapshot.rewards, normalizedReward);
+  if (!snapshot.profile_rewards.some((row) => row.profile_id === normalizedScope.profile_id && row.reward_id === normalizedReward.id)) {
+    snapshot.profile_rewards.push({
+      household_id: normalizedScope.household_id,
+      profile_id: normalizedScope.profile_id,
+      reward_id: normalizedReward.id,
+      cost_override: null,
+      enabled: true,
+      source: "local",
+    });
+  }
+  const events = [];
+  if (isNew) {
+    events.push(localEvent({ type: "reward_upsert", scope: normalizedScope, request_id: `${request_id}:reward`, payload: { reward: normalizedReward } }));
+    events.push(localEvent({
+      type: "profile_reward_upsert",
+      scope: normalizedScope,
+      request_id: `${request_id}:binding`,
+      depends_on: [`${request_id}:reward`],
+      payload: { profile_reward: snapshot.profile_rewards.at(-1) },
+    }));
+  }
+  return { snapshot, reward: normalizedReward, events };
+}
+
+export function applyRedemption(current, { scope = current.scope, reward_id, request_id = createId("redemption") }) {
+  const snapshot = normalizeGrowthLoopState(current, scope);
+  const normalizedScope = normalizeScope(scope);
+  const reward = snapshot.rewards.find((row) => row.id === reward_id);
+  const profileReward = snapshot.profile_rewards.find(
+    (row) => row.profile_id === normalizedScope.profile_id && row.reward_id === reward_id && row.enabled !== false,
+  );
+  if (!reward || !profileReward) return { snapshot, events: [], error: "reward_not_enabled" };
+  const cost = Number(profileReward.cost_override ?? reward.cost_points);
+  if (getBalance(snapshot) < cost) return { snapshot, events: [], error: "insufficient_points" };
+  const redemption = {
+    id: request_id,
+    household_id: normalizedScope.household_id,
+    profile_id: normalizedScope.profile_id,
+    reward_id,
+    reward_name_snapshot: reward.name,
+    cost_points_snapshot: cost,
+    status: "pending",
+    request_id,
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
+    source: "local",
+  };
+  snapshot.redemptions.push(redemption);
+  snapshot.ledger.push(normalizeLedgerEntry({
+    id: createId("ledger"),
+    household_id: normalizedScope.household_id,
+    profile_id: normalizedScope.profile_id,
+    point_item_id: null,
+    delta: -cost,
+    entry_type: "redemption",
+    item_name_snapshot: reward.name,
+    note: "待联网确认的奖励兑换",
+    request_id: `${request_id}:debit`,
+    occurred_on: new Date().toISOString().slice(0, 10),
+    status: "pending",
+    redemption_id: request_id,
+  }, normalizedScope));
+  return {
+    snapshot,
+    redemption,
+    events: [localEvent({
+      type: "reward_redeem",
+      scope: normalizedScope,
+      request_id,
+      payload: { profile_id: normalizedScope.profile_id, reward_id },
+    })],
+  };
+}
+
+export function mergeGrowthLoopSnapshot(remote, local) {
+  const remoteSnapshot = normalizeGrowthLoopState(remote, remote?.scope || local?.scope || {});
+  const localSnapshot = normalizeGrowthLoopState(local, remoteSnapshot.scope);
+  const mergeRows = (remoteRows, localRows, keyFor = (row) => row.id) => {
+    const rows = new Map((localRows || []).map((row) => [keyFor(row), row]));
+    for (const row of remoteRows || []) rows.set(keyFor(row), row);
+    return [...rows.values()];
+  };
+  const remoteRequests = new Set(remoteSnapshot.ledger.map((entry) => entry.request_id).filter(Boolean));
+  const merged = {
+    ...remoteSnapshot,
+    point_items: mergeRows(remoteSnapshot.point_items, localSnapshot.point_items),
+    profile_point_items: mergeRows(
+      remoteSnapshot.profile_point_items,
+      localSnapshot.profile_point_items,
+      (row) => `${row.profile_id}:${row.point_item_id}`,
+    ),
+    rewards: mergeRows(remoteSnapshot.rewards, localSnapshot.rewards),
+    profile_rewards: mergeRows(
+      remoteSnapshot.profile_rewards,
+      localSnapshot.profile_rewards,
+      (row) => `${row.profile_id}:${row.reward_id}`,
+    ),
+    ledger: [
+      ...remoteSnapshot.ledger,
+      ...localSnapshot.ledger.filter((entry) => !remoteRequests.has(entry.request_id)),
+    ],
+    redemptions: mergeRows(
+      remoteSnapshot.redemptions,
+      localSnapshot.redemptions,
+      (row) => row.request_id || row.id,
+    ),
+    sync: { ...remoteSnapshot.sync, ...(localSnapshot.sync || {}) },
+  };
+  return normalizeGrowthLoopState(merged, remoteSnapshot.scope);
+}
+
+export function scopeKeyForGrowthLoop(scope) {
+  return scopeKey(scope);
+}
diff --git a/src/learning-local-db.js b/src/learning-local-db.js
new file mode 100644
index 0000000..8fd74a2
--- /dev/null
+++ b/src/learning-local-db.js
@@ -0,0 +1,381 @@
+export const LEARNING_LOCAL_DB_NAME = "shadow-mate-learning-v1";
+export const LEARNING_LOCAL_DB_VERSION = 1;
+
+const OUTBOX_STATUSES = new Set(["pending", "retryable", "conflict", "rejected", "confirmed"]);
+
+function clone(value) {
+  return value === undefined ? undefined : structuredClone(value);
+}
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function normalizeOutboxEvent(event, sequence) {
+  const createdAt = event.created_at || nowIso();
+  return {
+    ...clone(event),
+    event_id: event.event_id,
+    scope_key: event.scope_key || "pending:pending",
+    sequence: event.sequence || sequence,
+    status: event.status || "pending",
+    attempts: Number(event.attempts || 0),
+    next_attempt_at: event.next_attempt_at ?? 0,
+    created_at: createdAt,
+    updated_at: event.updated_at || createdAt,
+    error_code: event.error_code || null,
+    error_message: event.error_message || null,
+    processing_by: event.processing_by || null,
+    lease_until: Number(event.lease_until || 0),
+  };
+}
+
+function rehomeOutboxEvent(event, scopeKey, scope) {
+  const next = normalizeOutboxEvent({
+    ...clone(event),
+    scope_key: scopeKey,
+    household_id: scope.household_id,
+    profile_id: scope.profile_id,
+    processing_by: null,
+    lease_until: 0,
+  }, event.sequence);
+  const payload = next.payload && typeof next.payload === "object" ? clone(next.payload) : null;
+  if (payload) {
+    if (next.type === "point_item_upsert" && payload.point_item) {
+      payload.point_item.household_id = scope.household_id;
+    }
+    if (next.type === "profile_point_item_upsert" && payload.profile_point_item) {
+      payload.profile_point_item.household_id = scope.household_id;
+      payload.profile_point_item.profile_id = scope.profile_id;
+    }
+    if (next.type === "point_record" && payload) payload.profile_id = scope.profile_id;
+    if (next.type === "reward_upsert" && payload.reward) {
+      payload.reward.household_id = scope.household_id;
+    }
+    if (next.type === "profile_reward_upsert" && payload.profile_reward) {
+      payload.profile_reward.household_id = scope.household_id;
+      payload.profile_reward.profile_id = scope.profile_id;
+    }
+    if (next.type === "reward_redeem" && payload) payload.profile_id = scope.profile_id;
+    if (next.type === "activity_event" && payload.event) {
+      payload.event.household_id = scope.household_id;
+      payload.event.profile_id = scope.profile_id;
+      payload.event.scope_key = scopeKey;
+    }
+    next.payload = payload;
+  }
+  return next;
+}
+
+function makeMemoryStore() {
+  const snapshots = new Map();
+  const outbox = new Map();
+  const activityEvents = new Map();
+  const sequences = new Map();
+
+  return {
+    kind: "memory",
+    async getSnapshot(scopeKey) {
+      return clone(snapshots.get(scopeKey) || null);
+    },
+    async putSnapshot(scopeKey, snapshot) {
+      snapshots.set(scopeKey, clone(snapshot));
+      return clone(snapshot);
+    },
+    async appendOutbox(event) {
+      const existing = outbox.get(event.event_id);
+      if (existing) return clone(existing);
+      const nextSequence = (sequences.get(event.scope_key || "pending:pending") || 0) + 1;
+      const normalized = normalizeOutboxEvent(event, nextSequence);
+      sequences.set(normalized.scope_key, nextSequence);
+      outbox.set(normalized.event_id, normalized);
+      return clone(normalized);
+    },
+    async getOutbox(eventId) {
+      return clone(outbox.get(eventId) || null);
+    },
+    async listOutbox(scopeKey, options = {}) {
+      const statuses = new Set(options.statuses || ["pending", "retryable", "conflict"]);
+      const now = Number(options.now ?? Date.now());
+      return [...outbox.values()]
+        .filter((event) => event.scope_key === scopeKey && statuses.has(event.status) && Number(event.next_attempt_at || 0) <= now)
+        .sort((left, right) => left.sequence - right.sequence)
+        .slice(0, options.limit || 100)
+        .map(clone);
+    },
+    async updateOutbox(eventId, patch) {
+      const current = outbox.get(eventId);
+      if (!current) return null;
+      const next = normalizeOutboxEvent({ ...current, ...clone(patch), updated_at: nowIso() }, current.sequence);
+      if (!OUTBOX_STATUSES.has(next.status)) throw new Error("outbox_status_invalid");
+      outbox.set(eventId, next);
+      return clone(next);
+    },
+    async claimOutbox(eventId, { worker_id, now = Date.now(), lease_ms = 30_000 } = {}) {
+      const current = outbox.get(eventId);
+      if (!current || !worker_id) return false;
+      const activeLease = Number(current.lease_until || 0) > Number(now)
+        && current.processing_by
+        && current.processing_by !== worker_id;
+      if (activeLease || !["pending", "retryable"].includes(current.status)) return false;
+      const next = normalizeOutboxEvent({
+        ...current,
+        processing_by: worker_id,
+        lease_until: Number(now) + Number(lease_ms),
+      }, current.sequence);
+      outbox.set(eventId, next);
+      return true;
+    },
+    async putActivityEvent(event) {
+      const existing = activityEvents.get(event.event_id);
+      if (existing) return clone(existing);
+      activityEvents.set(event.event_id, clone(event));
+      return clone(event);
+    },
+    async listActivityEvents(scopeKey) {
+      return [...activityEvents.values()].filter((event) => event.scope_key === scopeKey).map(clone);
+    },
+    async clearScope(scopeKey) {
+      snapshots.delete(scopeKey);
+      for (const [eventId, event] of outbox.entries()) if (event.scope_key === scopeKey) outbox.delete(eventId);
+      for (const [eventId, event] of activityEvents.entries()) if (event.scope_key === scopeKey) activityEvents.delete(eventId);
+      sequences.delete(scopeKey);
+    },
+    async clearAll() {
+      snapshots.clear();
+      outbox.clear();
+      activityEvents.clear();
+      sequences.clear();
+    },
+    async moveScope(fromScopeKey, toScopeKey, scope) {
+      const snapshot = snapshots.get(fromScopeKey);
+      if (snapshot) {
+        snapshots.delete(fromScopeKey);
+      }
+      const events = [...outbox.values()]
+        .filter((event) => event.scope_key === fromScopeKey)
+        .sort((left, right) => left.sequence - right.sequence);
+      let sequence = sequences.get(toScopeKey) || 0;
+      for (const event of events) {
+        outbox.delete(event.event_id);
+        const next = rehomeOutboxEvent(event, toScopeKey, scope);
+        sequence += 1;
+        next.sequence = sequence;
+        outbox.set(next.event_id, next);
+      }
+      sequences.delete(fromScopeKey);
+      sequences.set(toScopeKey, sequence);
+      for (const [eventId, event] of activityEvents.entries()) {
+        if (event.scope_key !== fromScopeKey) continue;
+        activityEvents.delete(eventId);
+        activityEvents.set(eventId, {
+          ...clone(event),
+          scope_key: toScopeKey,
+          household_id: scope.household_id,
+          profile_id: scope.profile_id,
+        });
+      }
+      return clone(snapshot || null);
+    },
+  };
+}
+
+function requestPromise(request) {
+  return new Promise((resolve, reject) => {
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error || new Error("indexeddb_request_failed"));
+  });
+}
+
+function transactionPromise(transaction) {
+  return new Promise((resolve, reject) => {
+    transaction.oncomplete = () => resolve();
+    transaction.onerror = () => reject(transaction.error || new Error("indexeddb_transaction_failed"));
+    transaction.onabort = () => reject(transaction.error || new Error("indexeddb_transaction_aborted"));
+  });
+}
+
+function openDatabase(indexedDB) {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(LEARNING_LOCAL_DB_NAME, LEARNING_LOCAL_DB_VERSION);
+    request.onupgradeneeded = () => {
+      const database = request.result;
+      if (!database.objectStoreNames.contains("snapshots")) database.createObjectStore("snapshots", { keyPath: "scope_key" });
+      if (!database.objectStoreNames.contains("outbox")) {
+        const store = database.createObjectStore("outbox", { keyPath: "event_id" });
+        store.createIndex("scope_status", ["scope_key", "status"], { unique: false });
+        store.createIndex("scope_sequence", ["scope_key", "sequence"], { unique: false });
+      }
+      if (!database.objectStoreNames.contains("activity_events")) database.createObjectStore("activity_events", { keyPath: "event_id" });
+    };
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error || new Error("indexeddb_open_failed"));
+  });
+}
+
+export function createMemoryLearningDb() {
+  return makeMemoryStore();
+}
+
+export function createIndexedDbLearningDb({ indexedDB = globalThis.indexedDB } = {}) {
+  if (!indexedDB) return makeMemoryStore();
+  const databasePromise = openDatabase(indexedDB).catch(() => makeMemoryStore());
+
+  return {
+    kind: "indexeddb",
+    async getSnapshot(scopeKey) {
+      const database = await databasePromise;
+      if (database.kind === "memory") return database.getSnapshot(scopeKey);
+      const transaction = database.transaction(["snapshots"], "readonly");
+      const row = await requestPromise(transaction.objectStore("snapshots").get(scopeKey));
+      return clone(row?.snapshot || null);
+    },
+    async putSnapshot(scopeKey, snapshot) {
+      const database = await databasePromise;
+      if (database.kind === "memory") return database.putSnapshot(scopeKey, snapshot);
+      const transaction = database.transaction(["snapshots"], "readwrite");
+      transaction.objectStore("snapshots").put({ scope_key: scopeKey, snapshot: clone(snapshot), updated_at: nowIso() });
+      await transactionPromise(transaction);
+      return clone(snapshot);
+    },
+    async appendOutbox(event) {
+      const database = await databasePromise;
+      if (database.kind === "memory") return database.appendOutbox(event);
+      const existing = await this.getOutbox(event.event_id);
+      if (existing) return existing;
+      const all = await this.listOutbox(event.scope_key || "pending:pending", { statuses: [...OUTBOX_STATUSES], now: Number.MAX_SAFE_INTEGER, limit: 100000 });
+      const nextSequence = all.reduce((max, item) => Math.max(max, Number(item.sequence || 0)), 0) + 1;
+      const normalized = normalizeOutboxEvent(event, nextSequence);
+      const transaction = database.transaction(["outbox"], "readwrite");
+      transaction.objectStore("outbox").put(normalized);
+      await transactionPromise(transaction);
+      return clone(normalized);
+    },
+    async getOutbox(eventId) {
+      const database = await databasePromise;
+      if (database.kind === "memory") return database.getOutbox(eventId);
+      const transaction = database.transaction(["outbox"], "readonly");
+      return clone(await requestPromise(transaction.objectStore("outbox").get(eventId)) || null);
+    },
+    async listOutbox(scopeKey, options = {}) {
+      const database = await databasePromise;
+      if (database.kind === "memory") return database.listOutbox(scopeKey, options);
+      const transaction = database.transaction(["outbox"], "readonly");
+      const rows = await requestPromise(transaction.objectStore("outbox").getAll());
+      const statuses = new Set(options.statuses || ["pending", "retryable", "conflict"]);
+      const now = Number(options.now ?? Date.now());
+      return rows
+        .filter((event) => event.scope_key === scopeKey && statuses.has(event.status) && Number(event.next_attempt_at || 0) <= now)
+        .sort((left, right) => left.sequence - right.sequence)
+        .slice(0, options.limit || 100)
+        .map((event) => clone(event));
+    },
+    async updateOutbox(eventId, patch) {
+      const database = await databasePromise;
+      if (database.kind === "memory") return database.updateOutbox(eventId, patch);
+      const current = await this.getOutbox(eventId);
+      if (!current) return null;
+      const next = normalizeOutboxEvent({ ...current, ...clone(patch), updated_at: nowIso() }, current.sequence);
+      if (!OUTBOX_STATUSES.has(next.status)) throw new Error("outbox_status_invalid");
+      const transaction = database.transaction(["outbox"], "readwrite");
+      transaction.objectStore("outbox").put(next);
+      await transactionPromise(transaction);
+      return clone(next);
+    },
+    async claimOutbox(eventId, { worker_id, now = Date.now(), lease_ms = 30_000 } = {}) {
+      if (!worker_id) return false;
+      const database = await databasePromise;
+      if (database.kind === "memory") return database.claimOutbox(eventId, { worker_id, now, lease_ms });
+      const transaction = database.transaction(["outbox"], "readwrite");
+      const store = transaction.objectStore("outbox");
+      const current = await requestPromise(store.get(eventId));
+      if (!current) return false;
+      const activeLease = Number(current.lease_until || 0) > Number(now)
+        && current.processing_by
+        && current.processing_by !== worker_id;
+      if (activeLease || !["pending", "retryable"].includes(current.status)) return false;
+      store.put(normalizeOutboxEvent({
+        ...current,
+        processing_by: worker_id,
+        lease_until: Number(now) + Number(lease_ms),
+      }, current.sequence));
+      await transactionPromise(transaction);
+      return true;
+    },
+    async putActivityEvent(event) {
+      const database = await databasePromise;
+      if (database.kind === "memory") return database.putActivityEvent(event);
+      const transaction = database.transaction(["activity_events"], "readwrite");
+      const store = transaction.objectStore("activity_events");
+      const existing = await requestPromise(store.get(event.event_id));
+      if (!existing) store.put(clone(event));
+      await transactionPromise(transaction);
+      return clone(existing || event);
+    },
+    async listActivityEvents(scopeKey) {
+      const database = await databasePromise;
+      if (database.kind === "memory") return database.listActivityEvents(scopeKey);
+      const transaction = database.transaction(["activity_events"], "readonly");
+      const rows = await requestPromise(transaction.objectStore("activity_events").getAll());
+      return rows.filter((event) => event.scope_key === scopeKey).map((event) => clone(event));
+    },
+    async clearScope(scopeKey) {
+      const database = await databasePromise;
+      if (database.kind === "memory") return database.clearScope(scopeKey);
+      const transaction = database.transaction(["snapshots", "outbox", "activity_events"], "readwrite");
+      transaction.objectStore("snapshots").delete(scopeKey);
+      for (const storeName of ["outbox", "activity_events"]) {
+        const store = transaction.objectStore(storeName);
+        const rows = await requestPromise(store.getAll());
+        rows.filter((event) => event.scope_key === scopeKey).forEach((event) => store.delete(event.event_id));
+      }
+      await transactionPromise(transaction);
+    },
+    async clearAll() {
+      const database = await databasePromise;
+      if (database.kind === "memory") return database.clearAll();
+      const transaction = database.transaction(["snapshots", "outbox", "activity_events"], "readwrite");
+      transaction.objectStore("snapshots").clear();
+      transaction.objectStore("outbox").clear();
+      transaction.objectStore("activity_events").clear();
+      await transactionPromise(transaction);
+    },
+    async moveScope(fromScopeKey, toScopeKey, scope) {
+      const database = await databasePromise;
+      if (database.kind === "memory") return database.moveScope(fromScopeKey, toScopeKey, scope);
+      const transaction = database.transaction(["snapshots", "outbox", "activity_events"], "readwrite");
+      const snapshotsStore = transaction.objectStore("snapshots");
+      const outboxStore = transaction.objectStore("outbox");
+      const activityStore = transaction.objectStore("activity_events");
+      const [snapshot, outboxRows, activityRows] = await Promise.all([
+        requestPromise(snapshotsStore.get(fromScopeKey)),
+        requestPromise(outboxStore.getAll()),
+        requestPromise(activityStore.getAll()),
+      ]);
+      snapshotsStore.delete(fromScopeKey);
+      const sourceEvents = outboxRows
+        .filter((event) => event.scope_key === fromScopeKey)
+        .sort((left, right) => left.sequence - right.sequence);
+      const targetEvents = outboxRows.filter((event) => event.scope_key === toScopeKey);
+      let sequence = targetEvents.reduce((max, event) => Math.max(max, Number(event.sequence || 0)), 0);
+      for (const event of sourceEvents) {
+        outboxStore.delete(event.event_id);
+        sequence += 1;
+        const next = rehomeOutboxEvent(event, toScopeKey, scope);
+        next.sequence = sequence;
+        outboxStore.put(next);
+      }
+      for (const event of activityRows.filter((item) => item.scope_key === fromScopeKey)) {
+        activityStore.delete(event.event_id);
+        activityStore.put({
+          ...clone(event),
+          scope_key: toScopeKey,
+          household_id: scope.household_id,
+          profile_id: scope.profile_id,
+        });
+      }
+      await transactionPromise(transaction);
+      return clone(snapshot || null);
+    },
+  };
+}
diff --git a/src/learning-state-envelope.js b/src/learning-state-envelope.js
new file mode 100644
index 0000000..95b14f8
--- /dev/null
+++ b/src/learning-state-envelope.js
@@ -0,0 +1,103 @@
+const LEGACY_STATE_KEYS = new Set([
+  "checkins",
+  "extra",
+  "points",
+  "bookShelf",
+  "peanutLog",
+  "peanutRead",
+]);
+
+const DEFAULT_CONTENT_CONFIG = {
+  schema_version: 1,
+  package_id: "foundation-v1",
+  package_version: 1,
+  enabled: true,
+  modules: {
+    chinese: true,
+    math: true,
+    english: true,
+    book: true,
+  },
+};
+
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+function cloneRecord(value) {
+  return isRecord(value) ? structuredClone(value) : {};
+}
+
+function cloneArray(value) {
+  return Array.isArray(value) ? structuredClone(value) : [];
+}
+
+function normalizeScope(scope = {}) {
+  return {
+    household_id: scope.householdId ?? scope.household_id ?? null,
+    profile_id: scope.profileId ?? scope.profile_id ?? null,
+  };
+}
+
+export function getLearningStateStorageKey(scope = {}) {
+  const householdId = scope.householdId ?? scope.household_id;
+  const profileId = scope.profileId ?? scope.profile_id;
+  if (!householdId || !profileId) return "shadow_mate_learning_v2:pending";
+  return `shadow_mate_learning_v2:${encodeURIComponent(householdId)}:${encodeURIComponent(profileId)}`;
+}
+
+function stableStringify(value) {
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+  if (!isRecord(value)) return JSON.stringify(value);
+  return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(",")}}`;
+}
+
+function hashString(value) {
+  let hash = 2166136261;
+  for (let index = 0; index < value.length; index += 1) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+
+function isEnvelope(value) {
+  return isRecord(value) && value.schema_version === 2 && isRecord(value.learning);
+}
+
+export function migrateLegacyLearningState(source, scope = {}) {
+  if (isEnvelope(source)) return structuredClone(source);
+
+  const legacy = isRecord(source) ? source : {};
+  const sourceHash = hashString(stableStringify(legacy));
+  const legacyUnknown = Object.fromEntries(
+    Object.entries(legacy).filter(([key]) => !LEGACY_STATE_KEYS.has(key)),
+  );
+
+  return {
+    schema_version: 2,
+    product_id: "shadow-mate",
+    scope: normalizeScope(scope),
+    learning: {
+      checkins: cloneRecord(legacy.checkins),
+      extra: cloneRecord(legacy.extra),
+      bookShelf: cloneRecord(legacy.bookShelf),
+      peanutLog: cloneArray(legacy.peanutLog),
+      peanutRead: cloneRecord(legacy.peanutRead),
+      content_config: structuredClone(DEFAULT_CONTENT_CONFIG),
+    },
+    legacy: {
+      points_readonly: cloneRecord(legacy.points),
+    },
+    extensions: {
+      legacy_unknown: structuredClone(legacyUnknown),
+    },
+    migration: {
+      source_schema: "legacy-v1",
+      source_key: "shadow_mate_workbench_v1",
+      source_hash: sourceHash,
+      migration_id: `legacy-v1:${sourceHash}`,
+      migrated_at: null,
+    },
+  };
+}
diff --git a/src/learning-state-storage.js b/src/learning-state-storage.js
new file mode 100644
index 0000000..b0ee597
--- /dev/null
+++ b/src/learning-state-storage.js
@@ -0,0 +1,158 @@
+import {
+  getLearningStateStorageKey,
+  migrateLegacyLearningState,
+} from "./learning-state-envelope.js";
+
+export const LEGACY_LEARNING_STATE_KEY = "shadow_mate_workbench_v1";
+export const PENDING_LEARNING_STATE_KEY = getLearningStateStorageKey();
+
+function hashString(value) {
+  let hash = 2166136261;
+  for (let index = 0; index < value.length; index += 1) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+
+function parseStoredState(raw) {
+  if (raw === null) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function backupLegacyValue(storage, raw, sourceHash) {
+  const backupKey = `shadow_mate_learning_v2:legacy_backup:${sourceHash}`;
+  if (storage.getItem(backupKey) === null) storage.setItem(backupKey, raw);
+  return backupKey;
+}
+
+function persistMigratedState(storage, key, raw, envelope, sourceHash = null) {
+  if (raw !== null) backupLegacyValue(storage, raw, sourceHash || hashString(raw));
+  storage.setItem(key, JSON.stringify(envelope));
+  return envelope;
+}
+
+function scopeIds(scope = {}) {
+  return {
+    householdId: scope.householdId ?? scope.household_id ?? null,
+    profileId: scope.profileId ?? scope.profile_id ?? null,
+  };
+}
+
+function hasChildScope(scope = {}) {
+  const ids = scopeIds(scope);
+  return Boolean(ids.householdId && ids.profileId);
+}
+
+function matchesScope(envelope, scope = {}) {
+  const { householdId: expectedHouseholdId, profileId: expectedProfileId } = scopeIds(scope);
+  return envelope.scope?.household_id === expectedHouseholdId && envelope.scope?.profile_id === expectedProfileId;
+}
+
+function isEmptyEnvelope(envelope) {
+  const learning = envelope?.learning || {};
+  return Object.keys(learning.checkins || {}).length === 0
+    && Object.keys(learning.extra || {}).length === 0
+    && Object.keys(learning.bookShelf || {}).length === 0
+    && Object.keys(learning.peanutRead || {}).length === 0
+    && (learning.peanutLog || []).length === 0
+    && Object.keys(envelope?.legacy?.points_readonly || {}).length === 0
+    && Object.keys(envelope?.extensions?.legacy_unknown || {}).length === 0;
+}
+
+function loadPendingEnvelope(storage) {
+  const pendingRaw = storage.getItem(PENDING_LEARNING_STATE_KEY);
+  if (pendingRaw !== null) {
+    const pendingState = parseStoredState(pendingRaw);
+    if (pendingState?.schema_version === 2 && pendingState.learning && matchesScope(pendingState, {})) {
+      return pendingState;
+    }
+    return persistMigratedState(
+      storage,
+      PENDING_LEARNING_STATE_KEY,
+      pendingRaw,
+      migrateLegacyLearningState(pendingState, {}),
+    );
+  }
+
+  const legacyRaw = storage.getItem(LEGACY_LEARNING_STATE_KEY);
+  if (legacyRaw !== null) {
+    return persistMigratedState(
+      storage,
+      PENDING_LEARNING_STATE_KEY,
+      legacyRaw,
+      migrateLegacyLearningState(parseStoredState(legacyRaw), {}),
+    );
+  }
+
+  const emptyEnvelope = migrateLegacyLearningState({}, {});
+  storage.setItem(PENDING_LEARNING_STATE_KEY, JSON.stringify(emptyEnvelope));
+  return emptyEnvelope;
+}
+
+export function loadLearningStateEnvelope(storage, scope = {}) {
+  if (!hasChildScope(scope)) return loadPendingEnvelope(storage);
+
+  const scopedKey = getLearningStateStorageKey(scope);
+  const scopedRaw = storage.getItem(scopedKey);
+  if (scopedRaw !== null) {
+    const scopedState = parseStoredState(scopedRaw);
+    if (scopedState?.schema_version === 2 && scopedState.learning && matchesScope(scopedState, scope)) {
+      return scopedState;
+    }
+    if (scopedState?.schema_version === 2 && scopedState.learning) {
+      const emptyEnvelope = migrateLegacyLearningState({}, scope);
+      return persistMigratedState(storage, scopedKey, scopedRaw, emptyEnvelope);
+    }
+    return persistMigratedState(
+      storage,
+      scopedKey,
+      scopedRaw,
+      migrateLegacyLearningState(scopedState, scope),
+    );
+  }
+
+  // A legacy global state is migrated to the pending namespace only. It must
+  // not be assigned to a child until the parent explicitly adopts it.
+  loadPendingEnvelope(storage);
+  const emptyEnvelope = migrateLegacyLearningState({}, scope);
+  storage.setItem(scopedKey, JSON.stringify(emptyEnvelope));
+  return emptyEnvelope;
+}
+
+export function adoptPendingLearningState(storage, scope = {}) {
+  if (!hasChildScope(scope)) return loadPendingEnvelope(storage);
+
+  const scopedKey = getLearningStateStorageKey(scope);
+  const existingRaw = storage.getItem(scopedKey);
+  if (existingRaw !== null) {
+    const existing = parseStoredState(existingRaw);
+    if (
+      existing?.schema_version === 2
+      && existing.learning
+      && matchesScope(existing, scope)
+      && !isEmptyEnvelope(existing)
+    ) {
+      return existing;
+    }
+  }
+
+  const pending = loadPendingEnvelope(storage);
+  const adopted = structuredClone(pending);
+  adopted.scope = {
+    household_id: scope.householdId ?? scope.household_id ?? null,
+    profile_id: scope.profileId ?? scope.profile_id ?? null,
+  };
+  adopted.migration = {
+    ...(adopted.migration || {}),
+    adopted_from: "pending",
+    adopted_to: adopted.scope.profile_id,
+  };
+  storage.setItem(scopedKey, JSON.stringify(adopted));
+  return adopted;
+}
diff --git a/supabase/migrations/20260814084607_growth_loop_foundation.sql b/supabase/migrations/20260814084607_growth_loop_foundation.sql
new file mode 100644
index 0000000..2ed30ca
--- /dev/null
+++ b/supabase/migrations/20260814084607_growth_loop_foundation.sql
@@ -0,0 +1,379 @@
+-- Shadow Mate Growth Loop foundation: household point items, child-specific
+-- configuration, and an immutable, idempotent point ledger.
+-- Rewards, redemptions, analytics events, and the IndexedDB outbox are
+-- intentionally separate follow-up slices.
+
+do $migration$
+begin
+  if not exists (
+    select 1
+    from pg_constraint
+    where conrelid = 'public.learning_profiles'::regclass
+      and conname = 'learning_profiles_id_household_key'
+  ) then
+    alter table public.learning_profiles
+      add constraint learning_profiles_id_household_key unique (id, household_id);
+  end if;
+end;
+$migration$;
+
+create table if not exists public.learning_point_items (
+  id uuid primary key default gen_random_uuid(),
+  household_id uuid not null
+    references public.learning_households(id) on delete cascade,
+  name text not null check (char_length(name) between 1 and 60),
+  description text,
+  default_points integer not null
+    check (default_points between -1000 and 1000 and default_points <> 0),
+  item_kind text not null default 'custom'
+    check (item_kind in ('custom', 'recommended')),
+  category text not null default 'growth'
+    check (category in ('growth', 'learning', 'family', 'other')),
+  icon_key text,
+  is_active boolean not null default true,
+  created_at timestamptz not null default now(),
+  updated_at timestamptz not null default now(),
+  unique (id, household_id)
+);
+
+create table if not exists public.learning_profile_point_items (
+  household_id uuid not null,
+  profile_id uuid not null,
+  point_item_id uuid not null,
+  points_override integer
+    check (points_override is null or (points_override between -1000 and 1000 and points_override <> 0)),
+  enabled boolean not null default true,
+  created_at timestamptz not null default now(),
+  updated_at timestamptz not null default now(),
+  primary key (profile_id, point_item_id),
+  constraint learning_profile_point_items_profile_fk
+    foreign key (profile_id, household_id)
+    references public.learning_profiles(id, household_id)
+    on delete cascade,
+  constraint learning_profile_point_items_item_fk
+    foreign key (point_item_id, household_id)
+    references public.learning_point_items(id, household_id)
+    on delete cascade
+);
+
+create table if not exists public.learning_point_ledger (
+  id uuid primary key default gen_random_uuid(),
+  household_id uuid not null,
+  profile_id uuid not null,
+  point_item_id uuid,
+  delta integer not null
+    check (delta between -1000 and 1000 and delta <> 0),
+  entry_type text not null
+    check (entry_type in ('manual', 'adjustment', 'initial_balance', 'redemption', 'refund')),
+  item_name_snapshot text not null check (char_length(item_name_snapshot) between 1 and 60),
+  note text check (note is null or char_length(note) <= 200),
+  request_id uuid not null,
+  actor_user_id uuid references auth.users(id) on delete set null,
+  created_at timestamptz not null default now(),
+  constraint learning_point_ledger_profile_fk
+    foreign key (profile_id, household_id)
+    references public.learning_profiles(id, household_id)
+    on delete cascade,
+  constraint learning_point_ledger_item_fk
+    foreign key (point_item_id, household_id)
+    references public.learning_point_items(id, household_id)
+    on delete set null,
+  constraint learning_point_ledger_request_key unique (profile_id, request_id)
+);
+
+create index if not exists learning_point_items_household_idx
+  on public.learning_point_items (household_id, is_active, created_at);
+
+create index if not exists learning_profile_point_items_lookup_idx
+  on public.learning_profile_point_items (household_id, profile_id, enabled);
+
+create index if not exists learning_point_ledger_profile_created_idx
+  on public.learning_point_ledger (profile_id, created_at desc);
+
+alter table public.learning_point_items enable row level security;
+alter table public.learning_profile_point_items enable row level security;
+alter table public.learning_point_ledger enable row level security;
+
+revoke all on table public.learning_point_items from anon;
+revoke all on table public.learning_profile_point_items from anon;
+revoke all on table public.learning_point_ledger from anon;
+revoke all on table public.learning_point_items from authenticated;
+revoke all on table public.learning_profile_point_items from authenticated;
+revoke all on table public.learning_point_ledger from authenticated;
+
+grant select, insert, update on table public.learning_point_items to authenticated;
+grant select, insert, update, delete on table public.learning_profile_point_items to authenticated;
+grant select on table public.learning_point_ledger to authenticated;
+
+drop policy if exists "learning point items: household members can read" on public.learning_point_items;
+create policy "learning point items: household members can read"
+on public.learning_point_items
+for select
+to authenticated
+using (
+  exists (
+    select 1
+    from public.learning_household_members member
+    where member.household_id = learning_point_items.household_id
+      and member.user_id = (select auth.uid())
+  )
+);
+
+drop policy if exists "learning point items: guardians can create" on public.learning_point_items;
+create policy "learning point items: guardians can create"
+on public.learning_point_items
+for insert
+to authenticated
+with check (
+  exists (
+    select 1
+    from public.learning_household_members member
+    where member.household_id = learning_point_items.household_id
+      and member.user_id = (select auth.uid())
+      and member.role in ('owner', 'guardian')
+  )
+);
+
+drop policy if exists "learning point items: guardians can update" on public.learning_point_items;
+create policy "learning point items: guardians can update"
+on public.learning_point_items
+for update
+to authenticated
+using (
+  exists (
+    select 1
+    from public.learning_household_members member
+    where member.household_id = learning_point_items.household_id
+      and member.user_id = (select auth.uid())
+      and member.role in ('owner', 'guardian')
+  )
+)
+with check (
+  exists (
+    select 1
+    from public.learning_household_members member
+    where member.household_id = learning_point_items.household_id
+      and member.user_id = (select auth.uid())
+      and member.role in ('owner', 'guardian')
+  )
+);
+
+drop policy if exists "learning profile point items: household members can read" on public.learning_profile_point_items;
+create policy "learning profile point items: household members can read"
+on public.learning_profile_point_items
+for select
+to authenticated
+using (
+  exists (
+    select 1
+    from public.learning_household_members member
+    where member.household_id = learning_profile_point_items.household_id
+      and member.user_id = (select auth.uid())
+  )
+);
+
+drop policy if exists "learning profile point items: guardians can create" on public.learning_profile_point_items;
+create policy "learning profile point items: guardians can create"
+on public.learning_profile_point_items
+for insert
+to authenticated
+with check (
+  exists (
+    select 1
+    from public.learning_household_members member
+    where member.household_id = learning_profile_point_items.household_id
+      and member.user_id = (select auth.uid())
+      and member.role in ('owner', 'guardian')
+  )
+);
+
+drop policy if exists "learning profile point items: guardians can update" on public.learning_profile_point_items;
+create policy "learning profile point items: guardians can update"
+on public.learning_profile_point_items
+for update
+to authenticated
+using (
+  exists (
+    select 1
+    from public.learning_household_members member
+    where member.household_id = learning_profile_point_items.household_id
+      and member.user_id = (select auth.uid())
+      and member.role in ('owner', 'guardian')
+  )
+)
+with check (
+  exists (
+    select 1
+    from public.learning_household_members member
+    where member.household_id = learning_profile_point_items.household_id
+      and member.user_id = (select auth.uid())
+      and member.role in ('owner', 'guardian')
+  )
+);
+
+drop policy if exists "learning profile point items: guardians can delete" on public.learning_profile_point_items;
+create policy "learning profile point items: guardians can delete"
+on public.learning_profile_point_items
+for delete
+to authenticated
+using (
+  exists (
+    select 1
+    from public.learning_household_members member
+    where member.household_id = learning_profile_point_items.household_id
+      and member.user_id = (select auth.uid())
+      and member.role in ('owner', 'guardian')
+  )
+);
+
+drop policy if exists "learning point ledger: household members can read" on public.learning_point_ledger;
+create policy "learning point ledger: household members can read"
+on public.learning_point_ledger
+for select
+to authenticated
+using (
+  exists (
+    select 1
+    from public.learning_household_members member
+    where member.household_id = learning_point_ledger.household_id
+      and member.user_id = (select auth.uid())
+  )
+);
+
+create or replace function public.learning_record_points(
+  p_profile_id uuid,
+  p_point_item_id uuid,
+  p_delta integer,
+  p_request_id uuid,
+  p_entry_type text default 'manual',
+  p_note text default null
+)
+returns setof public.learning_point_ledger
+language plpgsql
+security definer
+set search_path = ''
+as $function$
+declare
+  actor_id uuid := (select auth.uid());
+  profile_household_id uuid;
+  item_name text;
+  existing_row public.learning_point_ledger%rowtype;
+  saved_row public.learning_point_ledger%rowtype;
+begin
+  if actor_id is null then
+    raise exception 'learning_auth_required' using errcode = '42501';
+  end if;
+
+  if p_request_id is null then
+    raise exception 'learning_request_id_required' using errcode = '22023';
+  end if;
+
+  if p_delta is null or p_delta = 0 or p_delta not between -1000 and 1000 then
+    raise exception 'learning_point_delta_invalid' using errcode = '22023';
+  end if;
+
+  if p_entry_type is null
+     or p_entry_type not in ('manual', 'adjustment', 'initial_balance', 'redemption', 'refund') then
+    raise exception 'learning_point_entry_type_invalid' using errcode = '22023';
+  end if;
+
+  if p_note is not null and char_length(p_note) > 200 then
+    raise exception 'learning_point_note_too_long' using errcode = '22001';
+  end if;
+
+  select profile.household_id
+  into profile_household_id
+  from public.learning_profiles profile
+  join public.learning_household_members member
+    on member.household_id = profile.household_id
+  where profile.id = p_profile_id
+    and member.user_id = actor_id
+    and member.role in ('owner', 'guardian');
+
+  if not found then
+    raise exception 'learning_point_forbidden' using errcode = '42501';
+  end if;
+
+  -- A retry returns the original row. A reused request id with different
+  -- business values is rejected instead of silently changing history.
+  select *
+  into existing_row
+  from public.learning_point_ledger ledger
+  where ledger.profile_id = p_profile_id
+    and ledger.request_id = p_request_id;
+
+  if found then
+    if existing_row.point_item_id is not distinct from p_point_item_id
+       and existing_row.delta = p_delta
+       and existing_row.entry_type = p_entry_type
+       and existing_row.note is not distinct from p_note then
+      return next existing_row;
+      return;
+    end if;
+    raise exception 'learning_request_reuse_conflict' using errcode = 'P0001';
+  end if;
+
+  if p_point_item_id is not null then
+    select item.name
+    into item_name
+    from public.learning_point_items item
+    join public.learning_profile_point_items assignment
+      on assignment.point_item_id = item.id
+     and assignment.household_id = item.household_id
+    where item.id = p_point_item_id
+      and item.household_id = profile_household_id
+      and item.is_active
+      and assignment.profile_id = p_profile_id
+      and assignment.enabled;
+
+    if not found then
+      raise exception 'learning_point_item_unavailable' using errcode = '42501';
+    end if;
+  else
+    if p_entry_type not in ('adjustment', 'initial_balance', 'redemption', 'refund') then
+      raise exception 'learning_point_item_required' using errcode = '22023';
+    end if;
+    item_name := p_entry_type;
+  end if;
+
+  insert into public.learning_point_ledger (
+    household_id,
+    profile_id,
+    point_item_id,
+    delta,
+    entry_type,
+    item_name_snapshot,
+    note,
+    request_id,
+    actor_user_id
+  )
+  values (
+    profile_household_id,
+    p_profile_id,
+    p_point_item_id,
+    p_delta,
+    p_entry_type,
+    item_name,
+    p_note,
+    p_request_id,
+    actor_id
+  )
+  returning * into saved_row;
+
+  return next saved_row;
+end;
+$function$;
+
+revoke all on function public.learning_record_points(uuid, uuid, integer, uuid, text, text) from public;
+revoke all on function public.learning_record_points(uuid, uuid, integer, uuid, text, text) from anon;
+grant execute on function public.learning_record_points(uuid, uuid, integer, uuid, text, text)
+  to authenticated;
+
+comment on table public.learning_point_items is
+  'Household-owned reusable positive or corrective point items; child assignment is stored separately.';
+comment on table public.learning_profile_point_items is
+  'Many-to-many child configuration for household point items, including a child-specific value override.';
+comment on table public.learning_point_ledger is
+  'Append-only child point history. New rows are created through learning_record_points.';
+comment on function public.learning_record_points(uuid, uuid, integer, uuid, text, text) is
+  'Idempotently records one signed point event for a guardian-managed child scope.';
diff --git a/supabase/migrations/20260814085701_growth_loop_points_indexes.sql b/supabase/migrations/20260814085701_growth_loop_points_indexes.sql
new file mode 100644
index 0000000..3cb7677
--- /dev/null
+++ b/supabase/migrations/20260814085701_growth_loop_points_indexes.sql
@@ -0,0 +1,18 @@
+-- Cover the composite foreign keys introduced by the Growth Loop point slice.
+-- Keep this separate from the foundation migration so each local/remote
+-- migration remains independently reviewable and serially applicable.
+
+create index if not exists learning_profile_point_items_profile_scope_idx
+  on public.learning_profile_point_items (profile_id, household_id);
+
+create index if not exists learning_profile_point_items_item_scope_idx
+  on public.learning_profile_point_items (point_item_id, household_id);
+
+create index if not exists learning_point_ledger_profile_scope_idx
+  on public.learning_point_ledger (profile_id, household_id);
+
+create index if not exists learning_point_ledger_item_scope_idx
+  on public.learning_point_ledger (point_item_id, household_id);
+
+create index if not exists learning_point_ledger_actor_idx
+  on public.learning_point_ledger (actor_user_id);
diff --git a/supabase/migrations/20260814090121_growth_loop_rewards.sql b/supabase/migrations/20260814090121_growth_loop_rewards.sql
new file mode 100644
index 0000000..a48942b
--- /dev/null
+++ b/supabase/migrations/20260814090121_growth_loop_rewards.sql
@@ -0,0 +1,599 @@
+-- Shadow Mate Growth Loop reward and redemption foundation.
+-- Redemption changes are paired with point ledger rows; cancellation never
+-- edits the original redemption debit and instead appends a refund row.
+
+create table if not exists public.learning_rewards (
+  id uuid primary key default gen_random_uuid(),
+  household_id uuid not null
+    references public.learning_households(id) on delete cascade,
+  name text not null check (char_length(name) between 1 and 60),
+  description text,
+  cost_points integer not null check (cost_points between 1 and 100000),
+  reward_kind text not null default 'custom'
+    check (reward_kind in ('custom', 'recommended')),
+  category text not null default 'family'
+    check (category in ('family', 'activity', 'treat', 'other')),
+  icon_key text,
+  is_active boolean not null default true,
+  created_at timestamptz not null default now(),
+  updated_at timestamptz not null default now(),
+  unique (id, household_id)
+);
+
+create table if not exists public.learning_profile_rewards (
+  household_id uuid not null,
+  profile_id uuid not null,
+  reward_id uuid not null,
+  cost_override integer
+    check (cost_override is null or cost_override between 1 and 100000),
+  enabled boolean not null default true,
+  created_at timestamptz not null default now(),
+  updated_at timestamptz not null default now(),
+  primary key (profile_id, reward_id),
+  constraint learning_profile_rewards_profile_fk
+    foreign key (profile_id, household_id)
+    references public.learning_profiles(id, household_id)
+    on delete cascade,
+  constraint learning_profile_rewards_reward_fk
+    foreign key (reward_id, household_id)
+    references public.learning_rewards(id, household_id)
+    on delete cascade
+);
+
+create table if not exists public.learning_redemptions (
+  id uuid primary key default gen_random_uuid(),
+  household_id uuid not null,
+  profile_id uuid not null,
+  reward_id uuid not null,
+  reward_name_snapshot text not null check (char_length(reward_name_snapshot) between 1 and 60),
+  cost_points_snapshot integer not null check (cost_points_snapshot between 1 and 100000),
+  status text not null default 'pending'
+    check (status in ('pending', 'fulfilled', 'cancelled')),
+  request_id uuid not null,
+  actor_user_id uuid references auth.users(id) on delete set null,
+  fulfilled_at timestamptz,
+  fulfilled_by uuid references auth.users(id) on delete set null,
+  cancelled_at timestamptz,
+  cancelled_by uuid references auth.users(id) on delete set null,
+  created_at timestamptz not null default now(),
+  updated_at timestamptz not null default now(),
+  constraint learning_redemptions_profile_fk
+    foreign key (profile_id, household_id)
+    references public.learning_profiles(id, household_id)
+    on delete cascade,
+  constraint learning_redemptions_reward_fk
+    foreign key (reward_id, household_id)
+    references public.learning_rewards(id, household_id)
+    on delete restrict,
+  constraint learning_redemptions_request_key unique (profile_id, request_id)
+);
+
+alter table public.learning_point_ledger
+  add column if not exists redemption_id uuid;
+
+do $migration$
+begin
+  if not exists (
+    select 1
+    from pg_constraint
+    where conrelid = 'public.learning_point_ledger'::regclass
+      and conname = 'learning_point_ledger_redemption_fk'
+  ) then
+    alter table public.learning_point_ledger
+      add constraint learning_point_ledger_redemption_fk
+      foreign key (redemption_id)
+      references public.learning_redemptions(id)
+      on delete set null;
+  end if;
+end;
+$migration$;
+
+create index if not exists learning_rewards_household_idx
+  on public.learning_rewards (household_id, is_active, created_at);
+
+create index if not exists learning_profile_rewards_profile_scope_idx
+  on public.learning_profile_rewards (profile_id, household_id);
+
+create index if not exists learning_profile_rewards_reward_scope_idx
+  on public.learning_profile_rewards (reward_id, household_id);
+
+create index if not exists learning_redemptions_profile_created_idx
+  on public.learning_redemptions (profile_id, created_at desc);
+
+create index if not exists learning_redemptions_reward_scope_idx
+  on public.learning_redemptions (reward_id, household_id);
+
+create index if not exists learning_point_ledger_redemption_idx
+  on public.learning_point_ledger (redemption_id);
+
+alter table public.learning_rewards enable row level security;
+alter table public.learning_profile_rewards enable row level security;
+alter table public.learning_redemptions enable row level security;
+
+revoke all on table public.learning_rewards from anon;
+revoke all on table public.learning_profile_rewards from anon;
+revoke all on table public.learning_redemptions from anon;
+revoke all on table public.learning_rewards from authenticated;
+revoke all on table public.learning_profile_rewards from authenticated;
+revoke all on table public.learning_redemptions from authenticated;
+
+grant select, insert, update on table public.learning_rewards to authenticated;
+grant select, insert, update, delete on table public.learning_profile_rewards to authenticated;
+grant select on table public.learning_redemptions to authenticated;
+
+drop policy if exists "learning rewards: household members can read" on public.learning_rewards;
+create policy "learning rewards: household members can read"
+on public.learning_rewards
+for select
+to authenticated
+using (
+  exists (
+    select 1
+    from public.learning_household_members member
+    where member.household_id = learning_rewards.household_id
+      and member.user_id = (select auth.uid())
+  )
+);
+
+drop policy if exists "learning rewards: guardians can create" on public.learning_rewards;
+create policy "learning rewards: guardians can create"
+on public.learning_rewards
+for insert
+to authenticated
+with check (
+  exists (
+    select 1
+    from public.learning_household_members member
+    where member.household_id = learning_rewards.household_id
+      and member.user_id = (select auth.uid())
+      and member.role in ('owner', 'guardian')
+  )
+);
+
+drop policy if exists "learning rewards: guardians can update" on public.learning_rewards;
+create policy "learning rewards: guardians can update"
+on public.learning_rewards
+for update
+to authenticated
+using (
+  exists (
+    select 1
+    from public.learning_household_members member
+    where member.household_id = learning_rewards.household_id
+      and member.user_id = (select auth.uid())
+      and member.role in ('owner', 'guardian')
+  )
+)
+with check (
+  exists (
+    select 1
+    from public.learning_household_members member
+    where member.household_id = learning_rewards.household_id
+      and member.user_id = (select auth.uid())
+      and member.role in ('owner', 'guardian')
+  )
+);
+
+drop policy if exists "learning profile rewards: household members can read" on public.learning_profile_rewards;
+create policy "learning profile rewards: household members can read"
+on public.learning_profile_rewards
+for select
+to authenticated
+using (
+  exists (
+    select 1
+    from public.learning_household_members member
+    where member.household_id = learning_profile_rewards.household_id
+      and member.user_id = (select auth.uid())
+  )
+);
+
+drop policy if exists "learning profile rewards: guardians can create" on public.learning_profile_rewards;
+create policy "learning profile rewards: guardians can create"
+on public.learning_profile_rewards
+for insert
+to authenticated
+with check (
+  exists (
+    select 1
+    from public.learning_household_members member
+    where member.household_id = learning_profile_rewards.household_id
+      and member.user_id = (select auth.uid())
+      and member.role in ('owner', 'guardian')
+  )
+);
+
+drop policy if exists "learning profile rewards: guardians can update" on public.learning_profile_rewards;
+create policy "learning profile rewards: guardians can update"
+on public.learning_profile_rewards
+for update
+to authenticated
+using (
+  exists (
+    select 1
+    from public.learning_household_members member
+    where member.household_id = learning_profile_rewards.household_id
+      and member.user_id = (select auth.uid())
+      and member.role in ('owner', 'guardian')
+  )
+)
+with check (
+  exists (
+    select 1
+    from public.learning_household_members member
+    where member.household_id = learning_profile_rewards.household_id
+      and member.user_id = (select auth.uid())
+      and member.role in ('owner', 'guardian')
+  )
+);
+
+drop policy if exists "learning profile rewards: guardians can delete" on public.learning_profile_rewards;
+create policy "learning profile rewards: guardians can delete"
+on public.learning_profile_rewards
+for delete
+to authenticated
+using (
+  exists (
+    select 1
+    from public.learning_household_members member
+    where member.household_id = learning_profile_rewards.household_id
+      and member.user_id = (select auth.uid())
+      and member.role in ('owner', 'guardian')
+  )
+);
+
+drop policy if exists "learning redemptions: household members can read" on public.learning_redemptions;
+create policy "learning redemptions: household members can read"
+on public.learning_redemptions
+for select
+to authenticated
+using (
+  exists (
+    select 1
+    from public.learning_household_members member
+    where member.household_id = learning_redemptions.household_id
+      and member.user_id = (select auth.uid())
+  )
+);
+
+create or replace function private.learning_validate_point_ledger_entry()
+returns trigger
+language plpgsql
+set search_path = ''
+as $function$
+declare
+  redemption_profile_id uuid;
+  redemption_household_id uuid;
+begin
+  if new.entry_type in ('redemption', 'refund') and new.redemption_id is null then
+    raise exception 'learning_redemption_link_required' using errcode = '22023';
+  end if;
+
+  if new.entry_type not in ('redemption', 'refund') and new.redemption_id is not null then
+    raise exception 'learning_redemption_link_invalid' using errcode = '22023';
+  end if;
+
+  if new.redemption_id is not null then
+    select redemption.profile_id, redemption.household_id
+    into redemption_profile_id, redemption_household_id
+    from public.learning_redemptions redemption
+    where redemption.id = new.redemption_id;
+
+    if not found
+       or redemption_profile_id is distinct from new.profile_id
+       or redemption_household_id is distinct from new.household_id then
+      raise exception 'learning_redemption_scope_invalid' using errcode = '22023';
+    end if;
+  end if;
+
+  return new;
+end;
+$function$;
+
+drop trigger if exists learning_point_ledger_entry_guard on public.learning_point_ledger;
+create trigger learning_point_ledger_entry_guard
+before insert or update on public.learning_point_ledger
+for each row execute function private.learning_validate_point_ledger_entry();
+
+create or replace function public.learning_redeem_reward(
+  p_profile_id uuid,
+  p_reward_id uuid,
+  p_request_id uuid
+)
+returns setof public.learning_redemptions
+language plpgsql
+security definer
+set search_path = ''
+as $function$
+declare
+  actor_id uuid := (select auth.uid());
+  profile_household_id uuid;
+  reward_name text;
+  reward_cost integer;
+  current_balance bigint;
+  existing_row public.learning_redemptions%rowtype;
+  saved_row public.learning_redemptions%rowtype;
+begin
+  if actor_id is null then
+    raise exception 'learning_auth_required' using errcode = '42501';
+  end if;
+
+  if p_request_id is null then
+    raise exception 'learning_request_id_required' using errcode = '22023';
+  end if;
+
+  select profile.household_id
+  into profile_household_id
+  from public.learning_profiles profile
+  join public.learning_household_members member
+    on member.household_id = profile.household_id
+  where profile.id = p_profile_id
+    and member.user_id = actor_id
+    and member.role in ('owner', 'guardian');
+
+  if not found then
+    raise exception 'learning_point_forbidden' using errcode = '42501';
+  end if;
+
+  select *
+  into existing_row
+  from public.learning_redemptions redemption
+  where redemption.profile_id = p_profile_id
+    and redemption.request_id = p_request_id;
+
+  if found then
+    if existing_row.reward_id = p_reward_id then
+      return next existing_row;
+      return;
+    end if;
+    raise exception 'learning_request_reuse_conflict' using errcode = 'P0001';
+  end if;
+
+  perform 1
+  from public.learning_profiles profile
+  where profile.id = p_profile_id
+  for update;
+
+  select reward.name, coalesce(assignment.cost_override, reward.cost_points)
+  into reward_name, reward_cost
+  from public.learning_rewards reward
+  join public.learning_profile_rewards assignment
+    on assignment.reward_id = reward.id
+   and assignment.household_id = reward.household_id
+  where reward.id = p_reward_id
+    and reward.household_id = profile_household_id
+    and reward.is_active
+    and assignment.profile_id = p_profile_id
+    and assignment.enabled;
+
+  if not found then
+    raise exception 'learning_reward_unavailable' using errcode = '42501';
+  end if;
+
+  select coalesce(sum(ledger.delta), 0)
+  into current_balance
+  from public.learning_point_ledger ledger
+  where ledger.profile_id = p_profile_id;
+
+  if current_balance < reward_cost then
+    raise exception 'learning_reward_insufficient_points' using errcode = 'P0001';
+  end if;
+
+  insert into public.learning_redemptions (
+    household_id,
+    profile_id,
+    reward_id,
+    reward_name_snapshot,
+    cost_points_snapshot,
+    request_id,
+    actor_user_id
+  )
+  values (
+    profile_household_id,
+    p_profile_id,
+    p_reward_id,
+    reward_name,
+    reward_cost,
+    p_request_id,
+    actor_id
+  )
+  returning * into saved_row;
+
+  insert into public.learning_point_ledger (
+    household_id,
+    profile_id,
+    delta,
+    entry_type,
+    item_name_snapshot,
+    request_id,
+    actor_user_id,
+    redemption_id
+  )
+  values (
+    profile_household_id,
+    p_profile_id,
+    -reward_cost,
+    'redemption',
+    reward_name,
+    p_request_id,
+    actor_id,
+    saved_row.id
+  );
+
+  return next saved_row;
+end;
+$function$;
+
+create or replace function public.learning_fulfill_redemption(
+  p_redemption_id uuid
+)
+returns setof public.learning_redemptions
+language plpgsql
+security definer
+set search_path = ''
+as $function$
+declare
+  actor_id uuid := (select auth.uid());
+  current_row public.learning_redemptions%rowtype;
+  saved_row public.learning_redemptions%rowtype;
+begin
+  if actor_id is null then
+    raise exception 'learning_auth_required' using errcode = '42501';
+  end if;
+
+  select redemption.*
+  into current_row
+  from public.learning_redemptions redemption
+  join public.learning_household_members member
+    on member.household_id = redemption.household_id
+  where redemption.id = p_redemption_id
+    and member.user_id = actor_id
+    and member.role in ('owner', 'guardian')
+  for update of redemption;
+
+  if not found then
+    raise exception 'learning_redemption_forbidden' using errcode = '42501';
+  end if;
+
+  if current_row.status = 'fulfilled' then
+    return next current_row;
+    return;
+  end if;
+
+  if current_row.status <> 'pending' then
+    raise exception 'learning_redemption_not_fulfillable' using errcode = 'P0001';
+  end if;
+
+  update public.learning_redemptions redemption
+  set
+    status = 'fulfilled',
+    fulfilled_at = now(),
+    fulfilled_by = actor_id,
+    updated_at = now()
+  where redemption.id = p_redemption_id
+  returning * into saved_row;
+
+  return next saved_row;
+end;
+$function$;
+
+create or replace function public.learning_cancel_redemption(
+  p_redemption_id uuid,
+  p_request_id uuid,
+  p_note text default null
+)
+returns setof public.learning_redemptions
+language plpgsql
+security definer
+set search_path = ''
+as $function$
+declare
+  actor_id uuid := (select auth.uid());
+  current_row public.learning_redemptions%rowtype;
+  saved_row public.learning_redemptions%rowtype;
+  existing_refund public.learning_point_ledger%rowtype;
+begin
+  if actor_id is null then
+    raise exception 'learning_auth_required' using errcode = '42501';
+  end if;
+
+  if p_request_id is null then
+    raise exception 'learning_request_id_required' using errcode = '22023';
+  end if;
+
+  if p_note is not null and char_length(p_note) > 200 then
+    raise exception 'learning_redemption_note_too_long' using errcode = '22001';
+  end if;
+
+  select redemption.*
+  into current_row
+  from public.learning_redemptions redemption
+  join public.learning_household_members member
+    on member.household_id = redemption.household_id
+  where redemption.id = p_redemption_id
+    and member.user_id = actor_id
+    and member.role in ('owner', 'guardian')
+  for update of redemption;
+
+  if not found then
+    raise exception 'learning_redemption_forbidden' using errcode = '42501';
+  end if;
+
+  if current_row.status = 'cancelled' then
+    select ledger.*
+    into existing_refund
+    from public.learning_point_ledger ledger
+    where ledger.redemption_id = p_redemption_id
+      and ledger.request_id = p_request_id
+      and ledger.entry_type = 'refund';
+    if found then
+      return next current_row;
+      return;
+    end if;
+    raise exception 'learning_redemption_already_cancelled' using errcode = 'P0001';
+  end if;
+
+  if current_row.status <> 'pending' then
+    raise exception 'learning_redemption_not_cancellable' using errcode = 'P0001';
+  end if;
+
+  update public.learning_redemptions redemption
+  set
+    status = 'cancelled',
+    cancelled_at = now(),
+    cancelled_by = actor_id,
+    updated_at = now()
+  where redemption.id = p_redemption_id
+  returning * into saved_row;
+
+  insert into public.learning_point_ledger (
+    household_id,
+    profile_id,
+    delta,
+    entry_type,
+    item_name_snapshot,
+    note,
+    request_id,
+    actor_user_id,
+    redemption_id
+  )
+  values (
+    saved_row.household_id,
+    saved_row.profile_id,
+    saved_row.cost_points_snapshot,
+    'refund',
+    saved_row.reward_name_snapshot,
+    p_note,
+    p_request_id,
+    actor_id,
+    saved_row.id
+  );
+
+  return next saved_row;
+end;
+$function$;
+
+revoke all on function public.learning_redeem_reward(uuid, uuid, uuid) from public;
+revoke all on function public.learning_redeem_reward(uuid, uuid, uuid) from anon;
+grant execute on function public.learning_redeem_reward(uuid, uuid, uuid) to authenticated;
+
+revoke all on function public.learning_fulfill_redemption(uuid) from public;
+revoke all on function public.learning_fulfill_redemption(uuid) from anon;
+grant execute on function public.learning_fulfill_redemption(uuid) to authenticated;
+
+revoke all on function public.learning_cancel_redemption(uuid, uuid, text) from public;
+revoke all on function public.learning_cancel_redemption(uuid, uuid, text) from anon;
+grant execute on function public.learning_cancel_redemption(uuid, uuid, text) to authenticated;
+
+comment on table public.learning_rewards is
+  'Household-owned rewards that can be enabled per child and redeemed for points.';
+comment on table public.learning_profile_rewards is
+  'Many-to-many child configuration for household rewards, including a child-specific cost override.';
+comment on table public.learning_redemptions is
+  'Reward redemption state with stable snapshots; point debit and refund live in the immutable ledger.';
+comment on function public.learning_redeem_reward(uuid, uuid, uuid) is
+  'Atomically checks balance, creates a pending redemption, and appends the redemption debit.';
+comment on function public.learning_fulfill_redemption(uuid) is
+  'Marks a pending redemption fulfilled without rewriting point history.';
+comment on function public.learning_cancel_redemption(uuid, uuid, text) is
+  'Cancels a pending redemption and appends a compensating refund ledger row.';
diff --git a/supabase/migrations/20260814090652_growth_loop_rewards_indexes.sql b/supabase/migrations/20260814090652_growth_loop_rewards_indexes.sql
new file mode 100644
index 0000000..17f0626
--- /dev/null
+++ b/supabase/migrations/20260814090652_growth_loop_rewards_indexes.sql
@@ -0,0 +1,13 @@
+-- Cover reward redemption foreign keys before the schema reaches production.
+
+create index if not exists learning_redemptions_profile_scope_idx
+  on public.learning_redemptions (profile_id, household_id);
+
+create index if not exists learning_redemptions_actor_idx
+  on public.learning_redemptions (actor_user_id);
+
+create index if not exists learning_redemptions_fulfilled_by_idx
+  on public.learning_redemptions (fulfilled_by);
+
+create index if not exists learning_redemptions_cancelled_by_idx
+  on public.learning_redemptions (cancelled_by);
diff --git a/supabase/migrations/20260814094058_growth_loop_activity_events.sql b/supabase/migrations/20260814094058_growth_loop_activity_events.sql
new file mode 100644
index 0000000..cb805fb
--- /dev/null
+++ b/supabase/migrations/20260814094058_growth_loop_activity_events.sql
@@ -0,0 +1,172 @@
+-- Growth Loop diagnostics are an allowlisted, private activity stream.
+-- Product facts remain in the point/reward tables; this table is not exposed
+-- through the Data API and can only be written through the guarded RPC.
+
+create table if not exists private.learning_activity_events (
+  event_id uuid primary key,
+  product_id text not null check (product_id = 'shadow-mate'),
+  event_type text not null check (
+    event_type in (
+      'household_activated',
+      'learner_created',
+      'core_activation',
+      'growth_activity_recorded',
+      'retention_qualified',
+      'reward_redeemed',
+      'sync_failed',
+      'tts_failed'
+    )
+  ),
+  household_id uuid not null
+    references public.learning_households(id) on delete cascade,
+  profile_id uuid not null,
+  occurred_at timestamptz not null,
+  timezone text check (timezone is null or char_length(timezone) <= 64),
+  client_version text check (client_version is null or char_length(client_version) <= 32),
+  payload jsonb not null default '{}'::jsonb
+    check (octet_length(payload::text) <= 4096),
+  payload_hash text not null,
+  actor_user_id uuid references auth.users(id) on delete set null,
+  received_at timestamptz not null default now(),
+  constraint learning_activity_events_profile_scope_fk
+    foreign key (profile_id, household_id)
+    references public.learning_profiles(id, household_id)
+    on delete cascade
+);
+
+create index if not exists learning_activity_events_household_time_idx
+  on private.learning_activity_events (household_id, occurred_at desc);
+
+create index if not exists learning_activity_events_type_time_idx
+  on private.learning_activity_events (event_type, occurred_at desc);
+
+alter table private.learning_activity_events enable row level security;
+revoke all on table private.learning_activity_events from public;
+revoke all on table private.learning_activity_events from anon;
+revoke all on table private.learning_activity_events from authenticated;
+
+create or replace function public.learning_record_activity_event(p_event jsonb)
+returns table(event_id uuid, status text)
+language plpgsql
+security definer
+set search_path = ''
+as $function$
+declare
+  actor_id uuid := (select auth.uid());
+  event_uuid uuid;
+  event_product_id text;
+  event_type_value text;
+  event_household_id uuid;
+  event_profile_id uuid;
+  event_occurred_at timestamptz;
+  event_timezone text;
+  event_client_version text;
+  event_payload jsonb;
+  event_payload_hash text;
+  existing_row private.learning_activity_events%rowtype;
+begin
+  if actor_id is null then
+    raise exception 'learning_auth_required' using errcode = '42501';
+  end if;
+
+  if p_event is null or jsonb_typeof(p_event) <> 'object' then
+    raise exception 'activity_event_invalid' using errcode = '22023';
+  end if;
+
+  event_uuid := (p_event ->> 'event_id')::uuid;
+  event_product_id := p_event ->> 'product_id';
+  event_type_value := p_event ->> 'event_type';
+  event_household_id := (p_event ->> 'household_id')::uuid;
+  event_profile_id := (p_event ->> 'profile_id')::uuid;
+  event_occurred_at := (p_event ->> 'occurred_at')::timestamptz;
+  event_timezone := nullif(left(p_event ->> 'timezone', 64), '');
+  event_client_version := nullif(left(p_event ->> 'client_version', 32), '');
+  event_payload := coalesce(p_event -> 'payload', '{}'::jsonb);
+  event_payload_hash := md5(p_event::text);
+
+  if event_uuid is null
+     or event_product_id <> 'shadow-mate'
+     or event_type_value not in (
+       'household_activated', 'learner_created', 'core_activation',
+       'growth_activity_recorded', 'retention_qualified', 'reward_redeemed',
+       'sync_failed', 'tts_failed'
+     )
+     or event_household_id is null
+     or event_profile_id is null
+     or event_occurred_at is null
+     or jsonb_typeof(event_payload) <> 'object'
+     or octet_length(event_payload::text) > 4096 then
+    raise exception 'activity_event_invalid' using errcode = '22023';
+  end if;
+
+  if exists (
+    select 1
+    from jsonb_object_keys(event_payload) key_name
+    where key_name not in ('source', 'entry_type', 'error_code', 'retryable', 'client', 'days', 'count')
+  ) then
+    raise exception 'activity_event_payload_invalid' using errcode = '22023';
+  end if;
+
+  if not exists (
+    select 1
+    from public.learning_household_members member
+    where member.household_id = event_household_id
+      and member.user_id = actor_id
+      and member.role in ('owner', 'guardian')
+  ) then
+    raise exception 'learning_point_forbidden' using errcode = '42501';
+  end if;
+
+  select *
+  into existing_row
+  from private.learning_activity_events existing
+  where existing.event_id = event_uuid;
+
+  if found then
+    if existing_row.payload_hash <> event_payload_hash
+       or existing_row.event_type <> event_type_value
+       or existing_row.profile_id <> event_profile_id then
+      raise exception 'activity_event_idempotency_conflict' using errcode = 'P0001';
+    end if;
+    return query select existing_row.event_id, 'duplicate'::text;
+    return;
+  end if;
+
+  insert into private.learning_activity_events (
+    event_id,
+    product_id,
+    event_type,
+    household_id,
+    profile_id,
+    occurred_at,
+    timezone,
+    client_version,
+    payload,
+    payload_hash,
+    actor_user_id
+  ) values (
+    event_uuid,
+    event_product_id,
+    event_type_value,
+    event_household_id,
+    event_profile_id,
+    event_occurred_at,
+    event_timezone,
+    event_client_version,
+    event_payload,
+    event_payload_hash,
+    actor_id
+  );
+
+  return query select event_uuid, 'confirmed'::text;
+end;
+$function$;
+
+revoke all on function public.learning_record_activity_event(jsonb) from public;
+revoke all on function public.learning_record_activity_event(jsonb) from anon;
+grant execute on function public.learning_record_activity_event(jsonb) to authenticated;
+
+comment on table private.learning_activity_events is
+  'Allowlisted Growth Loop activity diagnostics; raw events are retained separately from product facts.';
+comment on function public.learning_record_activity_event(jsonb) is
+  'Records one allowlisted, guardian-scoped, idempotent activity event.';
diff --git a/supabase/migrations/20260814101037_growth_loop_point_dates.sql b/supabase/migrations/20260814101037_growth_loop_point_dates.sql
new file mode 100644
index 0000000..63a85b7
--- /dev/null
+++ b/supabase/migrations/20260814101037_growth_loop_point_dates.sql
@@ -0,0 +1,144 @@
+-- Preserve the date selected in the local-first calendar when a point event
+-- reaches the cloud. The original six-argument RPC remains for compatibility;
+-- the seven-argument overload is used by the Growth Loop client.
+
+alter table public.learning_point_ledger
+  add column if not exists occurred_on date not null default current_date;
+
+create index if not exists learning_point_ledger_profile_occurred_idx
+  on public.learning_point_ledger (profile_id, occurred_on desc);
+
+create or replace function public.learning_record_points(
+  p_profile_id uuid,
+  p_point_item_id uuid,
+  p_delta integer,
+  p_request_id uuid,
+  p_entry_type text,
+  p_note text,
+  p_occurred_on date
+)
+returns setof public.learning_point_ledger
+language plpgsql
+security definer
+set search_path = ''
+as $function$
+declare
+  actor_id uuid := (select auth.uid());
+  profile_household_id uuid;
+  item_name text;
+  existing_row public.learning_point_ledger%rowtype;
+  saved_row public.learning_point_ledger%rowtype;
+begin
+  if actor_id is null then
+    raise exception 'learning_auth_required' using errcode = '42501';
+  end if;
+
+  if p_request_id is null then
+    raise exception 'learning_request_id_required' using errcode = '22023';
+  end if;
+
+  if p_occurred_on is null then
+    raise exception 'learning_point_date_required' using errcode = '22023';
+  end if;
+
+  if p_delta is null or p_delta = 0 or p_delta not between -1000 and 1000 then
+    raise exception 'learning_point_delta_invalid' using errcode = '22023';
+  end if;
+
+  if p_entry_type is null
+     or p_entry_type not in ('manual', 'adjustment', 'initial_balance', 'redemption', 'refund') then
+    raise exception 'learning_point_entry_type_invalid' using errcode = '22023';
+  end if;
+
+  if p_note is not null and char_length(p_note) > 200 then
+    raise exception 'learning_point_note_too_long' using errcode = '22001';
+  end if;
+
+  select profile.household_id
+  into profile_household_id
+  from public.learning_profiles profile
+  join public.learning_household_members member
+    on member.household_id = profile.household_id
+  where profile.id = p_profile_id
+    and member.user_id = actor_id
+    and member.role in ('owner', 'guardian');
+
+  if not found then
+    raise exception 'learning_point_forbidden' using errcode = '42501';
+  end if;
+
+  select *
+  into existing_row
+  from public.learning_point_ledger ledger
+  where ledger.profile_id = p_profile_id
+    and ledger.request_id = p_request_id;
+
+  if found then
+    if existing_row.point_item_id is not distinct from p_point_item_id
+       and existing_row.delta = p_delta
+       and existing_row.entry_type = p_entry_type
+       and existing_row.note is not distinct from p_note
+       and existing_row.occurred_on = p_occurred_on then
+      return next existing_row;
+      return;
+    end if;
+    raise exception 'learning_request_reuse_conflict' using errcode = 'P0001';
+  end if;
+
+  if p_point_item_id is not null then
+    select item.name
+    into item_name
+    from public.learning_point_items item
+    join public.learning_profile_point_items assignment
+      on assignment.point_item_id = item.id
+     and assignment.household_id = item.household_id
+    where item.id = p_point_item_id
+      and item.household_id = profile_household_id
+      and item.is_active
+      and assignment.profile_id = p_profile_id
+      and assignment.enabled;
+
+    if not found then
+      raise exception 'learning_point_item_unavailable' using errcode = '42501';
+    end if;
+  else
+    if p_entry_type not in ('adjustment', 'initial_balance', 'redemption', 'refund') then
+      raise exception 'learning_point_item_required' using errcode = '22023';
+    end if;
+    item_name := p_entry_type;
+  end if;
+
+  insert into public.learning_point_ledger (
+    household_id,
+    profile_id,
+    point_item_id,
+    delta,
+    entry_type,
+    item_name_snapshot,
+    note,
+    request_id,
+    occurred_on,
+    actor_user_id
+  )
+  values (
+    profile_household_id,
+    p_profile_id,
+    p_point_item_id,
+    p_delta,
+    p_entry_type,
+    item_name,
+    p_note,
+    p_request_id,
+    p_occurred_on,
+    actor_id
+  )
+  returning * into saved_row;
+
+  return next saved_row;
+end;
+$function$;
+
+revoke all on function public.learning_record_points(uuid, uuid, integer, uuid, text, text, date) from public;
+revoke all on function public.learning_record_points(uuid, uuid, integer, uuid, text, text, date) from anon;
+grant execute on function public.learning_record_points(uuid, uuid, integer, uuid, text, text, date)
+  to authenticated;
diff --git a/supabase/migrations/20260814101235_growth_loop_activity_event_indexes.sql b/supabase/migrations/20260814101235_growth_loop_activity_event_indexes.sql
new file mode 100644
index 0000000..cb2c99d
--- /dev/null
+++ b/supabase/migrations/20260814101235_growth_loop_activity_event_indexes.sql
@@ -0,0 +1,7 @@
+-- Cover the two foreign-key lookups used by guardian-scoped diagnostics and
+-- the profile-level export/retention queries.
+create index if not exists learning_activity_events_actor_idx
+  on private.learning_activity_events (actor_user_id);
+
+create index if not exists learning_activity_events_profile_scope_idx
+  on private.learning_activity_events (profile_id, household_id, occurred_at desc);
diff --git a/supabase/migrations/20260814101420_growth_loop_point_rpc_compatibility.sql b/supabase/migrations/20260814101420_growth_loop_point_rpc_compatibility.sql
new file mode 100644
index 0000000..bf95f57
--- /dev/null
+++ b/supabase/migrations/20260814101420_growth_loop_point_rpc_compatibility.sql
@@ -0,0 +1,140 @@
+-- Keep the original six-argument points RPC unambiguous for existing clients.
+-- The date-aware overload is intentionally seven arguments with no defaults;
+-- old calls must continue resolving to the original function.
+
+drop function if exists public.learning_record_points(uuid, uuid, integer, uuid, text, text, date);
+
+create function public.learning_record_points(
+  p_profile_id uuid,
+  p_point_item_id uuid,
+  p_delta integer,
+  p_request_id uuid,
+  p_entry_type text,
+  p_note text,
+  p_occurred_on date
+)
+returns setof public.learning_point_ledger
+language plpgsql
+security definer
+set search_path = ''
+as $function$
+declare
+  actor_id uuid := (select auth.uid());
+  profile_household_id uuid;
+  item_name text;
+  existing_row public.learning_point_ledger%rowtype;
+  saved_row public.learning_point_ledger%rowtype;
+begin
+  if actor_id is null then
+    raise exception 'learning_auth_required' using errcode = '42501';
+  end if;
+
+  if p_request_id is null then
+    raise exception 'learning_request_id_required' using errcode = '22023';
+  end if;
+
+  if p_occurred_on is null then
+    raise exception 'learning_point_date_required' using errcode = '22023';
+  end if;
+
+  if p_delta is null or p_delta = 0 or p_delta not between -1000 and 1000 then
+    raise exception 'learning_point_delta_invalid' using errcode = '22023';
+  end if;
+
+  if p_entry_type is null
+     or p_entry_type not in ('manual', 'adjustment', 'initial_balance', 'redemption', 'refund') then
+    raise exception 'learning_point_entry_type_invalid' using errcode = '22023';
+  end if;
+
+  if p_note is not null and char_length(p_note) > 200 then
+    raise exception 'learning_point_note_too_long' using errcode = '22001';
+  end if;
+
+  select profile.household_id
+  into profile_household_id
+  from public.learning_profiles profile
+  join public.learning_household_members member
+    on member.household_id = profile.household_id
+  where profile.id = p_profile_id
+    and member.user_id = actor_id
+    and member.role in ('owner', 'guardian');
+
+  if not found then
+    raise exception 'learning_point_forbidden' using errcode = '42501';
+  end if;
+
+  select *
+  into existing_row
+  from public.learning_point_ledger ledger
+  where ledger.profile_id = p_profile_id
+    and ledger.request_id = p_request_id;
+
+  if found then
+    if existing_row.point_item_id is not distinct from p_point_item_id
+       and existing_row.delta = p_delta
+       and existing_row.entry_type = p_entry_type
+       and existing_row.note is not distinct from p_note
+       and existing_row.occurred_on = p_occurred_on then
+      return next existing_row;
+      return;
+    end if;
+    raise exception 'learning_request_reuse_conflict' using errcode = 'P0001';
+  end if;
+
+  if p_point_item_id is not null then
+    select item.name
+    into item_name
+    from public.learning_point_items item
+    join public.learning_profile_point_items assignment
+      on assignment.point_item_id = item.id
+     and assignment.household_id = item.household_id
+    where item.id = p_point_item_id
+      and item.household_id = profile_household_id
+      and item.is_active
+      and assignment.profile_id = p_profile_id
+      and assignment.enabled;
+
+    if not found then
+      raise exception 'learning_point_item_unavailable' using errcode = '42501';
+    end if;
+  else
+    if p_entry_type not in ('adjustment', 'initial_balance', 'redemption', 'refund') then
+      raise exception 'learning_point_item_required' using errcode = '22023';
+    end if;
+    item_name := p_entry_type;
+  end if;
+
+  insert into public.learning_point_ledger (
+    household_id,
+    profile_id,
+    point_item_id,
+    delta,
+    entry_type,
+    item_name_snapshot,
+    note,
+    request_id,
+    occurred_on,
+    actor_user_id
+  )
+  values (
+    profile_household_id,
+    p_profile_id,
+    p_point_item_id,
+    p_delta,
+    p_entry_type,
+    item_name,
+    p_note,
+    p_request_id,
+    p_occurred_on,
+    actor_id
+  )
+  returning * into saved_row;
+
+  return next saved_row;
+end;
+$function$;
+
+revoke all on function public.learning_record_points(uuid, uuid, integer, uuid, text, text, date) from public;
+revoke all on function public.learning_record_points(uuid, uuid, integer, uuid, text, text, date) from anon;
+grant execute on function public.learning_record_points(uuid, uuid, integer, uuid, text, text, date)
+  to authenticated;
diff --git a/supabase/tests/growth_loop_activity_events_test.sql b/supabase/tests/growth_loop_activity_events_test.sql
new file mode 100644
index 0000000..f01d444
--- /dev/null
+++ b/supabase/tests/growth_loop_activity_events_test.sql
@@ -0,0 +1,217 @@
+begin;
+select plan(16);
+
+select is(
+  to_regclass('private.learning_activity_events')::text,
+  'private.learning_activity_events',
+  'private activity event table exists'
+);
+
+select is(
+  (select count(*)
+   from information_schema.columns
+   where table_schema = 'private'
+     and table_name = 'learning_activity_events'
+     and column_name in (
+       'event_id', 'product_id', 'event_type', 'household_id', 'profile_id',
+       'occurred_at', 'timezone', 'client_version', 'payload', 'payload_hash',
+       'actor_user_id', 'received_at'
+     )),
+  12::bigint,
+  'activity events store only the bounded diagnostic contract'
+);
+
+select ok(
+  (select relrowsecurity from pg_class where oid = to_regclass('private.learning_activity_events')),
+  'activity event table has RLS enabled'
+);
+
+select ok(
+  coalesce((select not has_table_privilege('authenticated', 'private.learning_activity_events', 'select,insert,update,delete')), false),
+  'authenticated users cannot read or write the private event table directly'
+);
+
+select ok(
+  exists (
+    select 1
+    from pg_proc function
+    join pg_namespace namespace on namespace.oid = function.pronamespace
+    where namespace.nspname = 'public'
+      and function.proname = 'learning_record_activity_event'
+      and function.pronargs = 1
+  ),
+  'activity event RPC exists'
+);
+
+select ok(
+  has_function_privilege('authenticated', 'public.learning_record_activity_event(jsonb)', 'execute'),
+  'authenticated users can call the activity event RPC'
+);
+
+select ok(
+  not has_function_privilege('anon', 'public.learning_record_activity_event(jsonb)', 'execute'),
+  'anonymous users cannot call the activity event RPC'
+);
+
+set local role postgres;
+
+insert into auth.users (id, email, encrypted_password, raw_user_meta_data)
+values
+  ('77777777-7777-4777-8777-777777777777', 'activity-owner@example.test', '$2a$10$test-password-hash', '{}'::jsonb),
+  ('88888888-8888-4888-8888-888888888888', 'activity-other@example.test', '$2a$10$test-password-hash', '{}'::jsonb);
+
+insert into public.learning_households (id, name, owner_user_id)
+values (
+  '77777777-aaaa-4777-8777-777777777777',
+  '统计测试家庭',
+  '77777777-7777-4777-8777-777777777777'
+);
+
+insert into public.learning_household_members (household_id, user_id, role)
+values (
+  '77777777-aaaa-4777-8777-777777777777',
+  '77777777-7777-4777-8777-777777777777',
+  'owner'
+);
+
+insert into public.learning_profiles (id, household_id, display_name, grade_level)
+values (
+  '77777777-bbbb-4777-8777-777777777777',
+  '77777777-aaaa-4777-8777-777777777777',
+  '统计孩子',
+  4
+);
+
+set local role authenticated;
+set local request.jwt.claim.sub = '77777777-7777-4777-8777-777777777777';
+
+select lives_ok(
+  $$select * from public.learning_record_activity_event(jsonb_build_object(
+    'event_id', '77777777-cccc-4777-8777-777777777777',
+    'product_id', 'shadow-mate',
+    'event_type', 'core_activation',
+    'household_id', '77777777-aaaa-4777-8777-777777777777',
+    'profile_id', '77777777-bbbb-4777-8777-777777777777',
+    'occurred_at', '2026-08-14T10:00:00Z',
+    'timezone', 'Asia/Singapore',
+    'client_version', '1.3.7',
+    'payload', jsonb_build_object('source', 'point_item')
+  ))$$,
+  'guardian can record an allowlisted activity event'
+);
+
+set local role postgres;
+
+select is(
+  (select count(*) from private.learning_activity_events
+   where event_id = '77777777-cccc-4777-8777-777777777777'),
+  1::bigint,
+  'valid activity event is stored once in the private table'
+);
+
+set local role authenticated;
+set local request.jwt.claim.sub = '77777777-7777-4777-8777-777777777777';
+
+select is(
+  (select status from public.learning_record_activity_event(jsonb_build_object(
+    'event_id', '77777777-cccc-4777-8777-777777777777',
+    'product_id', 'shadow-mate',
+    'event_type', 'core_activation',
+    'household_id', '77777777-aaaa-4777-8777-777777777777',
+    'profile_id', '77777777-bbbb-4777-8777-777777777777',
+    'occurred_at', '2026-08-14T10:00:00Z',
+    'timezone', 'Asia/Singapore',
+    'client_version', '1.3.7',
+    'payload', jsonb_build_object('source', 'point_item')
+  ))),
+  'duplicate',
+  'same activity event is idempotent'
+);
+
+select throws_ok(
+  $$select * from public.learning_record_activity_event(jsonb_build_object(
+    'event_id', '77777777-cccc-4777-8777-777777777777',
+    'product_id', 'shadow-mate',
+    'event_type', 'core_activation',
+    'household_id', '77777777-aaaa-4777-8777-777777777777',
+    'profile_id', '77777777-bbbb-4777-8777-777777777777',
+    'occurred_at', '2026-08-14T10:00:00Z',
+    'payload', jsonb_build_object('source', 'different')
+  ))$$,
+  'P0001',
+  'activity_event_idempotency_conflict',
+  'same event id with a different payload is rejected'
+);
+
+select throws_ok(
+  $$select * from public.learning_record_activity_event(jsonb_build_object(
+    'event_id', '77777777-dddd-4777-8777-777777777777',
+    'product_id', 'shadow-mate',
+    'event_type', 'page_view',
+    'household_id', '77777777-aaaa-4777-8777-777777777777',
+    'profile_id', '77777777-bbbb-4777-8777-777777777777',
+    'occurred_at', '2026-08-14T10:00:00Z',
+    'payload', '{}'::jsonb
+  ))$$,
+  '22023',
+  'activity_event_invalid',
+  'non-allowlisted event types are rejected'
+);
+
+select throws_ok(
+  $$select * from public.learning_record_activity_event(jsonb_build_object(
+    'event_id', '77777777-eeee-4777-8777-777777777777',
+    'product_id', 'shadow-mate',
+    'event_type', 'sync_failed',
+    'household_id', '77777777-aaaa-4777-8777-777777777777',
+    'profile_id', '77777777-bbbb-4777-8777-777777777777',
+    'occurred_at', '2026-08-14T10:00:00Z',
+    'payload', jsonb_build_object('child_name', '不应上传')
+  ))$$,
+  '22023',
+  'activity_event_payload_invalid',
+  'payload keys outside the diagnostic allowlist are rejected'
+);
+
+select throws_ok(
+  $$select * from public.learning_record_activity_event(jsonb_build_object(
+    'event_id', '77777777-ffff-4777-8777-777777777777',
+    'product_id', 'shadow-mate',
+    'event_type', 'sync_failed',
+    'household_id', '77777777-aaaa-4777-8777-777777777777',
+    'profile_id', '77777777-bbbb-4777-8777-777777777777',
+    'occurred_at', '2026-08-14T10:00:00Z',
+    'payload', jsonb_build_object('error_code', repeat('x', 5000))
+  ))$$,
+  '22023',
+  'activity_event_invalid',
+  'oversized diagnostic payloads are rejected'
+);
+
+set local request.jwt.claim.sub = '88888888-8888-4888-8888-888888888888';
+
+select throws_ok(
+  $$select * from public.learning_record_activity_event(jsonb_build_object(
+    'event_id', '88888888-cccc-4888-8888-888888888888',
+    'product_id', 'shadow-mate',
+    'event_type', 'core_activation',
+    'household_id', '77777777-aaaa-4777-8777-777777777777',
+    'profile_id', '77777777-bbbb-4777-8777-777777777777',
+    'occurred_at', '2026-08-14T10:00:00Z',
+    'payload', '{}'::jsonb
+  ))$$,
+  '42501',
+  'learning_point_forbidden',
+  'a user outside the household cannot record its events'
+);
+
+set local role postgres;
+
+select is(
+  (select count(*) from private.learning_activity_events),
+  1::bigint,
+  'rejected and duplicate requests do not create extra activity rows'
+);
+
+select * from finish();
+rollback;
diff --git a/supabase/tests/growth_loop_point_dates_test.sql b/supabase/tests/growth_loop_point_dates_test.sql
new file mode 100644
index 0000000..4daa083
--- /dev/null
+++ b/supabase/tests/growth_loop_point_dates_test.sql
@@ -0,0 +1,106 @@
+begin;
+select plan(8);
+
+select is(
+  (select count(*)
+   from information_schema.columns
+   where table_schema = 'public'
+     and table_name = 'learning_point_ledger'
+     and column_name = 'occurred_on'),
+  1::bigint,
+  'point ledger preserves the local calendar date'
+);
+
+select ok(
+  exists (
+    select 1
+    from pg_proc function
+    join pg_namespace namespace on namespace.oid = function.pronamespace
+    where namespace.nspname = 'public'
+      and function.proname = 'learning_record_points'
+      and function.pronargs = 7
+  ),
+  'record points RPC exposes the date-aware overload'
+);
+
+select ok(
+  has_function_privilege(
+    'authenticated',
+    'public.learning_record_points(uuid,uuid,integer,uuid,text,text,date)',
+    'execute'
+  ),
+  'authenticated users can call the date-aware RPC'
+);
+
+select ok(
+  not has_function_privilege(
+    'anon',
+    'public.learning_record_points(uuid,uuid,integer,uuid,text,text,date)',
+    'execute'
+  ),
+  'anonymous users cannot call the date-aware RPC'
+);
+
+set local role postgres;
+
+insert into auth.users (id, email, encrypted_password, raw_user_meta_data)
+values ('55555555-5555-4555-8555-555555555555', 'point-date-owner@example.test', '$2a$10$test-password-hash', '{}'::jsonb);
+
+insert into public.learning_households (id, name, owner_user_id)
+values ('cccccccc-cccc-4ccc-8ccc-cccccccccccc', '日期测试家庭', '55555555-5555-4555-8555-555555555555');
+
+insert into public.learning_household_members (household_id, user_id, role)
+values ('cccccccc-cccc-4ccc-8ccc-cccccccccccc', '55555555-5555-4555-8555-555555555555', 'owner');
+
+insert into public.learning_profiles (id, household_id, display_name, grade_level)
+values ('cccccccc-dddd-4ccc-8ccc-cccccccccccc', 'cccccccc-cccc-4ccc-8ccc-cccccccccccc', '日期孩子', 4);
+
+insert into public.learning_point_items (id, household_id, name, default_points, item_kind, category)
+values ('cccccccc-eeee-4ccc-8ccc-cccccccccccc', 'cccccccc-cccc-4ccc-8ccc-cccccccccccc', '日期积分', 2, 'custom', 'growth');
+
+insert into public.learning_profile_point_items (household_id, profile_id, point_item_id)
+values ('cccccccc-cccc-4ccc-8ccc-cccccccccccc', 'cccccccc-dddd-4ccc-8ccc-cccccccccccc', 'cccccccc-eeee-4ccc-8ccc-cccccccccccc');
+
+set local role authenticated;
+set local request.jwt.claim.sub = '55555555-5555-4555-8555-555555555555';
+
+select lives_ok(
+  $$select * from public.learning_record_points(
+    'cccccccc-dddd-4ccc-8ccc-cccccccccccc',
+    'cccccccc-eeee-4ccc-8ccc-cccccccccccc',
+    2,
+    'cccccccc-ffff-4ccc-8ccc-cccccccccccc',
+    'manual',
+    '补记日期',
+    '2026-08-03'
+  )$$,
+  'date-aware RPC records a point event'
+);
+
+select is(
+  (select occurred_on from public.learning_point_ledger where request_id = 'cccccccc-ffff-4ccc-8ccc-cccccccccccc'),
+  date '2026-08-03',
+  'point event keeps the selected date'
+);
+
+select lives_ok(
+  $$select * from public.learning_record_points(
+    'cccccccc-dddd-4ccc-8ccc-cccccccccccc',
+    'cccccccc-eeee-4ccc-8ccc-cccccccccccc',
+    2,
+    'cccccccc-ffff-4ccc-8ccc-cccccccccccc',
+    'manual',
+    '补记日期',
+    '2026-08-03'
+  )$$,
+  'date-aware RPC remains idempotent'
+);
+
+select is(
+  (select count(*) from public.learning_point_ledger where profile_id = 'cccccccc-dddd-4ccc-8ccc-cccccccccccc'),
+  1::bigint,
+  'repeating the dated request does not duplicate history'
+);
+
+select * from finish();
+rollback;
diff --git a/supabase/tests/growth_loop_points_test.sql b/supabase/tests/growth_loop_points_test.sql
new file mode 100644
index 0000000..3c2cc9f
--- /dev/null
+++ b/supabase/tests/growth_loop_points_test.sql
@@ -0,0 +1,363 @@
+begin;
+select plan(30);
+
+select is(
+  to_regclass('public.learning_point_items')::text,
+  'learning_point_items',
+  'point item table exists'
+);
+
+select is(
+  to_regclass('public.learning_profile_point_items')::text,
+  'learning_profile_point_items',
+  'profile point item table exists'
+);
+
+select is(
+  to_regclass('public.learning_point_ledger')::text,
+  'learning_point_ledger',
+  'point ledger table exists'
+);
+
+select is(
+  (select count(*)
+   from information_schema.columns
+   where table_schema = 'public'
+     and table_name = 'learning_point_items'
+     and column_name in ('household_id', 'name', 'default_points', 'is_active')),
+  4::bigint,
+  'point items expose household, label, default points, and active state'
+);
+
+select is(
+  (select count(*)
+   from information_schema.columns
+   where table_schema = 'public'
+     and table_name = 'learning_profile_point_items'
+     and column_name in ('household_id', 'profile_id', 'point_item_id', 'points_override', 'enabled')),
+  5::bigint,
+  'profile point item config exposes household, child, item, override, and enabled state'
+);
+
+select is(
+  (select count(*)
+   from information_schema.columns
+   where table_schema = 'public'
+     and table_name = 'learning_point_ledger'
+     and column_name in ('household_id', 'profile_id', 'point_item_id', 'delta', 'request_id', 'entry_type', 'actor_user_id')),
+  7::bigint,
+  'ledger exposes scope, source item, signed delta, idempotency, entry type, and actor'
+);
+
+select ok(
+  (select count(*) = 3
+   from pg_class
+   where oid in (
+     to_regclass('public.learning_point_items'),
+     to_regclass('public.learning_profile_point_items'),
+     to_regclass('public.learning_point_ledger')
+   )
+   and relrowsecurity),
+  'RLS is enabled on all point tables'
+);
+
+select ok(
+  exists (
+    select 1
+    from pg_constraint
+    where conrelid = to_regclass('public.learning_point_ledger')
+      and contype = 'u'
+      and pg_get_constraintdef(oid) like '%profile_id%request_id%'
+  ),
+  'ledger has a per-child request idempotency constraint'
+);
+
+select ok(
+  exists (
+    select 1
+      from pg_proc function
+      join pg_namespace namespace on namespace.oid = function.pronamespace
+      where namespace.nspname = 'public'
+        and function.proname = 'learning_record_points'
+        and function.pronargs = 6
+  ),
+  'record points RPC has the stable request contract'
+);
+
+select ok(
+  coalesce((
+    select has_function_privilege(
+      'authenticated',
+      'public.learning_record_points(uuid,uuid,integer,uuid,text,text)',
+      'execute'
+    )
+    where exists (
+      select 1
+      from pg_proc function
+      join pg_namespace namespace on namespace.oid = function.pronamespace
+      where namespace.nspname = 'public'
+        and function.proname = 'learning_record_points'
+    )
+  ), false),
+  'authenticated users can call the record points RPC'
+);
+
+select ok(
+  coalesce((
+    select not has_function_privilege(
+      'anon',
+      'public.learning_record_points(uuid,uuid,integer,uuid,text,text)',
+      'execute'
+    )
+    where exists (
+      select 1
+      from pg_proc function
+      join pg_namespace namespace on namespace.oid = function.pronamespace
+      where namespace.nspname = 'public'
+        and function.proname = 'learning_record_points'
+    )
+  ), false),
+  'anonymous users cannot call the record points RPC'
+);
+
+select ok(
+  coalesce((
+    select not has_table_privilege('authenticated', 'public.learning_point_ledger', 'update,delete')
+    where to_regclass('public.learning_point_ledger') is not null
+  ), false),
+  'authenticated users cannot mutate or delete immutable ledger rows directly'
+);
+
+set local role postgres;
+
+insert into auth.users (id, email, encrypted_password, raw_user_meta_data)
+values
+  ('33333333-3333-4333-8333-333333333333', 'points-owner@example.test', '$2a$10$test-password-hash', '{}'::jsonb),
+  ('44444444-4444-4444-8444-444444444444', 'points-other@example.test', '$2a$10$test-password-hash', '{}'::jsonb);
+
+insert into public.learning_households (id, name, owner_user_id)
+values (
+  'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb',
+  '积分测试家庭',
+  '33333333-3333-4333-8333-333333333333'
+);
+
+insert into public.learning_household_members (household_id, user_id, role)
+values (
+  'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb',
+  '33333333-3333-4333-8333-333333333333',
+  'owner'
+);
+
+insert into public.learning_profiles (id, household_id, display_name, grade_level)
+values (
+  'bbbbbbbb-dddd-4bbb-8bbb-bbbbbbbbbbbb',
+  'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb',
+  '积分孩子',
+  4
+);
+
+set local role authenticated;
+set local request.jwt.claim.sub = '33333333-3333-4333-8333-333333333333';
+
+select lives_ok(
+  $$insert into public.learning_point_items (
+      id, household_id, name, default_points, item_kind, category
+    ) values (
+      'bbbbbbbb-cccc-4bbb-8bbb-bbbbbbbbbbbb',
+      'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb',
+      '整理玩具',
+      3,
+      'custom',
+      'growth'
+    )$$,
+  'guardian can create a household point item'
+);
+
+select lives_ok(
+  $$insert into public.learning_profile_point_items (
+      household_id, profile_id, point_item_id, points_override
+    ) values (
+      'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb',
+      'bbbbbbbb-dddd-4bbb-8bbb-bbbbbbbbbbbb',
+      'bbbbbbbb-cccc-4bbb-8bbb-bbbbbbbbbbbb',
+      4
+    )$$,
+  'guardian can assign the point item to one child with an override'
+);
+
+select is(
+  (select points_override
+   from public.learning_profile_point_items
+   where profile_id = 'bbbbbbbb-dddd-4bbb-8bbb-bbbbbbbbbbbb'
+     and point_item_id = 'bbbbbbbb-cccc-4bbb-8bbb-bbbbbbbbbbbb'),
+  4,
+  'child-specific point override is stored separately from household default'
+);
+
+select is(
+  (select count(*)
+   from public.learning_record_points(
+     'bbbbbbbb-dddd-4bbb-8bbb-bbbbbbbbbbbb',
+     'bbbbbbbb-cccc-4bbb-8bbb-bbbbbbbbbbbb',
+     4,
+     'bbbbbbbb-eeee-4bbb-8bbb-bbbbbbbbbbbb',
+     'manual',
+     '完成整理玩具'
+   )),
+  1::bigint,
+  'guardian can record one point event through the RPC'
+);
+
+select is(
+  (select item_name_snapshot
+   from public.learning_point_ledger
+   where request_id = 'bbbbbbbb-eeee-4bbb-8bbb-bbbbbbbbbbbb'),
+  '整理玩具',
+  'ledger stores the item label snapshot'
+);
+
+select is(
+  (select count(*)
+   from public.learning_record_points(
+     'bbbbbbbb-dddd-4bbb-8bbb-bbbbbbbbbbbb',
+     'bbbbbbbb-cccc-4bbb-8bbb-bbbbbbbbbbbb',
+     4,
+     'bbbbbbbb-eeee-4bbb-8bbb-bbbbbbbbbbbb',
+     'manual',
+     '完成整理玩具'
+   )),
+  1::bigint,
+  'repeating the same request returns the original row'
+);
+
+select is(
+  (select count(*)
+   from public.learning_point_ledger
+   where profile_id = 'bbbbbbbb-dddd-4bbb-8bbb-bbbbbbbbbbbb'),
+  1::bigint,
+  'repeating a request does not duplicate the ledger'
+);
+
+select throws_ok(
+  $$select * from public.learning_record_points(
+    'bbbbbbbb-dddd-4bbb-8bbb-bbbbbbbbbbbb',
+    'bbbbbbbb-cccc-4bbb-8bbb-bbbbbbbbbbbb',
+    5,
+    'bbbbbbbb-eeee-4bbb-8bbb-bbbbbbbbbbbb',
+    'manual',
+    '复用请求号'
+  )$$,
+  'P0001',
+  'learning_request_reuse_conflict',
+  'reusing a request id with different values is rejected'
+);
+
+select lives_ok(
+  $$select * from public.learning_record_points(
+    'bbbbbbbb-dddd-4bbb-8bbb-bbbbbbbbbbbb',
+    null,
+    -2,
+    'bbbbbbbb-ffff-4bbb-8bbb-bbbbbbbbbbbb',
+    'adjustment',
+    '家长修正'
+  )$$,
+  'guardian can record a separate signed adjustment without an item'
+);
+
+select throws_ok(
+  $$select * from public.learning_record_points(
+    'bbbbbbbb-dddd-4bbb-8bbb-bbbbbbbbbbbb',
+    null,
+    2,
+    'bbbbbbbb-1111-4bbb-8bbb-bbbbbbbbbbbb',
+    'manual',
+    '缺少积分项'
+  )$$,
+  '22023',
+  'learning_point_item_required',
+  'manual events require a configured point item'
+);
+
+select throws_ok(
+  $$insert into public.learning_point_ledger (
+      household_id, profile_id, delta, entry_type, item_name_snapshot, request_id
+    ) values (
+      'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb',
+      'bbbbbbbb-dddd-4bbb-8bbb-bbbbbbbbbbbb',
+      1,
+      'manual',
+      '越过 RPC',
+      'bbbbbbbb-2222-4bbb-8bbb-bbbbbbbbbbbb'
+    )$$,
+  '42501',
+  null,
+  'authenticated users cannot insert ledger rows directly'
+);
+
+select throws_ok(
+  $$update public.learning_point_ledger
+    set delta = 99
+    where request_id = 'bbbbbbbb-eeee-4bbb-8bbb-bbbbbbbbbbbb'$$,
+  '42501',
+  null,
+  'authenticated users cannot update ledger rows directly'
+);
+
+select throws_ok(
+  $$delete from public.learning_point_ledger
+    where request_id = 'bbbbbbbb-eeee-4bbb-8bbb-bbbbbbbbbbbb'$$,
+  '42501',
+  null,
+  'authenticated users cannot delete ledger rows directly'
+);
+
+set local request.jwt.claim.sub = '44444444-4444-4444-8444-444444444444';
+
+select is(
+  (select count(*) from public.learning_point_items),
+  0::bigint,
+  'another user cannot read point items from the first household'
+);
+
+select is(
+  (select count(*) from public.learning_profile_point_items),
+  0::bigint,
+  'another user cannot read child point assignments from the first household'
+);
+
+select is(
+  (select count(*) from public.learning_point_ledger),
+  0::bigint,
+  'another user cannot read the first household ledger'
+);
+
+select throws_ok(
+  $$select * from public.learning_record_points(
+    'bbbbbbbb-dddd-4bbb-8bbb-bbbbbbbbbbbb',
+    'bbbbbbbb-cccc-4bbb-8bbb-bbbbbbbbbbbb',
+    4,
+    'bbbbbbbb-3333-4bbb-8bbb-bbbbbbbbbbbb',
+    'manual',
+    '越权记分'
+  )$$,
+  '42501',
+  'learning_point_forbidden',
+  'another user cannot record points for the first household'
+);
+
+select throws_ok(
+  $$insert into public.learning_point_items (
+      household_id, name, default_points
+    ) values (
+      'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb',
+      '越权项目',
+      1
+    )$$,
+  '42501',
+  null,
+  'another user cannot create a point item in the first household'
+);
+
+select * from finish();
+rollback;
diff --git a/supabase/tests/growth_loop_rewards_schema_test.sql b/supabase/tests/growth_loop_rewards_schema_test.sql
new file mode 100644
index 0000000..0ea1aa1
--- /dev/null
+++ b/supabase/tests/growth_loop_rewards_schema_test.sql
@@ -0,0 +1,169 @@
+begin;
+select plan(15);
+
+select is(
+  to_regclass('public.learning_rewards')::text,
+  'learning_rewards',
+  'reward table exists'
+);
+
+select is(
+  to_regclass('public.learning_profile_rewards')::text,
+  'learning_profile_rewards',
+  'profile reward table exists'
+);
+
+select is(
+  to_regclass('public.learning_redemptions')::text,
+  'learning_redemptions',
+  'redemption table exists'
+);
+
+select is(
+  (select count(*)
+   from information_schema.columns
+   where table_schema = 'public'
+     and table_name = 'learning_point_ledger'
+     and column_name = 'redemption_id'),
+  1::bigint,
+  'point ledger can link redemption and refund entries'
+);
+
+select is(
+  (select count(*)
+   from information_schema.columns
+   where table_schema = 'public'
+     and table_name = 'learning_rewards'
+     and column_name in ('household_id', 'name', 'cost_points', 'is_active')),
+  4::bigint,
+  'rewards expose household, label, cost, and active state'
+);
+
+select is(
+  (select count(*)
+   from information_schema.columns
+   where table_schema = 'public'
+     and table_name = 'learning_profile_rewards'
+     and column_name in ('household_id', 'profile_id', 'reward_id', 'cost_override', 'enabled')),
+  5::bigint,
+  'profile reward config exposes scope, reward, override, and enabled state'
+);
+
+select is(
+  (select count(*)
+   from information_schema.columns
+   where table_schema = 'public'
+     and table_name = 'learning_redemptions'
+     and column_name in (
+       'household_id', 'profile_id', 'reward_id', 'reward_name_snapshot',
+       'cost_points_snapshot', 'status', 'request_id', 'actor_user_id'
+     )),
+  8::bigint,
+  'redemptions preserve scope, reward and cost snapshots, status, and idempotency actor'
+);
+
+select ok(
+  (select count(*) = 3
+   from pg_class
+   where oid in (
+     to_regclass('public.learning_rewards'),
+     to_regclass('public.learning_profile_rewards'),
+     to_regclass('public.learning_redemptions')
+   )
+   and relrowsecurity),
+  'RLS is enabled on all reward tables'
+);
+
+select ok(
+  exists (
+    select 1
+    from pg_constraint
+    where conrelid = to_regclass('public.learning_redemptions')
+      and contype = 'u'
+      and pg_get_constraintdef(oid) like '%profile_id%request_id%'
+  ),
+  'redemptions have a per-child request idempotency constraint'
+);
+
+select ok(
+  exists (
+    select 1
+    from pg_proc function
+    join pg_namespace namespace on namespace.oid = function.pronamespace
+    where namespace.nspname = 'public'
+      and function.proname = 'learning_redeem_reward'
+      and function.pronargs = 3
+  ),
+  'redeem reward RPC has child, reward, and request arguments'
+);
+
+select ok(
+  exists (
+    select 1
+    from pg_proc function
+    join pg_namespace namespace on namespace.oid = function.pronamespace
+    where namespace.nspname = 'public'
+      and function.proname = 'learning_fulfill_redemption'
+      and function.pronargs = 1
+  ),
+  'fulfill redemption RPC has one redemption argument'
+);
+
+select ok(
+  exists (
+    select 1
+    from pg_proc function
+    join pg_namespace namespace on namespace.oid = function.pronamespace
+    where namespace.nspname = 'public'
+      and function.proname = 'learning_cancel_redemption'
+      and function.pronargs = 3
+  ),
+  'cancel redemption RPC has redemption, request, and note arguments'
+);
+
+select ok(
+  coalesce((
+    select has_function_privilege(
+      'authenticated',
+      'public.learning_redeem_reward(uuid,uuid,uuid)',
+      'execute'
+    )
+    where exists (
+      select 1 from pg_proc function
+      join pg_namespace namespace on namespace.oid = function.pronamespace
+      where namespace.nspname = 'public'
+        and function.proname = 'learning_redeem_reward'
+        and function.pronargs = 3
+    )
+  ), false),
+  'authenticated users can call the redeem reward RPC'
+);
+
+select ok(
+  coalesce((
+    select not has_function_privilege(
+      'anon',
+      'public.learning_redeem_reward(uuid,uuid,uuid)',
+      'execute'
+    )
+    where exists (
+      select 1 from pg_proc function
+      join pg_namespace namespace on namespace.oid = function.pronamespace
+      where namespace.nspname = 'public'
+        and function.proname = 'learning_redeem_reward'
+        and function.pronargs = 3
+    )
+  ), false),
+  'anonymous users cannot call the redeem reward RPC'
+);
+
+select ok(
+  coalesce((
+    select not has_table_privilege('authenticated', 'public.learning_redemptions', 'insert,update,delete')
+    where to_regclass('public.learning_redemptions') is not null
+  ), false),
+  'authenticated users cannot write redemption rows directly'
+);
+
+select * from finish();
+rollback;
diff --git a/supabase/tests/growth_loop_rewards_test.sql b/supabase/tests/growth_loop_rewards_test.sql
new file mode 100644
index 0000000..0a199a9
--- /dev/null
+++ b/supabase/tests/growth_loop_rewards_test.sql
@@ -0,0 +1,355 @@
+begin;
+select plan(32);
+
+set local role postgres;
+
+insert into auth.users (id, email, encrypted_password, raw_user_meta_data)
+values
+  ('55555555-5555-4555-8555-555555555555', 'rewards-owner@example.test', '$2a$10$test-password-hash', '{}'::jsonb),
+  ('66666666-6666-4666-8666-666666666666', 'rewards-other@example.test', '$2a$10$test-password-hash', '{}'::jsonb);
+
+insert into public.learning_households (id, name, owner_user_id)
+values (
+  'cccccccc-cccc-4ccc-8ccc-cccccccccccc',
+  '奖励测试家庭',
+  '55555555-5555-4555-8555-555555555555'
+);
+
+insert into public.learning_household_members (household_id, user_id, role)
+values (
+  'cccccccc-cccc-4ccc-8ccc-cccccccccccc',
+  '55555555-5555-4555-8555-555555555555',
+  'owner'
+);
+
+insert into public.learning_profiles (id, household_id, display_name, grade_level)
+values (
+  'cccccccc-dddd-4ccc-8ccc-cccccccccccc',
+  'cccccccc-cccc-4ccc-8ccc-cccccccccccc',
+  '奖励孩子',
+  4
+);
+
+set local role authenticated;
+set local request.jwt.claim.sub = '55555555-5555-4555-8555-555555555555';
+
+select lives_ok(
+  $$insert into public.learning_rewards (
+      id, household_id, name, cost_points, reward_kind, category
+    ) values (
+      'cccccccc-eeee-4ccc-8ccc-cccccccccccc',
+      'cccccccc-cccc-4ccc-8ccc-cccccccccccc',
+      '亲子绘本时间',
+      5,
+      'custom',
+      'activity'
+    )$$,
+  'guardian can create a household reward'
+);
+
+select lives_ok(
+  $$insert into public.learning_profile_rewards (
+      household_id, profile_id, reward_id, cost_override
+    ) values (
+      'cccccccc-cccc-4ccc-8ccc-cccccccccccc',
+      'cccccccc-dddd-4ccc-8ccc-cccccccccccc',
+      'cccccccc-eeee-4ccc-8ccc-cccccccccccc',
+      4
+    )$$,
+  'guardian can assign a reward to one child with a cost override'
+);
+
+select lives_ok(
+  $$select * from public.learning_record_points(
+    'cccccccc-dddd-4ccc-8ccc-cccccccccccc',
+    null,
+    6,
+    'cccccccc-3333-4ccc-8ccc-cccccccccccc',
+    'initial_balance',
+    '期初积分'
+  )$$,
+  'guardian can seed a separately auditable initial balance'
+);
+
+select is(
+  (select count(*)
+   from public.learning_redeem_reward(
+     'cccccccc-dddd-4ccc-8ccc-cccccccccccc',
+     'cccccccc-eeee-4ccc-8ccc-cccccccccccc',
+     'cccccccc-ffff-4ccc-8ccc-cccccccccccc'
+   )),
+  1::bigint,
+  'redeeming an enabled reward creates one redemption'
+);
+
+select is(
+  (select cost_points_snapshot
+   from public.learning_redemptions
+   where request_id = 'cccccccc-ffff-4ccc-8ccc-cccccccccccc'),
+  4,
+  'redemption stores the child-specific cost snapshot'
+);
+
+select is(
+  (select status
+   from public.learning_redemptions
+   where request_id = 'cccccccc-ffff-4ccc-8ccc-cccccccccccc'),
+  'pending',
+  'new redemption starts as pending fulfillment'
+);
+
+select is(
+  (select ledger.delta
+   from public.learning_point_ledger ledger
+   join public.learning_redemptions redemption on redemption.id = ledger.redemption_id
+   where redemption.request_id = 'cccccccc-ffff-4ccc-8ccc-cccccccccccc'
+     and ledger.entry_type = 'redemption'),
+  -4,
+  'redemption appends a signed debit ledger row'
+);
+
+select ok(
+  exists (
+    select 1
+    from public.learning_point_ledger ledger
+    join public.learning_redemptions redemption on redemption.id = ledger.redemption_id
+    where redemption.request_id = 'cccccccc-ffff-4ccc-8ccc-cccccccccccc'
+      and ledger.entry_type = 'redemption'
+  ),
+  'redemption debit is linked to its redemption id'
+);
+
+select is(
+  (select count(*)
+   from public.learning_redeem_reward(
+     'cccccccc-dddd-4ccc-8ccc-cccccccccccc',
+     'cccccccc-eeee-4ccc-8ccc-cccccccccccc',
+     'cccccccc-ffff-4ccc-8ccc-cccccccccccc'
+   )),
+  1::bigint,
+  'repeating redemption request returns the original redemption'
+);
+
+select is(
+  (select count(*) from public.learning_redemptions),
+  1::bigint,
+  'repeating redemption request does not create another redemption'
+);
+
+select is(
+  (select count(*)
+   from public.learning_cancel_redemption(
+     (select id from public.learning_redemptions where request_id = 'cccccccc-ffff-4ccc-8ccc-cccccccccccc'),
+     'cccccccc-1111-4ccc-8ccc-cccccccccccc',
+     '本次暂不兑现'
+   )),
+  1::bigint,
+  'guardian can cancel a pending redemption'
+);
+
+select is(
+  (select status
+   from public.learning_redemptions
+   where request_id = 'cccccccc-ffff-4ccc-8ccc-cccccccccccc'),
+  'cancelled',
+  'cancelled redemption records its terminal status'
+);
+
+select is(
+  (select delta
+   from public.learning_point_ledger ledger
+   where ledger.redemption_id = (
+       select id from public.learning_redemptions
+       where request_id = 'cccccccc-ffff-4ccc-8ccc-cccccccccccc'
+     )
+     and ledger.entry_type = 'refund'),
+  4,
+  'cancellation appends a compensating refund ledger row'
+);
+
+select is(
+  (select count(*)
+   from public.learning_point_ledger ledger
+   where ledger.redemption_id = (
+       select id from public.learning_redemptions
+       where request_id = 'cccccccc-ffff-4ccc-8ccc-cccccccccccc'
+     )
+     and ledger.entry_type = 'refund'),
+  1::bigint,
+  'cancellation creates one refund row'
+);
+
+select is(
+  (select count(*)
+   from public.learning_cancel_redemption(
+     (select id from public.learning_redemptions where request_id = 'cccccccc-ffff-4ccc-8ccc-cccccccccccc'),
+     'cccccccc-1111-4ccc-8ccc-cccccccccccc',
+     '重复取消'
+   )),
+  1::bigint,
+  'repeating cancellation request returns the original cancellation'
+);
+
+select is(
+  (select count(*)
+   from public.learning_redeem_reward(
+     'cccccccc-dddd-4ccc-8ccc-cccccccccccc',
+     'cccccccc-eeee-4ccc-8ccc-cccccccccccc',
+     'cccccccc-2222-4ccc-8ccc-cccccccccccc'
+   )),
+  1::bigint,
+  'refunded points can be redeemed again'
+);
+
+select is(
+  (select count(*)
+   from public.learning_fulfill_redemption(
+     (select id from public.learning_redemptions where request_id = 'cccccccc-2222-4ccc-8ccc-cccccccccccc')
+   )),
+  1::bigint,
+  'guardian can fulfill a pending redemption'
+);
+
+select is(
+  (select status
+   from public.learning_redemptions
+   where request_id = 'cccccccc-2222-4ccc-8ccc-cccccccccccc'),
+  'fulfilled',
+  'fulfilled redemption records its terminal status'
+);
+
+select is(
+  (select count(*)
+   from public.learning_fulfill_redemption(
+     (select id from public.learning_redemptions where request_id = 'cccccccc-2222-4ccc-8ccc-cccccccccccc')
+   )),
+  1::bigint,
+  'repeating fulfillment is idempotent'
+);
+
+select throws_ok(
+  $$select * from public.learning_cancel_redemption(
+    (select id from public.learning_redemptions where request_id = 'cccccccc-2222-4ccc-8ccc-cccccccccccc'),
+    'cccccccc-5555-4ccc-8ccc-cccccccccccc',
+    '兑现后取消'
+  )$$,
+  'P0001',
+  'learning_redemption_not_cancellable',
+  'fulfilled redemption cannot be cancelled'
+);
+
+select throws_ok(
+  $$select * from public.learning_redeem_reward(
+    'cccccccc-dddd-4ccc-8ccc-cccccccccccc',
+    'cccccccc-eeee-4ccc-8ccc-cccccccccccc',
+    'cccccccc-6666-4ccc-8ccc-cccccccccccc'
+  )$$,
+  'P0001',
+  'learning_reward_insufficient_points',
+  'redemption is blocked when the child balance is insufficient'
+);
+
+select throws_ok(
+  $$select * from public.learning_record_points(
+    'cccccccc-dddd-4ccc-8ccc-cccccccccccc',
+    null,
+    -1,
+    'cccccccc-7777-4ccc-8ccc-cccccccccccc',
+    'redemption',
+    '伪造兑换流水'
+  )$$,
+  '22023',
+  'learning_redemption_link_required',
+  'generic point RPC cannot create an unlinked redemption debit'
+);
+
+select throws_ok(
+  $$insert into public.learning_redemptions (
+      household_id, profile_id, reward_id, reward_name_snapshot,
+      cost_points_snapshot, request_id
+    ) values (
+      'cccccccc-cccc-4ccc-8ccc-cccccccccccc',
+      'cccccccc-dddd-4ccc-8ccc-cccccccccccc',
+      'cccccccc-eeee-4ccc-8ccc-cccccccccccc',
+      '绕过 RPC',
+      1,
+      'cccccccc-8888-4ccc-8ccc-cccccccccccc'
+    )$$,
+  '42501',
+  null,
+  'authenticated users cannot insert redemption rows directly'
+);
+
+select throws_ok(
+  $$update public.learning_redemptions
+    set status = 'fulfilled'
+    where request_id = 'cccccccc-2222-4ccc-8ccc-cccccccccccc'$$,
+  '42501',
+  null,
+  'authenticated users cannot update redemption rows directly'
+);
+
+select throws_ok(
+  $$delete from public.learning_redemptions
+    where request_id = 'cccccccc-2222-4ccc-8ccc-cccccccccccc'$$,
+  '42501',
+  null,
+  'authenticated users cannot delete redemption rows directly'
+);
+
+set local request.jwt.claim.sub = '66666666-6666-4666-8666-666666666666';
+
+select is(
+  (select count(*) from public.learning_rewards),
+  0::bigint,
+  'another user cannot read rewards from the first household'
+);
+
+select is(
+  (select count(*) from public.learning_redemptions),
+  0::bigint,
+  'another user cannot read redemptions from the first household'
+);
+
+select throws_ok(
+  $$select * from public.learning_redeem_reward(
+    'cccccccc-dddd-4ccc-8ccc-cccccccccccc',
+    'cccccccc-eeee-4ccc-8ccc-cccccccccccc',
+    'cccccccc-9999-4ccc-8ccc-cccccccccccc'
+  )$$,
+  '42501',
+  'learning_point_forbidden',
+  'another user cannot redeem a reward for the first household'
+);
+
+select throws_ok(
+  $$insert into public.learning_rewards (household_id, name, cost_points)
+    values ('cccccccc-cccc-4ccc-8ccc-cccccccccccc', '越权奖励', 1)$$,
+  '42501',
+  null,
+  'another user cannot create a reward in the first household'
+);
+
+set local request.jwt.claim.sub = '55555555-5555-4555-8555-555555555555';
+
+select lives_ok(
+  $$select public.learning_delete_household('cccccccc-cccc-4ccc-8ccc-cccccccccccc')$$,
+  'owner can delete a household containing reward and redemption history'
+);
+
+select is(
+  (select count(*) from public.learning_rewards
+   where household_id = 'cccccccc-cccc-4ccc-8ccc-cccccccccccc'),
+  0::bigint,
+  'household deletion removes reward definitions'
+);
+
+select is(
+  (select count(*) from public.learning_redemptions
+   where household_id = 'cccccccc-cccc-4ccc-8ccc-cccccccccccc'),
+  0::bigint,
+  'household deletion removes redemption records'
+);
+
+select * from finish();
+rollback;
diff --git a/tests/e2e/growth-loop.spec.js b/tests/e2e/growth-loop.spec.js
new file mode 100644
index 0000000..6db0fad
--- /dev/null
+++ b/tests/e2e/growth-loop.spec.js
@@ -0,0 +1,79 @@
+import { test, expect } from "@playwright/test";
+
+test.describe("Growth Loop local-first boundary", () => {
+  test("lets a parent create a custom point item and a reward from the app", async ({ page }) => {
+    await page.goto("/");
+    await page.click('[data-mod="points"]');
+    await page.fill('#pointItemForm input[name="name"]', "自己刷牙");
+    await page.fill('#pointItemForm input[name="points"]', "2");
+    await page.click('#pointItemForm button[type="submit"]');
+    await expect(page.locator(".pts-card").filter({ hasText: "自己刷牙" })).toBeVisible();
+
+    const customCard = page.locator(".pts-card").filter({ hasText: "自己刷牙" });
+    await customCard.locator(".pts-toggle").click();
+    await expect(customCard).toHaveClass(/done/);
+
+    await page.click('[data-mod="grow"]');
+    await page.fill('#rewardForm input[name="name"]', "选一个故事");
+    await page.fill('#rewardForm input[name="cost"]', "2");
+    await page.click('#rewardForm button[type="submit"]');
+    const reward = page.locator(".reward-card").filter({ hasText: "选一个故事" });
+    await expect(reward).toBeVisible();
+    await reward.locator(".reward-redeem").click();
+    await expect(reward).toContainText("待联网确认");
+  });
+
+  test("adopts pending local actions and claims one outbox event across two pages", async ({ browser }) => {
+    const context = await browser.newContext();
+    const first = await context.newPage();
+    const second = await context.newPage();
+    await first.goto("/");
+    await second.goto("/");
+    await first.evaluate(() => window.growthLoop.hydrate());
+    await second.evaluate(() => window.growthLoop.hydrate());
+
+    await first.evaluate(async () => {
+      await window.growthLoop.recordPoint({
+        item: { id: crypto.randomUUID(), name: "双连接测试", default_points: 2 },
+        occurred_on: "2026-08-14",
+        request_id: crypto.randomUUID(),
+      });
+    });
+
+    await first.evaluate(async () => {
+      await window.growthLoop.loadScope(
+        { household_id: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", profile_id: "aaaaaaaa-bbbb-4aaa-8aaa-aaaaaaaaaaaa" },
+        { adoptPending: true },
+      );
+    });
+    await second.evaluate(async () => {
+      await window.growthLoop.loadScope({
+        household_id: "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa",
+        profile_id: "aaaaaaaa-bbbb-4aaa-8aaa-aaaaaaaaaaaa",
+      });
+    });
+    const pendingCount = await first.evaluate(async () => (await window.growthLoop.pendingOutbox()).length);
+    expect(pendingCount).toBeGreaterThan(0);
+    await expect.poll(() => second.evaluate(async () => (await window.growthLoop.pendingOutbox()).length)).toBe(pendingCount);
+
+    await first.evaluate(() => { window.__growthSyncSends = 0; });
+    await second.evaluate(() => { window.__growthSyncSends = 0; });
+    const syncScript = async () => {
+      await window.growthLoop.sync({
+        transport: {
+          send: async () => {
+            window.__growthSyncSends += 1;
+            await new Promise((resolve) => setTimeout(resolve, 40));
+            return { status: "confirmed", data: { id: crypto.randomUUID() } };
+          },
+        },
+      });
+    };
+    await Promise.all([first.evaluate(syncScript), second.evaluate(syncScript)]);
+
+    const sends = await first.evaluate(() => window.__growthSyncSends)
+      + await second.evaluate(() => window.__growthSyncSends);
+    expect(sends).toBe(pendingCount);
+    await context.close();
+  });
+});
diff --git a/tests/unit/learning-analytics.test.js b/tests/unit/learning-analytics.test.js
new file mode 100644
index 0000000..1caf15c
--- /dev/null
+++ b/tests/unit/learning-analytics.test.js
@@ -0,0 +1,51 @@
+import { describe, expect, it } from "vitest";
+import { ACTIVITY_EVENT_TYPES, activityEventIdFor, buildActivityEvent } from "../../src/learning-analytics.js";
+
+describe("Growth Loop activity events", () => {
+  it("builds an allowlisted event without child content or credentials", () => {
+    const event = buildActivityEvent({
+      event_type: ACTIVITY_EVENT_TYPES.CORE_ACTIVATION,
+      household_id: "household-1",
+      profile_id: "profile-1",
+      occurred_at: "2026-08-14T10:00:00.000Z",
+      client_version: "1.3.7",
+      payload: {
+        source: "point_item",
+        child_name: "不应上传",
+        email: "parent@example.com",
+        error: "自由文本不应上传",
+      },
+    });
+
+    expect(event).toEqual(expect.objectContaining({
+      event_type: "core_activation",
+      household_id: "household-1",
+      profile_id: "profile-1",
+      payload: { source: "point_item" },
+    }));
+    expect(JSON.stringify(event)).not.toContain("不应上传");
+    expect(JSON.stringify(event)).not.toContain("parent@example.com");
+  });
+
+  it("rejects event types outside the product allowlist", () => {
+    expect(() => buildActivityEvent({ event_type: "page_view", household_id: "h", profile_id: "p" }))
+      .toThrow("activity_event_type_invalid");
+  });
+
+  it("creates a stable UUID for one scope and event bucket", () => {
+    const first = activityEventIdFor({
+      household_id: "household-1",
+      profile_id: "profile-1",
+      event_type: ACTIVITY_EVENT_TYPES.HOUSEHOLD_ACTIVATED,
+      bucket: "once",
+    });
+    const second = activityEventIdFor({
+      household_id: "household-1",
+      profile_id: "profile-1",
+      event_type: ACTIVITY_EVENT_TYPES.HOUSEHOLD_ACTIVATED,
+      bucket: "once",
+    });
+    expect(first).toBe(second);
+    expect(first).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/);
+  });
+});
diff --git a/tests/unit/learning-cloud-state.test.js b/tests/unit/learning-cloud-state.test.js
new file mode 100644
index 0000000..ba91b83
--- /dev/null
+++ b/tests/unit/learning-cloud-state.test.js
@@ -0,0 +1,79 @@
+import { describe, expect, it } from "vitest";
+import {
+  buildCloudSavePayload,
+  normalizeCloudLearningState,
+} from "../../src/learning-cloud-state.js";
+
+const SCOPE = { household_id: "household-1", profile_id: "profile-2" };
+
+describe("cloud learning state contract", () => {
+  it("normalizes legacy remote state while keeping the optimistic version separate", () => {
+    const normalized = normalizeCloudLearningState({
+      state: {
+        checkins: { "2026-08-14": { chinese: 1 } },
+        points: { "2026-08": { "0": { "14": 1 } } },
+        futureField: { enabled: true },
+      },
+      version: 12,
+      updated_at: "2026-08-14T08:00:00.000Z",
+    }, SCOPE);
+
+    expect(normalized).toMatchObject({
+      version: 12,
+      updated_at: "2026-08-14T08:00:00.000Z",
+      state: {
+        schema_version: 2,
+        scope: SCOPE,
+        legacy: { points_readonly: { "2026-08": { "0": { "14": 1 } } } },
+        extensions: { legacy_unknown: { futureField: { enabled: true } } },
+      },
+    });
+    expect(normalized.state).not.toHaveProperty("version");
+  });
+
+  it("fails closed when a remote envelope belongs to another child", () => {
+    const normalized = normalizeCloudLearningState({
+      state: {
+        schema_version: 2,
+        scope: { household_id: "household-1", profile_id: "profile-1" },
+        learning: { checkins: { leaked: { math: 1 } } },
+      },
+      version: 8,
+      updated_at: "2026-08-14T08:00:00.000Z",
+    }, SCOPE);
+
+    expect(normalized.scope_mismatch).toBe(true);
+    expect(normalized.version).toBeNull();
+    expect(normalized.state.scope).toEqual(SCOPE);
+    expect(normalized.state.learning.checkins).toEqual({});
+  });
+
+  it("fails closed when a v2 remote envelope has no child scope", () => {
+    const normalized = normalizeCloudLearningState({
+      state: {
+        schema_version: 2,
+        learning: { checkins: { leaked: { math: 1 } } },
+      },
+      version: 5,
+    }, SCOPE);
+
+    expect(normalized.scope_mismatch).toBe(true);
+    expect(normalized.version).toBeNull();
+    expect(normalized.state.scope).toEqual(SCOPE);
+    expect(normalized.state.learning.checkins).toEqual({});
+  });
+
+  it("sends state schema and optimistic version as separate save fields", () => {
+    const state = {
+      schema_version: 2,
+      scope: SCOPE,
+      learning: { checkins: {} },
+      extensions: {},
+    };
+
+    expect(buildCloudSavePayload(state, 12)).toEqual({
+      p_state: state,
+      p_expected_version: 12,
+    });
+  });
+});
diff --git a/tests/unit/learning-export.test.js b/tests/unit/learning-export.test.js
new file mode 100644
index 0000000..2739623
--- /dev/null
+++ b/tests/unit/learning-export.test.js
@@ -0,0 +1,72 @@
+import { describe, expect, it } from "vitest";
+import { buildHouseholdExport } from "../../src/learning-export.js";
+
+describe("household export boundary", () => {
+  it("exports stable household and learner history without auth, device, analytics, or server internals", () => {
+    const payload = buildHouseholdExport({
+      exportedAt: "2026-08-14T08:00:00.000Z",
+      household: { id: "household-1", name: "测试家庭", internalAuditLog: "omit" },
+      learners: [{
+        id: "profile-1",
+        household_id: "household-1",
+        display_name: "小影",
+        grade_level: 0,
+        created_at: "2026-08-01T08:00:00.000Z",
+        updated_at: "2026-08-14T08:00:00.000Z",
+        state: { schema_version: 2, learning: { checkins: {} } },
+        state_version: 4,
+        state_updated_at: "2026-08-14T08:00:00.000Z",
+        auth_email: "parent@example.com",
+        session_key: "secret",
+        sound_preferences: { volume: 0.6 },
+        activity_events: [{ event_name: "core_activation" }],
+        server_audit_log: [{ action: "read" }],
+      }],
+      consents: [{
+        household_id: "household-1",
+        consent_type: "learner_data_processing",
+        policy_version: "privacy-v1",
+        consented_at: "2026-08-01T08:00:00.000Z",
+        created_at: "2026-08-01T08:00:00.000Z",
+      }],
+      growthLoop: {
+        pointItems: [{ id: "item-1", profile_id: "profile-1", name: "整理玩具" }],
+        profilePointItems: [{ profile_id: "profile-1", point_item_id: "item-1" }],
+        rewards: [{ id: "reward-1", profile_id: "profile-1", name: "看绘本" }],
+        profileRewards: [{ profile_id: "profile-1", reward_id: "reward-1" }],
+        ledger: [{ id: "ledger-1", profile_id: "profile-1", delta: 2 }],
+        redemptions: [{ id: "redemption-1", profile_id: "profile-1", status: "pending" }],
+      },
+    });
+
+    expect(payload).toMatchObject({
+      export_schema_version: 1,
+      product_id: "shadow-mate",
+      exported_at: "2026-08-14T08:00:00.000Z",
+      household: { id: "household-1", name: "测试家庭" },
+      learners: [{
+        id: "profile-1",
+        household_id: "household-1",
+        state_version: 4,
+        state: { schema_version: 2 },
+      }],
+      consents: [{ consent_type: "learner_data_processing", policy_version: "privacy-v1", created_at: "2026-08-01T08:00:00.000Z" }],
+      growth_loop: {
+        point_items: [{ id: "item-1" }],
+        profile_point_items: [{ profile_id: "profile-1" }],
+        rewards: [{ id: "reward-1" }],
+        profile_rewards: [{ profile_id: "profile-1" }],
+        ledger: [{ id: "ledger-1" }],
+        redemptions: [{ id: "redemption-1" }],
+      },
+    });
+
+    const serialized = JSON.stringify(payload);
+    expect(serialized).not.toContain("parent@example.com");
+    expect(serialized).not.toContain("secret");
+    expect(serialized).not.toContain("sound_preferences");
+    expect(serialized).not.toContain("activity_events");
+    expect(serialized).not.toContain("server_audit_log");
+    expect(serialized).not.toContain("internalAuditLog");
+  });
+});
diff --git a/tests/unit/learning-growth-cloud.test.js b/tests/unit/learning-growth-cloud.test.js
new file mode 100644
index 0000000..390832c
--- /dev/null
+++ b/tests/unit/learning-growth-cloud.test.js
@@ -0,0 +1,62 @@
+import { describe, expect, it, vi } from "vitest";
+import { createGrowthLoopTransport } from "../../src/learning-growth-cloud.js";
+
+describe("Growth Loop Supabase transport", () => {
+  it("maps a point event to the idempotent point RPC", async () => {
+    const rpc = vi.fn(async () => ({ data: [{ id: "ledger-1" }], error: null }));
+    const transport = createGrowthLoopTransport({ client: { rpc } });
+
+    await expect(transport.send({
+      type: "point_record",
+      request_id: "request-1",
+      payload: {
+        profile_id: "profile-1",
+        point_item_id: "item-1",
+        delta: 2,
+        entry_type: "manual",
+        note: null,
+        occurred_on: "2026-08-14",
+      },
+    })).resolves.toEqual(expect.objectContaining({ status: "confirmed", data: { id: "ledger-1" } }));
+    expect(rpc).toHaveBeenCalledWith("learning_record_points", expect.objectContaining({
+      p_profile_id: "profile-1",
+      p_point_item_id: "item-1",
+      p_delta: 2,
+      p_request_id: "request-1",
+      p_occurred_on: "2026-08-14",
+    }));
+  });
+
+  it("classifies network and idempotency errors without exposing a success state", async () => {
+    const transport = createGrowthLoopTransport({
+      client: { rpc: vi.fn(async () => ({ data: null, error: { status: 409, message: "idempotency_conflict" } })) },
+    });
+    await expect(transport.send({ type: "point_record", request_id: "request-1", payload: {} }))
+      .resolves.toEqual(expect.objectContaining({ status: "conflict", error_code: "idempotency_conflict" }));
+  });
+
+  it("strips local-only metadata before writing public product tables", async () => {
+    const upsert = vi.fn(() => ({
+      select: () => ({ single: async () => ({ data: { id: "item-1" }, error: null }) }),
+    }));
+    const transport = createGrowthLoopTransport({ client: { from: vi.fn(() => ({ upsert })) } });
+
+    await transport.send({
+      type: "point_item_upsert",
+      payload: { point_item: {
+        id: "item-1",
+        household_id: "household-1",
+        name: "整理玩具",
+        description: "自定义成长任务",
+        default_points: 2,
+        item_kind: "custom",
+        category: "growth",
+        icon_key: "star",
+        is_active: true,
+        source: "local",
+      } },
+    });
+
+    expect(upsert).toHaveBeenCalledWith(expect.not.objectContaining({ source: "local" }), { onConflict: "id" });
+  });
+});
diff --git a/tests/unit/learning-growth-loop-controller.test.js b/tests/unit/learning-growth-loop-controller.test.js
new file mode 100644
index 0000000..4bda8de
--- /dev/null
+++ b/tests/unit/learning-growth-loop-controller.test.js
@@ -0,0 +1,29 @@
+import { describe, expect, it } from "vitest";
+import { createMemoryLearningDb } from "../../src/learning-local-db.js";
+import { createGrowthLoopController } from "../../src/learning-growth-loop-controller.js";
+
+describe("Growth Loop controller scope adoption", () => {
+  it("rebinds pending local actions before the first cloud sync", async () => {
+    const controller = createGrowthLoopController({ db: createMemoryLearningDb() });
+    await controller.loadScope({ household_id: null, profile_id: null });
+    await controller.recordPoint({
+      item: { id: "item-1", name: "整理玩具", default_points: 2 },
+      occurred_on: "2026-08-14",
+      request_id: "request-1",
+    });
+
+    await controller.loadScope(
+      { household_id: "household-1", profile_id: "profile-1" },
+      { adoptPending: true },
+    );
+
+    const pending = await controller.pendingOutbox();
+    expect(pending.length).toBeGreaterThan(0);
+    expect(pending.every((event) => event.scope_key === "household-1:profile-1")).toBe(true);
+    expect(pending.find((event) => event.type === "point_record")?.payload.profile_id).toBe("profile-1");
+    expect(controller.getSnapshot().scope).toEqual({ household_id: "household-1", profile_id: "profile-1" });
+    expect(controller.getSnapshot().ledger).toEqual([
+      expect.objectContaining({ household_id: "household-1", profile_id: "profile-1" }),
+    ]);
+  });
+});
diff --git a/tests/unit/learning-growth-loop-sync.test.js b/tests/unit/learning-growth-loop-sync.test.js
new file mode 100644
index 0000000..0112bdc
--- /dev/null
+++ b/tests/unit/learning-growth-loop-sync.test.js
@@ -0,0 +1,85 @@
+import { describe, expect, it, vi } from "vitest";
+import { createMemoryLearningDb } from "../../src/learning-local-db.js";
+import { createOutboxSync } from "../../src/learning-growth-loop-sync.js";
+
+describe("Growth Loop outbox sync", () => {
+  it("submits events in sequence and removes only confirmed events", async () => {
+    const db = createMemoryLearningDb();
+    await db.appendOutbox({ event_id: "event-1", scope_key: "h:p", sequence: 1, type: "point_item_upsert" });
+    await db.appendOutbox({ event_id: "event-2", scope_key: "h:p", sequence: 2, type: "point_record" });
+    const seen = [];
+    const sync = createOutboxSync({
+      db,
+      transport: { send: vi.fn(async (event) => { seen.push(event.event_id); return { status: "confirmed" }; }) },
+      now: () => 1000,
+      jitter: 0,
+      random: () => 0,
+    });
+
+    await expect(sync.syncScope("h:p")).resolves.toEqual(expect.objectContaining({ confirmed: 2, pending: 0 }));
+    expect(seen).toEqual(["event-1", "event-2"]);
+    await expect(db.listOutbox("h:p")).resolves.toEqual([]);
+  });
+
+  it("backs off a retryable failure and stops before sending later events", async () => {
+    const db = createMemoryLearningDb();
+    await db.appendOutbox({ event_id: "event-1", scope_key: "h:p", type: "point_item_upsert" });
+    await db.appendOutbox({ event_id: "event-2", scope_key: "h:p", type: "point_record" });
+    const send = vi.fn(async () => ({ status: "retryable", error_code: "timeout" }));
+    const sync = createOutboxSync({ db, transport: { send }, now: () => 1000, retryBaseMs: 100, jitter: 0, random: () => 0 });
+
+    await expect(sync.syncScope("h:p")).resolves.toEqual(expect.objectContaining({ retryable: 1, pending: 2 }));
+    expect(send).toHaveBeenCalledTimes(1);
+    await expect(db.getOutbox("event-1")).resolves.toEqual(expect.objectContaining({
+      status: "retryable",
+      attempts: 1,
+      next_attempt_at: 1100,
+    }));
+  });
+
+  it("records a conflict and does not silently delete the event", async () => {
+    const db = createMemoryLearningDb();
+    await db.appendOutbox({ event_id: "event-1", scope_key: "h:p", type: "point_record" });
+    const sync = createOutboxSync({
+      db,
+      transport: { send: vi.fn(async () => ({ status: "conflict", error_code: "idempotency_conflict" })) },
+      now: () => 1000,
+      jitter: 0,
+      random: () => 0,
+    });
+
+    await expect(sync.syncScope("h:p")).resolves.toEqual(expect.objectContaining({ conflict: 1, blocked: true }));
+    await expect(db.getOutbox("event-1")).resolves.toEqual(expect.objectContaining({ status: "conflict" }));
+  });
+
+  it("does not send the same event twice when two sync connections race", async () => {
+    const db = createMemoryLearningDb();
+    await db.appendOutbox({ event_id: "event-1", scope_key: "h:p", type: "point_record" });
+    let sends = 0;
+    const transport = {
+      send: vi.fn(async () => {
+        sends += 1;
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        return { status: "confirmed", data: { id: "remote-1" } };
+      }),
+    };
+    const createSync = (workerId) => createOutboxSync({
+      db,
+      transport,
+      workerId,
+      now: () => 1000,
+      leaseMs: 5000,
+      jitter: 0,
+      random: () => 0,
+    });
+
+    const [first, second] = await Promise.all([
+      createSync("tab-a").syncScope("h:p"),
+      createSync("tab-b").syncScope("h:p"),
+    ]);
+
+    expect(sends).toBe(1);
+    expect(first.confirmed + second.confirmed).toBe(1);
+    await expect(db.getOutbox("event-1")).resolves.toEqual(expect.objectContaining({ status: "confirmed" }));
+  });
+});
diff --git a/tests/unit/learning-growth-loop.test.js b/tests/unit/learning-growth-loop.test.js
new file mode 100644
index 0000000..abeb0ac
--- /dev/null
+++ b/tests/unit/learning-growth-loop.test.js
@@ -0,0 +1,152 @@
+import { describe, expect, it } from "vitest";
+import {
+  applyPointAction,
+  applyRedemption,
+  closePointPeriod,
+  createGrowthLoopState,
+  getActivePointAction,
+  getBalance,
+  getPointPeriodTotal,
+  mergeGrowthLoopSnapshot,
+  recommendedPointItems,
+} from "../../src/learning-growth-loop.js";
+
+const scope = { household_id: "household-1", profile_id: "profile-1" };
+
+describe("Growth Loop local projection", () => {
+  it("records a point action locally and creates an ordered sync event", () => {
+    const item = { ...recommendedPointItems[0], id: "item-1" };
+    const state = createGrowthLoopState(scope);
+    const result = applyPointAction(state, {
+      scope,
+      item,
+      occurred_on: "2026-08-14",
+      request_id: "request-1",
+    });
+
+    expect(result.snapshot.point_items).toHaveLength(1);
+    expect(result.snapshot.profile_point_items).toEqual([
+      expect.objectContaining({ profile_id: "profile-1", point_item_id: "item-1", enabled: true }),
+    ]);
+    expect(result.snapshot.ledger).toEqual([
+      expect.objectContaining({ delta: 2, entry_type: "manual", status: "pending", occurred_on: "2026-08-14" }),
+    ]);
+    expect(result.events).toEqual([
+      expect.objectContaining({ type: "point_item_upsert" }),
+      expect.objectContaining({ type: "profile_point_item_upsert" }),
+      expect.objectContaining({ type: "point_record", request_id: "request-1" }),
+    ]);
+    expect(getBalance(result.snapshot)).toBe(2);
+    expect(getActivePointAction(result.snapshot, "item-1", "2026-08-14")).toBe(true);
+  });
+
+  it("uses an immutable reverse entry for a local undo", () => {
+    const item = { ...recommendedPointItems[0], id: "item-1" };
+    const first = applyPointAction(createGrowthLoopState(scope), {
+      scope,
+      item,
+      occurred_on: "2026-08-14",
+      request_id: "request-1",
+    });
+    const second = applyPointAction(first.snapshot, {
+      scope,
+      item,
+      occurred_on: "2026-08-14",
+      request_id: "request-2",
+    });
+
+    expect(second.snapshot.ledger).toHaveLength(2);
+    expect(second.snapshot.ledger[1]).toEqual(expect.objectContaining({ delta: -2, entry_type: "adjustment" }));
+    expect(second.snapshot.ledger[1].metadata).toEqual(expect.objectContaining({ undo_of: "request-1" }));
+    expect(getBalance(second.snapshot)).toBe(0);
+    expect(getActivePointAction(second.snapshot, "item-1", "2026-08-14")).toBe(false);
+  });
+
+  it("keeps pending local actions when a cloud snapshot is merged", () => {
+    const item = { ...recommendedPointItems[0], id: "item-1" };
+    const local = applyPointAction(createGrowthLoopState(scope), {
+      scope,
+      item,
+      occurred_on: "2026-08-14",
+      request_id: "request-local",
+    }).snapshot;
+    const remote = createGrowthLoopState(scope);
+    remote.point_items = [{ ...item, name: "云端名称" }];
+    remote.ledger = [{
+      id: "remote-ledger-1",
+      request_id: "request-remote",
+      profile_id: "profile-1",
+      point_item_id: "item-1",
+      delta: 3,
+      status: "confirmed",
+    }];
+
+    const merged = mergeGrowthLoopSnapshot(remote, local);
+    expect(merged.ledger.map((entry) => entry.request_id)).toEqual(["request-remote", "request-local"]);
+    expect(merged.point_items[0].name).toBe("云端名称");
+  });
+
+  it("keeps a newly created local definition when the cloud already has other definitions", () => {
+    const remote = createGrowthLoopState(scope);
+    remote.point_items = [{ id: "remote-item", name: "云端项目", default_points: 2 }];
+    const local = createGrowthLoopState(scope);
+    local.point_items = [{ id: "local-item", name: "离线项目", default_points: 3 }];
+
+    const merged = mergeGrowthLoopSnapshot(remote, local);
+    expect(merged.point_items.map((item) => item.id)).toEqual(["local-item", "remote-item"]);
+  });
+
+  it("keeps an offline redemption pending and does not call it finally successful", () => {
+    const state = createGrowthLoopState(scope);
+    state.rewards = [{ id: "reward-1", name: "去公园", cost_points: 5, is_active: true }];
+    state.profile_rewards = [{ profile_id: "profile-1", reward_id: "reward-1", enabled: true }];
+    state.ledger = [{
+      id: "ledger-1",
+      request_id: "point-1",
+      profile_id: "profile-1",
+      delta: 8,
+      entry_type: "manual",
+      status: "confirmed",
+    }];
+
+    const result = applyRedemption(state, {
+      scope,
+      reward_id: "reward-1",
+      request_id: "redeem-1",
+    });
+
+    expect(result.snapshot.redemptions[0]).toEqual(expect.objectContaining({ status: "pending", id: "redeem-1" }));
+    expect(result.snapshot.ledger.at(-1)).toEqual(expect.objectContaining({ delta: -5, status: "pending", entry_type: "redemption" }));
+    expect(getBalance(result.snapshot)).toBe(3);
+    expect(result.events).toEqual([expect.objectContaining({ type: "reward_redeem", request_id: "redeem-1" })]);
+  });
+
+  it("ends a point period with immutable adjustment entries while preserving history", () => {
+    const item = { ...recommendedPointItems[0], id: "item-1" };
+    const first = applyPointAction(createGrowthLoopState(scope), {
+      scope,
+      item,
+      occurred_on: "2026-08-14",
+      request_id: "request-1",
+    });
+    const closed = closePointPeriod(first.snapshot, {
+      scope,
+      period_key: "2026-08",
+      request_id: "close-1",
+    });
+
+    expect(closed.snapshot.ledger).toHaveLength(2);
+    expect(closed.snapshot.ledger.at(-1)).toEqual(expect.objectContaining({
+      delta: -2,
+      entry_type: "adjustment",
+      status: "pending",
+    }));
+    expect(closed.snapshot.ledger.at(-1).metadata).toEqual(expect.objectContaining({
+      period_close: "2026-08",
+      undo_of: "request-1",
+    }));
+    expect(getPointPeriodTotal(closed.snapshot, "item-1", "2026-08")).toBe(0);
+    expect(closed.snapshot.ledger[0]).toEqual(expect.objectContaining({ request_id: "request-1", delta: 2 }));
+    expect(closed.events).toEqual([expect.objectContaining({ type: "point_record" })]);
+  });
+});
diff --git a/tests/unit/learning-local-db.test.js b/tests/unit/learning-local-db.test.js
new file mode 100644
index 0000000..0f8f09a
--- /dev/null
+++ b/tests/unit/learning-local-db.test.js
@@ -0,0 +1,88 @@
+import { describe, expect, it } from "vitest";
+import { createMemoryLearningDb } from "../../src/learning-local-db.js";
+
+describe("local Growth Loop database", () => {
+  it("isolates snapshots by household and profile scope", async () => {
+    const db = createMemoryLearningDb();
+    await db.putSnapshot("household-1:profile-1", { scope: { profile_id: "profile-1" }, value: 1 });
+    await db.putSnapshot("household-1:profile-2", { scope: { profile_id: "profile-2" }, value: 2 });
+
+    await expect(db.getSnapshot("household-1:profile-1")).resolves.toEqual({ scope: { profile_id: "profile-1" }, value: 1 });
+    await expect(db.getSnapshot("household-1:profile-2")).resolves.toEqual({ scope: { profile_id: "profile-2" }, value: 2 });
+  });
+
+  it("assigns a monotonic sequence per scope and preserves outbox order", async () => {
+    const db = createMemoryLearningDb();
+    await db.appendOutbox({ event_id: "event-2", scope_key: "h:p", type: "point_record" });
+    await db.appendOutbox({ event_id: "event-1", scope_key: "h:p", type: "point_item_upsert" });
+    await db.appendOutbox({ event_id: "other", scope_key: "h:other", type: "point_record" });
+
+    await expect(db.listOutbox("h:p")).resolves.toEqual([
+      expect.objectContaining({ event_id: "event-2", sequence: 1 }),
+      expect.objectContaining({ event_id: "event-1", sequence: 2 }),
+    ]);
+    await expect(db.listOutbox("h:other")).resolves.toEqual([
+      expect.objectContaining({ event_id: "other", sequence: 1 }),
+    ]);
+  });
+
+  it("does not duplicate the same event when an app retries the local write", async () => {
+    const db = createMemoryLearningDb();
+    const event = { event_id: "event-1", scope_key: "h:p", type: "point_record" };
+    const first = await db.appendOutbox(event);
+    const second = await db.appendOutbox(event);
+
+    expect(second).toEqual(first);
+    await expect(db.listOutbox("h:p")).resolves.toHaveLength(1);
+  });
+
+  it("keeps rejected events available for export instead of deleting them", async () => {
+    const db = createMemoryLearningDb();
+    await db.appendOutbox({ event_id: "event-1", scope_key: "h:p", type: "point_record" });
+    await db.updateOutbox("event-1", { status: "rejected", error_code: "scope_deleted" });
+
+    await expect(db.listOutbox("h:p", { statuses: ["rejected"] })).resolves.toEqual([
+      expect.objectContaining({ event_id: "event-1", status: "rejected", error_code: "scope_deleted" }),
+    ]);
+  });
+
+  it("claims an event once when two connections try to sync the same scope", async () => {
+    const db = createMemoryLearningDb();
+    await db.appendOutbox({ event_id: "event-1", scope_key: "h:p", type: "point_record" });
+
+    await expect(db.claimOutbox("event-1", { worker_id: "tab-a", now: 1000, lease_ms: 5000 }))
+      .resolves.toBe(true);
+    await expect(db.claimOutbox("event-1", { worker_id: "tab-b", now: 1000, lease_ms: 5000 }))
+      .resolves.toBe(false);
+    await expect(db.getOutbox("event-1")).resolves.toEqual(expect.objectContaining({
+      processing_by: "tab-a",
+      lease_until: 6000,
+    }));
+  });
+
+  it("moves pending local records and outbox events into the authenticated scope", async () => {
+    const db = createMemoryLearningDb();
+    await db.putSnapshot("pending:pending", { scope: { household_id: null, profile_id: null }, value: 1 });
+    await db.appendOutbox({
+      event_id: "event-1",
+      scope_key: "pending:pending",
+      household_id: null,
+      profile_id: null,
+      type: "point_record",
+      payload: { profile_id: null },
+    });
+
+    await db.moveScope("pending:pending", "household-1:profile-1", {
+      household_id: "household-1",
+      profile_id: "profile-1",
+    });
+
+    await expect(db.getSnapshot("pending:pending")).resolves.toBeNull();
+    await expect(db.getOutbox("event-1")).resolves.toEqual(expect.objectContaining({
+      scope_key: "household-1:profile-1",
+      household_id: "household-1",
+      profile_id: "profile-1",
+      payload: { profile_id: "profile-1" },
+    }));
+  });
+});
diff --git a/tests/unit/learning-state-envelope.test.js b/tests/unit/learning-state-envelope.test.js
new file mode 100644
index 0000000..6dc92f0
--- /dev/null
+++ b/tests/unit/learning-state-envelope.test.js
@@ -0,0 +1,73 @@
+import { describe, expect, it } from "vitest";
+import {
+  getLearningStateStorageKey,
+  migrateLegacyLearningState,
+} from "../../src/learning-state-envelope.js";
+
+describe("learning state envelope migration", () => {
+  it("wraps legacy state without losing unknown fields or treating old points as current balance", () => {
+    const legacy = {
+      checkins: { "2026-08-14": { "chinese-literacy": true } },
+      extra: { mathCount: 3 },
+      points: { "2026-8": { "0": { "14": 1 } } },
+      bookShelf: {},
+      peanutLog: [],
+      peanutRead: {},
+      futureField: { keep: true },
+    };
+
+    const migrated = migrateLegacyLearningState(legacy, {
+      householdId: "household-1",
+      profileId: "profile-1",
+    });
+
+    expect(migrated).toMatchObject({
+      schema_version: 2,
+      product_id: "shadow-mate",
+      scope: { household_id: "household-1", profile_id: "profile-1" },
+      learning: {
+        checkins: legacy.checkins,
+        extra: legacy.extra,
+        bookShelf: legacy.bookShelf,
+        peanutLog: legacy.peanutLog,
+        peanutRead: legacy.peanutRead,
+      },
+      legacy: { points_readonly: legacy.points },
+      extensions: { legacy_unknown: { futureField: legacy.futureField } },
+    });
+    expect(migrated).not.toHaveProperty("learning.points");
+    expect(migrated.migration.source_schema).toBe("legacy-v1");
+    expect(migrated.migration.migration_id).toMatch(/^legacy-v1:/);
+  });
+
+  it("uses a different local namespace for every child and a separate pending namespace", () => {
+    const firstChild = getLearningStateStorageKey({ householdId: "household-1", profileId: "profile-1" });
+    const secondChild = getLearningStateStorageKey({ householdId: "household-1", profileId: "profile-2" });
+    const pending = getLearningStateStorageKey();
+
+    expect(firstChild).toBe("shadow_mate_learning_v2:household-1:profile-1");
+    expect(secondChild).toBe("shadow_mate_learning_v2:household-1:profile-2");
+    expect(firstChild).not.toBe(secondChild);
+    expect(pending).toBe("shadow_mate_learning_v2:pending");
+  });
+
+  it("normalizes malformed legacy containers to safe defaults", () => {
+    const migrated = migrateLegacyLearningState({
+      checkins: [],
+      extra: null,
+      points: null,
+      bookShelf: "not-an-object",
+      peanutLog: "not-an-array",
+      peanutRead: false,
+    });
+
+    expect(migrated.learning).toMatchObject({
+      checkins: {},
+      extra: {},
+      bookShelf: {},
+      peanutLog: [],
+      peanutRead: {},
+    });
+    expect(migrated.legacy.points_readonly).toEqual({});
+  });
+});
diff --git a/tests/unit/learning-state-storage.test.js b/tests/unit/learning-state-storage.test.js
new file mode 100644
index 0000000..d67978d
--- /dev/null
+++ b/tests/unit/learning-state-storage.test.js
@@ -0,0 +1,123 @@
+import { describe, expect, it } from "vitest";
+import { getLearningStateStorageKey, migrateLegacyLearningState } from "../../src/learning-state-envelope.js";
+import {
+  adoptPendingLearningState,
+  loadLearningStateEnvelope,
+} from "../../src/learning-state-storage.js";
+
+function memoryStorage(initial = {}) {
+  const data = new Map(Object.entries(initial));
+  return {
+    data,
+    getItem(key) {
+      return data.has(key) ? data.get(key) : null;
+    },
+    setItem(key, value) {
+      data.set(key, String(value));
+    },
+    removeItem(key) {
+      data.delete(key);
+    },
+  };
+}
+
+describe("learning state storage", () => {
+  it("keeps legacy global data pending until a parent explicitly assigns it to one child", () => {
+    const legacyRaw = JSON.stringify({
+      checkins: { "2026-08-14": { "chinese-literacy": true } },
+      points: { "2026-8": { "0": { "14": 1 } } },
+    });
+    const storage = memoryStorage({ shadow_mate_workbench_v1: legacyRaw });
+
+    const envelope = loadLearningStateEnvelope(storage, {
+      householdId: "household-1",
+      profileId: "profile-1",
+    });
+
+    const scopedKey = getLearningStateStorageKey({ householdId: "household-1", profileId: "profile-1" });
+    const pending = loadLearningStateEnvelope(storage);
+    expect(envelope.learning.checkins).toEqual({});
+    expect(pending.learning.checkins).toEqual({ "2026-08-14": { "chinese-literacy": true } });
+    expect(storage.getItem(scopedKey)).toBe(JSON.stringify(envelope));
+    expect(storage.getItem("shadow_mate_workbench_v1")).toBe(legacyRaw);
+
+    const secondChild = loadLearningStateEnvelope(storage, {
+      householdId: "household-1",
+      profileId: "profile-2",
+    });
+    expect(secondChild.learning.checkins).toEqual({});
+
+    const adopted = adoptPendingLearningState(storage, {
+      householdId: "household-1",
+      profileId: "profile-1",
+    });
+    expect(adopted.scope).toEqual({ household_id: "household-1", profile_id: "profile-1" });
+    expect(adopted.learning.checkins).toEqual({ "2026-08-14": { "chinese-literacy": true } });
+    expect(adopted.migration.adopted_from).toBe("pending");
+
+    const otherChildAfterAdoption = loadLearningStateEnvelope(storage, {
+      householdId: "household-1",
+      profileId: "profile-2",
+    });
+    expect(otherChildAfterAdoption.learning.checkins).toEqual({});
+    expect(storage.getItem("shadow_mate_learning_v2:pending")).toBe(JSON.stringify(pending));
+  });
+
+  it("does not return a state whose embedded scope belongs to another child", () => {
+    const scopedKey = getLearningStateStorageKey({ householdId: "household-1", profileId: "profile-2" });
+    const wrongScope = migrateLegacyLearningState(
+      { checkins: { "2026-08-14": { "chinese-literacy": true } } },
+      { householdId: "household-1", profileId: "profile-1" },
+    );
+    const storage = memoryStorage({ [scopedKey]: JSON.stringify(wrongScope) });
+
+    const loaded = loadLearningStateEnvelope(storage, {
+      householdId: "household-1",
+      profileId: "profile-2",
+    });
+
+    expect(loaded.scope).toEqual({ household_id: "household-1", profile_id: "profile-2" });
+    expect(loaded.learning.checkins).toEqual({});
+    expect(storage.getItem(scopedKey)).toBe(JSON.stringify(loaded));
+  });
+
+  it("backs up malformed legacy content by its raw value and remains idempotent", () => {
+    const legacyRaw = "{not-json";
+    const storage = memoryStorage({ shadow_mate_workbench_v1: legacyRaw });
+
+    const first = loadLearningStateEnvelope(storage, {
+      householdId: "household-1",
+      profileId: "profile-1",
+    });
+    const second = loadLearningStateEnvelope(storage, {
+      householdId: "household-1",
+      profileId: "profile-1",
+    });
+
+    expect(first).toEqual(second);
+    expect(first.learning.checkins).toEqual({});
+    expect([...storage.data.entries()]).toContainEqual([
+      expect.stringMatching(/^shadow_mate_learning_v2:legacy_backup:/),
+      legacyRaw,
+    ]);
+  });
+
+  it("does not overwrite an existing child state during explicit adoption", () => {
+    const scope = { householdId: "household-1", profileId: "profile-1" };
+    const scopedKey = getLearningStateStorageKey(scope);
+    const pending = migrateLegacyLearningState({
+      checkins: { pending: { chinese: 1 } },
+    });
+    const existing = migrateLegacyLearningState({
+      checkins: { existing: { math: 1 } },
+    }, scope);
+    const storage = memoryStorage({
+      ["shadow_mate_learning_v2:pending"]: JSON.stringify(pending),
+      [scopedKey]: JSON.stringify(existing),
+    });
+
+    const result = adoptPendingLearningState(storage, scope);
+
+    expect(result.learning.checkins).toEqual({ existing: { math: 1 } });
+  });
+});