recallnest 2.6.1 → 3.0.0

package/src/synthesis-contract.ts

@@ -0,0 +1,286 @@
+/**
+ * dream 合成契约 —— cluster insight 与 cross-memory pattern 的提示词、解析与写库前校验。
+ *
+ * 为什么单独一个模块（2026-08-23）：
+ * 在此之前，「簇 → 一条派生记忆」这件事没有契约，只有两个各自为政的 LLM 调用：
+ *   - cluster_insight 走 `generateL0` —— 那是**分块索引摘要器**，提示词写的是
+ *     「给对话片段写一句话摘要，用于快速检索」，从不要求结论、因果、决策或行动，
+ *     还明文要求「端口号/IP/URL/文件路径 → 原样保留」。名字叫 insight，干的是做目录。
+ *   - cross_memory_pattern 走 `extractPattern` —— 目标概念写的是「反复出现的偏好、
+ *     行为倾向、价值观」，那是**性格画像**框架，于是产出星座运势腔。
+ *
+ * 2026-08-22 的全量诊断量到了后果（同长度区间 40–160 字，确定性正则，无 LLM 判官）：
+ *   手写 pivot 40.4% > 原料 transcript 25.1% > insight 14.4% > pattern 12.1%
+ *   —— **产物的结论密度低于它自己的原料，合成这一步在做减法**；
+ *   pattern 侧 56.1% 命中性向归因句式，对照原料 1.4%（40 倍富集）。
+ * 同一批真实簇做三臂对照（n=40，种子 9001）：只把提示词换成结论导向 + 允许弃权，
+ * 同模型下结论连接词 17.5% → 32.3%、性向归因 62.5% → 0%、弃权率 0% → 22.5%。
+ * 结论一直在输入里，是合成把它变成了目录。
+ *
+ * 所以这里定的是三件事，缺一条都会退回老样子：
+ *   1. **目标概念**：要的是「可复用结论」（规则/因果/决策/踩坑/判断转折），不是摘要，
+ *      更不是性格描写。两个提示词都显式禁掉「注重/强调/倾向于」那一族措辞。
+ *   2. **弃权路径**：炼不出来必须能说「没有」。老 `generateL0` 的 `if (!insight)` 只在
+ *      LLM 调用失败时触发，**永远不会因为「这簇不值得留」而不写** —— 2,427 条按构造
+ *      全是情节摘要，就是这么来的。
+ *   3. **写库前校验**：LLM 说了什么不算数，能过校验才写。老路径只检查
+ *      `response.length < 5`，后果是库里有 28 条记忆的正文**就是它自己的系统提示词原文**。
+ *
+ * 本模块是纯函数 + 常量，不碰网络也不碰库，故校验规则可以直接单测。
+ */
+
+/** 一条合格的合成产物。 */
+export interface SynthesisOutput {
+  /** 结论正文。不截断 —— 截断一句结论等于毁掉它。 */
+  text: string;
+  /** 支撑这条结论的源记录编号（1-based，已去重升序，且都在簇内）。 */
+  evidence: number[];
+}
+
+/** 校验不通过的原因。逐项区分是为了让「LLM 不好好干活」有形状，而不是笼统一个 null。 */
+export type SynthesisRejectReason =
+  | "unparsable"          // 拿不到 JSON
+  | "flag-not-boolean"    // has 字段不是 boolean
+  | "empty-text"          // 说有结论却没给正文
+  | "too-short"
+  | "too-long"
+  | "prompt-echo"         // 正文是提示词自身的回声（老路径进库 28 条的形态）
+  | "evidence-missing"    // 没给 evidence 或不是数组
+  | "evidence-too-few"    // 合法编号不够
+  | "evidence-out-of-range"; // 编号不是簇内真实存在的下标
+
+export type SynthesisVerdict =
+  | { status: "ok"; output: SynthesisOutput }
+  | { status: "abstained" }
+  | { status: "rejected"; reason: SynthesisRejectReason };
+
+/** 正文长度闸。下界防空壳，上界防 LLM 把整段推理倒进来。 */
+export const SYNTHESIS_MIN_LEN = 12;
+export const SYNTHESIS_MAX_LEN = 300;
+
+/**
+ * 提示词回声标记 —— 命中任意一条即判 `prompt-echo`。
+ *
+ * 挑选判据：必须是**只可能来自提示词本身**的长串。一条真实结论里不会出现
+ * 「宁可不产出」或「记忆索引助手」，但完全可能出现「JSON」「evidence」这类词，
+ * 所以后者不进表 —— 这张表宁可漏也不能误杀真结论。
+ * 头两条是老 `generateL0` 提示词的原文，那 28 条泄漏就是照它进的库。
+ */
+export const PROMPT_ECHO_MARKERS: readonly string[] = [
+  "保真规则",
+  "端口号/IP/URL/文件路径",
+  "记忆索引助手",
+  "记忆模式发现助手",
+  "宁可不产出",
+  "那是性格描写不是结论",
+  "不要加任何解释或代码围栏",
+];
+
+/** 送进模型的簇文本总预算（字符）。三臂实验用的就是这个量级，够 p90 簇全文进模型。 */
+export const CLUSTER_INPUT_BUDGET = 12_000;
+
+/**
+ * 把总预算在簇成员之间**等额分配**，短成员用不完的份额让给长成员。
+ *
+ * 老路径是 `text.slice(0, 2000)` —— 整簇拼成一条长文本后从头切。实测 64.2% 的簇被截，
+ * 中位只有 62.7% 的源文本进得了模型，p10 仅 13.8%：**排在后面的成员根本没被看见**，
+ * 而簇最大有 168 个成员。等额分配保证每条源都有机会出现在模型眼前，这是「跨条目结论」
+ * 能成立的物理前提 —— 看不到的东西无法被跨。
+ *
+ * 算法：按长度升序，每轮把「剩余预算 / 剩余条数」作为当条份额；短于份额的整条收下并
+ * 把余量退回池子，长于份额的截到份额并加省略号。单趟 O(n log n)。
+ */
+export function allocateClusterBudget(texts: string[], totalBudget = CLUSTER_INPUT_BUDGET): string[] {
+  if (texts.length === 0) return [];
+  const out = new Array<string>(texts.length);
+  const order = texts
+    .map((t, i) => ({ i, len: t.length }))
+    .sort((a, b) => a.len - b.len);
+
+  let remainingBudget = Math.max(0, totalBudget);
+  let remainingCount = order.length;
+
+  for (const { i } of order) {
+    const share = Math.floor(remainingBudget / remainingCount);
+    const text = texts[i];
+    if (text.length <= share) {
+      out[i] = text;
+      remainingBudget -= text.length;
+    } else {
+      // 至少留 1 个字符，避免 share=0 时产出空串（空串会让编号错位、evidence 无从指认）
+      out[i] = share > 1 ? `${text.slice(0, share - 1)}…` : text.slice(0, 1);
+      remainingBudget -= out[i].length;
+    }
+    remainingCount--;
+  }
+  return out;
+}
+
+/** 把簇文本编号拼成 user message。编号是 1-based，与 evidence 的语义一致。 */
+export function numberClusterTexts(texts: string[]): string {
+  return texts.map((t, i) => `[${i + 1}] ${t}`).join("\n");
+}
+
+/**
+ * cluster insight 的提示词。
+ *
+ * 与三臂实验里跑出 32.3%（qwen-turbo）/ 45.2%（qwen-max）的那版同源，另加两条：
+ * 「三要素齐全」的硬要求，以及 evidence 字段 —— 后者不只是为了可追溯，它同时是一道
+ * 隐性质检：说不出这句话是从哪几条来的，通常意味着它是凭空润色出来的。
+ */
+export const CLUSTER_INSIGHT_PROMPT = `你在为一个长期记忆库提炼「可复用结论」。下面是同一次工作中若干条编号记录。
+
+一条合格的结论必须**自带理由或后果**。只说"该做什么"而不说"为什么"或"否则会怎样"的，
+不是结论，是待办事项——待办会过期，结论不会，而这个库只留不会过期的东西。
+
+形状（两段都在才写）：
+  ① 在什么条件下、对什么对象，该怎么做或会怎样
+  ② 为什么 / 否则会怎样 / 根因是什么
+
+合格示例：
+  多 org 协作不能用 fine-grained token，必须换 classic PAT，因为一个 fine-grained token 只能绑定一个 resource owner。
+  分派前必须先等 store 完成惰性初始化，否则读到的 hasFtsSupport 还是初始化前的 false，hybrid 检索会静默落回 vector 路径。
+  批量删记忆要显式关掉 cascade，否则同 scope 内相似度高的条目会被连带降权，本意要保护的池子反而先受伤。
+
+不合格示例（这几种一律返回 has:false，不要硬改成合格的样子）：
+  配置扫描路径时应统一添加多个目录以兼容不同格式   ← 只有动作，没说不这么做会怎样
+  完成了三版对齐与定稿，删除了旧草稿              ← 复述经过
+  注重流程闭环与规范性，重视可追溯                ← 性格描写
+  把端口改成 8080 后服务恢复正常                  ← 绑死在一次性对象上
+
+其余硬性要求：
+- 结论要在未来另一个不同场景里仍然成立。绑死在一次性对象上的（某个进程号、某次会议、某天的待办）不算。
+- 不要写某人"注重什么""强调什么""倾向于什么"——那是性格描写不是结论。
+- evidence 填支撑这条结论的记录编号，至少 1 个，且必须是上面真实出现过的编号。
+- 这批记录里**大多数**确实提炼不出这样的结论，那就老实返回 has:false。宁可不产出，也不要把待办事项包装成结论。
+
+只输出**一个** JSON 对象，不要加任何解释或代码围栏。即使你想到不止一条结论，也只输出最重要的那一条，
+不要输出多个 JSON 对象——多输出的会被整条丢弃。
+{"has": true, "conclusion": "一句话，不超过120字", "evidence": [编号, ...]}
+或 {"has": false}`;
+
+/**
+ * cross-memory pattern 的提示词。
+ *
+ * 目标概念从「反复出现的偏好、行为倾向、价值观或循环主题」换成「跨条目才成立的
+ * 规则/因果/决策/踩坑/判断转折」。旧措辞是这一侧 56.1% 性向归因的直接来源：
+ * 它要的就是性格画像，模型只是忠实执行。
+ *
+ * evidence ≥2 在这里是**定义性**的，不是可选的严格度：单条支撑的东西按定义不是
+ * 跨条目模式。旧提示词嘴上写了「至少 2 条记忆作为证据支撑」，实现却既不接收也不校验
+ * 编号，于是这句话零成本。
+ */
+export const CLUSTER_PATTERN_PROMPT = `你在为一个长期记忆库提炼「跨条目才成立的结论」。下面是同一组相关记录，已编号。
+
+和逐条摘要不同，你要找的是单独看任何一条都看不出来、必须放在一起才成立的东西。
+而且它必须**自带理由或后果**：只说"该做什么"而不说"为什么"或"否则会怎样"的，
+不是结论，是待办事项——待办会过期，结论不会，而这个库只留不会过期的东西。
+
+形状（两段都在才写）：
+  ① 这类情况反复出现时，固定该怎么做 / 会怎样
+  ② 为什么 / 否则会怎样 / 根因是什么
+
+合格示例：
+  这套流程里凡是"改了真相源"的动作都必须连带扫引用点，因为漏扫不会报错，只会让两份文档各说各话，直到几天后被别人撞见。
+  同一个 bug 连修三次不成必须停下来质疑架构，而不是第四次重试，因为前三次失败说明诊断本身是错的，重试只是在错误位置上继续投入。
+
+不合格示例（这几种一律返回 has:false，不要硬改成合格的样子）：
+  注重规则有效性验证和成本效益评估，倾向于通过增量改造提升效果   ← 性格画像，这一类是本任务最常见的错误产出
+  多次进行配置调整与验证，持续关注同步状态                      ← 复述经过
+  统一使用绝对路径调用脚本                                      ← 只有动作，没说不这么做会怎样
+
+其余硬性要求：
+- 必须由**至少 2 条**记录共同支撑，把这些编号填进 evidence。只有 1 条支撑的不算跨条目。
+- 绑死在一次性对象上的（某个进程号、某次会议、某天的待办）不算。
+- 这批记录里**大多数**确实凑不出这样的跨条目结论，那就老实返回 has:false。宁可不产出，也不要把"他们都在做类似的事"写成模式。
+
+只输出**一个** JSON 对象，不要加任何解释或代码围栏。即使你想到不止一条模式，也只输出最重要的那一条，
+不要输出多个 JSON 对象——多输出的会被整条丢弃。
+{"has": true, "pattern": "一句话，不超过150字", "evidence": [编号, ...]}
+或 {"has": false}`;
+
+/**
+ * 从可能带围栏 / 带前言的原始回复里抠出 JSON 对象。与 `chatJson` 同款兜底。
+ *
+ * **刻意保持严格**：模型偶尔会一口气输出多个 JSON 对象（一条结论一个），
+ * 此时「第一个 { 到最后一个 }」跨越了所有对象、解析失败，整条判 unparsable。
+ * 不去挑其中一个来救 —— 挑哪一条是任意的，而任意选择会让「模型没照契约干活」
+ * 这件事从计数里消失。根因在提示词侧治（两个提示词都写死「只输出一个 JSON 对象」）；
+ * 2026-08-23 实测该形态占 3.3%（60 次调用 2 次），且 finish_reason 全为 stop、
+ * 与 token 截断无关——所以不要试图靠加大 max_tokens 来修它。
+ */
+export function parseSynthesisJson(raw: string | null): Record<string, unknown> | null {
+  if (!raw) return null;
+  const fence = raw.match(/```(?:json)?\s*\n?([\s\S]*?)```/);
+  const candidates = [fence ? fence[1].trim() : raw.trim()];
+  const start = raw.indexOf("{");
+  const end = raw.lastIndexOf("}");
+  if (start >= 0 && end > start) candidates.push(raw.slice(start, end + 1));
+
+  for (const c of candidates) {
+    try {
+      const parsed = JSON.parse(c) as unknown;
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return parsed as Record<string, unknown>;
+      }
+    } catch {
+      // 试下一个候选
+    }
+  }
+  return null;
+}
+
+/**
+ * 写库前的唯一一道闸。**不做任何补救性纠正** —— 不截断、不补 evidence、不猜 has 的意图。
+ * 补救会让「模型没照契约干活」这件事消失在日志之外，而那正是要看见的东西。
+ */
+export function validateSynthesis(params: {
+  parsed: Record<string, unknown> | null;
+  /** 正文字段名：insight 侧是 conclusion，pattern 侧是 pattern。 */
+  textField: string;
+  /** 簇成员数，用来判 evidence 编号是否真实存在。 */
+  memberCount: number;
+  /** 合法 evidence 编号的下限。insight = 1，pattern = 2（定义性要求）。 */
+  minEvidence: number;
+}): SynthesisVerdict {
+  const { parsed, textField, memberCount, minEvidence } = params;
+  if (!parsed) return { status: "rejected", reason: "unparsable" };
+
+  const has = parsed.has;
+  if (typeof has !== "boolean") return { status: "rejected", reason: "flag-not-boolean" };
+  if (!has) return { status: "abstained" };
+
+  const rawText = parsed[textField];
+  if (typeof rawText !== "string" || rawText.trim().length === 0) {
+    return { status: "rejected", reason: "empty-text" };
+  }
+  const text = rawText.trim();
+  if (text.length < SYNTHESIS_MIN_LEN) return { status: "rejected", reason: "too-short" };
+  if (text.length > SYNTHESIS_MAX_LEN) return { status: "rejected", reason: "too-long" };
+  if (PROMPT_ECHO_MARKERS.some(m => text.includes(m))) {
+    return { status: "rejected", reason: "prompt-echo" };
+  }
+
+  const rawEvidence = parsed.evidence;
+  if (!Array.isArray(rawEvidence)) return { status: "rejected", reason: "evidence-missing" };
+
+  const seen = new Set<number>();
+  let sawOutOfRange = false;
+  for (const item of rawEvidence) {
+    const n = typeof item === "number" ? item : Number(item);
+    if (!Number.isInteger(n)) { sawOutOfRange = true; continue; }
+    if (n < 1 || n > memberCount) { sawOutOfRange = true; continue; }
+    seen.add(n);
+  }
+  const evidence = [...seen].sort((a, b) => a - b);
+
+  if (evidence.length < minEvidence) {
+    // 一个都没对上（且确实给了越界编号）说明模型在编号；对上了但不够数是证据不足。
+    return {
+      status: "rejected",
+      reason: evidence.length === 0 && sawOutOfRange ? "evidence-out-of-range" : "evidence-too-few",
+    };
+  }
+
+  return { status: "ok", output: { text, evidence } };
+}

