@anmol-srv/sigil 0.10.3

package/integrations/hermes/README.md

@@ -0,0 +1,41 @@
+# Hermes integration
+
+Sigil ships as a [Hermes Agent](https://hermes.chat) memory provider plugin. The plugin source lives at [`plugin/`](./plugin) — copy that directory into Hermes' plugin tree on whichever machine runs Hermes.
+
+## Quick deploy (manual)
+
+```bash
+# 1. From the Sigil repo root on your laptop:
+scp -r integrations/hermes/plugin/ \
+    claude@neutron:.hermes/hermes-agent/plugins/memory/sigil/
+
+# 2. On the server:
+ssh claude@neutron
+sigil --help                          # confirm sigil CLI is on PATH
+sigil init                            # configure DB + embedder + LLM (once)
+hermes config set memory.provider sigil
+```
+
+Restart Hermes. Verify with `hermes memory status` (or whatever Hermes' status command surfaces).
+
+## What the plugin does
+
+| Hermes hook | Sigil call | Why |
+|---|---|---|
+| `is_available()` | `which sigil` | Avoid network calls; just check the binary exists. |
+| `initialize(session_id, platform, ...)` | sets namespace = `hermes-<platform>` | Per-platform classification — see plugin/README.md. |
+| `prefetch(query)` | `sigil search <q> --namespace=hermes-<platform>,default --limit=5 --no-graph` | Fast cross-namespace recall = the shared brain. |
+| `sync_turn(user, assistant)` | `sigil remember --bg "<user>"` in a daemon thread | Non-blocking. Sigil's classifier decides what's worth keeping. |
+| `get_tool_schemas()` | `sigil_search`, `sigil_remember` | Lets the model explicitly drill down or save mid-turn. |
+
+The contract Hermes expects is documented at `~/.hermes/hermes-agent/website/docs/developer-guide/memory-provider-plugin.md` on any Hermes install.
+
+## Future: one-shot install via `sigil init`
+
+A `src/lib/clients/hermes.js` module (5th client alongside Claude Code / Cursor / Codex / Kiro) would let `sigil init` copy this plugin into `~/.hermes/hermes-agent/plugins/memory/sigil/` and flip `memory.provider: sigil` in `config.yaml` automatically. That lands when we're confident the manual deploy works end-to-end.
+
+## Caveats
+
+- **Sigil CLI must be on `PATH`** on whichever machine runs Hermes. If `which sigil` returns nothing, `is_available()` returns false and Hermes silently falls back to its built-in memory.
+- **`~/.sigil/.env` must be configured** — run `sigil init` on the Hermes host before activating the plugin.
+- **The plugin shells out for every prefetch.** Latency is `sigil search` latency. The plugin keeps this path retrieval-only; if Hermes' per-turn budget is tighter, we could move to in-process via a Python<>Node bridge — out of scope for v0.1.

package/integrations/hermes/plugin/README.md

@@ -0,0 +1,72 @@
+# Sigil Memory Provider
+
+Persistent memory for Hermes Agent, backed by [Sigil](https://github.com/anmolsrv/sigil) — a local-first knowledge engine with atomic facts, entity graph, and hybrid retrieval. Same memory store used by Claude Code, Cursor, Codex CLI, and Kiro.
+
+## Why this exists
+
+You're running Hermes on a server (e.g. via iMessage / Telegram / Discord gateway) and you also use Claude Code / Cursor / etc. on your laptop. You want **one brain** that all of them share — without copying memories around or rebuilding them per tool.
+
+This plugin makes that real: every Hermes turn lands in a Sigil namespace, every laptop turn lands in `default`, and cross-namespace search means anyone can recall anything.
+
+## Requirements
+
+- Sigil CLI on `PATH` — `npm install -g @anmol-srv/sigil`
+- `sigil init` completed once (configures DB, embedder, LLM provider)
+- Postgres reachable from this machine (local install or shared via Tailscale / cloud)
+
+## Setup
+
+```bash
+hermes config set memory.provider sigil
+```
+
+No additional env vars or config files — Sigil reads its own `~/.sigil/.env`.
+
+## How it classifies sources
+
+Each Hermes platform writes to its own Sigil namespace:
+
+| Hermes platform | Sigil namespace |
+|---|---|
+| `cli`       | `hermes-cli` |
+| `imessage`  | `hermes-imessage` |
+| `telegram`  | `hermes-telegram` |
+| `discord`   | `hermes-discord` |
+| `cron`      | `hermes-cron` |
+
+Recall reads across **two namespaces**: the active platform's own (`hermes-imessage`) AND `default` (where the user's laptop tools write). Result: a fact captured in iMessage is reachable when you're back at your laptop in Claude Code, and vice versa.
+
+To see what's in each namespace:
+
+```bash
+sigil facts --namespace=hermes-imessage
+sigil facts --namespace=default
+sigil namespace list
+```
+
+## Tools exposed to the model
+
+| Tool | Purpose |
+|---|---|
+| `sigil_search` | Drill-down search across this platform + `default`. The model is told to use this only when the auto-injected context didn't surface what it needed. |
+| `sigil_remember` | Explicit save. The model is told to use this only when the user asks ("remember that...") or a critical fact arrives mid-turn. |
+
+Routine fact capture happens automatically via `sync_turn` — no model action required.
+
+## What lives where
+
+| Layer | Where | Owns |
+|---|---|---|
+| This plugin | `~/.hermes/hermes-agent/plugins/memory/sigil/` | The Hermes ABC contract — initialize, prefetch, sync_turn, tool dispatch. Thin subprocess wrapper. |
+| Sigil CLI | `which sigil` | Hybrid search, fact extraction, AUDM dedup, pod-aware retrieval, embedder calls. |
+| Sigil config | `~/.sigil/.env` | DB connection, embedder choice, LLM provider. Run `sigil init` to reconfigure. |
+| Sigil data | Postgres (`SIGIL_DB_HOST` in `~/.sigil/.env`) | All facts, entities, pods, relations. Shared across machines when they point at the same Postgres. |
+
+## Shared brain across machines
+
+Point `SIGIL_DB_HOST` in every machine's `~/.sigil/.env` at the *same* Postgres. Two common topologies:
+
+1. **Server-hosted Postgres** — Postgres on this server; laptop connects over Tailscale.
+2. **Cloud Postgres** — Supabase / Neon / RDS; both machines connect to it.
+
+Either way: one DB, many writers, every namespace visible from everywhere.

package/integrations/hermes/plugin/__init__.py

@@ -0,0 +1,353 @@
+"""Sigil memory provider for Hermes Agent.
+
+Bridges Hermes' memory system to a local Sigil install via the `sigil` CLI.
+No new network surface — the plugin shells out to the same subprocess
+commands Claude Code uses through its hooks. This means Hermes inherits
+all of Sigil's behavior for free: AUDM dedup, Hebbian retrieval, hot-context
+budgets, pod-aware blending, the lot.
+
+Architecture
+------------
+    prefetch(query)     → `sigil search <q> --namespace=<ns>,default`
+    sync_turn(u, a)     → `sigil remember --bg "<user_content>"` (daemon thread)
+    is_available()      → shell test: `sigil --help` returns 0
+    handle_tool_call()  → explicit search / remember invocations from the model
+
+Shared brain via namespaces
+---------------------------
+Each Hermes platform writes to its own Sigil namespace:
+
+    cli       → hermes-cli
+    telegram  → hermes-telegram
+    imessage  → hermes-imessage
+    discord   → hermes-discord
+    cron      → hermes-cron
+
+Search reads across the platform's own namespace AND `default` — the
+namespace Claude Code's hooks write to from the user's laptop. Result:
+facts captured anywhere are reachable from anywhere, with natural source
+classification (a Hermes-iMessage fact lives in `hermes-imessage`, a
+laptop-Claude-Code fact lives in `default`, but both surface in any
+search).
+
+Requires
+--------
+    sigil  CLI on PATH (the local install — `npm install -g @anmolsrv/sigil`
+           or wherever the binary is installed)
+    ~/.sigil/.env  configured (run `sigil init` once before activating
+                   this plugin)
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import shutil
+import subprocess
+import threading
+from typing import Any, Dict, List, Optional
+
+from agent.memory_provider import MemoryProvider
+
+logger = logging.getLogger(__name__)
+
+# Subprocess timeouts. Search is on the prompt-critical path → tight budget.
+# Remember is fire-and-forget via --bg, but we still cap the spawn-and-detach.
+_SEARCH_TIMEOUT_S = 5
+_REMEMBER_TIMEOUT_S = 10
+_PREFETCH_LIMIT = 5
+
+# Cap the prefetched context block — Hermes already has a memory_char_limit
+# in config.yaml, but we trim early to avoid wasting characters on results
+# the agent will never use.
+_PREFETCH_CHAR_LIMIT = 2000
+
+
+def _clean_text(value: Any) -> str:
+    """Strip subprocess noise that can break Hermes' tool/result framing."""
+    if value is None:
+        return ""
+    return str(value).replace("\x00", "").strip()
+
+
+def _ok(payload: Dict[str, Any]) -> str:
+    return json.dumps(payload, ensure_ascii=False)
+
+
+def _err(message: str) -> str:
+    return json.dumps({"error": message}, ensure_ascii=False)
+
+
+def _sigil_search_args(query: str, namespaces: str, limit: int) -> List[str]:
+    return [
+        "sigil", "search", query,
+        f"--namespace={namespaces}",
+        f"--limit={limit}",
+        "--no-graph",
+        "--no-route",
+        "--no-synthesize",
+    ]
+
+
+# ---------------------------------------------------------------------------
+# Provider
+# ---------------------------------------------------------------------------
+
+class SigilProvider(MemoryProvider):
+    """Hermes memory provider backed by a local Sigil install."""
+
+    def __init__(self) -> None:
+        self._session_id: str = ""
+        self._platform: str = "cli"
+        self._namespace: str = "hermes-cli"
+        self._search_namespaces: str = "hermes-cli,default"
+        self._hermes_home: str = ""
+        self._sync_thread: Optional[threading.Thread] = None
+
+    @property
+    def name(self) -> str:
+        return "sigil"
+
+    # -- Lifecycle -----------------------------------------------------------
+
+    def is_available(self) -> bool:
+        """Check the sigil CLI is on PATH. No network calls."""
+        return shutil.which("sigil") is not None
+
+    def initialize(self, session_id: str, **kwargs: Any) -> None:
+        self._session_id = session_id
+        self._platform = kwargs.get("platform", "cli")
+        self._namespace = f"hermes-{self._platform}"
+        # Cross-namespace search: this platform's facts PLUS the default
+        # namespace where Claude Code writes from the user's other machines.
+        self._search_namespaces = f"{self._namespace},default"
+        self._hermes_home = kwargs.get("hermes_home", "")
+        logger.info(
+            "Sigil provider initialised: namespace=%s session=%s platform=%s",
+            self._namespace, session_id, self._platform,
+        )
+
+    def shutdown(self) -> None:
+        if self._sync_thread and self._sync_thread.is_alive():
+            self._sync_thread.join(timeout=5.0)
+
+    # -- Recall (per-turn) ---------------------------------------------------
+
+    def system_prompt_block(self) -> str:
+        return (
+            "## Memory (Sigil)\n"
+            "Persistent memory across all your sessions and the user's other AI tools "
+            "(Claude Code, Cursor, Codex CLI, Kiro). Recent relevant facts are "
+            f"auto-injected at the top of each turn from namespaces `{self._search_namespaces}`. "
+            "Trust the injection — answer from it first.\n\n"
+            "Call `sigil_search` ONLY for drill-down questions when the injection "
+            "clearly missed something specific. Call `sigil_remember` ONLY when the "
+            "user explicitly asks (\"remember that...\", \"save this...\") or when "
+            "they share a critical fact mid-turn that the Stop-equivalent flush will "
+            "miss."
+        )
+
+    def prefetch(self, query: str, *, session_id: str = "") -> str:
+        """Synchronous recall before the next API call.
+
+        Calls `sigil search` against this platform's namespace plus `default`
+        (the cross-machine shared brain). Returns the raw CLI output as
+        context text; Sigil's hybrid search already formats one fact per line
+        which is exactly what the system prompt wants.
+        """
+        if not query or not query.strip():
+            return ""
+
+        try:
+            result = subprocess.run(
+                _sigil_search_args(query, self._search_namespaces, _PREFETCH_LIMIT),
+                timeout=_SEARCH_TIMEOUT_S,
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+        except subprocess.TimeoutExpired:
+            logger.warning("sigil search timed out after %ss", _SEARCH_TIMEOUT_S)
+            return ""
+        except Exception as exc:  # noqa: BLE001 — never break the agent's turn
+            logger.warning("sigil search failed: %s", exc)
+            return ""
+
+        if result.returncode != 0:
+            logger.warning("sigil search exit %s: %s", result.returncode, _clean_text(result.stderr))
+            return ""
+
+        out = _clean_text(result.stdout)
+        if not out or out == "No results found.":
+            return ""
+
+        # Trim early — Hermes also enforces memory_char_limit but truncating
+        # here avoids feeding the model results it can't use.
+        return out[:_PREFETCH_CHAR_LIMIT]
+
+    # -- Write (per-turn) ----------------------------------------------------
+
+    def sync_turn(self, user_content: str, assistant_content: str, *,
+                  session_id: str = "") -> None:
+        """Persist memorable content from the just-completed turn.
+
+        Sigil's `remember` command runs its own classifier + AUDM dedup, so
+        we don't try to be clever about what's "memorable" — just hand
+        the user message over and let Sigil decide.
+
+        Background thread is belt-and-braces: `sigil remember --bg` already
+        spawns a detached subprocess, but wrapping it in a daemon thread
+        means the .run() call itself can't block sync_turn.
+        """
+        text = (user_content or "").strip()
+        if not text:
+            return
+
+        # Sigil's CLI takes facts as positional args. We send the raw user
+        # message — its ingestion pipeline classifies, extracts, dedupes.
+        # Trimming to a sensible upper bound avoids enormous argv on long
+        # pasted content.
+        snippet = text[:4000]
+
+        def _save() -> None:
+            try:
+                subprocess.run(
+                    ["sigil", "remember", "--bg", snippet],
+                    env={**os.environ, "DEFAULT_NAMESPACE": self._namespace},
+                    timeout=_REMEMBER_TIMEOUT_S,
+                    capture_output=True,
+                )
+            except Exception as exc:  # noqa: BLE001
+                logger.warning("sigil remember failed: %s", exc)
+
+        # If the previous turn's sync is still running, let it finish first
+        # so we don't pile up zombie threads on chatty sessions.
+        if self._sync_thread and self._sync_thread.is_alive():
+            self._sync_thread.join(timeout=5.0)
+        self._sync_thread = threading.Thread(target=_save, daemon=True)
+        self._sync_thread.start()
+
+    # -- Tools (explicit invocation by the model) ----------------------------
+
+    def get_tool_schemas(self) -> List[Dict[str, Any]]:
+        return [
+            {
+                "name": "sigil_search",
+                "description": (
+                    "Search persistent memory across all of the user's AI sessions "
+                    "(this Hermes platform + their laptop's Claude Code / Cursor / "
+                    "Codex / Kiro). Use for drill-down questions when the "
+                    "auto-injected context block didn't surface what you need."
+                ),
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "query": {
+                            "type": "string",
+                            "description": "Natural-language search query."
+                        },
+                        "limit": {
+                            "type": "integer",
+                            "description": "Max results (default 5).",
+                            "default": _PREFETCH_LIMIT,
+                        },
+                    },
+                    "required": ["query"],
+                },
+            },
+            {
+                "name": "sigil_remember",
+                "description": (
+                    "Save a single self-contained fact to persistent memory. Use "
+                    "ONLY when the user explicitly asks to remember something, or "
+                    "when they share a critical mid-turn fact. Routine facts are "
+                    "captured automatically — don't double-save."
+                ),
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "fact": {
+                            "type": "string",
+                            "description": (
+                                "A short, self-contained statement that makes sense "
+                                "out of context. Not a conversation summary."
+                            )
+                        },
+                    },
+                    "required": ["fact"],
+                },
+            },
+        ]
+
+    def handle_tool_call(self, tool_name: str, args: Dict[str, Any]) -> Any:
+        if tool_name == "sigil_search":
+            return self._tool_search(args)
+        if tool_name == "sigil_remember":
+            return self._tool_remember(args)
+        return _err(f"unknown tool: {tool_name}")
+
+    def _tool_search(self, args: Dict[str, Any]) -> str:
+        query = (args.get("query") or "").strip()
+        if not query:
+            return _err("query is required")
+        limit = int(args.get("limit", _PREFETCH_LIMIT))
+
+        try:
+            result = subprocess.run(
+                _sigil_search_args(query, self._search_namespaces, limit),
+                timeout=_SEARCH_TIMEOUT_S,
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+        except Exception as exc:  # noqa: BLE001
+            return _err(_clean_text(f"sigil search failed: {exc}"))
+
+        if result.returncode != 0:
+            return _err(_clean_text(result.stderr or "search exited non-zero"))
+        return _ok({"results": _clean_text(result.stdout)})
+
+    def _tool_remember(self, args: Dict[str, Any]) -> str:
+        fact = (args.get("fact") or "").strip()
+        if not fact:
+            return _err("fact is required")
+
+        try:
+            result = subprocess.run(
+                ["sigil", "remember", "--bg", fact],
+                env={**os.environ, "DEFAULT_NAMESPACE": self._namespace},
+                timeout=_REMEMBER_TIMEOUT_S,
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+        except Exception as exc:  # noqa: BLE001
+            return _err(_clean_text(f"sigil remember failed: {exc}"))
+
+        if result.returncode != 0:
+            return _err(_clean_text(result.stderr or "remember exited non-zero"))
+        return _ok({"ok": True, "namespace": self._namespace})
+
+    # -- Config --------------------------------------------------------------
+    #
+    # Sigil reads its own ~/.sigil/.env (DB connection, embedder, LLM provider).
+    # Hermes doesn't need to know any of that — we return an empty schema so
+    # `hermes memory setup` doesn't ask redundant questions.
+
+    def get_config_schema(self) -> List[Dict[str, Any]]:
+        return []
+
+    def save_config(self, values: Dict[str, Any], hermes_home: str) -> None:
+        # No-op — Sigil owns its own config at ~/.sigil/.env. Run `sigil init`
+        # to (re)configure it.
+        return None
+
+
+# ---------------------------------------------------------------------------
+# Plugin entry point
+# ---------------------------------------------------------------------------
+
+def register(ctx: Any) -> None:
+    """Called by Hermes' memory plugin discovery system."""
+    ctx.register_memory_provider(SigilProvider())

package/integrations/hermes/plugin/plugin.yaml

@@ -0,0 +1,10 @@
+name: sigil
+version: 0.1.0
+description: >
+  Persistent shared-brain memory via a local Sigil install. Hermes turns are
+  saved to a per-platform namespace; recall reads across that namespace plus
+  `default` (where the user's laptop tools — Claude Code, Cursor, Codex, Kiro —
+  write). One Postgres backs every machine; sources/pods classify the source.
+hooks:
+  - prefetch
+  - sync_turn

package/knexfile.js

@@ -0,0 +1,15 @@
+import 'dotenv/config';
+
+const env = (key, fallback) => process.env[key] ?? fallback;
+
+export default {
+  client: 'pg',
+  connection: {
+    host: env('SIGIL_DB_HOST', 'localhost'),
+    port: Number(env('SIGIL_DB_PORT', 5432)),
+    database: env('SIGIL_DB_NAME', 'sigil'),
+    user: env('SIGIL_DB_USER', 'sigil_app'),
+    password: env('SIGIL_DB_PASSWORD', ''),
+  },
+  migrations: { directory: './src/db/migrations' },
+};

package/package.json

@@ -0,0 +1,100 @@
+{
+  "name": "@anmol-srv/sigil",
+  "version": "0.10.3",
+  "type": "module",
+  "description": "Local-first memory infrastructure for AI coding agents. One brain shared across Claude Code, Codex CLI, Cursor, Kiro, Continue, Cline, Windsurf — any MCP client. Organized in pluggable pods, stored in your own Postgres. No cloud, no telemetry. Auto-captured from Claude Code via hooks; surfaced everywhere else as a 9-tool MCP server.",
+  "bin": {
+    "sigil": "dist/cli.js"
+  },
+  "scripts": {
+    "dev": "node --watch src/server.js",
+    "start": "node src/server.js",
+    "test": "vitest",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix",
+    "build": "node build.js",
+    "prepublishOnly": "npm run build",
+    "migrate": "knex migrate:latest",
+    "migrate:rollback": "knex migrate:rollback",
+    "migrate:make": "knex migrate:make"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "files": [
+    "dist/",
+    "prompts/",
+    "src/db/migrations/",
+    "integrations/",
+    "knexfile.js",
+    "LICENSE",
+    "README.md"
+  ],
+  "keywords": [
+    "sigil",
+    "memory",
+    "ai-memory",
+    "persistent-memory",
+    "agent-memory",
+    "long-term-memory",
+    "shared-memory",
+    "ai-agent",
+    "coding-agent",
+    "ai-infrastructure",
+    "mcp",
+    "mcp-server",
+    "model-context-protocol",
+    "claude",
+    "claude-code",
+    "codex",
+    "codex-cli",
+    "cursor",
+    "kiro",
+    "windsurf",
+    "continue-dev",
+    "cline",
+    "chatgpt",
+    "ollama",
+    "rag",
+    "knowledge-graph",
+    "knowledge-base",
+    "vector-search",
+    "hybrid-search",
+    "llm",
+    "context",
+    "pgvector",
+    "postgres",
+    "local-first"
+  ],
+  "author": "Anmol Srivastava",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Anmol-Srv/sigil.git"
+  },
+  "homepage": "https://github.com/Anmol-Srv/sigil#readme",
+  "bugs": {
+    "url": "https://github.com/Anmol-Srv/sigil/issues"
+  },
+  "dependencies": {
+    "@iarna/toml": "^2.2.5",
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "dotenv": "^17.3.1",
+    "knex": "^3.1.0",
+    "pg": "^8.20.0"
+  },
+  "optionalDependencies": {
+    "@anthropic-ai/sdk": "^0.30.0"
+  },
+  "devDependencies": {
+    "@clack/prompts": "^1.2.0",
+    "@electric-sql/pglite": "^0.4.4",
+    "dayjs": "^1.11.19",
+    "esbuild": "^0.28.0",
+    "eslint": "^10.0.3",
+    "lodash-es": "^4.17.23",
+    "nanoid": "^5.1.7",
+    "vitest": "^4.0.18",
+    "zod": "^3.24.0"
+  }
+}

package/prompts/audm-decision.md

@@ -0,0 +1,31 @@
+You are comparing two facts from an organizational knowledge base. Decide if the NEW fact should be added as a separate entry or if it updates/replaces the EXISTING fact.
+
+## Decisions
+
+- **UPDATE** — The new fact covers the same topic/event/observation as the existing fact, even if worded differently. They describe the same underlying thing. Replace the existing fact with the new version. **Err on the side of UPDATE** — a knowledge base with fewer, better facts is more useful than one with many overlapping facts.
+- **ADD** — The new fact describes a genuinely different piece of information. Different event, different metric, different insight. Not just a rephrase.
+- **CONTRADICT** — The new fact directly contradicts the existing fact (e.g., different numbers for the same metric, opposite conclusions).
+
+## Examples
+
+EXISTING: "Database Design session covered normalization from 1NF through 3NF"
+NEW: "Database Design Fundamentals covered database normalization (1NF through 3NF), live schema design, and denormalization"
+→ **UPDATE** (same core topic, new version adds more detail)
+
+EXISTING: "Rahul Sharma recommended starting with PostgreSQL"
+NEW: "In Q&A, a student asked about Redis vs PostgreSQL. Rahul recommended starting with PostgreSQL, moving to Redis for server-side revocation."
+→ **UPDATE** (same recommendation, new version adds the question context)
+
+EXISTING: "Session had 78% attendance with 32 of 41 enrolled"
+NEW: "Session had 8 attendees with an average rating of 4.4/5"
+→ **ADD** (different metrics — one is attendance %, other is count + rating)
+
+EXISTING: "Students said 3NF was covered too quickly"
+NEW: "Students requested more practice exercises for 3NF"
+→ **UPDATE** (same underlying feedback about 3NF pacing)
+
+EXISTING: "Session started 2 minutes late"
+NEW: "Session started on time"
+→ **CONTRADICT**
+
+Respond with exactly one of: UPDATE, ADD, or CONTRADICT.

package/prompts/chunk-context.md

@@ -0,0 +1,23 @@
+You are enriching chunks of a document with contextual prefixes. Each chunk is a section of a larger document, and your job is to write a brief context sentence (1-2 sentences, 50-100 tokens) that situates the chunk within the full document.
+
+The prefix should help a search engine understand what the chunk is about even when read in isolation. Include the document title, section topic, and any relevant framing from the surrounding document.
+
+Do NOT repeat the chunk content. Just provide the context that would be lost if the chunk were read alone.
+
+## Input
+
+You will receive:
+1. The full document text
+2. A list of chunk excerpts (first 200 characters of each)
+
+## Output
+
+Respond with ONLY a JSON array of strings — one context prefix per chunk, in the same order as the input chunks.
+
+Example:
+```json
+[
+  "This chunk from the API Design Guide covers authentication requirements for the REST API.",
+  "This section of the API Design Guide describes rate limiting policies and retry behavior."
+]
+```