claude-smart 0.2.41 → 0.2.43

package/plugin/vendor/reflexio/reflexio/integrations/openclaw-embedded/references/comparison.md

@@ -0,0 +1,31 @@
+# openclaw-embedded vs integrations/openclaw
+
+Two Openclaw integrations ship in the same repo. This doc explains when to pick which.
+
+| Aspect | `integrations/openclaw/` (federated) | `integrations/openclaw-embedded/` (this plugin) |
+|---|---|---|
+| Reflexio server required | Yes | No |
+| Storage | Reflexio server (SQLite / Supabase / pgvector) | Openclaw's native memory (`.md` files at `.reflexio/`) |
+| Extraction LLM | Server-side (uses Reflexio's prompt bank on the server) | Openclaw's agent LLM + sub-agents (via `api.runtime.subagent.run()`) |
+| Dedup | Server-side batch + cross-instance aggregation | Per-write shallow + daily full-sweep |
+| Multi-user / multi-agent | Yes (each `agentId` → distinct `user_id`) | No (one instance = one user) |
+| Cross-instance playbook sharing | Yes (aggregation → agent playbooks) | No (v1 out of scope) |
+| External dependencies | `reflexio` CLI, LLM API key on the server, running server | Openclaw only (agent's own LLM) |
+| CLI integration | Shells out to `reflexio search / publish / aggregate` | None — pure in-Openclaw |
+| Target user | Teams with many agent instances behind a shared server | Solo user, no infrastructure |
+
+## Pick `openclaw-embedded` if:
+
+- You don't want to run a Reflexio server.
+- You only have one agent instance, or memory sharing across instances doesn't matter.
+- You prefer fewer moving parts.
+
+## Pick `integrations/openclaw/` (federated) if:
+
+- You have or want to run a Reflexio server.
+- You have multiple agent instances and want cross-instance playbook sharing via aggregation.
+- You want multi-user support (each human treated as a distinct Reflexio user).
+
+## Can both be installed?
+
+Yes — no conflict. Different hook names, different skill names, different cron jobs, different extraPaths. But installing both is pointless: they serve the same purpose by different means. Pick one.

package/plugin/vendor/reflexio/reflexio/integrations/openclaw-embedded/references/future-work.md

@@ -0,0 +1,47 @@
+# Future Work
+
+Items explicitly deferred from v1. Each has a rationale for why it's not in scope yet.
+
+## Convert to code-plugin (`definePluginEntry` + `registerCommand`)
+
+**Rationale:** V1 uses the legacy "Hook-only / Non-capability" plugin pattern (matches the `self-improving-agent` example). Converting to a code-plugin would gain:
+- Real slash commands (`/reflexio-consolidate` instead of `/skill reflexio-consolidate`)
+- `api.runtime.config.write` for programmatic config changes (currently we use `exec` + `openclaw config set`)
+- Potentially cleaner cron registration (if the plugin SDK exposes it)
+
+**Cost:** TypeScript plugin scaffolding, SDK version pinning, build pipeline.
+
+## Cross-instance playbook sharing
+
+**Rationale:** V1 treats one Openclaw instance as one user. Sharing playbooks across instances would require infrastructure (sync service, shared extraPath on network storage, or federation via Reflexio server). V1 punts this to `integrations/openclaw/` (federated) which already solves it.
+
+**Option for v2:** Lightweight git-based sync — checkpoint `.reflexio/` to a shared git remote; other instances pull periodically.
+
+## Participation in Openclaw's native dreaming
+
+**Rationale:** Openclaw's memory-core plugin has a built-in "dreaming" consolidation system (opt-in, runs daily at 3am). Our full-sweep consolidation is a parallel structure, not a participant. Participating would require a plugin API not yet exposed by memory-core.
+
+**Watch for:** an `api.runtime.memoryCore.dreaming.registerConsolidator()` or similar in future Openclaw releases.
+
+## Ported expert / should-generate prompt variants
+
+**Rationale:** Reflexio's prompt_bank has `playbook_extraction_main_expert` and `playbook_should_generate`. V1 skips these as YAGNI:
+- Expert-mode is for advanced scenarios beyond v1.
+- `should_generate` is a cost-saving pre-check; extraction returning an empty list achieves the same at small additional cost.
+
+## Removed frontmatter fields
+
+- `source_sessions` — dead-pointer problem; LLM has no reliable way to recover session keys long after the fact.
+- `confirmation_kind` — no v1 consumer.
+- `confidence` — LLM self-assigned confidence is unreliable; omit rather than hallucinate precision.
+- `tags` — agent-assigned, not normalized; semantic search on body content suffices.
+
+Add any of these in v2 only if a concrete consumer materializes.
+
+## Native Windows support
+
+**Rationale:** V1 used shell scripts that assumed Unix. V1.1 moved to registered tools (`reflexio_write_profile`, `reflexio_write_playbook`), which are platform-agnostic. This item is resolved.
+
+## Playbook TTL / expiration
+
+**Rationale:** The 99% case is "playbooks never expire". V1 drops the field; occasional task-specific playbooks encode time bounds in the `## When` text. V2 could add structured playbook expiration if a concrete use case materializes.

package/plugin/vendor/reflexio/reflexio/integrations/openclaw-embedded/references/porting-notes.md

@@ -0,0 +1,52 @@
+# Porting Notes: Reflexio prompt_bank → openclaw-embedded prompts
+
+Track every deviation from source prompts so maintainers can re-apply adaptations when upstream versions bump.
+
+## profile_extraction.md
+
+**Source:** `open_source/reflexio/reflexio/server/prompt/prompt_bank/profile_update_instruction_start/v1.0.0.prompt.md`
+
+**Initial port:** 2026-04-16
+
+**Changes from source:**
+
+- **Output format**: `StructuredProfilesOutput` JSON with `profiles: list[ProfileAddItem{content, ttl, metadata}]` → array of `{topic_kebab, content, ttl}` objects that drive `reflexio_write_profile` tool calls per item.
+- **Dropped fields**: `custom_features` dict, `metadata` field. Our frontmatter doesn't carry these.
+- **Added guidance**: slug generation rules — kebab-case, ≤48 chars, `[a-z0-9][a-z0-9-]*`.
+- **Kept verbatim**: TTL enum semantics, "do NOT re-extract existing profiles" constraint, extraction criteria (what counts as a profile signal).
+- **Variable substitution**: `existing_profiles` in source was populated by Reflexio server from SQL. In our port, the Flow C sub-agent runs `memory_search(top_k=10, filter={type: profile})` and injects results into the `{existing_profiles_context}` slot.
+
+**On upstream upgrade (e.g., to v2.0.0):** diff the source file, re-apply the output-format, dropped-fields, added-guidance deltas.
+
+## playbook_extraction.md
+
+**Source:** `open_source/reflexio/reflexio/server/prompt/prompt_bank/playbook_extraction_context/v2.0.0.prompt.md`
+
+**Initial port:** 2026-04-16
+
+**Changes from source:**
+
+- **Output schema**: 6-field (`trigger`, `instruction`, `pitfall`, `rationale`, `blocking_issue`, `content`) → 3-field (`When`, `What`, `Why`).
+  - **Rationale (preserved in design spec section 9):** forcing DO+DON'T symmetry (instruction + pitfall) often leads the LLM to hallucinate a symmetric "don't" when only a "do" was actually observed. Collapsing to `## What` lets the content carry whichever was observed.
+- **Autoregressive ordering adapted**: source generates rationale first, then structured fields, then content. Our port generates `Why → What → When` internally but emits `When → What → Why` in the document.
+- **Dropped**: expert-mode branches (separate `playbook_extraction_context_expert/` source); `existing_feedbacks` variable (upstream v2 already removed it).
+- **Strengthened**: explicit "no confirmation → no playbook" gate. Our skill and prompt both enforce that a correction without a following confirmation is NOT grounds for writing a playbook.
+- **Variable substitution**: `{transcript}` is passed by the Flow C sub-agent; no other runtime variables.
+
+**On upstream upgrade:** diff the source file, re-apply field collapse, ordering adaptation, expert-branch drop, confirmation gate.
+
+## shallow_dedup_pairwise.md
+
+**Source:** New file; informed by `profile_deduplication/*.prompt.md` and `playbook_deduplication/*.prompt.md`.
+
+- Simplified to strictly pairwise (candidate vs. top-1 neighbor). Reflexio's native dedup is N-way group-based.
+- Output schema: `{decision: enum, merged_content?, merged_slug?, rationale}`.
+- Our full-sweep cron handles N-way; shallow stays in the hot path.
+
+## full_consolidation.md
+
+**Source:** New file; informed by `playbook_aggregation/v1.0.0.prompt.md`.
+
+- Adapted for single-instance n-way clustering; Reflexio's aggregation is cross-instance.
+- Output schema: `{action: enum, merged_content?, merged_slug?, ids_merged_in, ids_kept_separate, rationale}`.
+- Cluster size capped at 10.

package/plugin/vendor/reflexio/reflexio/integrations/openclaw-embedded/scripts/install.sh

@@ -0,0 +1,52 @@
+#!/usr/bin/env bash
+# openclaw-embedded install.sh — plugin installation.
+# Skills are served from the extension dir via the manifest.
+# Agents are injected via extraSystemPrompt at runtime.
+# HEARTBEAT.md is appended on first agent session by setup.ts.
+set -euo pipefail
+
+PLUGIN_DIR="$(cd "$(dirname "$0")/../plugin" && pwd)"
+OPENCLAW_HOME="${OPENCLAW_HOME:-$HOME/.openclaw}"
+
+die() { echo "error: $*" >&2; exit 1; }
+info() { echo "==> $*"; }
+
+# 1. Prereq checks
+info "Checking prerequisites..."
+command -v openclaw >/dev/null || die "openclaw CLI required but not found on PATH"
+command -v node >/dev/null     || die "node required but not found on PATH"
+
+# 2. Install the plugin
+info "Installing plugin..."
+openclaw plugins uninstall --force reflexio-embedded 2>/dev/null || true
+rm -rf "$OPENCLAW_HOME/extensions/reflexio-embedded"
+openclaw plugins install "$PLUGIN_DIR"
+openclaw plugins enable reflexio-embedded 2>/dev/null || true
+
+# 3. Enable active-memory plugin and configure per-agent targeting
+info "Enabling active-memory plugin..."
+openclaw plugins enable active-memory || \
+  echo "warning: active-memory enable failed — plugin may already be enabled or unavailable; continuing"
+
+info "Configuring active-memory agent targeting..."
+openclaw config set plugins.entries.active-memory.config.agents '["*"]' || \
+  echo "warning: active-memory agent targeting config failed"
+
+info "Registering .reflexio/ as memory extraPath..."
+openclaw config set agents.defaults.memorySearch.extraPaths '[".reflexio/"]' --strict-json || \
+  echo "warning: extraPath registration failed"
+
+# 4. Restart gateway
+info "Restarting openclaw gateway..."
+openclaw gateway restart
+
+# 5. Verify
+info "Verification:"
+if openclaw plugins inspect reflexio-embedded 2>/dev/null | grep -q "Status: loaded"; then
+  info "  ✓ plugin registered and loaded"
+else
+  echo "  ⚠ plugin did not reach 'loaded' status; run 'openclaw plugins inspect reflexio-embedded' to debug"
+fi
+
+info "Installation complete."
+info "Skills are served from the extension dir. HEARTBEAT.md is set up on first agent session."

package/plugin/vendor/reflexio/reflexio/integrations/openclaw-embedded/scripts/uninstall.sh

@@ -0,0 +1,36 @@
+#!/usr/bin/env bash
+# openclaw-embedded uninstall.sh — reverses install.sh.
+# Leaves workspace/.reflexio/ user data intact unless --purge is passed.
+set -euo pipefail
+
+OPENCLAW_HOME="${OPENCLAW_HOME:-$HOME/.openclaw}"
+PURGE_DATA="${1:-}"
+
+info() { echo "==> $*"; }
+
+info "Disabling plugin..."
+openclaw plugins disable reflexio-embedded 2>/dev/null || echo "(already disabled)"
+
+info "Uninstalling plugin..."
+openclaw plugins uninstall --force reflexio-embedded 2>/dev/null || echo "(already uninstalled)"
+rm -rf "$OPENCLAW_HOME/extensions/reflexio-embedded"
+
+info "Cleaning up state files..."
+rm -f "$OPENCLAW_HOME/reflexio-consolidation-state.json"
+
+info "Removing heartbeat entry..."
+if [[ -f "$OPENCLAW_HOME/workspace/HEARTBEAT.md" ]]; then
+  sed -i '' '/## Reflexio Consolidation Check/,/^$/d' "$OPENCLAW_HOME/workspace/HEARTBEAT.md" 2>/dev/null || true
+fi
+
+if [[ "$PURGE_DATA" == "--purge" ]]; then
+  info "Purging .reflexio/ user data per --purge flag..."
+  rm -rf "$PWD/.reflexio"
+else
+  info "User data at .reflexio/ preserved. Use --purge to delete it too."
+fi
+
+info "Restarting openclaw gateway..."
+openclaw gateway restart
+
+info "Uninstall complete."

package/plugin/vendor/reflexio/reflexio/integrations/openclaw-embedded/tests/consolidate.test.ts

@@ -0,0 +1,135 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+import { runConsolidation } from "../plugin/lib/consolidate.ts";
+import type { CommandRunner, InferFn, MemorySearchResult } from "../plugin/lib/openclaw-cli.ts";
+
+let workspace: string;
+
+beforeEach(() => {
+  workspace = fs.mkdtempSync(path.join(os.tmpdir(), "rfx-cons-"));
+  fs.mkdirSync(path.join(workspace, ".reflexio", "profiles"), { recursive: true });
+  fs.mkdirSync(path.join(workspace, ".reflexio", "playbooks"), { recursive: true });
+});
+
+afterEach(() => {
+  fs.rmSync(workspace, { recursive: true, force: true });
+});
+
+function writeTestProfile(name: string, id: string, body: string, ttl = "infinity"): string {
+  const filePath = path.join(workspace, ".reflexio", "profiles", name);
+  const expires = ttl === "infinity" ? "never" : "2099-01-01";
+  fs.writeFileSync(filePath, `---\ntype: profile\nid: ${id}\ncreated: 2026-04-20T00:00:00Z\nttl: ${ttl}\nexpires: ${expires}\n---\n\n${body}\n`);
+  return filePath;
+}
+
+function createMockRunner(searchResults: MemorySearchResult[]): CommandRunner {
+  return async (argv) => {
+    if (argv.includes("memory") && argv.includes("search")) {
+      return { stdout: JSON.stringify({ results: searchResults }), stderr: "", code: 0 };
+    }
+    if (argv.includes("memory") && argv.includes("index")) {
+      return { stdout: "", stderr: "", code: 0 };
+    }
+    return { stdout: "", stderr: "unexpected command", code: 1 };
+  };
+}
+
+describe("runConsolidation", () => {
+  it("does nothing with fewer than 2 files", async () => {
+    writeTestProfile("single.md", "prof_aaa0", "Only one fact.");
+    const runner = createMockRunner([]);
+    const inferFn: InferFn = async () => null;
+
+    const result = await runConsolidation({ workspaceDir: workspace, runner, inferFn });
+    expect(result.filesDeleted).toBe(0);
+    expect(result.filesWritten).toBe(0);
+  });
+
+  it("clusters by relative path (real-world memory search format)", async () => {
+    const p1 = writeTestProfile("food-a.md", "prof_aaa0", "User likes Chinese food.");
+    const p2 = writeTestProfile("food-b.md", "prof_bbb0", "User likes Chinese cuisine.");
+
+    // Memory search returns RELATIVE paths (as in production)
+    const searchResults: MemorySearchResult[] = [
+      { path: ".reflexio/profiles/food-b.md", score: 0.8, snippet: "User likes Chinese cuisine.", startLine: 1, endLine: 5, source: "memory" },
+    ];
+    const runner = createMockRunner(searchResults);
+
+    const inferFn: InferFn = async () => JSON.stringify({
+      action: "consolidate",
+      facts: [{ slug: "food-preference-chinese", body: "User likes Chinese food and cuisine.", source_ids: ["prof_aaa0", "prof_bbb0"] }],
+      ids_to_delete: ["prof_aaa0", "prof_bbb0"],
+      rationale: "Merged duplicate Chinese food preferences.",
+    });
+
+    const result = await runConsolidation({ workspaceDir: workspace, runner, inferFn });
+    expect(result.filesWritten).toBe(1);
+    expect(result.filesDeleted).toBe(2);
+    expect(fs.existsSync(p1)).toBe(false);
+    expect(fs.existsSync(p2)).toBe(false);
+
+    const profileDir = path.join(workspace, ".reflexio", "profiles");
+    const remaining = fs.readdirSync(profileDir).filter((f) => f.endsWith(".md"));
+    expect(remaining).toHaveLength(1);
+    const content = fs.readFileSync(path.join(profileDir, remaining[0]), "utf8");
+    expect(content).toContain("User likes Chinese food and cuisine.");
+  });
+
+  it("keeps all when LLM returns keep_all", async () => {
+    const p1 = writeTestProfile("food.md", "prof_aaa0", "User likes Chinese food.");
+    const p2 = writeTestProfile("mode.md", "prof_bbb0", "User prefers dark mode.");
+
+    const searchResults: MemorySearchResult[] = [
+      { path: ".reflexio/profiles/mode.md", score: 0.5, snippet: "User prefers dark mode.", startLine: 1, endLine: 5, source: "memory" },
+    ];
+    const runner = createMockRunner(searchResults);
+    const inferFn: InferFn = async () => JSON.stringify({ action: "keep_all" });
+
+    const result = await runConsolidation({ workspaceDir: workspace, runner, inferFn });
+    expect(result.filesDeleted).toBe(0);
+    expect(result.filesWritten).toBe(0);
+    expect(fs.existsSync(p1)).toBe(true);
+    expect(fs.existsSync(p2)).toBe(true);
+  });
+
+  it("skips cluster when inferFn fails", async () => {
+    writeTestProfile("a.md", "prof_aaa0", "Fact A.");
+    writeTestProfile("b.md", "prof_bbb0", "Fact B.");
+
+    const searchResults: MemorySearchResult[] = [
+      { path: ".reflexio/profiles/b.md", score: 0.8, snippet: "Fact B.", startLine: 1, endLine: 5, source: "memory" },
+    ];
+    const runner = createMockRunner(searchResults);
+    const inferFn: InferFn = async () => null;
+
+    const result = await runConsolidation({ workspaceDir: workspace, runner, inferFn });
+    expect(result.filesDeleted).toBe(0);
+  });
+
+  it("filters out self-matches from search results", async () => {
+    writeTestProfile("food-a.md", "prof_aaa0", "User likes Chinese food.");
+    writeTestProfile("food-b.md", "prof_bbb0", "User likes Chinese cuisine.");
+
+    // Search returns the file itself as the top result (self-match) + a real neighbor
+    const searchResults: MemorySearchResult[] = [
+      { path: ".reflexio/profiles/food-a.md", score: 1.0, snippet: "User likes Chinese food.", startLine: 1, endLine: 5, source: "memory" },
+      { path: ".reflexio/profiles/food-b.md", score: 0.8, snippet: "User likes Chinese cuisine.", startLine: 1, endLine: 5, source: "memory" },
+    ];
+    const runner = createMockRunner(searchResults);
+
+    const inferFn: InferFn = async () => JSON.stringify({
+      action: "consolidate",
+      facts: [{ slug: "food-chinese", body: "User likes Chinese food.", source_ids: ["prof_aaa0", "prof_bbb0"] }],
+      ids_to_delete: ["prof_aaa0", "prof_bbb0"],
+      rationale: "Dedup.",
+    });
+
+    const result = await runConsolidation({ workspaceDir: workspace, runner, inferFn });
+    expect(result.profilesClustered).toBe(2);
+    expect(result.filesWritten).toBe(1);
+    expect(result.filesDeleted).toBe(2);
+  });
+});

package/plugin/vendor/reflexio/reflexio/integrations/openclaw-embedded/tests/dedup.test.ts

@@ -0,0 +1,104 @@
+import { describe, it, expect } from "vitest";
+
+import { preprocessQuery, judgeDedup, extractId } from "../plugin/lib/dedup.ts";
+import type { InferFn } from "../plugin/lib/openclaw-cli.ts";
+
+function createMockInferFn(result: string | null): InferFn {
+  return async () => {
+    if (result === null) return null;
+    return result;
+  };
+}
+
+describe("preprocessQuery", () => {
+  it("returns LLM-rewritten query on success", async () => {
+    const inferFn = createMockInferFn(
+      "User dietary preference vegan. Related: plant-based, no animal products"
+    );
+    const result = await preprocessQuery("Oh sorry I typed it wrong, I do like vegan food", inferFn);
+    expect(result).toBe(
+      "User dietary preference vegan. Related: plant-based, no animal products"
+    );
+  });
+
+  it("falls back to raw text when infer fails", async () => {
+    const inferFn = createMockInferFn(null);
+    const raw = "I like apple juice";
+    const result = await preprocessQuery(raw, inferFn);
+    expect(result).toBe(raw);
+  });
+
+  it("falls back to raw text when infer returns empty string", async () => {
+    const inferFn = createMockInferFn("");
+    const raw = "timezone is PST";
+    const result = await preprocessQuery(raw, inferFn);
+    expect(result).toBe(raw);
+  });
+});
+
+describe("judgeDedup", () => {
+  it("returns merge_and_resolve when LLM merges", async () => {
+    const inferFn = createMockInferFn('{"decision": "merge_and_resolve", "resolved": "User does not like Greek food."}');
+    const result = await judgeDedup("User does not like Greek food.", "User likes Greek food.", inferFn);
+    expect(result).toEqual({ decision: "merge_and_resolve", resolved: "User does not like Greek food." });
+  });
+
+  it("returns merge_and_resolve preserving non-contradicted facts", async () => {
+    const inferFn = createMockInferFn('{"decision": "merge_and_resolve", "resolved": "User does not like Chinese food. User likes Greek food."}');
+    const result = await judgeDedup(
+      "User does not like Chinese food.",
+      "User likes Chinese food. User likes Greek food.",
+      inferFn
+    );
+    expect(result).toEqual({
+      decision: "merge_and_resolve",
+      resolved: "User does not like Chinese food. User likes Greek food.",
+    });
+  });
+
+  it("returns keep_both for different topics", async () => {
+    const inferFn = createMockInferFn('{"decision": "keep_both"}');
+    const result = await judgeDedup("User likes dark mode", "User is a developer", inferFn);
+    expect(result).toEqual({ decision: "keep_both" });
+  });
+
+  it("defaults to keep_both when infer fails", async () => {
+    const inferFn = createMockInferFn(null);
+    const result = await judgeDedup("A", "B", inferFn);
+    expect(result).toEqual({ decision: "keep_both" });
+  });
+
+  it("defaults to keep_both on malformed JSON", async () => {
+    const inferFn = createMockInferFn("I think they are related");
+    const result = await judgeDedup("A", "B", inferFn);
+    expect(result).toEqual({ decision: "keep_both" });
+  });
+
+  it("defaults to keep_both on merge_and_resolve with empty resolved", async () => {
+    const inferFn = createMockInferFn('{"decision": "merge_and_resolve", "resolved": ""}');
+    const result = await judgeDedup("A", "B", inferFn);
+    expect(result).toEqual({ decision: "keep_both" });
+  });
+
+  it("defaults to keep_both on unexpected decision value", async () => {
+    const inferFn = createMockInferFn('{"decision": "supersede"}');
+    const result = await judgeDedup("A", "B", inferFn);
+    expect(result).toEqual({ decision: "keep_both" });
+  });
+});
+
+describe("extractId", () => {
+  it("extracts prof_ id from snippet", () => {
+    const snippet = "---\ntype: profile\nid: prof_sdtk\ncreated: 2026\n---\nContent";
+    expect(extractId(snippet)).toBe("prof_sdtk");
+  });
+
+  it("extracts pbk_ id from snippet", () => {
+    const snippet = "---\ntype: playbook\nid: pbk_az4k\n---\nContent";
+    expect(extractId(snippet)).toBe("pbk_az4k");
+  });
+
+  it("returns null when no id found", () => {
+    expect(extractId("no frontmatter here")).toBeNull();
+  });
+});

package/plugin/vendor/reflexio/reflexio/integrations/openclaw-embedded/tests/io.test.ts

@@ -0,0 +1,175 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { generateNanoid, validateSlug, validateTtl, computeExpires, writeProfileFile, writePlaybookFile, deleteFile } from "../plugin/lib/io.ts";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+describe("generateNanoid", () => {
+  it("returns a 4-character string of [a-z0-9]", () => {
+    const id = generateNanoid();
+    expect(id).toMatch(/^[a-z0-9]{4}$/);
+  });
+
+  it("produces different values across calls", () => {
+    const ids = new Set(Array.from({ length: 10 }, () => generateNanoid()));
+    expect(ids.size).toBeGreaterThan(1);
+  });
+});
+
+describe("validateSlug", () => {
+  it("accepts valid kebab-case slugs", () => {
+    expect(() => validateSlug("diet-vegetarian")).not.toThrow();
+    expect(() => validateSlug("abc")).not.toThrow();
+    expect(() => validateSlug("a1b2")).not.toThrow();
+  });
+
+  it("rejects empty string", () => {
+    expect(() => validateSlug("")).toThrow();
+  });
+
+  it("rejects uppercase", () => {
+    expect(() => validateSlug("Diet-Vegetarian")).toThrow();
+  });
+
+  it("rejects leading hyphen", () => {
+    expect(() => validateSlug("-diet")).toThrow();
+  });
+
+  it("rejects slashes", () => {
+    expect(() => validateSlug("foo/bar")).toThrow();
+  });
+
+  it("rejects strings longer than 48 chars", () => {
+    expect(() => validateSlug("a".repeat(49))).toThrow();
+  });
+});
+
+describe("validateTtl", () => {
+  it("accepts all valid TTL values", () => {
+    for (const ttl of ["one_day", "one_week", "one_month", "one_quarter", "one_year", "infinity"]) {
+      expect(() => validateTtl(ttl as any)).not.toThrow();
+    }
+  });
+
+  it("rejects invalid TTL", () => {
+    expect(() => validateTtl("one_millennium" as any)).toThrow();
+  });
+});
+
+describe("computeExpires", () => {
+  it("returns 'never' for infinity", () => {
+    expect(computeExpires("infinity", "2026-04-17T00:00:00Z")).toBe("never");
+  });
+
+  it("returns a date string for one_year", () => {
+    const result = computeExpires("one_year", "2026-04-17T00:00:00Z");
+    expect(result).toMatch(/^\d{4}-\d{2}-\d{2}$/);
+    expect(result).toBe("2027-04-17");
+  });
+
+  it("returns correct date for one_day", () => {
+    expect(computeExpires("one_day", "2026-04-17T00:00:00Z")).toBe("2026-04-18");
+  });
+});
+
+describe("writeProfileFile", () => {
+  let workspace: string;
+
+  beforeEach(() => {
+    workspace = fs.mkdtempSync(path.join(os.tmpdir(), "rfx-test-"));
+    fs.mkdirSync(path.join(workspace, ".reflexio", "profiles"), { recursive: true });
+  });
+
+  afterEach(() => {
+    fs.rmSync(workspace, { recursive: true, force: true });
+  });
+
+  it("creates a profile file with correct frontmatter", () => {
+    const result = writeProfileFile({
+      slug: "diet-vegan",
+      ttl: "infinity",
+      body: "User is vegan.",
+      workspace,
+    });
+    expect(fs.existsSync(result)).toBe(true);
+    const content = fs.readFileSync(result, "utf8");
+    expect(content).toContain("type: profile");
+    expect(content).toContain("id: prof_");
+    expect(content).toContain("ttl: infinity");
+    expect(content).toContain("expires: never");
+    expect(content).toContain("User is vegan.");
+  });
+
+  it("includes supersedes when provided", () => {
+    const result = writeProfileFile({
+      slug: "diet-vegan",
+      ttl: "infinity",
+      body: "User is vegan.",
+      supersedes: ["prof_abc1"],
+      workspace,
+    });
+    const content = fs.readFileSync(result, "utf8");
+    expect(content).toContain("supersedes: [prof_abc1]");
+  });
+
+  it("omits supersedes when not provided", () => {
+    const result = writeProfileFile({
+      slug: "diet-vegan",
+      ttl: "infinity",
+      body: "User is vegan.",
+      workspace,
+    });
+    const content = fs.readFileSync(result, "utf8");
+    expect(content).not.toContain("supersedes");
+  });
+
+  it("leaves no .tmp files on success", () => {
+    writeProfileFile({ slug: "test", ttl: "infinity", body: "x", workspace });
+    const tmps = fs.readdirSync(path.join(workspace, ".reflexio", "profiles"))
+      .filter((f) => f.includes(".tmp"));
+    expect(tmps).toHaveLength(0);
+  });
+});
+
+describe("writePlaybookFile", () => {
+  let workspace: string;
+
+  beforeEach(() => {
+    workspace = fs.mkdtempSync(path.join(os.tmpdir(), "rfx-test-"));
+    fs.mkdirSync(path.join(workspace, ".reflexio", "playbooks"), { recursive: true });
+  });
+
+  afterEach(() => {
+    fs.rmSync(workspace, { recursive: true, force: true });
+  });
+
+  it("creates a playbook file with correct frontmatter (no ttl/expires)", () => {
+    const result = writePlaybookFile({
+      slug: "commit-no-trailers",
+      body: "## When\nCommit message.\n\n## What\nNo trailers.\n\n## Why\nUser said so.",
+      workspace,
+    });
+    expect(fs.existsSync(result)).toBe(true);
+    const content = fs.readFileSync(result, "utf8");
+    expect(content).toContain("type: playbook");
+    expect(content).toContain("id: pbk_");
+    expect(content).not.toContain("ttl:");
+    expect(content).not.toContain("expires:");
+    expect(content).toContain("## When");
+  });
+});
+
+describe("deleteFile", () => {
+  it("deletes an existing file", () => {
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "rfx-del-"));
+    const f = path.join(tmp, "test.md");
+    fs.writeFileSync(f, "x");
+    deleteFile(f);
+    expect(fs.existsSync(f)).toBe(false);
+    fs.rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it("does not throw when file is missing", () => {
+    expect(() => deleteFile("/tmp/nonexistent-reflexio-test.md")).not.toThrow();
+  });
+});