package/src/version-manager.ts

@@ -29,14 +29,90 @@ export interface VersionGroupMetadata {
   version_created: string;
 }
 
+export interface SingletonVersionGroupRepair {
+  id: string;
+  groupId: string;
+}
+
 // ============================================================================
 // Core Functions
 // ============================================================================
 
+/**
+ * Plan repairs for version groups that have only one surviving member.
+ *
+ * Planning is pure so callers can take the membership snapshot under their
+ * own storage lock, then apply the returned metadata-only repairs atomically.
+ */
+export function planSingletonVersionGroupRepairs(
+  entries: Array<Pick<MemoryEntry, "id" | "metadata">>,
+): SingletonVersionGroupRepair[] {
+  const groups = new Map<string, { count: number; onlyMemberId: string }>();
+
+  for (const entry of entries) {
+    const meta = parseMetadata(entry.metadata);
+    const groupId = typeof meta.version_group === "string" ? meta.version_group : null;
+    if (!groupId) continue;
+
+    const current = groups.get(groupId);
+    if (current) current.count++;
+    else groups.set(groupId, { count: 1, onlyMemberId: entry.id });
+  }
+
+  return [...groups.entries()]
+    .filter(([, group]) => group.count === 1)
+    .map(([groupId, group]) => ({ id: group.onlyMemberId, groupId }));
+}
+
+/** Remove only the three fields that make an entry a version-group member. */
+export function clearVersionGroupMetadata(
+  meta: Record<string, unknown>,
+  expectedGroupId: string,
+): Record<string, unknown> {
+  if (meta.version_group !== expectedGroupId) return meta;
+  delete meta.version_group;
+  delete meta.version_rank;
+  delete meta.version_created;
+  return meta;
+}
+
+/**
+ * 纯计算版：给一条 entry 的（已解析）metadata 打 version-group 三键，不写库。
+ * 就地修改并返回传入的 meta 对象。
+ *
+ * 供 consolidation-engine 3a 在 patchMetadataBatch 的 patchFn 里使用 —— patchFn 在
+ * 锁内拿到库中最新 meta，这里只负责"该设哪些键"；groupId 的决策（沿用已有组 or
+ * 新生成）由调用方在 cluster 级做一次、全 cluster 共享，修掉了旧路径"每个 member
+ * 重新从旧内存串判组 → 各造一个新 groupId"的 Bug-1 半边。
+ *
+ * @param preserveCreated canonical 语义：已有 version_created 则保留；member 语义传 false（总是刷新）
+ */
+export function computeVersionGroupPatch(
+  meta: Record<string, unknown>,
+  entry: MemoryEntry,
+  groupId: string,
+  preserveCreated: boolean,
+  nowIso: string,
+): Record<string, unknown> {
+  meta.version_group = groupId;
+  meta.version_rank = computeVersionRank(entry);
+  if (!preserveCreated || !meta.version_created) meta.version_created = nowIso;
+  return meta;
+}
+
 /**
  * Create a version group from two entries that would otherwise be merged.
  * Instead of archiving the weaker one, both get tagged with the same group.
  *
+ * ⚠️ 2026-08-14 起 consolidation-engine 3a 不再走本函数（改走 computeVersionGroupPatch
+ * + patchMetadataBatch，每 cluster 一次 commit）。本函数保留原签名原行为（逐条 update，
+ * 每次调用 2 个 commit），唯一剩余调用方是 llm-consolidation.ts:executeMergeDecisions ——
+ * 该路径的调用链（auto-consolidation.ts）生产零 import 且被 RECALLNEST_LLM_CONSOLIDATION
+ * flag 关闭，是不可达死代码；其调用循环里还留着与 Bug-1 同族的 stale-canonical 问题
+ * （多 member 时每次从旧内存串判组）。**有意不修不批量化**：给不可达路径补测试无收益。
+ * 若 auto-consolidation 被接回生产路径，先修那个循环再上线（见 2026-08-14 dream 根治
+ * 方案 plan.md D 节否决项）。
+ *
  * @param store      Memory store
  * @param canonical  The stronger entry (higher canonicalScore)
  * @param member     The weaker entry
@@ -79,6 +155,13 @@ export async function createVersionGroup(
   return groupId;
 }
 
+/** 3a 批量路径的 groupId 决策：canonical 已有组沿用，否则新生成（cluster 级一次）。 */
+export function resolveGroupId(canonical: MemoryEntry): string {
+  const canonMeta = parseMetadata(canonical.metadata);
+  const existing = typeof canonMeta.version_group === "string" ? canonMeta.version_group : null;
+  return existing ?? generateGroupId();
+}
+
 /**
  * Compute version rank for an entry.
  * Formula: (0.5 * importance + 0.5 * confidence) × (1 + log1p(accessCount))

package/src/workflow-observation-schema.ts

@@ -1,6 +1,7 @@
 import { z } from "zod";
 
 import { boundedStringSchema, identifierSchema, normalizedStringListSchema, optionalBoundedStringSchema } from "./schema-utils.js";
+import { RECALLED_IDS_CAP } from "./recall-ledger.js";
 
 export const WORKFLOW_OBSERVATION_OUTCOMES = [
   "success",
@@ -11,6 +12,27 @@ export const WORKFLOW_OBSERVATION_OUTCOMES = [
 
 export const WorkflowObservationOutcomeSchema = z.enum(WORKFLOW_OBSERVATION_OUTCOMES);
 
+/**
+ * P0 join key：这次任务用到过哪些记忆。
+ *
+ * 超上限**截断而不报错**——观测层的第一守则是别把上报挡回去，一条记多了的
+ * observation 也远好过一条写不进去的。
+ * // simplified: capped, best-effort join signal — 不是账目，别拿它做审计口径。
+ * 需要完整读取轨迹时查 audit.jsonl 的 retrieve 记录。
+ */
+const recalledIdsSchema = z.array(z.string().trim().min(1).max(128))
+  .transform((items) => {
+    const deduped: string[] = [];
+    const seen = new Set<string>();
+    for (const item of items) {
+      if (seen.has(item)) continue;
+      seen.add(item);
+      deduped.push(item);
+    }
+    return deduped.slice(0, RECALLED_IDS_CAP);
+  })
+  .optional();
+
 export const WorkflowObservationInputSchema = z.object({
   workflowId: identifierSchema("workflowId", 120),
   outcome: WorkflowObservationOutcomeSchema.default("success"),
@@ -24,6 +46,10 @@ export const WorkflowObservationInputSchema = z.object({
   recordedAt: z.string().datetime().default(() => new Date().toISOString()),
   skillId: optionalBoundedStringSchema(128),
   idempotencyKey: optionalBoundedStringSchema(160),
+  /** P0 join key（会话级）：上报这条 observation 的读者身份，对应 memory metadata 的 readerIds。 */
+  readerId: optionalBoundedStringSchema(64),
+  /** P0 join key（任务级，更精确）：本次任务窗口内被检索返回过的 memory id。 */
+  recalledIds: recalledIdsSchema,
 });
 
 export const WorkflowObservationRecordSchema = WorkflowObservationInputSchema.extend({

package/integrations/gemini-cli/README.md

@@ -1,57 +0,0 @@
-# Gemini CLI Integration
-
-> Gemini CLI 接入指南：一键配 MCP + continuity 规则，让 Gemini CLI 在新窗口里主动恢复稳定上下文。
-
-## Quick Start
-
-```bash
-bash integrations/gemini-cli/setup.sh
-```
-
-## What It Does
-
-- Adds RecallNest as an MCP server in `~/.gemini/settings.json` with `trust: true`
-- Installs a managed RecallNest block in `~/.gemini/GEMINI.md`
-
-## Continuity Rules
-
-The managed block comes from [gemini-md-snippet.md](gemini-md-snippet.md) and tells Gemini CLI to:
-
-- call `resume_context` at the start of fresh windows or continuity-sensitive tasks
-- run lightweight `search_memory` on task pivots inside the same project before repo exploration drifts
-- reuse known `scope` / `sessionId` and the resolved scope returned by `resume_context` in follow-up recall calls
-- treat recalled or startup-hook repo state as unverified until this window explicitly checks the repo
-- save `checkpoint_session` before leaving resumable work
-- do not inspect repo state just to enrich a close-window checkpoint unless the user explicitly asked for repo state
-- do not write unverified repo-state claims into `checkpoint_session`
-- capture durable facts with `store_memory` and reusable workflows with `store_workflow_pattern`
-
-## Shared Index
-
-Gemini CLI shares the same LanceDB index as Claude Code and Codex. Memories ingested from any source are searchable by all three.
-
-## Manual Setup
-
-Add to `~/.gemini/settings.json`:
-
-```json
-{
-  "mcpServers": {
-    "recallnest": {
-      "command": "bun",
-      "args": ["run", "RECALLNEST_PATH/src/mcp-server.ts"],
-      "trust": true
-    }
-  }
-}
-```
-
-Replace `RECALLNEST_PATH` with your actual path.
-
-Then copy [gemini-md-snippet.md](gemini-md-snippet.md) into `~/.gemini/GEMINI.md` if you are not using `setup.sh`.
-
-## Verify
-
-Start Gemini CLI and ask: "resume my context for RecallNest continuity work"
-
-If `resume_context` or `search_memory` is called, you're set.

package/integrations/gemini-cli/setup.sh

@@ -1,64 +0,0 @@
-#!/usr/bin/env bash
-# RecallNest — Gemini CLI MCP setup (idempotent)
-# Usage: bash integrations/gemini-cli/setup.sh
-
-set -euo pipefail
-
-GEMINI_SETTINGS="$HOME/.gemini/settings.json"
-GEMINI_MD="$HOME/.gemini/GEMINI.md"
-GEMINI_DIR="$HOME/.gemini"
-RECALLNEST_DIR="$(cd "$(dirname "$0")/../.." && pwd)"
-MCP_ENTRY="$RECALLNEST_DIR/src/mcp-server.ts"
-RULES_SNIPPET="$RECALLNEST_DIR/integrations/gemini-cli/gemini-md-snippet.md"
-RULES_HELPER="$RECALLNEST_DIR/integrations/shared/install-managed-block.sh"
-
-if [[ ! -f "$MCP_ENTRY" ]]; then
-  echo "ERROR: $MCP_ENTRY not found. Run this from the recallnest repo root."
-  exit 1
-fi
-
-if [[ ! -f "$RULES_HELPER" ]]; then
-  echo "ERROR: $RULES_HELPER not found."
-  exit 1
-fi
-
-# Create ~/.gemini/ and settings.json if missing
-mkdir -p "$GEMINI_DIR"
-if [[ ! -f "$GEMINI_SETTINGS" ]]; then
-  echo '{}' > "$GEMINI_SETTINGS"
-  echo "Created $GEMINI_SETTINGS"
-fi
-
-# Check if already configured
-if bun -e "
-  const c = JSON.parse(require('fs').readFileSync('$GEMINI_SETTINGS','utf8'));
-  process.exit(c.mcpServers?.recallnest ? 0 : 1);
-" 2>/dev/null; then
-  echo "RecallNest MCP already configured in $GEMINI_SETTINGS — skipping."
-else
-  bun -e "
-    const fs = require('fs');
-    const c = JSON.parse(fs.readFileSync('$GEMINI_SETTINGS','utf8'));
-    if (!c.mcpServers) c.mcpServers = {};
-    c.mcpServers.recallnest = {
-      command: 'bun',
-      args: ['run', '$MCP_ENTRY'],
-      trust: true
-    };
-    fs.writeFileSync('$GEMINI_SETTINGS', JSON.stringify(c, null, 2) + '\n');
-  "
-  echo "Added RecallNest MCP to $GEMINI_SETTINGS"
-fi
-
-. "$RULES_HELPER"
-install_managed_markdown_block "$RULES_SNIPPET" "$GEMINI_MD" "recallnest-continuity"
-echo "Installed RecallNest continuity rules in $GEMINI_MD"
-
-echo ""
-echo "Setup complete. Restart Gemini CLI to activate."
-echo ""
-echo "Continuity baseline seed:"
-echo "  (cd \"$RECALLNEST_DIR\" && bun run seed:continuity)"
-echo ""
-echo "Managed snippet source:"
-echo "  $RULES_SNIPPET"